pptx-kit-preview 0.3.2 → 0.4.0

package/dist/src-CDTTqUfI.js

@@ -0,0 +1,4177 @@
+import { getEffectiveColorMap, getGroupChildren, getGroupTransform, getParagraphAlignment, getParagraphBullet, getParagraphBulletImageBytes, getParagraphBulletStyle, getParagraphIndent, getParagraphLevel, getParagraphPropertiesEffective, getParagraphSpacing, getPresentationFonts, getPresentationTheme, getShapeAdjustValues, getShapeAltTitle, getShapeBodyPrEffective, getShapeBoundsResolved, getShapeChartSpec, getShapeClickAction, getShapeCustomGeometry, getShapeDescription, getShapeEffectsEffective, getShapeFillColorResolved, getShapeFillEffective, getShapeFlip, getShapeGradientFill, getShapeGradientFillEffective, getShapeHyperlink, getShapeHyperlinkTooltip, getShapeImageBiLevelThreshold, getShapeImageBrightness, getShapeImageBytes, getShapeImageContrast, getShapeImageCrop, getShapeImageDuotone, getShapeImageFillBytes, getShapeImageFormat, getShapeImageLinkUrl, getShapeImageOpacity, getShapeImagePartName, getShapeKind, getShapeName, getShapeParagraphCount, getShapeParagraphElements, getShapePatternFill, getShapePlaceholderType, getShapePreset, getShapeRotation, getShapeRunClickAction, getShapeRunFormat, getShapeRunFormatEffective, getShapeRunHyperlink, getShapeRunHyperlinkTooltip, getShapeStrokeArrow, getShapeStrokeCap, getShapeStrokeColorResolved, getShapeStrokeCompound, getShapeStrokeDash, getShapeStrokeEffective, getShapeStrokeJoin, getShapeTextAnchor, getShapeTextAutoFitParams, getShapeTextBodyRotationDeg, getShapeTextColumns, getShapeTextDirection, getShapeTextMargins, getShapeXmlString, getSlideBackground, getSlideBackgroundGradientFill, getSlideBackgroundImageBytes, getSlideBackgroundPatternFill, getSlideIndex, getSlideLayout, getSlideLayoutBackground, getSlideLayoutBackgroundGradientFill, getSlideLayoutBackgroundImageBytes, getSlideLayoutBackgroundPatternFill, getSlideLayoutShapes, getSlideMasterBackground, getSlideMasterBackgroundGradientFill, getSlideMasterBackgroundImageBytes, getSlideMasterBackgroundPatternFill, getSlideMasterShapes, getSlideShapes, getSlideSize, getTableCellAnchor, getTableCellBorders, getTableCellFill, getTableCellMargins, getTableCellParagraphs, getTableCellSpan, getTableCells, getTableColumnWidths, getTableDimensions, getTableRowHeights, getTableStyleFlags, isChartShape, isParagraphBulletPicture, isShapeImageGrayscale, isShapePlaceholder, isShapeTextBox, isTableShape, resolveDeckBodyTextColor } from "pptx-kit";
+//#region src/text-layout.ts
+const SANS = "Carlito";
+const SERIF = "Caladea";
+const ARIAL = "Liberation Sans";
+const TIMES = "Liberation Serif";
+const MONO = "Liberation Mono";
+const substituteFamily = (family) => {
+	if (!family) return SANS;
+	const f = family.trim().toLowerCase();
+	if (f.startsWith("calibri") || f.startsWith("aptos")) return SANS;
+	if (f.startsWith("cambria")) return SERIF;
+	if (f === "arial" || f === "helvetica" || f === "helvetica neue" || f.startsWith("arial ")) return ARIAL;
+	if (f === "times new roman" || f === "times" || f.startsWith("times ")) return TIMES;
+	if (f === "courier new" || f === "courier" || f === "consolas" || f.startsWith("courier ")) return MONO;
+	return SANS;
+};
+const isCjk = (cp) => cp >= 12352 && cp <= 12447 || cp >= 12448 && cp <= 12543 || cp >= 19968 && cp <= 40959 || cp >= 44032 && cp <= 55215;
+const AVG_GLYPH_W_RATIO$1 = .55;
+const defaultMeasurer = (text, spec) => {
+	let w = 0;
+	for (const ch of text) {
+		const ratio = isCjk(ch.codePointAt(0) ?? 0) ? 1 : AVG_GLYPH_W_RATIO$1;
+		w += spec.sizePx * ratio;
+	}
+	const n = [...text].length;
+	if (n > 1) w += spec.letterSpacingPx * (n - 1);
+	return { widthPx: w };
+};
+const FALLBACK_ASCENT = .9;
+const FALLBACK_DESCENT = .22;
+const FALLBACK_LINEGAP = .08;
+const CENTER_ANCHOR_DROP = .036;
+const GRID_NUDGE_X = -.75;
+const specOf = (piece) => ({
+	family: piece.family,
+	sizePx: piece.sizePx,
+	bold: piece.bold,
+	italic: piece.italic,
+	letterSpacingPx: piece.letterSpacingPx
+});
+const bulletSpec = (b) => ({
+	family: b.family,
+	sizePx: b.sizePx,
+	bold: false,
+	italic: false,
+	letterSpacingPx: 0
+});
+const escapeXml$1 = (s) => s.replace(/[&<>"]/g, (c) => ({
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;"
+})[c] ?? c);
+const fmt = (n) => {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+};
+const layoutTextSvg = (input, measure) => {
+	const widthCache = /* @__PURE__ */ new Map();
+	const metricCache = /* @__PURE__ */ new Map();
+	const key = (text, s) => `${s.family}|${s.sizePx}|${s.bold}|${s.italic}|${s.letterSpacingPx}|${text}`;
+	const mWidth = (text, s) => {
+		const k = key(text, s);
+		let w = widthCache.get(k);
+		if (w === void 0) {
+			w = measure(text, s).widthPx;
+			widthCache.set(k, w);
+		}
+		return w;
+	};
+	const mMetrics = (piece) => {
+		const s = specOf(piece);
+		const k = `${s.family}|${s.sizePx}|${s.bold}|${s.italic}`;
+		let m = metricCache.get(k);
+		if (!m) {
+			const r = measure("Mg", s);
+			m = r.ascentPx !== void 0 && r.descentPx !== void 0 ? {
+				a: r.ascentPx,
+				d: r.descentPx,
+				g: r.lineGapPx ?? 0
+			} : {
+				a: piece.sizePx * FALLBACK_ASCENT,
+				d: piece.sizePx * FALLBACK_DESCENT,
+				g: piece.sizePx * FALLBACK_LINEGAP
+			};
+			metricCache.set(k, m);
+		}
+		return m;
+	};
+	const buildLines = (contentLeft, contentRight) => {
+		const lines = [];
+		let cursorY = 0;
+		for (const para of input.paragraphs) {
+			cursorY += para.spcBefPx;
+			const wrapLeft = contentLeft + para.marLpx;
+			const wrapRight = contentRight - para.marRpx;
+			const firstLeft = wrapLeft + para.firstIndentPx;
+			const hasText = para.pieces.some((p) => !p.isBreak && p.text !== "");
+			const bullet = para.bullet && hasText ? para.bullet : null;
+			const bulletLead = bullet ? bullet.imageHref ? bullet.sizePx + mWidth(" ", bulletSpec(bullet)) : mWidth(`${bullet.text} `, bulletSpec(bullet)) : 0;
+			const avail = Math.max(1, wrapRight - wrapLeft);
+			const tokens = [];
+			for (const piece of para.pieces) {
+				if (piece.isBreak) {
+					tokens.push({
+						text: "",
+						piece,
+						isSpace: false,
+						isBreak: true,
+						width: 0
+					});
+					continue;
+				}
+				for (const seg of piece.text.match(/\s+|\S+/g) ?? []) {
+					const isSpace = /^\s+$/.test(seg);
+					const w = mWidth(seg, specOf(piece));
+					if (input.wrap && !isSpace && w > avail - bulletLead && [...seg].length > 1) for (const ch of seg) tokens.push({
+						text: ch,
+						piece,
+						isSpace: false,
+						isBreak: false,
+						width: mWidth(ch, specOf(piece))
+					});
+					else tokens.push({
+						text: seg,
+						piece,
+						isSpace,
+						isBreak: false,
+						width: w
+					});
+				}
+			}
+			const wrapped = wrapTokens(tokens, input.wrap, wrapRight - firstLeft - bulletLead, avail);
+			const paraLines = wrapped.length > 0 ? wrapped : [[]];
+			for (let li = 0; li < paraLines.length; li++) {
+				const toks = paraLines[li];
+				let ascent = 0;
+				let descent = 0;
+				let lineGap = 0;
+				for (const t of toks) {
+					if (t.isSpace || t.isBreak) continue;
+					const m = mMetrics(t.piece);
+					if (m.a > ascent) ascent = m.a;
+					if (m.d > descent) descent = m.d;
+					if (m.g > lineGap) lineGap = m.g;
+				}
+				if (ascent === 0) {
+					ascent = para.fallbackSizePx * FALLBACK_ASCENT;
+					descent = para.fallbackSizePx * FALLBACK_DESCENT;
+					lineGap = para.fallbackSizePx * FALLBACK_LINEGAP;
+				}
+				const isFirst = li === 0;
+				const lineLeft = bullet ? Math.max(wrapLeft, firstLeft + bulletLead) : (isFirst ? firstLeft : wrapLeft) + bulletLead;
+				const line = {
+					tokens: toks,
+					ascent,
+					descent,
+					lineGap,
+					topY: cursorY,
+					advance: 0,
+					anchorX: lineLeft,
+					textAnchor: "start",
+					bullet: null
+				};
+				if (para.align === "center") {
+					line.textAnchor = "middle";
+					line.anchorX = (lineLeft + wrapRight) / 2;
+				} else if (para.align === "right") {
+					line.textAnchor = "end";
+					line.anchorX = wrapRight;
+				}
+				if (isFirst && bullet) line.bullet = {
+					x: firstLeft,
+					baselineDy: 0,
+					b: bullet
+				};
+				line.advance = lineAdvance(line, para);
+				cursorY += line.advance;
+				lines.push(line);
+			}
+			cursorY += para.spcAftPx;
+		}
+		return {
+			lines,
+			blockH: cursorY
+		};
+	};
+	const vert = input.vert ?? "none";
+	const cx = input.boxXpx + input.boxWpx / 2;
+	const cy = input.boxYpx + input.boxHpx / 2;
+	const frame = vert === "none" ? {
+		x: input.boxXpx,
+		y: input.boxYpx,
+		w: input.boxWpx,
+		h: input.boxHpx
+	} : {
+		x: cx - input.boxHpx / 2,
+		y: cy - input.boxWpx / 2,
+		w: input.boxHpx,
+		h: input.boxWpx
+	};
+	const columns = vert === "none" ? input.columns ?? null : null;
+	const body = emitPlacements(columns && columns.count >= 2 ? placeColumns(frame, columns, input.anchor, buildLines) : placeSingle(frame, input.anchor, buildLines));
+	if (vert === "none") return body;
+	return `<g transform="rotate(${vert === "cw90" ? 90 : 270} ${fmt(cx)} ${fmt(cy)})">${body}</g>`;
+};
+const anchorOffsetY = (frameY, frameH, blockH, anchor, firstLine) => {
+	let offsetY = frameY;
+	if (anchor === "center") offsetY = frameY + (frameH - blockH) / 2;
+	else if (anchor === "bottom") offsetY = frameY + (frameH - blockH);
+	if ((anchor === "center" || anchor === "bottom") && firstLine) offsetY += CENTER_ANCHOR_DROP * (firstLine.ascent + firstLine.descent);
+	return offsetY;
+};
+const placeSingle = (frame, anchor, buildLines) => {
+	const { lines, blockH } = buildLines(frame.x, frame.x + frame.w);
+	const offsetY = anchorOffsetY(frame.y, frame.h, blockH, anchor, lines[0]);
+	return lines.map((line) => ({
+		line,
+		baselineY: offsetY + line.topY + topPad(line) + line.ascent,
+		dx: 0
+	}));
+};
+const placeColumns = (frame, columns, anchor, buildLines) => {
+	const gap = columns.gapPx;
+	const colW = Math.max(1, (frame.w - (columns.count - 1) * gap) / columns.count);
+	const { lines } = buildLines(frame.x, frame.x + colW);
+	let col = 0;
+	let colStartTopY = 0;
+	const colHasLine = [];
+	let tallest = 0;
+	const placed = [];
+	for (const line of lines) {
+		const localBottom = line.topY - colStartTopY + line.advance;
+		if (col < columns.count - 1 && localBottom > frame.h && colHasLine[col]) {
+			col += 1;
+			colStartTopY = line.topY;
+		}
+		const localTopY = line.topY - colStartTopY;
+		placed.push({
+			line,
+			localTopY,
+			col
+		});
+		colHasLine[col] = true;
+		if (localTopY + line.advance > tallest) tallest = localTopY + line.advance;
+	}
+	const offsetY = anchorOffsetY(frame.y, frame.h, tallest, anchor, lines[0]);
+	return placed.map(({ line, localTopY, col: c }) => ({
+		line,
+		baselineY: offsetY + localTopY + topPad(line) + line.ascent,
+		dx: c * (colW + gap)
+	}));
+};
+const emitPlacements = (placements) => {
+	const parts = [];
+	for (const { line, baselineY, dx } of placements) {
+		if (line.bullet) {
+			const b = line.bullet.b;
+			if (b.imageHref) parts.push(`<image x="${fmt(line.bullet.x + dx + GRID_NUDGE_X)}" y="${fmt(baselineY - b.sizePx)}" width="${fmt(b.sizePx)}" height="${fmt(b.sizePx)}" href="${b.imageHref}" xlink:href="${b.imageHref}" preserveAspectRatio="xMidYMid meet"/>`);
+			else parts.push(`<text x="${fmt(line.bullet.x + dx + GRID_NUDGE_X)}" y="${fmt(baselineY)}" font-family="${escapeXml$1(b.family)}" font-size="${fmt(b.sizePx)}" fill="${b.fillHex}" xml:space="preserve">${escapeXml$1(b.text)}</text>`);
+		}
+		parts.push(emitLine(line, baselineY, dx));
+	}
+	return parts.join("");
+};
+const topPad = (line) => {
+	const lead = line.advance - (line.ascent + line.descent);
+	return lead > 0 ? lead / 2 : 0;
+};
+const lineAdvance = (line, para) => {
+	const natural = line.ascent + line.descent + line.lineGap;
+	let adv;
+	if (para.lineSpacing?.kind === "pct") adv = para.lineSpacing.value * natural;
+	else if (para.lineSpacing?.kind === "pts") adv = para.lineSpacing.px;
+	else adv = natural;
+	return adv * para.lineAdvanceScale;
+};
+const emitLine = (line, baselineY, dx) => {
+	const toks = [...line.tokens];
+	while (toks.length > 0 && (toks[toks.length - 1].isSpace || toks[toks.length - 1].isBreak)) toks.pop();
+	const content = toks.filter((t) => !t.isBreak);
+	if (content.length === 0) return "";
+	const tspans = groupTokens(content).map((g) => tspan(g)).join("");
+	if (tspans === "") return "";
+	return `<text x="${fmt(line.anchorX + dx + GRID_NUDGE_X)}" y="${fmt(baselineY)}" text-anchor="${line.textAnchor}" xml:space="preserve">${tspans}</text>`;
+};
+const groupTokens = (toks) => {
+	const groups = [];
+	for (const t of toks) {
+		if (t.isBreak) continue;
+		const last = groups[groups.length - 1];
+		if (last && samePiece(last.piece, t.piece)) last.text += t.text;
+		else groups.push({
+			text: t.text,
+			piece: t.piece
+		});
+	}
+	return groups;
+};
+const samePiece = (a, b) => a.family === b.family && a.sizePx === b.sizePx && a.bold === b.bold && a.italic === b.italic && a.letterSpacingPx === b.letterSpacingPx && a.fillHex === b.fillHex && a.underline === b.underline && a.strike === b.strike && a.superSub === b.superSub && a.href === b.href;
+const tspan = (g) => {
+	const p = g.piece;
+	const sizePx = p.superSub !== 0 ? p.sizePx * .65 : p.sizePx;
+	const attrs = [
+		`font-family="${escapeXml$1(p.family)}"`,
+		`font-size="${fmt(sizePx)}"`,
+		`fill="${p.fillHex}"`
+	];
+	if (p.bold) attrs.push("font-weight=\"700\"");
+	if (p.italic) attrs.push("font-style=\"italic\"");
+	const deco = [];
+	if (p.underline) deco.push("underline");
+	if (p.strike) deco.push("line-through");
+	if (deco.length) attrs.push(`text-decoration="${deco.join(" ")}"`);
+	if (p.letterSpacingPx !== 0) attrs.push(`letter-spacing="${fmt(p.letterSpacingPx)}"`);
+	if (p.superSub === 1) attrs.push(`baseline-shift="${fmt(p.sizePx * .33)}"`);
+	else if (p.superSub === -1) attrs.push(`baseline-shift="${fmt(-p.sizePx * .16)}"`);
+	return `<tspan ${attrs.join(" ")}>${escapeXml$1(g.text)}</tspan>`;
+};
+const wrapTokens = (tokens, wrap, firstAvail, avail) => {
+	const lines = [];
+	let cur = [];
+	let lineW = 0;
+	let trailingSpaceW = 0;
+	let first = true;
+	const trimTrailing = () => {
+		while (cur.length > 0 && (cur[cur.length - 1].isSpace || cur[cur.length - 1].isBreak)) cur.pop();
+	};
+	const close = () => {
+		trimTrailing();
+		lines.push(cur);
+		cur = [];
+		lineW = 0;
+		trailingSpaceW = 0;
+		first = false;
+	};
+	for (const tok of tokens) {
+		if (tok.isBreak) {
+			cur.push(tok);
+			close();
+			continue;
+		}
+		if (tok.isSpace) {
+			cur.push(tok);
+			lineW += tok.width;
+			trailingSpaceW += tok.width;
+			continue;
+		}
+		const limit = first ? firstAvail : avail;
+		const contentW = lineW - trailingSpaceW;
+		if (wrap && contentW > 0 && contentW + tok.width > limit + .5) {
+			close();
+			cur.push(tok);
+			lineW = tok.width;
+		} else {
+			cur.push(tok);
+			lineW += tok.width;
+		}
+		trailingSpaceW = 0;
+	}
+	trimTrailing();
+	if (cur.length > 0) lines.push(cur);
+	return lines;
+};
+//#endregion
+//#region src/render-slide.ts
+const DEFAULT_SIZE = {
+	width: 12192e3,
+	height: 6858e3
+};
+const EMU_PER_PX = 9525;
+const PX_PER_PT = 96 / 72;
+const DEFAULT_BODY_PT = 18;
+const DEFAULT_TITLE_PT = 44;
+const DEFAULT_FONT = "Calibri, 'Helvetica Neue', Arial, sans-serif";
+const DEFAULT_INSET_X = 91440;
+const DEFAULT_INSET_Y = 45720;
+const u8ToBase64 = (data) => {
+	let s = "";
+	const chunk = 32768;
+	for (let i = 0; i < data.length; i += chunk) s += String.fromCharCode(...data.subarray(i, i + chunk));
+	return btoa(s);
+};
+const imageMime = {
+	png: "image/png",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	bmp: "image/bmp",
+	tiff: "image/tiff",
+	webp: "image/webp",
+	svg: "image/svg+xml"
+};
+const bytesToDataUrl = (bytes) => {
+	const fmt = detectImageFormatLocal(bytes);
+	return `data:${fmt ? imageMime[fmt] ?? "image/png" : "image/png"};base64,${u8ToBase64(bytes)}`;
+};
+const EXT_TO_MIME = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	bmp: "image/bmp",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	avif: "image/avif",
+	heic: "image/heic",
+	heif: "image/heif"
+};
+const mimeFromPartName = (name) => {
+	if (!name) return null;
+	const dot = name.lastIndexOf(".");
+	if (dot < 0) return null;
+	return EXT_TO_MIME[name.slice(dot + 1).toLowerCase()] ?? null;
+};
+const renderPicture = (shape, pres, x, y, w, h, transform, textOverlay, bytes, format) => {
+	let mime = null;
+	if (bytes && format) mime = imageMime[format] ?? null;
+	if (bytes && !mime) mime = mimeFromPartName(getShapeImagePartName(shape));
+	if (bytes && mime) {
+		const dataUrl = `data:${mime};base64,${u8ToBase64(bytes)}`;
+		const crop = getShapeImageCrop(shape);
+		let imgX = x, imgY = y, imgW = w, imgH = h;
+		let clipDef = "";
+		let clipAttr = "";
+		const cropL = crop?.left ?? 0;
+		const cropT = crop?.top ?? 0;
+		const cropR = crop?.right ?? 0;
+		const cropB = crop?.bottom ?? 0;
+		if (cropL > 0 || cropT > 0 || cropR > 0 || cropB > 0) {
+			const scaleX = 1 / Math.max(.001, 1 - cropL - cropR);
+			const scaleY = 1 / Math.max(.001, 1 - cropT - cropB);
+			imgW = w * scaleX;
+			imgH = h * scaleY;
+			imgX = x - imgW * cropL;
+			imgY = y - imgH * cropT;
+			const clipId = mintId();
+			clipDef = `<defs><clipPath id="${clipId}"><rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}"/></clipPath></defs>`;
+			clipAttr = ` clip-path="url(#${clipId})"`;
+		}
+		const brightness = getShapeImageBrightness(shape) ?? 0;
+		const contrast = getShapeImageContrast(shape) ?? 1;
+		const opacity = getShapeImageOpacity(shape) ?? 1;
+		const grayscale = isShapeImageGrayscale(shape);
+		const biLevel = getShapeImageBiLevelThreshold(shape);
+		const duotone = getShapeImageDuotone(pres, shape);
+		let filterAttr = "";
+		if (brightness !== 0 || contrast !== 1 || grayscale || biLevel !== null || duotone && (duotone.firstColor || duotone.secondColor)) {
+			const fid = mintId();
+			const prims = [];
+			if (brightness !== 0 || contrast !== 1) prims.push(`<feComponentTransfer><feFuncR type="linear" slope="${contrast}" intercept="${brightness}"/><feFuncG type="linear" slope="${contrast}" intercept="${brightness}"/><feFuncB type="linear" slope="${contrast}" intercept="${brightness}"/></feComponentTransfer>`);
+			if (grayscale) prims.push(`<feColorMatrix type="matrix" values="0.2126 0.7152 0.0722 0 0  0.2126 0.7152 0.0722 0 0  0.2126 0.7152 0.0722 0 0  0 0 0 1 0"/>`);
+			if (duotone && duotone.firstColor && duotone.secondColor) {
+				const [r1, g1, b1] = hexChannels(duotone.firstColor);
+				const [r2, g2, b2] = hexChannels(duotone.secondColor);
+				const steps = 16;
+				const tR = [];
+				const tG = [];
+				const tB = [];
+				for (let i = 0; i < steps; i++) {
+					const t = i / (steps - 1);
+					tR.push(((r1 + (r2 - r1) * t) / 255).toFixed(4));
+					tG.push(((g1 + (g2 - g1) * t) / 255).toFixed(4));
+					tB.push(((b1 + (b2 - b1) * t) / 255).toFixed(4));
+				}
+				prims.push(`<feColorMatrix type="matrix" values="0.2126 0.7152 0.0722 0 0  0.2126 0.7152 0.0722 0 0  0.2126 0.7152 0.0722 0 0  0 0 0 1 0"/>`, `<feComponentTransfer><feFuncR type="table" tableValues="${tR.join(" ")}"/><feFuncG type="table" tableValues="${tG.join(" ")}"/><feFuncB type="table" tableValues="${tB.join(" ")}"/></feComponentTransfer>`);
+			}
+			if (biLevel !== null) {
+				const t = biLevel / 100;
+				const steps = 32;
+				const vals = [];
+				for (let i = 0; i < steps; i++) vals.push(i / (steps - 1) >= t ? "1" : "0");
+				const tableStr = vals.join(" ");
+				prims.push(`<feComponentTransfer><feFuncR type="discrete" tableValues="${tableStr}"/><feFuncG type="discrete" tableValues="${tableStr}"/><feFuncB type="discrete" tableValues="${tableStr}"/></feComponentTransfer>`);
+			}
+			clipDef += `<defs><filter id="${fid}">${prims.join("")}</filter></defs>`;
+			filterAttr = ` filter="url(#${fid})"`;
+		}
+		const opacityAttr = opacity !== 1 ? ` opacity="${opacity.toFixed(3)}"` : "";
+		return `${clipDef}<g${transform}${clipAttr}><image x="${E(imgX)}" y="${E(imgY)}" width="${E(imgW)}" height="${E(imgH)}" href="${dataUrl}" xlink:href="${dataUrl}" preserveAspectRatio="none"${filterAttr}${opacityAttr}/></g><g${transform}>${textOverlay}</g>`;
+	}
+	const linkUrl = getShapeImageLinkUrl(shape);
+	const label = !bytes ? linkUrl ? `picture (link: ${linkUrl.length > 48 ? linkUrl.slice(0, 45) + "…" : linkUrl})` : "picture (no bytes)" : `picture (${format ?? "unknown"}${bytes ? `, ${bytes.byteLength} B` : ""})`;
+	return `<g data-pptx-fallback="image"${transform}><rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}" fill="#F3F4F6" stroke="#9CA3AF" stroke-width="${E(9525)}" stroke-dasharray="${E(5e4)},${E(3e4)}"/>${renderPicturePlaceholderLabel(x, y, w, h, label)}${textOverlay}</g>`;
+};
+const renderPicturePlaceholderLabel = (x, y, w, h, text) => {
+	const cx = x + w / 2;
+	const cy = y + h / 2;
+	return `${`<title>${escapeXml(text)}</title>`}${`<text x="${E(cx)}" y="${E(cy)}" text-anchor="middle" dominant-baseline="middle" font-family="sans-serif" font-weight="600" font-size="${(13 * PX_PER_PT).toFixed(2)}" fill="#374151">${escapeXml(text)}</text>`}`;
+};
+const escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+const SCHEME_TO_THEME = {
+	tx1: "dark1",
+	bg1: "light1",
+	tx2: "dark2",
+	bg2: "light2",
+	dk1: "dark1",
+	lt1: "light1",
+	dk2: "dark2",
+	lt2: "light2",
+	accent1: "accent1",
+	accent2: "accent2",
+	accent3: "accent3",
+	accent4: "accent4",
+	accent5: "accent5",
+	accent6: "accent6",
+	hlink: "hyperlink",
+	folHlink: "followedHyperlink"
+};
+const hexChannels = (hex) => {
+	const h = hex.startsWith("#") ? hex.slice(1) : hex;
+	return [
+		Number.parseInt(h.slice(0, 2), 16) || 0,
+		Number.parseInt(h.slice(2, 4), 16) || 0,
+		Number.parseInt(h.slice(4, 6), 16) || 0
+	];
+};
+const mixHex = (aHex, bHex, t) => {
+	const aa = aHex.startsWith("#") ? aHex.slice(1) : aHex;
+	const bb = bHex.startsWith("#") ? bHex.slice(1) : bHex;
+	const part = (h, off) => Number.parseInt(h.slice(off, off + 2), 16);
+	const r = Math.round(part(aa, 0) * t + part(bb, 0) * (1 - t));
+	const g = Math.round(part(aa, 2) * t + part(bb, 2) * (1 - t));
+	const b = Math.round(part(aa, 4) * t + part(bb, 4) * (1 - t));
+	const h = (n) => Math.max(0, Math.min(255, n)).toString(16).padStart(2, "0").toUpperCase();
+	return `#${h(r)}${h(g)}${h(b)}`;
+};
+const normalizeHex = (s) => {
+	if (s.startsWith("#")) return s;
+	if (/^[0-9A-Fa-f]{6}$/.test(s)) return `#${s}`;
+	if (/^[0-9A-Fa-f]{8}$/.test(s)) return `#${s.slice(2)}`;
+	return s;
+};
+const resolveColor = (c, theme, fallback = "#1F2937") => {
+	if (!c) return fallback;
+	let token = null;
+	if (c.startsWith("scheme:")) token = c.slice(7);
+	else if (SCHEME_TO_THEME[c]) token = c;
+	if (token !== null) {
+		if (theme) {
+			const key = SCHEME_TO_THEME[activeColorMap?.[token] ?? token] ?? SCHEME_TO_THEME[token];
+			if (key) return normalizeHex(theme[key]);
+		}
+		if (token === "tx1" || token === "dk1") return "#000000";
+		if (token === "bg1" || token === "lt1") return "#FFFFFF";
+		if (token === "tx2" || token === "dk2") return "#1F2937";
+		if (token === "bg2" || token === "lt2") return "#E5E7EB";
+		return fallback;
+	}
+	return normalizeHex(c);
+};
+let nextDefId = 0;
+const mintId = () => `pkdef-${(nextDefId++).toString(36)}`;
+let activeColorMap = null;
+let activeDeckTextColor = "#000000";
+const gradientDef = (grad, theme) => {
+	const id = mintId();
+	const stops = grad.stops.map((s) => `<stop offset="${s.offset.toFixed(4)}" stop-color="${resolveColor(s.color, theme, "#E5E7EB")}"/>`).join("");
+	if (grad.path === "circle" || grad.path === "rect" || grad.path === "shape") {
+		const focus = grad.focus ?? {
+			left: .5,
+			top: .5,
+			right: .5,
+			bottom: .5
+		};
+		const cx = (focus.left + focus.right) / 2;
+		const cy = (focus.top + focus.bottom) / 2;
+		const reversed = grad.stops.slice().reverse().map((s) => `<stop offset="${(1 - s.offset).toFixed(4)}" stop-color="${resolveColor(s.color, theme, "#E5E7EB")}"/>`).join("");
+		return {
+			defs: `<defs><radialGradient id="${id}" gradientUnits="objectBoundingBox" cx="${cx.toFixed(4)}" cy="${cy.toFixed(4)}" r="${Math.max(.5, Math.max(cx, cy, 1 - cx, 1 - cy)).toFixed(4)}">${reversed}</radialGradient></defs>`,
+			fillAttr: `url(#${id})`
+		};
+	}
+	const angleRad = (grad.angleDeg ?? 0) * Math.PI / 180;
+	const dx = Math.cos(angleRad) / 2;
+	const dy = Math.sin(angleRad) / 2;
+	const x1 = .5 - dx;
+	const y1 = .5 - dy;
+	const x2 = .5 + dx;
+	const y2 = .5 + dy;
+	return {
+		defs: `<defs><linearGradient id="${id}" gradientUnits="objectBoundingBox" x1="${x1.toFixed(4)}" y1="${y1.toFixed(4)}" x2="${x2.toFixed(4)}" y2="${y2.toFixed(4)}">${stops}</linearGradient></defs>`,
+		fillAttr: `url(#${id})`
+	};
+};
+const patternDef = (pat) => {
+	const id = mintId();
+	const fg = pat.foreground;
+	const bg = pat.background;
+	const preset = pat.preset;
+	let body = "";
+	const W = 8;
+	const H = 8;
+	const stripe = (orientation, width = 1) => {
+		if (orientation === "h") return `<path d="M0 ${H / 2}H${W}" stroke="${fg}" stroke-width="${width}"/>`;
+		if (orientation === "v") return `<path d="M${W / 2} 0V${H}" stroke="${fg}" stroke-width="${width}"/>`;
+		if (orientation === "d") return `<path d="M0 0L${W} ${H}" stroke="${fg}" stroke-width="${width}"/>`;
+		return `<path d="M${W} 0L0 ${H}" stroke="${fg}" stroke-width="${width}"/>`;
+	};
+	const BAYER4 = [
+		0,
+		8,
+		2,
+		10,
+		12,
+		4,
+		14,
+		6,
+		3,
+		11,
+		1,
+		9,
+		15,
+		7,
+		13,
+		5
+	];
+	const screen = (density) => {
+		const threshold = density * 16;
+		const out = [];
+		for (let i = 0; i < 16; i++) if (BAYER4[i] < threshold) {
+			const cx = i % 4 * 2;
+			const cy = Math.floor(i / 4) * 2;
+			out.push(`<rect x="${cx}" y="${cy}" width="2" height="2" fill="${fg}"/>`);
+		}
+		return out.join("");
+	};
+	const pctMatch = /^pct(\d+)$/.exec(preset);
+	if (pctMatch) body = screen(Math.min(100, Math.max(0, Number.parseInt(pctMatch[1], 10))) / 100);
+	else if (preset === "horzBrick" || preset === "ltHorizontal" || preset === "narHorz") body = stripe("h", .8);
+	else if (preset === "dkHorizontal") body = stripe("h", 2);
+	else if (preset === "ltVertical" || preset === "narVert") body = stripe("v", .8);
+	else if (preset === "dkVertical") body = stripe("v", 2);
+	else if (preset === "ltUpDiag" || preset === "wdUpDiag") body = stripe("d", .8);
+	else if (preset === "dkUpDiag") body = stripe("d", 2);
+	else if (preset === "ltDnDiag" || preset === "wdDnDiag") body = stripe("a", .8);
+	else if (preset === "dkDnDiag") body = stripe("a", 2);
+	else if (preset === "ltHorzCross" || preset === "smGrid" || preset === "cross") body = stripe("h", .8) + stripe("v", .8);
+	else if (preset === "dkHorzCross" || preset === "lgGrid" || preset === "plaid") body = stripe("h", 2) + stripe("v", 2);
+	else if (preset === "diagCross" || preset === "trellis" || preset === "shingle" || preset === "dashUpDiag" || preset === "dashDnDiag") body = stripe("d", .8) + stripe("a", .8);
+	else if (preset === "dkUpDiagStripe" || preset === "dkDnDiagStripe") body = stripe(preset === "dkUpDiagStripe" ? "d" : "a", 2);
+	else if (preset === "wave" || preset === "zigZag") body = `<path d="M0 4Q2 2 4 4T8 4" stroke="${fg}" stroke-width="0.8" fill="none"/>`;
+	else if (preset === "weave" || preset === "divot") body = `<path d="M0 0L4 4 0 8M4 0L8 4 4 8" stroke="${fg}" stroke-width="0.8" fill="none"/>`;
+	else if (preset === "sphere") body = `<circle cx="4" cy="4" r="3" fill="${fg}" fill-opacity="0.7"/>`;
+	else if (preset === "solidDmnd" || preset === "openDmnd") body = `<path d="M4 1L7 4 4 7 1 4Z" fill="${preset === "solidDmnd" ? fg : "none"}" stroke="${fg}" stroke-width="0.6"/>`;
+	else body = screen(.5);
+	return {
+		defs: `<defs><pattern id="${id}" patternUnits="userSpaceOnUse" width="${W}" height="${H}"><rect width="${W}" height="${H}" fill="${bg}"/>${body}</pattern></defs>`,
+		fillAttr: `url(#${id})`
+	};
+};
+const DASH_PATTERNS = {
+	solid: "",
+	dot: "1 3",
+	dash: "4 3",
+	lgDash: "8 3",
+	dashDot: "4 3 1 3",
+	lgDashDot: "8 3 1 3",
+	lgDashDotDot: "8 3 1 3 1 3",
+	sysDash: "3 1",
+	sysDot: "1 1",
+	sysDashDot: "3 1 1 1",
+	sysDashDotDot: "3 1 1 1 1 1"
+};
+const arrowSize = (size) => size === "sm" ? 3 : size === "lg" ? 7 : 5;
+const buildArrowMarker = (type, width, length, color, orient) => {
+	const id = mintId();
+	const w = arrowSize(width);
+	const h = arrowSize(length);
+	let body;
+	switch (type) {
+		case "triangle":
+		case "arrow":
+			body = `<path d="M0 0L${w} ${h / 2}L0 ${h}z" fill="${color}"/>`;
+			break;
+		case "stealth":
+			body = `<path d="M0 0L${w} ${h / 2}L0 ${h}L${w * .4} ${h / 2}z" fill="${color}"/>`;
+			break;
+		case "diamond":
+			body = `<path d="M0 ${h / 2}L${w / 2} 0L${w} ${h / 2}L${w / 2} ${h}z" fill="${color}"/>`;
+			break;
+		case "oval":
+			body = `<ellipse cx="${w / 2}" cy="${h / 2}" rx="${w / 2}" ry="${h / 2}" fill="${color}"/>`;
+			break;
+		default: body = "";
+	}
+	return {
+		id,
+		def: `<defs><marker id="${id}" viewBox="0 0 ${w} ${h}" refX="${w}" refY="${h / 2}" markerWidth="${w}" markerHeight="${h}" orient="${orient}">${body}</marker></defs>`
+	};
+};
+const paint = (shape, fill, stroke, theme, isPlaceholder, pres) => {
+	let fillColor;
+	let defs = "";
+	if (fill.kind === "solid") {
+		let resolved = null;
+		if (shape && pres) resolved = getShapeFillColorResolved(pres, shape);
+		fillColor = resolved ?? resolveColor(fill.color, theme, "#E5E7EB");
+	} else if (fill.kind === "none") fillColor = "none";
+	else if (fill.kind === "gradient") {
+		const grad = shape ? pres ? getShapeGradientFillEffective(pres, shape) : getShapeGradientFill(shape) : null;
+		if (grad) {
+			const built = gradientDef(grad, theme);
+			defs = built.defs;
+			fillColor = built.fillAttr;
+		} else fillColor = (shape && pres ? getShapeFillColorResolved(pres, shape) : null) ?? "none";
+	} else if (fill.kind === "pattern") {
+		const pat = shape && pres ? getShapePatternFill(pres, shape) : null;
+		if (pat) {
+			const built = patternDef(pat);
+			defs = built.defs;
+			fillColor = built.fillAttr;
+		} else fillColor = "#BFDBFE";
+	} else if (fill.kind === "image") fillColor = "#DDD6FE";
+	else fillColor = "none";
+	let strokeColor = "none";
+	let strokeWidth = 0;
+	const strokeAttrParts = [];
+	let markerAttrs = "";
+	if (stroke.kind === "solid") {
+		let resolved = null;
+		if (shape && pres) resolved = getShapeStrokeColorResolved(pres, shape);
+		strokeColor = resolved ?? resolveColor(stroke.color, theme, "#9CA3AF");
+		strokeWidth = stroke.widthEmu ?? 9525;
+		if (shape) {
+			const dash = getShapeStrokeDash(shape);
+			if (dash && dash !== "solid") {
+				const pattern = DASH_PATTERNS[dash];
+				if (pattern) {
+					const swPx = strokeWidth / EMU_PER_PX;
+					const arr = pattern.split(" ").map((n) => (Number.parseFloat(n) * swPx).toFixed(2)).join(" ");
+					strokeAttrParts.push(`stroke-dasharray="${arr}"`);
+				}
+			}
+			const cap = getShapeStrokeCap(shape);
+			if (cap === "rnd") strokeAttrParts.push("stroke-linecap=\"round\"");
+			else if (cap === "sq") strokeAttrParts.push("stroke-linecap=\"square\"");
+			else if (cap === "flat") strokeAttrParts.push("stroke-linecap=\"butt\"");
+			const join = getShapeStrokeJoin(shape);
+			if (join === "round") strokeAttrParts.push("stroke-linejoin=\"round\"");
+			else if (join === "bevel") strokeAttrParts.push("stroke-linejoin=\"bevel\"");
+			else if (join === "miter") strokeAttrParts.push("stroke-linejoin=\"miter\"");
+			if (getShapeStrokeCompound(shape) === "dbl") strokeWidth = Math.max(strokeWidth, 19050);
+			const head = getShapeStrokeArrow(shape, "head");
+			const tail = getShapeStrokeArrow(shape, "tail");
+			if (head && head.type !== "none") {
+				const m = buildArrowMarker(head.type, head.width, head.length, strokeColor, "auto-start-reverse");
+				defs += m.def;
+				markerAttrs += ` marker-start="url(#${m.id})"`;
+			}
+			if (tail && tail.type !== "none") {
+				const m = buildArrowMarker(tail.type, tail.width, tail.length, strokeColor, "auto");
+				defs += m.def;
+				markerAttrs += ` marker-end="url(#${m.id})"`;
+			}
+		}
+	}
+	return {
+		fill: fillColor,
+		stroke: strokeColor,
+		strokeWidth,
+		defs,
+		strokeAttrs: strokeAttrParts.join(" "),
+		markerAttrs
+	};
+};
+const polygon = (n, rotation = -Math.PI / 2) => {
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		const a = rotation + i * 2 * Math.PI / n;
+		out.push([.5 + .5 * Math.cos(a), .5 + .5 * Math.sin(a)]);
+	}
+	return out;
+};
+const star = (points, innerRatio = .42) => {
+	const out = [];
+	const rotation = -Math.PI / 2;
+	for (let i = 0; i < points * 2; i++) {
+		const a = rotation + i * Math.PI / points;
+		const r = i % 2 === 0 ? .5 : .5 * innerRatio;
+		out.push([.5 + r * Math.cos(a), .5 + r * Math.sin(a)]);
+	}
+	return out;
+};
+const PRESET_POINTS = {
+	triangle: () => [
+		[.5, 0],
+		[1, 1],
+		[0, 1]
+	],
+	rtTriangle: () => [
+		[0, 0],
+		[1, 1],
+		[0, 1]
+	],
+	diamond: () => [
+		[.5, 0],
+		[1, .5],
+		[.5, 1],
+		[0, .5]
+	],
+	parallelogram: () => [
+		[.25, 0],
+		[1, 0],
+		[.75, 1],
+		[0, 1]
+	],
+	trapezoid: () => [
+		[.25, 0],
+		[.75, 0],
+		[1, 1],
+		[0, 1]
+	],
+	pentagon: () => polygon(5),
+	hexagon: () => polygon(6),
+	heptagon: () => polygon(7),
+	octagon: () => polygon(8),
+	decagon: () => polygon(10),
+	dodecagon: () => polygon(12),
+	star4: () => star(4),
+	star5: () => star(5),
+	star6: () => star(6),
+	star7: () => star(7),
+	star8: () => star(8),
+	star10: () => star(10),
+	star12: () => star(12),
+	star16: () => star(16),
+	star24: () => star(24),
+	star32: () => star(32),
+	rightArrow: () => [
+		[0, .3],
+		[.65, .3],
+		[.65, 0],
+		[1, .5],
+		[.65, 1],
+		[.65, .7],
+		[0, .7]
+	],
+	leftArrow: () => [
+		[1, .3],
+		[.35, .3],
+		[.35, 0],
+		[0, .5],
+		[.35, 1],
+		[.35, .7],
+		[1, .7]
+	],
+	upArrow: () => [
+		[.3, 1],
+		[.3, .35],
+		[0, .35],
+		[.5, 0],
+		[1, .35],
+		[.7, .35],
+		[.7, 1]
+	],
+	downArrow: () => [
+		[.3, 0],
+		[.3, .65],
+		[0, .65],
+		[.5, 1],
+		[1, .65],
+		[.7, .65],
+		[.7, 0]
+	],
+	leftRightArrow: () => [
+		[0, .5],
+		[.18, .2],
+		[.18, .35],
+		[.82, .35],
+		[.82, .2],
+		[1, .5],
+		[.82, .8],
+		[.82, .65],
+		[.18, .65],
+		[.18, .8]
+	],
+	upDownArrow: () => [
+		[.5, 0],
+		[.2, .18],
+		[.35, .18],
+		[.35, .82],
+		[.2, .82],
+		[.5, 1],
+		[.8, .82],
+		[.65, .82],
+		[.65, .18],
+		[.8, .18]
+	],
+	chevron: () => [
+		[0, 0],
+		[.7, 0],
+		[1, .5],
+		[.7, 1],
+		[0, 1],
+		[.3, .5]
+	],
+	bentArrow: () => [
+		[0, .45],
+		[.55, .45],
+		[.55, .25],
+		[.55, .05],
+		[.95, .05],
+		[.95, .55],
+		[.8, .55],
+		[.8, .85],
+		[0, .85]
+	],
+	homePlate: () => [
+		[0, 0],
+		[.75, 0],
+		[1, .5],
+		[.75, 1],
+		[0, 1]
+	]
+};
+const PRESET_PATHS = {
+	wedgeRectCallout: (x, y, w, h) => {
+		const bodyH = h * .78;
+		const tailTipX = x + w * .12;
+		const tailTipY = y + h;
+		const tailBaseLeft = x + w * .18;
+		const tailBaseRight = x + w * .32;
+		const bodyB = y + bodyH;
+		return `M${x},${y} L${x + w},${y} L${x + w},${bodyB} L${tailBaseRight},${bodyB} L${tailTipX},${tailTipY} L${tailBaseLeft},${bodyB} L${x},${bodyB} Z`;
+	},
+	wedgeRoundRectCallout: (x, y, w, h) => {
+		const r = Math.min(w, h) * .08;
+		const bodyH = h * .78;
+		const tailTipX = x + w * .12;
+		const tailTipY = y + h;
+		const tailBaseLeft = x + w * .18;
+		const tailBaseRight = x + w * .32;
+		const bodyB = y + bodyH;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${bodyB - r} A${r},${r} 0 0 1 ${x + w - r},${bodyB} L${tailBaseRight},${bodyB} L${tailTipX},${tailTipY} L${tailBaseLeft},${bodyB} L${x + r},${bodyB} A${r},${r} 0 0 1 ${x},${bodyB - r} L${x},${y + r} A${r},${r} 0 0 1 ${x + r},${y} Z`;
+	},
+	wedgeEllipseCallout: (x, y, w, h) => {
+		const bodyCy = y + h * .39;
+		const bodyRy = h * .39;
+		const cx = x + w / 2;
+		const bodyRx = w / 2;
+		const tailTipX = x + w * .12;
+		const tailTipY = y + h;
+		const tailBaseAngle = 1.5;
+		return `M${cx + bodyRx * Math.cos(tailBaseAngle - .18)},${bodyCy + bodyRy * Math.sin(tailBaseAngle - .18)} A${bodyRx},${bodyRy} 0 1 0 ${cx + bodyRx * Math.cos(1.68)},${bodyCy + bodyRy * Math.sin(1.68)} L${tailTipX},${tailTipY} Z`;
+	},
+	cloudCallout: (x, y, w, h) => {
+		const bodyH = h * .78;
+		const cx = x + w / 2;
+		const cy = y + bodyH / 2;
+		const rx = w / 2 * .92;
+		const ry = bodyH / 2 * .85;
+		const lobes = 10;
+		const path = [];
+		for (let i = 0; i < lobes; i++) {
+			const a = i / lobes * 2 * Math.PI - Math.PI / 2;
+			const lobeRx = rx * .32;
+			const lobeRy = ry * .32;
+			const px0 = cx + rx * Math.cos(a);
+			const py0 = cy + ry * Math.sin(a);
+			if (i === 0) path.push(`M${px0 - lobeRx},${py0}`);
+			path.push(`A${lobeRx},${lobeRy} 0 1 1 ${px0 + lobeRx},${py0}`);
+			const nextA = (i + 1) / lobes * 2 * Math.PI - Math.PI / 2;
+			const nextX = cx + rx * Math.cos(nextA) - lobeRx;
+			const nextY = cy + ry * Math.sin(nextA);
+			path.push(`L${nextX},${nextY}`);
+		}
+		path.push("Z");
+		const tailX = x + w * .18;
+		const tailY = y + h * .95;
+		return `${path.join(" ")} M${tailX - 6},${tailY - 14} a4,3 0 1 0 1,0 Z M${tailX},${tailY} a6,4 0 1 0 1,0 Z`;
+	},
+	heart: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const top = y + h * .27;
+		return `M${cx},${y + h} C${x},${y + h * .55} ${x},${top} ${cx},${y + h * .4} C${x + w},${top} ${x + w},${y + h * .55} ${cx},${y + h} Z`;
+	},
+	sun: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const innerR = Math.min(w, h) * .25;
+		const outerR = Math.min(w, h) * .5;
+		const rays = 12;
+		const path = [];
+		for (let i = 0; i < rays * 2; i++) {
+			const r = i % 2 === 0 ? outerR : innerR;
+			const a = i / (rays * 2) * 2 * Math.PI - Math.PI / 2;
+			const px0 = cx + r * Math.cos(a);
+			const py0 = cy + r * Math.sin(a);
+			path.push(`${i === 0 ? "M" : "L"}${px0},${py0}`);
+		}
+		path.push("Z");
+		return path.join(" ");
+	},
+	smileyFace: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2 - 1;
+		const eyeR = r * .07;
+		const eyeOff = r * .32;
+		const mouthW = r * .5;
+		const mouthY = cy + r * .18;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r},${cy} A${r},${r} 0 1 0 ${cx + r},${cy} Z M${cx - eyeOff + eyeR},${cy - eyeOff} A${eyeR},${eyeR} 0 1 1 ${cx - eyeOff - eyeR},${cy - eyeOff} A${eyeR},${eyeR} 0 1 1 ${cx - eyeOff + eyeR},${cy - eyeOff} Z M${cx + eyeOff + eyeR},${cy - eyeOff} A${eyeR},${eyeR} 0 1 1 ${cx + eyeOff - eyeR},${cy - eyeOff} A${eyeR},${eyeR} 0 1 1 ${cx + eyeOff + eyeR},${cy - eyeOff} Z M${cx - mouthW},${mouthY} Q${cx},${mouthY + r * .32} ${cx + mouthW},${mouthY}`;
+	},
+	lightningBolt: (x, y, w, h) => {
+		return `M${x + w * .5},${y} L${x + w * .15},${y + h * .55} L${x + w * .45},${y + h * .55} L${x + w * .3},${y + h} L${x + w * .85},${y + h * .4} L${x + w * .55},${y + h * .4} L${x + w * .7},${y} Z`;
+	},
+	flowChartProcess: (x, y, w, h) => `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z`,
+	flowChartAlternateProcess: (x, y, w, h) => {
+		const r = Math.min(w, h) * .18;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${y + h - r} A${r},${r} 0 0 1 ${x + w - r},${y + h} L${x + r},${y + h} A${r},${r} 0 0 1 ${x},${y + h - r} L${x},${y + r} A${r},${r} 0 0 1 ${x + r},${y} Z`;
+	},
+	flowChartDecision: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${cx},${y} L${x + w},${cy} L${cx},${y + h} L${x},${cy} Z`;
+	},
+	flowChartTerminator: (x, y, w, h) => {
+		const r = h / 2;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w - r},${y + h} L${x + r},${y + h} A${r},${r} 0 0 1 ${x + r},${y} Z`;
+	},
+	flowChartConnector: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		return `M${cx + r},${cy} A${r},${r} 0 1 1 ${cx - r},${cy} A${r},${r} 0 1 1 ${cx + r},${cy} Z`;
+	},
+	flowChartDocument: (x, y, w, h) => {
+		const wave = h * .18;
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h - wave} C${x + w * .75},${y + h + wave * .5} ${x + w * .25},${y + h - wave * 2} ${x},${y + h - wave * .5} Z`;
+	},
+	flowChartMultidocument: (x, y, w, h) => {
+		const inset = w * .06;
+		return `${`M${x + inset},${y + inset * .6} L${x + w},${y + inset * .6} L${x + w},${y + h - inset * .6} L${x + w - inset},${y + h - inset * .6} L${x + w - inset},${y + inset * .6}`} Z ${`M${x},${y + inset * 1.2} L${x + w - inset},${y + inset * 1.2} L${x + w - inset},${y + h * .85} C${x + (w - inset) * .75},${y + h + 6} ${x + (w - inset) * .25},${y + h * .75} ${x},${y + h * .95} Z`}`;
+	},
+	flowChartPredefinedProcess: (x, y, w, h) => {
+		const inset = w * .1;
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z M${x + inset},${y} L${x + inset},${y + h} M${x + w - inset},${y} L${x + w - inset},${y + h}`;
+	},
+	flowChartInternalStorage: (x, y, w, h) => {
+		const inset = Math.min(w, h) * .1;
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z M${x + inset},${y} L${x + inset},${y + h} M${x},${y + inset} L${x + w},${y + inset}`;
+	},
+	flowChartManualInput: (x, y, w, h) => {
+		return `M${x},${y + h * .35} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z`;
+	},
+	flowChartManualOperation: (x, y, w, h) => {
+		return `M${x},${y} L${x + w},${y} L${x + w * .8},${y + h} L${x + w * .2},${y + h} Z`;
+	},
+	flowChartInputOutput: (x, y, w, h) => {
+		const skew = w * .18;
+		return `M${x + skew},${y} L${x + w},${y} L${x + w - skew},${y + h} L${x},${y + h} Z`;
+	},
+	flowChartPunchedTape: (x, y, w, h) => {
+		const wave = h * .12;
+		return `M${x},${y + wave} C${x + w * .25},${y - wave} ${x + w * .75},${y + wave * 2} ${x + w},${y + wave} L${x + w},${y + h - wave} C${x + w * .75},${y + h + wave} ${x + w * .25},${y + h - wave * 2} ${x},${y + h - wave} Z`;
+	},
+	flowChartCard: (x, y, w, h) => {
+		const cut = h * .3;
+		return `M${x + cut},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} L${x},${y + cut} Z`;
+	},
+	flowChartPunchedCard: (x, y, w, h) => {
+		const cut = h * .2;
+		return `M${x + cut},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} L${x},${y + cut} Z`;
+	},
+	flowChartOnlineStorage: (x, y, w, h) => {
+		const cap = w * .12;
+		return `M${x + cap},${y} L${x + w},${y} L${x + w},${y + h} L${x + cap},${y + h} A${cap},${h / 2} 0 0 1 ${x + cap},${y} Z`;
+	},
+	flowChartMagneticDisk: (x, y, w, h) => {
+		const er = h * .12;
+		return `M${x},${y + er} A${w / 2},${er} 0 0 1 ${x + w},${y + er} L${x + w},${y + h - er} A${w / 2},${er} 0 0 1 ${x},${y + h - er} Z M${x},${y + er} A${w / 2},${er} 0 0 0 ${x + w},${y + er}`;
+	},
+	flowChartMagneticDrum: (x, y, w, h) => {
+		const er = w * .12;
+		return `M${x + er},${y} L${x + w - er},${y} A${er},${h / 2} 0 0 1 ${x + w - er},${y + h} L${x + er},${y + h} A${er},${h / 2} 0 0 1 ${x + er},${y} Z M${x + w - er},${y} A${er},${h / 2} 0 0 0 ${x + w - er},${y + h}`;
+	},
+	flowChartMagneticTape: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r * .7},${cy + r * .7} L${x + w},${y + h} L${cx + r},${cy} Z`;
+	},
+	flowChartSummingJunction: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		const off = r * Math.SQRT1_2;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r},${cy} A${r},${r} 0 1 0 ${cx + r},${cy} Z M${cx - off},${cy - off} L${cx + off},${cy + off} M${cx - off},${cy + off} L${cx + off},${cy - off}`;
+	},
+	flowChartOr: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r},${cy} A${r},${r} 0 1 0 ${cx + r},${cy} Z M${cx - r},${cy} L${cx + r},${cy} M${cx},${cy - r} L${cx},${cy + r}`;
+	},
+	flowChartCollate: (x, y, w, h) => {
+		return `M${x},${y} L${x + w},${y} L${x},${y + h} L${x + w},${y + h} Z`;
+	},
+	flowChartSort: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${cx},${y} L${x + w},${cy} L${cx},${y + h} L${x},${cy} Z M${x},${cy} L${x + w},${cy}`;
+	},
+	flowChartExtract: (x, y, w, h) => {
+		return `M${x + w / 2},${y} L${x + w},${y + h} L${x},${y + h} Z`;
+	},
+	flowChartMerge: (x, y, w, h) => {
+		return `M${x},${y} L${x + w},${y} L${x + w / 2},${y + h} Z`;
+	},
+	flowChartOfflineStorage: (x, y, w, h) => {
+		return `M${x + w / 2},${y} L${x + w},${y + h} L${x},${y + h} Z M${x + w * .25},${y + h * .75} L${x + w * .75},${y + h * .75}`;
+	},
+	flowChartDelay: (x, y, w, h) => {
+		const r = h / 2;
+		return `M${x},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w - r},${y + h} L${x},${y + h} Z`;
+	},
+	flowChartDisplay: (x, y, w, h) => {
+		const r = h / 2;
+		return `M${x + r * .5},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w - r},${y + h} L${x + r * .5},${y + h} L${x},${y + h / 2} Z`;
+	},
+	flowChartPreparation: (x, y, w, h) => {
+		const cut = w * .18;
+		return `M${x + cut},${y} L${x + w - cut},${y} L${x + w},${y + h / 2} L${x + w - cut},${y + h} L${x + cut},${y + h} L${x},${y + h / 2} Z`;
+	},
+	notchedRightArrow: (x, y, w, h) => {
+		return `M${x},${y + h * .3} L${x + w * .65},${y + h * .3} L${x + w * .65},${y} L${x + w},${y + h / 2} L${x + w * .65},${y + h} L${x + w * .65},${y + h * .7} L${x},${y + h * .7} L${x + w * .15},${y + h / 2} Z`;
+	},
+	stripedRightArrow: (x, y, w, h) => {
+		const stripe = w * .04;
+		return `M${x},${y + h * .3} L${x + stripe},${y + h * .3} L${x + stripe},${y + h * .7} L${x},${y + h * .7} Z M${x + stripe * 2.5},${y + h * .3} L${x + stripe * 3.5},${y + h * .3} L${x + stripe * 3.5},${y + h * .7} L${x + stripe * 2.5},${y + h * .7} Z M${x + stripe * 5},${y + h * .3} L${x + w * .65},${y + h * .3} L${x + w * .65},${y} L${x + w},${y + h / 2} L${x + w * .65},${y + h} L${x + w * .65},${y + h * .7} L${x + stripe * 5},${y + h * .7} Z`;
+	},
+	curvedRightArrow: (x, y, w, h) => {
+		return `M${x},${y + h * .6} Q${x + w * .5},${y} ${x + w * .85},${y + h * .25} L${x + w},${y + h * .45} L${x + w * .85},${y + h * .55} L${x + w * .7},${y + h * .35} Q${x + w * .45},${y + h * .18} ${x + w * .15},${y + h * .75} Z`;
+	},
+	uturnArrow: (x, y, w, h) => {
+		return `M${x},${y + h} L${x},${y + h / 2} A${w * .4},${h * .4} 0 0 1 ${x + w * .8},${y + h / 2} L${x + w * .8},${y + h * .25} L${x + w},${y + h * .45} L${x + w * .8},${y + h * .65} L${x + w * .8},${y + h / 2} A${w * .2},${h * .25} 0 0 0 ${x + w * .2},${y + h / 2} L${x + w * .2},${y + h} Z`;
+	},
+	leftBracket: (x, y, w, h) => {
+		return `M${x + w},${y} L${x},${y} L${x},${y + h} L${x + w},${y + h}`;
+	},
+	rightBracket: (x, y, w, h) => {
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h}`;
+	},
+	bracketPair: (x, y, w, h) => {
+		return `M${x + w * .1},${y} L${x},${y} L${x},${y + h} L${x + w * .1},${y + h} M${x + w * .9},${y} L${x + w},${y} L${x + w},${y + h} L${x + w * .9},${y + h}`;
+	},
+	leftBrace: (x, y, w, h) => {
+		const mid = y + h / 2;
+		return `M${x + w},${y} Q${x},${y} ${x},${mid - 8} Q${x},${mid} ${x - 4},${mid} Q${x},${mid} ${x},${mid + 8} Q${x},${y + h} ${x + w},${y + h}`;
+	},
+	rightBrace: (x, y, w, h) => {
+		const mid = y + h / 2;
+		return `M${x},${y} Q${x + w},${y} ${x + w},${mid - 8} Q${x + w},${mid} ${x + w + 4},${mid} Q${x + w},${mid} ${x + w},${mid + 8} Q${x + w},${y + h} ${x},${y + h}`;
+	},
+	bracePair: (x, y, w, h) => {
+		const mid = y + h / 2;
+		return `M${x + w * .12},${y} Q${x},${y} ${x},${mid - 8} Q${x},${mid} ${x - 4},${mid} Q${x},${mid} ${x},${mid + 8} Q${x},${y + h} ${x + w * .12},${y + h} M${x + w * .88},${y} Q${x + w},${y} ${x + w},${mid - 8} Q${x + w},${mid} ${x + w + 4},${mid} Q${x + w},${mid} ${x + w},${mid + 8} Q${x + w},${y + h} ${x + w * .88},${y + h}`;
+	},
+	snip1Rect: (x, y, w, h) => {
+		const c = Math.min(w, h) * .18;
+		return `M${x},${y} L${x + w - c},${y} L${x + w},${y + c} L${x + w},${y + h} L${x},${y + h} Z`;
+	},
+	snip2SameRect: (x, y, w, h) => {
+		const c = Math.min(w, h) * .18;
+		return `M${x + c},${y} L${x + w - c},${y} L${x + w},${y + c} L${x + w},${y + h} L${x},${y + h} L${x},${y + c} Z`;
+	},
+	snip2DiagRect: (x, y, w, h) => {
+		const c = Math.min(w, h) * .18;
+		return `M${x},${y} L${x + w - c},${y} L${x + w},${y + c} L${x + w},${y + h} L${x + c},${y + h} L${x},${y + h - c} Z`;
+	},
+	snipRoundRect: (x, y, w, h) => {
+		const c = Math.min(w, h) * .18;
+		return `M${x + c},${y} A${c},${c} 0 0 0 ${x},${y + c} L${x},${y + h} L${x + w},${y + h} L${x + w},${y + c} L${x + w - c},${y} Z`;
+	},
+	round1Rect: (x, y, w, h) => {
+		const r = Math.min(w, h) * .18;
+		return `M${x},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${y + h} L${x},${y + h} Z`;
+	},
+	round2SameRect: (x, y, w, h) => {
+		const r = Math.min(w, h) * .18;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${y + h} L${x},${y + h} L${x},${y + r} A${r},${r} 0 0 1 ${x + r},${y} Z`;
+	},
+	round2DiagRect: (x, y, w, h) => {
+		const r = Math.min(w, h) * .18;
+		return `M${x},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${y + h} L${x + r},${y + h} A${r},${r} 0 0 1 ${x},${y + h - r} Z`;
+	},
+	ribbon: (x, y, w, h) => {
+		const notch = w * .06;
+		const bodyTop = y + h * .2;
+		const bodyBot = y + h * .8;
+		return `M${x},${bodyTop} L${x + notch * 2},${y} L${x + w - notch * 2},${y} L${x + w},${bodyTop} L${x + w * .85},${bodyTop + (bodyBot - bodyTop) / 2} L${x + w},${bodyBot} L${x + w - notch * 2},${y + h} L${x + w - notch * 4},${bodyBot} L${x + notch * 4},${bodyBot} L${x + notch * 2},${y + h} L${x},${bodyBot} L${x + w * .15},${bodyTop + (bodyBot - bodyTop) / 2} Z`;
+	},
+	ribbon2: (x, y, w, h) => {
+		const notch = w * .06;
+		const bodyTop = y + h * .2;
+		const bodyBot = y + h * .8;
+		return `M${x},${bodyBot} L${x + notch * 2},${y + h} L${x + w - notch * 2},${y + h} L${x + w},${bodyBot} L${x + w * .85},${bodyTop + (bodyBot - bodyTop) / 2} L${x + w},${bodyTop} L${x + w - notch * 2},${y} L${x + w - notch * 4},${bodyTop} L${x + notch * 4},${bodyTop} L${x + notch * 2},${y} L${x},${bodyTop} L${x + w * .15},${bodyTop + (bodyBot - bodyTop) / 2} Z`;
+	},
+	verticalScroll: (x, y, w, h) => {
+		const r = w * .08;
+		return `M${x + r},${y + r} A${r},${r} 0 0 1 ${x + r * 2},${y} L${x + w},${y} L${x + w},${y + h - r} A${r},${r} 0 0 1 ${x + w - r * 2},${y + h} L${x},${y + h} L${x},${y + r} A${r},${r} 0 0 1 ${x + r},${y + r} Z`;
+	},
+	horizontalScroll: (x, y, w, h) => {
+		const r = h * .08;
+		return `M${x + r},${y + r} A${r},${r} 0 0 1 ${x},${y + r * 2} L${x},${y + h} L${x + w - r},${y + h} A${r},${r} 0 0 1 ${x + w},${y + h - r * 2} L${x + w},${y} L${x + r},${y} A${r},${r} 0 0 1 ${x + r},${y + r} Z`;
+	},
+	wave: (x, y, w, h) => {
+		return `M${x},${y + h * .5} C${x + w * .25},${y - h * .1} ${x + w * .5},${y + h * .85} ${x + w * .75},${y + h * .3} C${x + w * .85},${y + h * .05} ${x + w * .95},${y + h * .4} ${x + w},${y + h * .5} L${x + w},${y + h} C${x + w * .75},${y + h * .4} ${x + w * .5},${y + h * 1.1} ${x + w * .25},${y + h * .55} C${x + w * .15},${y + h * .3} ${x + w * .05},${y + h * .6} ${x},${y + h * .55} Z`;
+	},
+	doubleWave: (x, y, w, h) => {
+		return `M${x},${y + h * .4} C${x + w * .15},${y - h * .05} ${x + w * .35},${y + h * .65} ${x + w * .5},${y + h * .3} C${x + w * .65},${y - h * .05} ${x + w * .85},${y + h * .65} ${x + w},${y + h * .4} L${x + w},${y + h} C${x + w * .85},${y + h * .4} ${x + w * .65},${y + h * 1.05} ${x + w * .5},${y + h * .7} C${x + w * .35},${y + h * 1.05} ${x + w * .15},${y + h * .4} ${x},${y + h} Z`;
+	},
+	mathPlus: (x, y, w, h) => {
+		const t = Math.min(w, h) * .2;
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${cx - t / 2},${y} L${cx + t / 2},${y} L${cx + t / 2},${cy - t / 2} L${x + w},${cy - t / 2} L${x + w},${cy + t / 2} L${cx + t / 2},${cy + t / 2} L${cx + t / 2},${y + h} L${cx - t / 2},${y + h} L${cx - t / 2},${cy + t / 2} L${x},${cy + t / 2} L${x},${cy - t / 2} L${cx - t / 2},${cy - t / 2} Z`;
+	},
+	mathMinus: (x, y, w, h) => {
+		const t = h * .3;
+		const cy = y + h / 2;
+		return `M${x},${cy - t / 2} L${x + w},${cy - t / 2} L${x + w},${cy + t / 2} L${x},${cy + t / 2} Z`;
+	},
+	mathMultiply: (x, y, w, h) => {
+		const t = Math.min(w, h) * .16;
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${x},${y + t} L${x + t},${y} L${cx},${cy - t} L${x + w - t},${y} L${x + w},${y + t} L${cx + t},${cy} L${x + w},${y + h - t} L${x + w - t},${y + h} L${cx},${cy + t} L${x + t},${y + h} L${x},${y + h - t} L${cx - t},${cy} Z`;
+	},
+	mathDivide: (x, y, w, h) => {
+		const dot = Math.min(w, h) * .1;
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${x},${cy - dot * .4} L${x + w},${cy - dot * .4} L${x + w},${cy + dot * .4} L${x},${cy + dot * .4} Z M${cx - dot},${y + h * .18} A${dot},${dot} 0 1 0 ${cx + dot},${y + h * .18} A${dot},${dot} 0 1 0 ${cx - dot},${y + h * .18} Z M${cx - dot},${y + h * .82} A${dot},${dot} 0 1 0 ${cx + dot},${y + h * .82} A${dot},${dot} 0 1 0 ${cx - dot},${y + h * .82} Z`;
+	},
+	mathEqual: (x, y, w, h) => {
+		const t = h * .2;
+		return `M${x},${y + h * .3 - t / 2} L${x + w},${y + h * .3 - t / 2} L${x + w},${y + h * .3 + t / 2} L${x},${y + h * .3 + t / 2} Z M${x},${y + h * .7 - t / 2} L${x + w},${y + h * .7 - t / 2} L${x + w},${y + h * .7 + t / 2} L${x},${y + h * .7 + t / 2} Z`;
+	},
+	mathNotEqual: (x, y, w, h) => {
+		const t = h * .15;
+		const cy = y + h / 2;
+		return `M${x},${cy - h * .18 - t / 2} L${x + w},${cy - h * .18 - t / 2} L${x + w},${cy - h * .18 + t / 2} L${x},${cy - h * .18 + t / 2} Z M${x},${cy + h * .18 - t / 2} L${x + w},${cy + h * .18 - t / 2} L${x + w},${cy + h * .18 + t / 2} L${x},${cy + h * .18 + t / 2} Z M${x + w * .7},${y} L${x + w * .85},${y} L${x + w * .3},${y + h} L${x + w * .15},${y + h} Z`;
+	},
+	actionButtonBlank: (x, y, w, h) => {
+		const r = Math.min(w, h) * .06;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 1 ${x + w},${y + r} L${x + w},${y + h - r} A${r},${r} 0 0 1 ${x + w - r},${y + h} L${x + r},${y + h} A${r},${r} 0 0 1 ${x},${y + h - r} L${x},${y + r} A${r},${r} 0 0 1 ${x + r},${y} Z`;
+	},
+	irregularSeal1: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		const offsets = [
+			1,
+			.45,
+			.95,
+			.5,
+			1,
+			.4,
+			.9,
+			.55,
+			1,
+			.45,
+			.95,
+			.5,
+			1,
+			.4,
+			.9,
+			.55
+		];
+		const points = [];
+		for (let i = 0; i < offsets.length; i++) {
+			const a = i / offsets.length * 2 * Math.PI - Math.PI / 2;
+			const r = offsets[i] ?? 1;
+			const px0 = cx + rx * r * Math.cos(a);
+			const py0 = cy + ry * r * Math.sin(a);
+			points.push(`${i === 0 ? "M" : "L"}${px0},${py0}`);
+		}
+		points.push("Z");
+		return points.join(" ");
+	},
+	irregularSeal2: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		const offsets = [
+			1,
+			.4,
+			.95,
+			.5,
+			.9,
+			.35,
+			.85,
+			.45,
+			1,
+			.4,
+			.95,
+			.5,
+			.9,
+			.35,
+			.85,
+			.45,
+			1,
+			.4,
+			.95,
+			.5,
+			.9,
+			.35,
+			.85,
+			.45
+		];
+		const points = [];
+		for (let i = 0; i < offsets.length; i++) {
+			const a = i / offsets.length * 2 * Math.PI - Math.PI / 2;
+			const r = offsets[i] ?? 1;
+			const px0 = cx + rx * r * Math.cos(a);
+			const py0 = cy + ry * r * Math.sin(a);
+			points.push(`${i === 0 ? "M" : "L"}${px0},${py0}`);
+		}
+		points.push("Z");
+		return points.join(" ");
+	},
+	cloud: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2 * .92;
+		const ry = h / 2 * .85;
+		const lobes = 10;
+		const path = [];
+		for (let i = 0; i < lobes; i++) {
+			const a = i / lobes * 2 * Math.PI - Math.PI / 2;
+			const lobeRx = rx * .32;
+			const lobeRy = ry * .32;
+			const px0 = cx + rx * Math.cos(a);
+			const py0 = cy + ry * Math.sin(a);
+			if (i === 0) path.push(`M${px0 - lobeRx},${py0}`);
+			path.push(`A${lobeRx},${lobeRy} 0 1 1 ${px0 + lobeRx},${py0}`);
+			const nextA = (i + 1) / lobes * 2 * Math.PI - Math.PI / 2;
+			const nextX = cx + rx * Math.cos(nextA) - lobeRx;
+			const nextY = cy + ry * Math.sin(nextA);
+			path.push(`L${nextX},${nextY}`);
+		}
+		path.push("Z");
+		return path.join(" ");
+	},
+	pie: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		return `M${cx},${cy} L${cx + r},${cy} A${r},${r} 0 1 1 ${cx},${cy - r} Z`;
+	},
+	chord: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		return `M${cx + rx},${cy} A${rx},${ry} 0 1 1 ${cx - rx},${cy} L${cx + rx},${cy} Z`;
+	},
+	teardrop: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		return `M${cx},${y} L${x + w},${y} L${x + w},${cy} A${rx},${ry} 0 1 1 ${cx - rx},${cy} A${rx},${ry} 0 0 1 ${cx},${y} Z`;
+	},
+	arc: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		return `M${cx + rx},${cy} A${rx},${ry} 0 1 1 ${cx},${cy + ry}`;
+	},
+	blockArc: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const outerR = Math.min(w, h) / 2;
+		const innerR = outerR * .6;
+		return `M${cx + outerR},${cy} A${outerR},${outerR} 0 1 1 ${cx},${cy - outerR} L${cx},${cy - innerR} A${innerR},${innerR} 0 1 0 ${cx + innerR},${cy} Z`;
+	},
+	moon: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const rx = w / 2;
+		const ry = h / 2;
+		const innerRx = rx * .78;
+		const offsetX = rx * .32;
+		return `M${cx + rx},${cy} A${rx},${ry} 0 1 1 ${cx - rx},${cy} A${rx},${ry} 0 1 1 ${cx + rx},${cy} M${cx - rx + offsetX + innerRx},${cy} A${innerRx},${ry * .95} 0 1 1 ${cx - rx + offsetX - innerRx},${cy} A${innerRx},${ry * .95} 0 1 1 ${cx - rx + offsetX + innerRx},${cy}`;
+	},
+	plus: (x, y, w, h) => {
+		const t = Math.min(w, h) * .3;
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		return `M${cx - t / 2},${y} L${cx + t / 2},${y} L${cx + t / 2},${cy - t / 2} L${x + w},${cy - t / 2} L${x + w},${cy + t / 2} L${cx + t / 2},${cy + t / 2} L${cx + t / 2},${y + h} L${cx - t / 2},${y + h} L${cx - t / 2},${cy + t / 2} L${x},${cy + t / 2} L${x},${cy - t / 2} L${cx - t / 2},${cy - t / 2} Z`;
+	},
+	plaque: (x, y, w, h) => {
+		const r = Math.min(w, h) * .18;
+		return `M${x + r},${y} L${x + w - r},${y} A${r},${r} 0 0 0 ${x + w},${y + r} L${x + w},${y + h - r} A${r},${r} 0 0 0 ${x + w - r},${y + h} L${x + r},${y + h} A${r},${r} 0 0 0 ${x},${y + h - r} L${x},${y + r} A${r},${r} 0 0 0 ${x + r},${y} Z`;
+	},
+	can: (x, y, w, h) => {
+		const er = h * .12;
+		return `M${x},${y + er} A${w / 2},${er} 0 0 1 ${x + w},${y + er} L${x + w},${y + h - er} A${w / 2},${er} 0 0 1 ${x},${y + h - er} Z M${x},${y + er} A${w / 2},${er} 0 0 0 ${x + w},${y + er}`;
+	},
+	cube: (x, y, w, h) => {
+		const d = Math.min(w, h) * .2;
+		return `M${x},${y + d} L${x + d},${y} L${x + w},${y} L${x + w},${y + h - d} L${x + w - d},${y + h} L${x},${y + h} Z M${x},${y + d} L${x + w - d},${y + d} L${x + w},${y} M${x + w - d},${y + d} L${x + w - d},${y + h}`;
+	},
+	bevel: (x, y, w, h) => {
+		const d = Math.min(w, h) * .12;
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z M${x + d},${y + d} L${x + w - d},${y + d} L${x + w - d},${y + h - d} L${x + d},${y + h - d} Z M${x},${y} L${x + d},${y + d} M${x + w},${y} L${x + w - d},${y + d} M${x},${y + h} L${x + d},${y + h - d} M${x + w},${y + h} L${x + w - d},${y + h - d}`;
+	},
+	donut: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		const innerR = r * .65;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r},${cy} A${r},${r} 0 1 0 ${cx + r},${cy} Z M${cx + innerR},${cy} A${innerR},${innerR} 0 1 1 ${cx - innerR},${cy} A${innerR},${innerR} 0 1 1 ${cx + innerR},${cy} Z`;
+	},
+	noSmoking: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const r = Math.min(w, h) / 2;
+		const innerR = r * .78;
+		const t = r * .12;
+		return `M${cx + r},${cy} A${r},${r} 0 1 0 ${cx - r},${cy} A${r},${r} 0 1 0 ${cx + r},${cy} Z M${cx + innerR},${cy} A${innerR},${innerR} 0 1 1 ${cx - innerR},${cy} A${innerR},${innerR} 0 1 1 ${cx + innerR},${cy} Z M${cx - r * .71 - t},${cy - r * .71 + t} L${cx - r * .71 + t},${cy - r * .71 - t} L${cx + r * .71 + t},${cy + r * .71 - t} L${cx + r * .71 - t},${cy + r * .71 + t} Z`;
+	},
+	frame: (x, y, w, h) => {
+		const f = Math.min(w, h) * .1;
+		return `M${x},${y} L${x + w},${y} L${x + w},${y + h} L${x},${y + h} Z M${x + f},${y + f} L${x + f},${y + h - f} L${x + w - f},${y + h - f} L${x + w - f},${y + f} Z`;
+	},
+	halfFrame: (x, y, w, h) => {
+		const f = Math.min(w, h) * .15;
+		return `M${x},${y} L${x + w},${y} L${x + w - f},${y + f} L${x + f},${y + f} L${x + f},${y + h - f} L${x},${y + h} Z`;
+	},
+	corner: (x, y, w, h) => {
+		const tx = w * .4;
+		const ty = h * .4;
+		return `M${x},${y} L${x + tx},${y} L${x + tx},${y + h - ty} L${x + w},${y + h - ty} L${x + w},${y + h} L${x},${y + h} Z`;
+	},
+	diagStripe: (x, y, w, h) => {
+		return `M${x},${y} L${x + w * .6},${y} L${x},${y + h * .6} Z`;
+	},
+	ellipseRibbon: (x, y, w, h) => {
+		const notch = w * .08;
+		const bodyTop = y + h * .2;
+		const bodyBot = y + h * .85;
+		const arcDip = h * .15;
+		return `M${x},${bodyTop} C${x + w * .3},${bodyTop - arcDip} ${x + w * .7},${bodyTop - arcDip} ${x + w},${bodyTop} L${x + w * .85},${bodyTop + (bodyBot - bodyTop) / 2} L${x + w},${bodyBot} L${x + w - notch * 2},${y + h} L${x + w - notch * 4},${bodyBot} C${x + w * .7},${bodyBot + arcDip * .4} ${x + w * .3},${bodyBot + arcDip * .4} L${x + notch * 4},${bodyBot} L${x + notch * 2},${y + h} L${x},${bodyBot} L${x + w * .15},${bodyTop + (bodyBot - bodyTop) / 2} Z`;
+	},
+	ellipseRibbon2: (x, y, w, h) => {
+		const notch = w * .08;
+		const bodyTop = y + h * .15;
+		const bodyBot = y + h * .8;
+		const arcRise = h * .15;
+		return `M${x},${bodyBot} C${x + w * .3},${bodyBot + arcRise} ${x + w * .7},${bodyBot + arcRise} ${x + w},${bodyBot} L${x + w * .85},${bodyTop + (bodyBot - bodyTop) / 2} L${x + w},${bodyTop} L${x + w - notch * 2},${y} L${x + w - notch * 4},${bodyTop} C${x + w * .7},${bodyTop - arcRise * .4} ${x + w * .3},${bodyTop - arcRise * .4} L${x + notch * 4},${bodyTop} L${x + notch * 2},${y} L${x},${bodyTop} L${x + w * .15},${bodyTop + (bodyBot - bodyTop) / 2} Z`;
+	},
+	quadArrow: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const tip = .2;
+		const stem = .15;
+		const headW = .35;
+		return `M${cx},${y} L${cx + headW * w},${y + tip * h} L${cx + stem * w},${y + tip * h} L${cx + stem * w},${cy - stem * h} L${x + w - tip * w},${cy - stem * h} L${x + w - tip * w},${cy - headW * h} L${x + w},${cy} L${x + w - tip * w},${cy + headW * h} L${x + w - tip * w},${cy + stem * h} L${cx + stem * w},${cy + stem * h} L${cx + stem * w},${y + h - tip * h} L${cx + headW * w},${y + h - tip * h} L${cx},${y + h} L${cx - headW * w},${y + h - tip * h} L${cx - stem * w},${y + h - tip * h} L${cx - stem * w},${cy + stem * h} L${x + tip * w},${cy + stem * h} L${x + tip * w},${cy + headW * h} L${x},${cy} L${x + tip * w},${cy - headW * h} L${x + tip * w},${cy - stem * h} L${cx - stem * w},${cy - stem * h} L${cx - stem * w},${y + tip * h} L${cx - headW * w},${y + tip * h} Z`;
+	},
+	leftRightUpArrow: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const tip = .2;
+		const stem = .15;
+		const headW = .35;
+		return `M${cx},${y} L${cx + headW * w},${y + tip * h} L${cx + stem * w},${y + tip * h} L${cx + stem * w},${y + h - tip * h} L${x + w - tip * w},${y + h - tip * h} L${x + w - tip * w},${y + h - headW * h} L${x + w},${y + h} L${x + w - tip * w},${y + h + headW * h} L${x + w - tip * w},${y + h - tip * h} L${cx - stem * w},${y + h - tip * h} L${cx - stem * w},${y + tip * h} L${cx - headW * w},${y + tip * h} Z`;
+	},
+	bentUpArrow: (x, y, w, h) => {
+		const stem = .3;
+		const tip = .25;
+		return `M${x},${y + h * .55} L${x + w * .5},${y + h * .55} L${x + w * .5},${y + tip * h} L${x + w * (.5 - stem * .5)},${y + tip * h} L${x + w * .75},${y} L${x + w},${y + tip * h} L${x + w * .65},${y + tip * h} L${x + w * .65},${y + h * .55 + h * .4} L${x},${y + h * .55 + h * .4} Z`;
+	},
+	curvedLeftArrow: (x, y, w, h) => {
+		return `M${x + w},${y + h * .6} Q${x + w * .5},${y} ${x + w * .15},${y + h * .25} L${x},${y + h * .45} L${x + w * .15},${y + h * .55} L${x + w * .3},${y + h * .35} Q${x + w * .55},${y + h * .18} ${x + w * .85},${y + h * .75} Z`;
+	},
+	curvedUpArrow: (x, y, w, h) => {
+		return `M${x + w * .4},${y + h} Q${x},${y + h * .5} ${x + w * .25},${y + h * .15} L${x + w * .45},${y} L${x + w * .55},${y + h * .15} L${x + w * .35},${y + h * .3} Q${x + w * .18},${y + h * .55} ${x + w * .75},${y + h * .85} Z`;
+	},
+	curvedDownArrow: (x, y, w, h) => {
+		return `M${x + w * .4},${y} Q${x},${y + h * .5} ${x + w * .25},${y + h * .85} L${x + w * .45},${y + h} L${x + w * .55},${y + h * .85} L${x + w * .35},${y + h * .7} Q${x + w * .18},${y + h * .45} ${x + w * .75},${y + h * .15} Z`;
+	},
+	swooshArrow: (x, y, w, h) => {
+		return `M${x},${y + h * .75} C${x + w * .35},${y + h} ${x + w * .65},${y + h * .3} ${x + w * .75},${y + h * .2} L${x + w * .65},${y + h * .05} L${x + w},${y + h * .18} L${x + w * .78},${y + h * .45} L${x + w * .7},${y + h * .3} C${x + w * .55},${y + h * .6} ${x + w * .35},${y + h * .9} ${x},${y + h * .85} Z`;
+	},
+	circularArrow: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const outerR = Math.min(w, h) / 2;
+		const innerR = outerR * .62;
+		const midR = (outerR + innerR) / 2;
+		return `M${cx},${cy - outerR} A${outerR},${outerR} 0 1 1 ${cx - outerR},${cy} L${cx - midR - midR * .25},${cy + outerR * .15} L${cx - midR + midR * .25},${cy + outerR * .3} L${cx - innerR},${cy} A${innerR},${innerR} 0 1 0 ${cx},${cy - innerR} Z`;
+	},
+	leftCircularArrow: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const outerR = Math.min(w, h) / 2;
+		const innerR = outerR * .62;
+		return `M${cx},${cy - outerR} A${outerR},${outerR} 0 1 0 ${cx + outerR},${cy} L${cx + (outerR + innerR) / 2 + (outerR + innerR) / 2 * .25},${cy + outerR * .15} L${cx + (outerR + innerR) / 2 - (outerR + innerR) / 2 * .25},${cy + outerR * .3} L${cx + innerR},${cy} A${innerR},${innerR} 0 1 1 ${cx},${cy - innerR} Z`;
+	},
+	leftRightCircularArrow: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const outerR = Math.min(w, h) / 2;
+		const innerR = outerR * .62;
+		return `M${cx - outerR * .15},${cy - outerR * 1.05} L${cx + outerR * .15},${cy - outerR * 1.05} L${cx + outerR * .1},${cy - outerR * .85} A${outerR},${outerR} 0 1 1 ${cx - outerR * .1},${cy - outerR * .85} Z M${cx},${cy - innerR} A${innerR},${innerR} 0 1 0 ${cx},${cy + innerR}`;
+	},
+	rightArrowCallout: (x, y, w, h) => {
+		const headW = w * .25;
+		return `M${x},${y + h * .3} L${x + w - headW},${y + h * .3} L${x + w - headW},${y} L${x + w},${y + h / 2} L${x + w - headW},${y + h} L${x + w - headW},${y + h * .7} L${x},${y + h * .7} Z`;
+	},
+	leftArrowCallout: (x, y, w, h) => {
+		const headW = w * .25;
+		return `M${x + headW},${y + h * .3} L${x + w},${y + h * .3} L${x + w},${y + h * .7} L${x + headW},${y + h * .7} L${x + headW},${y + h} L${x},${y + h / 2} L${x + headW},${y} Z`;
+	},
+	upArrowCallout: (x, y, w, h) => {
+		const headH = h * .25;
+		return `M${x + w * .3},${y + headH} L${x + w * .3},${y + h} L${x + w * .7},${y + h} L${x + w * .7},${y + headH} L${x + w},${y + headH} L${x + w / 2},${y} L${x},${y + headH} Z`;
+	},
+	downArrowCallout: (x, y, w, h) => {
+		const headH = h * .25;
+		return `M${x + w * .3},${y} L${x + w * .7},${y} L${x + w * .7},${y + h - headH} L${x + w},${y + h - headH} L${x + w / 2},${y + h} L${x},${y + h - headH} L${x + w * .3},${y + h - headH} Z`;
+	},
+	leftRightArrowCallout: (x, y, w, h) => {
+		const headW = w * .2;
+		return `M${x},${y + h / 2} L${x + headW},${y} L${x + headW},${y + h * .3} L${x + w - headW},${y + h * .3} L${x + w - headW},${y} L${x + w},${y + h / 2} L${x + w - headW},${y + h} L${x + w - headW},${y + h * .7} L${x + headW},${y + h * .7} L${x + headW},${y + h} Z`;
+	},
+	upDownArrowCallout: (x, y, w, h) => {
+		const headH = h * .2;
+		return `M${x + w / 2},${y} L${x},${y + headH} L${x + w * .3},${y + headH} L${x + w * .3},${y + h - headH} L${x},${y + h - headH} L${x + w / 2},${y + h} L${x + w},${y + h - headH} L${x + w * .7},${y + h - headH} L${x + w * .7},${y + headH} L${x + w},${y + headH} Z`;
+	},
+	quadArrowCallout: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const tip = .16;
+		const stem = .18;
+		const headW = .32;
+		const txt = .28;
+		return `M${cx - txt * w},${cy - txt * h} L${cx - txt * w},${cy - stem * h} L${cx - stem * w},${cy - stem * h} L${cx - stem * w},${y + tip * h} L${cx - headW * w},${y + tip * h} L${cx},${y} L${cx + headW * w},${y + tip * h} L${cx + stem * w},${y + tip * h} L${cx + stem * w},${cy - stem * h} L${cx + txt * w},${cy - stem * h} L${cx + txt * w},${cy - txt * h} L${x + w - tip * w},${cy - txt * h} L${x + w - tip * w},${cy - headW * h} L${x + w},${cy} L${x + w - tip * w},${cy + headW * h} L${x + w - tip * w},${cy + txt * h} L${cx + txt * w},${cy + txt * h} L${cx + txt * w},${cy + stem * h} L${cx + stem * w},${cy + stem * h} L${cx + stem * w},${y + h - tip * h} L${cx + headW * w},${y + h - tip * h} L${cx},${y + h} L${cx - headW * w},${y + h - tip * h} L${cx - stem * w},${y + h - tip * h} L${cx - stem * w},${cy + stem * h} L${cx - txt * w},${cy + stem * h} L${cx - txt * w},${cy + txt * h} L${x + tip * w},${cy + txt * h} L${x + tip * w},${cy + headW * h} L${x},${cy} L${x + tip * w},${cy - headW * h} L${x + tip * w},${cy - txt * h} Z`;
+	},
+	actionButtonHome: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s},${cy + s * .6} L${cx - s},${cy - s * .1} L${cx},${cy - s * .7} L${cx + s},${cy - s * .1} L${cx + s},${cy + s * .6} L${cx + s * .3},${cy + s * .6} L${cx + s * .3},${cy + s * .1} L${cx - s * .3},${cy + s * .1} L${cx - s * .3},${cy + s * .6} Z`;
+	},
+	actionButtonForwardNext: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s * .7},${cy - s} L${cx + s * .7},${cy} L${cx - s * .7},${cy + s} Z`;
+	},
+	actionButtonBackPrevious: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx + s * .7},${cy - s} L${cx - s * .7},${cy} L${cx + s * .7},${cy + s} Z`;
+	},
+	actionButtonEnd: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s},${cy - s} L${cx + s * .4},${cy} L${cx - s},${cy + s} Z M${cx + s * .5},${cy - s} L${cx + s},${cy - s} L${cx + s},${cy + s} L${cx + s * .5},${cy + s} Z`;
+	},
+	actionButtonBeginning: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx + s},${cy - s} L${cx - s * .4},${cy} L${cx + s},${cy + s} Z M${cx - s * .5},${cy - s} L${cx - s},${cy - s} L${cx - s},${cy + s} L${cx - s * .5},${cy + s} Z`;
+	},
+	actionButtonReturn: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .28;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx + s},${cy - s} L${cx + s * .4},${cy - s} L${cx + s * .4},${cy + s * .2} L${cx - s * .2},${cy + s * .2} L${cx - s * .2},${cy - s * .2} L${cx - s},${cy + s * .2} L${cx - s * .2},${cy + s} L${cx - s * .2},${cy + s * .5} L${cx + s},${cy + s * .5} Z`;
+	},
+	actionButtonHelp: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s * .4},${cy - s * .4} Q${cx - s * .4},${cy - s} ${cx},${cy - s} Q${cx + s * .4},${cy - s} ${cx + s * .4},${cy - s * .4} Q${cx + s * .4},${cy} ${cx},${cy} L${cx},${cy + s * .4} M${cx - s * .18},${cy + s * .8} L${cx + s * .18},${cy + s * .8} L${cx + s * .18},${cy + s} L${cx - s * .18},${cy + s} Z`;
+	},
+	actionButtonInformation: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s * .2},${cy - s * .7} L${cx + s * .2},${cy - s * .7} L${cx + s * .2},${cy - s * .35} L${cx - s * .2},${cy - s * .35} Z M${cx - s * .2},${cy - s * .1} L${cx + s * .2},${cy - s * .1} L${cx + s * .2},${cy + s} L${cx - s * .2},${cy + s} Z`;
+	},
+	actionButtonDocument: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s * .6},${cy - s} L${cx + s * .3},${cy - s} L${cx + s * .6},${cy - s * .7} L${cx + s * .6},${cy + s} L${cx - s * .6},${cy + s} Z M${cx + s * .3},${cy - s} L${cx + s * .3},${cy - s * .7} L${cx + s * .6},${cy - s * .7}`;
+	},
+	actionButtonSound: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		return `${PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""} M${cx - s},${cy - s * .4} L${cx - s * .3},${cy - s * .4} L${cx + s * .3},${cy - s} L${cx + s * .3},${cy + s} L${cx - s * .3},${cy + s * .4} L${cx - s},${cy + s * .4} Z M${cx + s * .55},${cy - s * .4} Q${cx + s * .95},${cy} ${cx + s * .55},${cy + s * .4}`;
+	},
+	actionButtonMovie: (x, y, w, h) => {
+		const cx = x + w / 2;
+		const cy = y + h / 2;
+		const s = Math.min(w, h) * .3;
+		const out = [PRESET_PATHS.actionButtonBlank?.(x, y, w, h) ?? ""];
+		out.push(`M${cx - s},${cy - s * .6} L${cx + s},${cy - s * .6} L${cx + s},${cy + s * .6} L${cx - s},${cy + s * .6} Z`);
+		for (let i = 0; i < 4; i++) {
+			const px0 = cx - s + (i + .5) * (s * 2 / 4);
+			out.push(`M${px0 - s * .08},${cy - s * .45} L${px0 + s * .08},${cy - s * .45} L${px0 + s * .08},${cy - s * .3} L${px0 - s * .08},${cy - s * .3} Z`);
+			out.push(`M${px0 - s * .08},${cy + s * .3} L${px0 + s * .08},${cy + s * .3} L${px0 + s * .08},${cy + s * .45} L${px0 - s * .08},${cy + s * .45} Z`);
+		}
+		return out.join(" ");
+	},
+	borderCallout1: (x, y, w, h) => {
+		return `M${x},${y} L${x + w * .6},${y} L${x + w * .6},${y + h * .5} L${x},${y + h * .5} Z M${x + w * .6},${y + h * .5} L${x + w},${y + h}`;
+	},
+	borderCallout2: (x, y, w, h) => {
+		return `M${x},${y} L${x + w * .6},${y} L${x + w * .6},${y + h * .5} L${x},${y + h * .5} Z M${x + w * .6},${y + h * .5} L${x + w * .85},${y + h * .75} L${x + w},${y + h}`;
+	},
+	borderCallout3: (x, y, w, h) => {
+		return `M${x},${y} L${x + w * .6},${y} L${x + w * .6},${y + h * .5} L${x},${y + h * .5} Z M${x + w * .6},${y + h * .5} L${x + w * .75},${y + h * .65} L${x + w * .9},${y + h * .65} L${x + w},${y + h}`;
+	},
+	accentCallout1: (x, y, w, h) => {
+		return `M${x},${y} L${x + w * .6},${y} L${x + w * .6},${y + h * .5} L${x},${y + h * .5} Z M${x + w * .58},${y} L${x + w * .58},${y + h * .5} M${x + w * .6},${y + h * .5} L${x + w},${y + h}`;
+	},
+	accentBorderCallout1: (x, y, w, h) => {
+		return PRESET_PATHS.accentCallout1?.(x, y, w, h) ?? "";
+	},
+	callout1: (x, y, w, h) => {
+		return `M${x},${y + h * .5} L${x + w},${y + h}`;
+	},
+	callout2: (x, y, w, h) => {
+		return `M${x},${y + h * .5} L${x + w * .6},${y + h * .7} L${x + w},${y + h}`;
+	},
+	callout3: (x, y, w, h) => {
+		return `M${x},${y + h * .5} L${x + w * .4},${y + h * .55} L${x + w * .7},${y + h * .8} L${x + w},${y + h}`;
+	},
+	straightConnector1: (x, y, w, h) => `M${x},${y} L${x + w},${y + h}`,
+	bentConnector2: (x, y, w, h) => `M${x},${y} L${x + w},${y} L${x + w},${y + h}`,
+	bentConnector3: (x, y, w, h) => `M${x},${y} L${x + w / 2},${y} L${x + w / 2},${y + h} L${x + w},${y + h}`,
+	bentConnector4: (x, y, w, h) => `M${x},${y} L${x + w * .33},${y} L${x + w * .33},${y + h * .5} L${x + w * .66},${y + h * .5} L${x + w * .66},${y + h} L${x + w},${y + h}`,
+	bentConnector5: (x, y, w, h) => `M${x},${y} L${x + w * .25},${y} L${x + w * .25},${y + h * .5} L${x + w * .75},${y + h * .5} L${x + w * .75},${y + h} L${x + w},${y + h}`,
+	curvedConnector2: (x, y, w, h) => `M${x},${y} Q${x + w},${y} ${x + w},${y + h}`,
+	curvedConnector3: (x, y, w, h) => `M${x},${y} C${x + w * .5},${y} ${x + w * .5},${y + h} ${x + w},${y + h}`,
+	curvedConnector4: (x, y, w, h) => `M${x},${y} C${x + w * .33},${y} ${x + w * .33},${y + h * .5} ${x + w * .5},${y + h * .5} C${x + w * .66},${y + h * .5} ${x + w * .66},${y + h} ${x + w},${y + h}`,
+	curvedConnector5: (x, y, w, h) => `M${x},${y} C${x + w * .25},${y} ${x + w * .25},${y + h * .25} ${x + w * .5},${y + h * .5} C${x + w * .75},${y + h * .75} ${x + w * .75},${y + h} ${x + w},${y + h}`
+};
+const ALIGNMENT_TO_CSS = {
+	left: "left",
+	center: "center",
+	right: "right",
+	justify: "justify"
+};
+const ANCHOR_TO_CSS = {
+	top: "flex-start",
+	center: "center",
+	bottom: "flex-end"
+};
+const placeholderDefaultPt = (phType) => {
+	if (phType === "title" || phType === "ctrTitle") return DEFAULT_TITLE_PT;
+	if (phType === "subTitle") return 32;
+	if (phType === "ftr" || phType === "dt" || phType === "sldNum") return 12;
+	return DEFAULT_BODY_PT;
+};
+const bulletChar = (level) => level <= 0 ? "•" : level === 1 ? "◦" : "▪";
+const bulletAutoNumType = (style) => {
+	if (style === "number") return "arabicPeriod";
+	if (style !== null && typeof style === "object" && "autoNum" in style) return style.autoNum ?? null;
+	return null;
+};
+const toRoman = (n) => {
+	if (n <= 0) return String(n);
+	const map = [
+		[1e3, "M"],
+		[900, "CM"],
+		[500, "D"],
+		[400, "CD"],
+		[100, "C"],
+		[90, "XC"],
+		[50, "L"],
+		[40, "XL"],
+		[10, "X"],
+		[9, "IX"],
+		[5, "V"],
+		[4, "IV"],
+		[1, "I"]
+	];
+	let out = "";
+	let r = n;
+	for (const [v, s] of map) while (r >= v) {
+		out += s;
+		r -= v;
+	}
+	return out;
+};
+const toAlpha = (n) => {
+	if (n <= 0) return String(n);
+	let r = n;
+	let out = "";
+	while (r > 0) {
+		r -= 1;
+		out = String.fromCharCode(65 + r % 26) + out;
+		r = Math.floor(r / 26);
+	}
+	return out;
+};
+const formatAutoNum = (token, n) => {
+	const arabic = String(n);
+	switch (token) {
+		case "arabicPlain": return arabic;
+		case "arabicPeriod": return `${arabic}.`;
+		case "arabicParenR": return `${arabic})`;
+		case "arabicParenBoth": return `(${arabic})`;
+		case "romanUcPeriod": return `${toRoman(n)}.`;
+		case "romanLcPeriod": return `${toRoman(n).toLowerCase()}.`;
+		case "romanUcParenR": return `${toRoman(n)})`;
+		case "romanLcParenR": return `${toRoman(n).toLowerCase()})`;
+		case "romanUcParenBoth": return `(${toRoman(n)})`;
+		case "romanLcParenBoth": return `(${toRoman(n).toLowerCase()})`;
+		case "alphaUcPeriod": return `${toAlpha(n)}.`;
+		case "alphaLcPeriod": return `${toAlpha(n).toLowerCase()}.`;
+		case "alphaUcParenR": return `${toAlpha(n)})`;
+		case "alphaLcParenR": return `${toAlpha(n).toLowerCase()})`;
+		case "alphaUcParenBoth": return `(${toAlpha(n)})`;
+		case "alphaLcParenBoth": return `(${toAlpha(n).toLowerCase()})`;
+		default: return `${arabic}.`;
+	}
+};
+const renderRun = (text, format, theme, effectivePt, _wasDefault = false) => {
+	if (text === "") return "";
+	const styles = [];
+	styles.push(`font-size:${(effectivePt * PX_PER_PT).toFixed(2)}px`);
+	styles.push(`line-height:1.05`);
+	if (format?.font) styles.push(`font-family:${escapeXml(format.font)}, ${DEFAULT_FONT}`);
+	if (format?.bold) styles.push("font-weight:700");
+	if (format?.italic) styles.push("font-style:italic");
+	const underline = format?.underline;
+	const strike = format?.strike;
+	const hasUnderline = underline !== void 0 && underline !== false && underline !== "none";
+	const hasStrike = strike !== void 0 && strike !== false && strike !== "noStrike";
+	if (hasUnderline && hasStrike) styles.push("text-decoration:underline line-through");
+	else if (hasUnderline) styles.push("text-decoration:underline");
+	else if (hasStrike) styles.push("text-decoration:line-through");
+	if (format?.color !== void 0 && format.color !== null) styles.push(`color:${resolveColor(format.color, theme, "#000000")}`);
+	if (format?.spc !== void 0 && format.spc !== 0) {
+		const trackingPx = format.spc / 100 * PX_PER_PT;
+		styles.push(`letter-spacing:${trackingPx.toFixed(3)}px`);
+	}
+	if (format?.baseline !== void 0 && format.baseline !== 0) {
+		const direction = format.baseline > 0 ? "super" : "sub";
+		styles.push(`vertical-align:${direction}`);
+		styles.push("font-size:0.65em");
+	}
+	if (format?.cap === "all") styles.push("text-transform:uppercase");
+	else if (format?.cap === "small") styles.push("font-variant:small-caps");
+	if (format?.highlight !== void 0 && format.highlight !== null) styles.push(`background-color:${resolveColor(format.highlight, theme, "#FFFF00")}`);
+	const html = text.split("\n").map((part) => escapeXml(part)).join("<br/>");
+	return `<span style="${styles.join(";")}">${html}</span>`;
+};
+const LINE_HEIGHT = 1.05;
+const AVG_GLYPH_W_RATIO = .55;
+const hasUnderlineFmt = (fmt) => {
+	const u = fmt?.underline;
+	return u !== void 0 && u !== false && u !== "none";
+};
+const hasStrikeFmt = (fmt) => {
+	const s = fmt?.strike;
+	return s !== void 0 && s !== false && s !== "noStrike";
+};
+const alignOf = (a) => a === "center" || a === "right" || a === "justify" ? a : "left";
+const verticalLayoutOf = (vert) => {
+	switch (vert) {
+		case "vert":
+		case "eaVert":
+		case "wordArtVert":
+		case "wordArtVertRtl": return "cw90";
+		case "vert270":
+		case "mongolianVert": return "cw270";
+		case null: return "none";
+	}
+};
+const buildAndLayoutSvgText = (a) => {
+	const scale = a.autoFitScale;
+	const paragraphs = a.paraData.map((para, pi) => {
+		const pieces = [];
+		for (const run of para.runs) {
+			if (run.text === "\n" && run.fmt === null) {
+				pieces.push(breakPiece());
+				continue;
+			}
+			let fmt = run.fmt;
+			if (run.href) {
+				const hlinkColor = a.theme ? normalizeHex(a.theme.hyperlink) : "#0563C1";
+				fmt = {
+					...fmt,
+					color: fmt?.color ?? hlinkColor,
+					underline: fmt?.underline ?? true
+				};
+			}
+			const family = substituteFamily(fmt?.font ?? a.themeFace);
+			const sizePx = run.sizePt * scale * PX_PER_PT;
+			const fillHex = fmt?.color !== void 0 && fmt.color !== null ? resolveColor(fmt.color, a.theme, "#000000") : a.defaultColor;
+			const superSub = fmt?.baseline !== void 0 && fmt.baseline !== 0 ? fmt.baseline > 0 ? 1 : -1 : 0;
+			const letterSpacingPx = fmt?.spc !== void 0 && fmt.spc !== 0 ? fmt.spc / 100 * PX_PER_PT : 0;
+			const caps = fmt?.cap === "all" || fmt?.cap === "small";
+			const base = {
+				family,
+				sizePx,
+				bold: fmt?.bold ?? false,
+				italic: fmt?.italic ?? false,
+				letterSpacingPx,
+				fillHex,
+				underline: hasUnderlineFmt(fmt),
+				strike: hasStrikeFmt(fmt),
+				superSub,
+				href: run.href ?? null
+			};
+			const segs = run.text.split("\n");
+			segs.forEach((seg, i) => {
+				pieces.push({
+					...base,
+					text: caps ? seg.toUpperCase() : seg,
+					isBreak: false
+				});
+				if (i < segs.length - 1) pieces.push(breakPiece());
+			});
+		}
+		const marLpx = para.indent.leftEmu !== null ? para.indent.leftEmu / EMU_PER_PX * scale : para.level > 0 ? para.level * 24 * PX_PER_PT * scale : 0;
+		const marRpx = para.indent.rightEmu !== null ? para.indent.rightEmu / EMU_PER_PX * scale : 0;
+		const firstIndentPx = para.indent.firstLineEmu !== null ? para.indent.firstLineEmu / EMU_PER_PX * scale : 0;
+		const spcBefPx = para.spcBefPts !== null && para.spcBefPts > 0 ? para.spcBefPts * PX_PER_PT * scale : 0;
+		const spcAftPx = para.spcAftPts !== null && para.spcAftPts > 0 ? para.spcAftPts * PX_PER_PT * scale : 0;
+		const lineSpacing = para.lineSpacing?.kind === "pct" ? {
+			kind: "pct",
+			value: para.lineSpacing.value
+		} : para.lineSpacing?.kind === "pts" ? {
+			kind: "pts",
+			px: para.lineSpacing.value * PX_PER_PT * scale
+		} : null;
+		return {
+			align: alignOf(para.align),
+			marLpx,
+			marRpx,
+			firstIndentPx,
+			spcBefPx,
+			spcAftPx,
+			lineSpacing,
+			lineAdvanceScale: a.lineHeightScale,
+			bullet: buildBullet(a, para, pi),
+			pieces,
+			fallbackSizePx: a.defaultPt * scale * PX_PER_PT
+		};
+	});
+	return layoutTextSvg({
+		boxXpx: a.innerX / EMU_PER_PX,
+		boxYpx: a.innerY / EMU_PER_PX,
+		boxWpx: a.innerW / EMU_PER_PX,
+		boxHpx: a.innerH / EMU_PER_PX,
+		anchor: a.anchor,
+		wrap: a.wrap,
+		paragraphs,
+		vert: a.vert,
+		columns: a.columns
+	}, a.measure);
+};
+const breakPiece = () => ({
+	text: "",
+	family: "",
+	sizePx: 0,
+	bold: false,
+	italic: false,
+	letterSpacingPx: 0,
+	fillHex: "#000000",
+	underline: false,
+	strike: false,
+	superSub: 0,
+	href: null,
+	isBreak: true
+});
+const buildBullet = (a, para, pi) => {
+	const explicitChar = para.bulletStyle !== null && typeof para.bulletStyle === "object" && "char" in para.bulletStyle ? para.bulletStyle.char : null;
+	const numberLabel = a.numberLabels[pi] ?? null;
+	if (!(para.bulletStyle === "bullet" || explicitChar !== null || numberLabel !== null || para.bulletIsPicture || para.bulletStyle !== "none" && para.level > 0)) return null;
+	const char = para.bulletIsPicture ? "■" : numberLabel ?? explicitChar ?? bulletChar(para.level);
+	const baseSizePx = a.defaultPt * PX_PER_PT * a.autoFitScale;
+	const sizePx = para.bulletDetail.sizePct !== null ? baseSizePx * para.bulletDetail.sizePct : para.bulletDetail.sizePts !== null ? para.bulletDetail.sizePts * PX_PER_PT * a.autoFitScale : baseSizePx;
+	const fillHex = para.bulletDetail.color ? resolveColor(para.bulletDetail.color, a.theme, "#000000") : a.defaultColor;
+	return {
+		text: char,
+		family: substituteFamily(para.bulletDetail.font ?? a.themeFace),
+		sizePx,
+		fillHex,
+		...para.bulletImageHref ? { imageHref: para.bulletImageHref } : {}
+	};
+};
+const renderTextBody = (pres, shape, bounds, theme, phType, ctx) => {
+	let paragraphCount;
+	try {
+		paragraphCount = getShapeParagraphCount(shape);
+	} catch {
+		return "";
+	}
+	if (paragraphCount === 0) return "";
+	const defaultPt = placeholderDefaultPt(phType);
+	const themeFonts = getPresentationFonts(pres);
+	const themeFace = phType === "title" || phType === "ctrTitle" ? themeFonts?.majorLatin ?? null : themeFonts?.minorLatin ?? null;
+	const effectiveDefaultFont = themeFace ? `${escapeXml(themeFace)}, ${DEFAULT_FONT}` : DEFAULT_FONT;
+	let effectiveBody;
+	try {
+		effectiveBody = getShapeBodyPrEffective(pres, shape);
+	} catch {
+		effectiveBody = {
+			anchor: getShapeTextAnchor(shape),
+			wrap: null,
+			vert: getShapeTextDirection(shape),
+			margins: getShapeTextMargins(shape) ?? {
+				left: null,
+				top: null,
+				right: null,
+				bottom: null
+			}
+		};
+	}
+	const isAutoshape = !isShapePlaceholder(shape) && !isShapeTextBox(shape);
+	const defaultAlign = isAutoshape ? "center" : "left";
+	const defaultAnchor = isAutoshape ? "center" : "top";
+	const anchor = effectiveBody.anchor ?? defaultAnchor;
+	const margins = effectiveBody.margins;
+	const lIns = margins.left ?? DEFAULT_INSET_X;
+	const tIns = margins.top ?? DEFAULT_INSET_Y;
+	const rIns = margins.right ?? DEFAULT_INSET_X;
+	const bIns = margins.bottom ?? DEFAULT_INSET_Y;
+	const innerX = bounds.x + lIns;
+	const innerY = bounds.y + tIns;
+	const innerW = Math.max(0, bounds.w - lIns - rIns);
+	const innerH = Math.max(0, bounds.h - tIns - bIns);
+	if (innerW <= 0 || innerH <= 0) return "";
+	const paraData = [];
+	let hasAnyText = false;
+	for (let p = 0; p < paragraphCount; p++) {
+		let effective;
+		try {
+			effective = getParagraphPropertiesEffective(pres, shape, p);
+		} catch {
+			effective = {
+				align: getParagraphAlignment(shape, p),
+				level: getParagraphLevel(shape, p),
+				marL: null,
+				marR: null,
+				indent: null,
+				lineSpacing: null,
+				spcBefPts: null,
+				spcAftPts: null,
+				rtl: null,
+				bullet: null
+			};
+		}
+		const align = effective.align ?? defaultAlign;
+		const level = effective.level;
+		const bulletStyle = getParagraphBullet(shape, p) ?? effective.bullet;
+		let bulletDetail = {
+			color: null,
+			sizePct: null,
+			sizePts: null,
+			font: null
+		};
+		try {
+			bulletDetail = getParagraphBulletStyle(pres, shape, p);
+		} catch {}
+		let bulletIsPicture = false;
+		try {
+			bulletIsPicture = isParagraphBulletPicture(shape, p);
+		} catch {}
+		let bulletImageHref = null;
+		if (bulletIsPicture) try {
+			const bytes = getParagraphBulletImageBytes(shape, p);
+			if (bytes) bulletImageHref = bytesToDataUrl(bytes);
+		} catch {}
+		const lineSpacing = effective.lineSpacing;
+		let spcBefPts = effective.spcBefPts;
+		let spcAftPts = effective.spcAftPts;
+		const indent = {
+			leftEmu: effective.marL,
+			rightEmu: effective.marR,
+			firstLineEmu: effective.indent
+		};
+		try {
+			const spacing = getParagraphSpacing(shape, p);
+			if (spacing.beforePts !== null) spcBefPts = spacing.beforePts;
+			if (spacing.afterPts !== null) spcAftPts = spacing.afterPts;
+		} catch {}
+		try {
+			const lit = getParagraphIndent(shape, p);
+			if (lit.leftEmu !== null) indent.leftEmu = lit.leftEmu;
+			if (lit.rightEmu !== null) indent.rightEmu = lit.rightEmu;
+			if (lit.firstLineEmu !== null) indent.firstLineEmu = lit.firstLineEmu;
+		} catch {}
+		const runs = [];
+		let elements = [];
+		try {
+			elements = getShapeParagraphElements(shape, p);
+		} catch {
+			elements = [];
+		}
+		let rIdx = 0;
+		for (const el of elements) {
+			if (el.kind === "br") {
+				runs.push({
+					text: "\n",
+					fmt: null,
+					sizePt: defaultPt
+				});
+				continue;
+			}
+			const txt = el.text;
+			let fmt = el.format;
+			let href;
+			let hrefTip;
+			if (el.kind === "r") {
+				try {
+					fmt = getShapeRunFormatEffective(pres, shape, p, rIdx);
+				} catch {
+					fmt = getShapeRunFormat(shape, p, rIdx);
+				}
+				try {
+					href = getShapeRunHyperlink(shape, p, rIdx) ?? void 0;
+					if (!href) {
+						const act = getShapeRunClickAction(shape, p, rIdx);
+						if (act?.kind === "slide") {
+							const idx = getSlideIndex(pres, act.slide);
+							if (idx >= 0) href = `#slide-${idx + 1}`;
+						} else if (act?.kind === "url") href = act.url;
+					}
+					if (href) hrefTip = getShapeRunHyperlinkTooltip(shape, p, rIdx) ?? void 0;
+				} catch {
+					href = void 0;
+				}
+				rIdx++;
+			}
+			const sizePt = fmt?.size ?? defaultPt;
+			if (txt) hasAnyText = true;
+			runs.push({
+				text: txt,
+				fmt,
+				sizePt,
+				...href !== void 0 ? { href } : {},
+				...hrefTip !== void 0 ? { hrefTip } : {}
+			});
+		}
+		paraData.push({
+			align,
+			level,
+			bulletStyle,
+			bulletDetail,
+			bulletIsPicture,
+			bulletImageHref,
+			runs,
+			lineSpacing,
+			spcBefPts,
+			spcAftPts,
+			indent
+		});
+	}
+	if (!hasAnyText) return "";
+	const authoredAutofit = getShapeTextAutoFitParams(shape);
+	let autoFitScale = authoredAutofit?.fontScale ?? 1;
+	let lineHeightScale = 1 - (authoredAutofit?.lnSpcReduction ?? 0);
+	if (!authoredAutofit) {
+		const innerWPx = innerW / EMU_PER_PX;
+		const innerHPx = innerH / EMU_PER_PX;
+		let totalH = 0;
+		for (const para of paraData) {
+			let maxSize = defaultPt;
+			let totalChars = 0;
+			let cjkChars = 0;
+			for (const run of para.runs) {
+				if (run.sizePt > maxSize) maxSize = run.sizePt;
+				totalChars += run.text.length;
+				for (let i = 0; i < run.text.length; i++) {
+					const c = run.text.charCodeAt(i);
+					if (c >= 12352 && c <= 12447 || c >= 12448 && c <= 12543 || c >= 19968 && c <= 40959 || c >= 44032 && c <= 55215) cjkChars++;
+				}
+			}
+			if (totalChars === 0) totalChars = 1;
+			const cjkRatio = cjkChars / totalChars;
+			const glyphRatio = cjkRatio * 1 + (1 - cjkRatio) * AVG_GLYPH_W_RATIO;
+			const sizePx = maxSize * PX_PER_PT;
+			const charsPerLine = Math.max(1, Math.floor(innerWPx / Math.max(1, sizePx * glyphRatio)));
+			const lineCount = Math.max(1, Math.ceil(totalChars / charsPerLine));
+			totalH += sizePx * LINE_HEIGHT * lineCount;
+		}
+		if (totalH > innerHPx) autoFitScale = Math.max(.4, innerHPx / totalH);
+	}
+	LINE_HEIGHT * lineHeightScale;
+	const numberLabels = Array.from({ length: paraData.length }, () => null);
+	{
+		let counter = 0;
+		let activeLevel = -1;
+		let activeType = null;
+		for (let i = 0; i < paraData.length; i++) {
+			const para = paraData[i];
+			const num = bulletAutoNumType(para.bulletStyle);
+			if (num === null) {
+				counter = 0;
+				activeLevel = -1;
+				activeType = null;
+				continue;
+			}
+			if (para.level !== activeLevel || num !== activeType) {
+				counter = 1;
+				activeLevel = para.level;
+				activeType = num;
+			} else counter += 1;
+			numberLabels[i] = formatAutoNum(num, counter);
+		}
+	}
+	const paragraphs = [];
+	for (let pi = 0; pi < paraData.length; pi++) {
+		const para = paraData[pi];
+		const runHtmls = para.runs.map((run) => {
+			let runFmt = run.fmt;
+			if (run.href) {
+				const hlinkColor = theme ? normalizeHex(theme.hyperlink) : "#0563C1";
+				runFmt = {
+					...runFmt,
+					color: runFmt?.color ?? hlinkColor,
+					underline: runFmt?.underline ?? true
+				};
+			}
+			const span = renderRun(run.text, runFmt, theme, run.sizePt * autoFitScale, run.fmt?.size === void 0);
+			if (!run.href) return span;
+			const targetAttrs = run.href.startsWith("#") ? "" : " target=\"_blank\" rel=\"noopener noreferrer\"";
+			const titleAttr = run.hrefTip ? ` title="${escapeXml(run.hrefTip)}"` : "";
+			return `<a href="${escapeXml(run.href)}"${targetAttrs}${titleAttr} style="color:inherit;text-decoration:inherit">${span}</a>`;
+		});
+		let lineHeightCss = "";
+		if (para.lineSpacing?.kind === "pct") lineHeightCss = `line-height:${para.lineSpacing.value.toFixed(3)}`;
+		else if (para.lineSpacing?.kind === "pts") lineHeightCss = `line-height:${(para.lineSpacing.value * PX_PER_PT * autoFitScale).toFixed(2)}px`;
+		const marginTopCss = para.spcBefPts !== null && para.spcBefPts > 0 ? `margin-top:${(para.spcBefPts * PX_PER_PT * autoFitScale).toFixed(2)}px` : "";
+		const marginBottomCss = para.spcAftPts !== null && para.spcAftPts > 0 ? `margin-bottom:${(para.spcAftPts * PX_PER_PT * autoFitScale).toFixed(2)}px` : "";
+		const leftPx = para.indent.leftEmu !== null ? para.indent.leftEmu / EMU_PER_PX * autoFitScale : para.level > 0 ? para.level * 24 * PX_PER_PT * autoFitScale : 0;
+		const rightPx = para.indent.rightEmu !== null ? para.indent.rightEmu / EMU_PER_PX * autoFitScale : 0;
+		const firstLinePx = para.indent.firstLineEmu !== null ? para.indent.firstLineEmu / EMU_PER_PX * autoFitScale : 0;
+		const pStyles = [
+			marginTopCss || (marginBottomCss ? "" : "margin:0"),
+			marginBottomCss,
+			"padding:0",
+			`text-align:${ALIGNMENT_TO_CSS[para.align] ?? "left"}`,
+			lineHeightCss,
+			leftPx > 0 ? `padding-left:${leftPx.toFixed(2)}px` : "",
+			rightPx > 0 ? `padding-right:${rightPx.toFixed(2)}px` : "",
+			firstLinePx !== 0 ? `text-indent:${firstLinePx.toFixed(2)}px` : ""
+		].filter(Boolean);
+		let prefix = "";
+		const explicitChar = para.bulletStyle !== null && typeof para.bulletStyle === "object" && "char" in para.bulletStyle ? para.bulletStyle.char : null;
+		const numberLabel = numberLabels[pi];
+		const showBullet = para.bulletStyle === "bullet" || explicitChar !== null || numberLabel !== null || para.bulletIsPicture || para.bulletStyle !== "none" && para.level > 0;
+		if (showBullet && para.bulletImageHref) {
+			const baseBulletPx = defaultPt * PX_PER_PT * autoFitScale;
+			const bulletPx = para.bulletDetail.sizePct !== null ? baseBulletPx * para.bulletDetail.sizePct : para.bulletDetail.sizePts !== null ? para.bulletDetail.sizePts * PX_PER_PT * autoFitScale : baseBulletPx;
+			const imgStyles = [
+				`width:${bulletPx.toFixed(2)}px`,
+				`height:${bulletPx.toFixed(2)}px`,
+				"display:inline-block",
+				"vertical-align:baseline",
+				`margin-right:${(.4 * defaultPt * PX_PER_PT * autoFitScale).toFixed(2)}px`
+			];
+			prefix = `<img src="${para.bulletImageHref}" alt="" style="${imgStyles.join(";")}"/>`;
+		} else if (showBullet) {
+			const char = para.bulletIsPicture ? "■" : numberLabel ?? explicitChar ?? bulletChar(para.level);
+			const bulletStyles = [`margin-right:${(.4 * defaultPt * PX_PER_PT * autoFitScale).toFixed(2)}px`];
+			if (para.bulletDetail.color) bulletStyles.push(`color:${resolveColor(para.bulletDetail.color, theme, "#000000")}`);
+			if (para.bulletDetail.sizePct !== null) bulletStyles.push(`font-size:${(para.bulletDetail.sizePct * 100).toFixed(1)}%`);
+			else if (para.bulletDetail.sizePts !== null) bulletStyles.push(`font-size:${(para.bulletDetail.sizePts * PX_PER_PT * autoFitScale).toFixed(2)}px`);
+			if (para.bulletDetail.font) bulletStyles.push(`font-family:${escapeXml(para.bulletDetail.font)}, ${DEFAULT_FONT}`);
+			prefix = `<span style="${bulletStyles.join(";")}">${escapeXml(char)}</span>`;
+		}
+		paragraphs.push(`<p style="${pStyles.join(";")}">${prefix}${runHtmls.join("") || "&#8203;"}</p>`);
+	}
+	const justify = ANCHOR_TO_CSS[anchor] ?? "flex-start";
+	const defaultColor = activeDeckTextColor;
+	if (ctx.mode === "svg") {
+		const svgScale = authoredAutofit?.fontScale ?? 1;
+		const svgLineScale = 1 - (authoredAutofit?.lnSpcReduction ?? 0);
+		const svgVert = verticalLayoutOf(effectiveBody.vert ?? getShapeTextDirection(shape));
+		const svgCols = getShapeTextColumns(shape);
+		const svgColumns = svgVert === "none" && svgCols && svgCols.count >= 2 ? {
+			count: svgCols.count,
+			gapPx: svgCols.gapEmu !== void 0 ? svgCols.gapEmu / EMU_PER_PX : 12
+		} : null;
+		const svgInner = buildAndLayoutSvgText({
+			pres,
+			shape,
+			theme,
+			paraData,
+			numberLabels,
+			autoFitScale: svgScale,
+			lineHeightScale: svgLineScale,
+			defaultPt,
+			themeFace,
+			defaultColor,
+			anchor: anchor === "center" || anchor === "bottom" ? anchor : "top",
+			wrap: effectiveBody.wrap !== "none",
+			innerX,
+			innerY,
+			innerW,
+			innerH,
+			measure: ctx.measure,
+			vert: svgVert,
+			columns: svgColumns
+		});
+		const bodyRotDegSvg = getShapeTextBodyRotationDeg(shape);
+		if (bodyRotDegSvg !== null && bodyRotDegSvg !== 0) {
+			const pivotX = innerX + innerW / 2;
+			const pivotY = innerY + innerH / 2;
+			return `<g transform="rotate(${bodyRotDegSvg} ${E(pivotX)} ${E(pivotY)})">${svgInner}</g>`;
+		}
+		return svgInner;
+	}
+	const vert = effectiveBody.vert ?? getShapeTextDirection(shape);
+	let writingMode = "";
+	let extraTransform = "";
+	if (vert === "vert" || vert === "eaVert") writingMode = "writing-mode:vertical-rl";
+	else if (vert === "vert270" || vert === "mongolianVert") {
+		writingMode = "writing-mode:vertical-lr";
+		if (vert === "vert270") extraTransform = ";transform:rotate(180deg)";
+	} else if (vert === "wordArtVert") writingMode = "writing-mode:vertical-rl;text-orientation:upright";
+	else if (vert === "wordArtVertRtl") writingMode = "writing-mode:vertical-rl;text-orientation:upright;direction:rtl";
+	const cols = getShapeTextColumns(shape);
+	let colStyles = "";
+	if (cols && cols.count >= 2) {
+		const gapPx = cols.gapEmu !== void 0 ? (cols.gapEmu / EMU_PER_PX).toFixed(2) : "12";
+		colStyles = `;column-count:${cols.count};column-gap:${gapPx}px`;
+	}
+	const vertStyles = (writingMode ? `;${writingMode}${extraTransform}` : "") + colStyles;
+	const body = `<div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;flex-direction:column;justify-content:${justify};width:100%;height:100%;box-sizing:border-box;overflow:visible;font-family:${effectiveDefaultFont};color:${defaultColor};${effectiveBody.wrap === "none" ? "white-space:nowrap" : "word-break:break-word"}${vertStyles}">${paragraphs.join("")}</div>`;
+	const foreign = `<foreignObject x="${E(innerX)}" y="${E(innerY)}" width="${E(innerW)}" height="${E(innerH)}" overflow="visible">${body}</foreignObject>`;
+	const bodyRotDeg = getShapeTextBodyRotationDeg(shape);
+	if (bodyRotDeg !== null && bodyRotDeg !== 0) {
+		const pivotX = innerX + innerW / 2;
+		const pivotY = innerY + innerH / 2;
+		return `<g transform="rotate(${bodyRotDeg} ${E(pivotX)} ${E(pivotY)})">${foreign}</g>`;
+	}
+	return foreign;
+};
+const E = (n) => (n / EMU_PER_PX).toFixed(2);
+const px = (n) => n.toFixed(2);
+const accentSequence = (theme) => {
+	const fallbacks = [
+		"#5B9BD5",
+		"#ED7D31",
+		"#A5A5A5",
+		"#FFC000",
+		"#4472C4",
+		"#70AD47"
+	];
+	if (!theme) return fallbacks;
+	const hexes = [
+		theme.accent1,
+		theme.accent2,
+		theme.accent3,
+		theme.accent4,
+		theme.accent5,
+		theme.accent6
+	].map((c) => normalizeHex(c)).filter((c) => /^#[0-9A-Fa-f]{6}$/.test(c));
+	return hexes.length > 0 ? hexes : fallbacks;
+};
+const layoutChart = (xEmu, yEmu, wEmu, hEmu, hasTitle, hasAxes, titleOverlay = false, legendOverlay = false, hasLegend = true) => {
+	const x = xEmu / EMU_PER_PX;
+	const y = yEmu / EMU_PER_PX;
+	const w = wEmu / EMU_PER_PX;
+	const h = hEmu / EMU_PER_PX;
+	const titleStrip = hasTitle && !titleOverlay ? 18 : 0;
+	const legendStrip = hasLegend && !legendOverlay ? 18 : 0;
+	const padding = 8;
+	const yAxisGutter = hasAxes ? 40 : 0;
+	const xAxisGutter = hasAxes ? 18 : 0;
+	return {
+		x,
+		y,
+		w,
+		h,
+		plotX: x + padding + yAxisGutter,
+		plotY: y + titleStrip + padding,
+		plotW: Math.max(0, w - 2 * padding - yAxisGutter),
+		plotH: Math.max(0, h - titleStrip - legendStrip - xAxisGutter - 2 * padding),
+		titleY: y + (titleOverlay ? 14 : titleStrip - 2),
+		legendY: y + h - (legendOverlay ? 18 : legendStrip / 2)
+	};
+};
+const niceStep = (range, target = 5) => {
+	if (range <= 0) return 1;
+	const rawStep = range / target;
+	const base = Math.pow(10, Math.floor(Math.log10(rawStep)));
+	const m = rawStep / base;
+	return (m < 1.5 ? 1 : m < 3 ? 2 : m < 7 ? 5 : 10) * base;
+};
+const niceTicks = (min, max, target = 5) => {
+	const range = max - min;
+	if (range <= 0) return [min];
+	const step = niceStep(range, target);
+	const start = Math.ceil(min / step) * step;
+	const ticks = [];
+	for (let v = start; v <= max + step / 2; v += step) ticks.push(v);
+	return ticks;
+};
+const formatTick = (v) => {
+	if (v === 0) return "0";
+	const abs = Math.abs(v);
+	if (abs >= 1e9) return `${(v / 1e9).toFixed(1)}B`;
+	if (abs >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
+	if (abs >= 1e4) return `${(v / 1e3).toFixed(0)}K`;
+	if (abs >= 1e3) return `${(v / 1e3).toFixed(1)}K`;
+	if (Number.isInteger(v)) return v.toString();
+	return v.toFixed(abs < 1 ? 2 : 1);
+};
+const formatAxisLabel = (v, formatCode) => {
+	if (!formatCode) return formatTick(v);
+	let prefix = "";
+	let suffix = "";
+	let body = formatCode;
+	const leadMatch = /^"((?:\\.|[^"\\])*)"/.exec(body);
+	if (leadMatch) {
+		prefix = leadMatch[1].replace(/\\(.)/g, "$1");
+		body = body.slice(leadMatch[0].length);
+	} else if (body.startsWith("$") || body.startsWith("¥") || /^[£€]/.test(body)) {
+		prefix = body[0];
+		body = body.slice(1);
+	}
+	const tailMatch = /"((?:\\.|[^"\\])*)"$/.exec(body);
+	if (tailMatch) {
+		suffix = tailMatch[1].replace(/\\(.)/g, "$1");
+		body = body.slice(0, body.length - tailMatch[0].length);
+	}
+	if (body.includes("%")) {
+		const decMatch = /0\.(0+)%/.exec(body);
+		const dec = decMatch ? decMatch[1].length : 0;
+		return prefix + `${(v * 100).toFixed(dec)}%` + suffix;
+	}
+	if (body.includes("#,##") || /\.(0+)/.test(body) || /^0+$/.test(body)) return prefix + formatWithGrouping(v, body) + suffix;
+	return prefix + formatTick(v) + suffix;
+};
+const formatWithGrouping = (v, fmt) => {
+	const decMatch = /\.(0+)/.exec(fmt);
+	const dec = decMatch ? decMatch[1].length : 0;
+	const [intPart, fracPart] = Math.abs(v).toFixed(dec).split(".");
+	const grouped = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+	return (v < 0 ? "-" : "") + grouped + (fracPart ? `.${fracPart}` : "");
+};
+const DISPLAY_UNIT_DIVISOR = {
+	hundreds: 100,
+	thousands: 1e3,
+	tenThousands: 1e4,
+	hundredThousands: 1e5,
+	millions: 1e6,
+	tenMillions: 1e7,
+	hundredMillions: 1e8,
+	billions: 1e9,
+	trillions: 0xe8d4a51000
+};
+const DISPLAY_UNIT_LABEL = {
+	hundreds: "Hundreds",
+	thousands: "Thousands",
+	tenThousands: "Ten Thousands",
+	hundredThousands: "Hundred Thousands",
+	millions: "Millions",
+	tenMillions: "Ten Millions",
+	hundredMillions: "Hundred Millions",
+	billions: "Billions",
+	trillions: "Trillions"
+};
+const DEFAULT_AXIS_COLOR = "#000000";
+const DEFAULT_GRID_COLOR = "#D9D9D9";
+const AXIS_TICK_LEN = 5;
+const axisTickAttrs = (style) => {
+	const sz = style?.sizePt ?? 10;
+	const fill = style?.color ?? "#6B7280";
+	const weight = style?.bold ? " font-weight=\"600\"" : "";
+	const italic = style?.italic ? " font-style=\"italic\"" : "";
+	return `font-family="sans-serif" font-size="${sz.toFixed(1)}" fill="${fill}"${weight}${italic}`;
+};
+const renderValueAxis = (f, axis) => {
+	const ticks = axis.majorUnit ? (() => {
+		const out = [];
+		const start = Math.ceil(axis.min / axis.majorUnit) * axis.majorUnit;
+		for (let t = start; t <= axis.max + 1e-9; t += axis.majorUnit) out.push(t);
+		return out.length > 0 ? out : niceTicks(axis.min, axis.max);
+	})() : niceTicks(axis.min, axis.max);
+	const out = [];
+	const range = axis.max - axis.min || 1;
+	const fmtTick = (t) => axis.percent ? `${Math.round(t * 100)}%` : formatAxisLabel(axis.displayUnits ? t / DISPLAY_UNIT_DIVISOR[axis.displayUnits] : t, axis.numberFormat);
+	const showGrid = axis.majorGridlines ?? false;
+	const gridStroke = axis.majorGridlineColor ?? DEFAULT_GRID_COLOR;
+	const axisColor = axis.lineColor ?? DEFAULT_AXIS_COLOR;
+	const tickMark = axis.majorTickMark ?? "out";
+	const tickLen = AXIS_TICK_LEN;
+	for (const t of ticks) if (axis.orientation === "vertical") {
+		const yp = f.plotY + f.plotH - (t - axis.min) / range * f.plotH;
+		if (showGrid) out.push(`<line x1="${px(f.plotX)}" y1="${px(yp)}" x2="${px(f.plotX + f.plotW)}" y2="${px(yp)}" stroke="${gridStroke}" stroke-width="0.5"/>`);
+		if (tickMark !== "none") {
+			const tx1 = tickMark === "in" ? f.plotX : f.plotX - tickLen;
+			const tx2 = tickMark === "out" ? f.plotX : tickMark === "cross" ? f.plotX + tickLen : f.plotX + tickLen;
+			out.push(`<line x1="${px(tx1)}" y1="${px(yp)}" x2="${px(tx2)}" y2="${px(yp)}" stroke="${axisColor}" stroke-width="1"/>`);
+		}
+		const labelX = f.plotX - 4;
+		const rot = axis.labelRotationDeg ?? 0;
+		const transform = rot ? ` transform="rotate(${rot} ${px(labelX)} ${px(yp)})"` : "";
+		out.push(`<text x="${px(labelX)}" y="${px(yp)}" text-anchor="end" dominant-baseline="middle" ${axisTickAttrs(axis.labelStyle)}${transform}>${escapeXml(fmtTick(t))}</text>`);
+	} else {
+		const xp = f.plotX + (t - axis.min) / range * f.plotW;
+		if (showGrid) out.push(`<line x1="${px(xp)}" y1="${px(f.plotY)}" x2="${px(xp)}" y2="${px(f.plotY + f.plotH)}" stroke="${gridStroke}" stroke-width="0.5"/>`);
+		if (tickMark !== "none") {
+			const baseY = f.plotY + f.plotH;
+			const ty1 = tickMark === "in" ? baseY : baseY + tickLen;
+			const ty2 = tickMark === "out" ? baseY : tickMark === "cross" ? baseY - tickLen : baseY - tickLen;
+			out.push(`<line x1="${px(xp)}" y1="${px(ty1)}" x2="${px(xp)}" y2="${px(ty2)}" stroke="${axisColor}" stroke-width="1"/>`);
+		}
+		const horizLabelY = f.plotY + f.plotH + 12;
+		const rotH = axis.labelRotationDeg ?? 0;
+		const transformH = rotH ? ` transform="rotate(${rotH} ${px(xp)} ${px(horizLabelY)})"` : "";
+		out.push(`<text x="${px(xp)}" y="${px(horizLabelY)}" text-anchor="middle" dominant-baseline="middle" ${axisTickAttrs(axis.labelStyle)}${transformH}>${escapeXml(fmtTick(t))}</text>`);
+	}
+	if (axis.displayUnits) {
+		const lbl = DISPLAY_UNIT_LABEL[axis.displayUnits];
+		if (axis.orientation === "vertical") {
+			const lblX = f.plotX - 26;
+			const lblY = f.plotY + f.plotH / 2;
+			out.push(`<text x="${px(lblX)}" y="${px(lblY)}" text-anchor="middle" font-family="sans-serif" font-size="9" fill="#6B7280" font-style="italic" transform="rotate(-90 ${px(lblX)} ${px(lblY)})">${escapeXml(lbl)}</text>`);
+		} else out.push(`<text x="${px(f.plotX + f.plotW)}" y="${px(f.plotY + f.plotH + 22)}" text-anchor="end" font-family="sans-serif" font-size="9" fill="#6B7280" font-style="italic">${escapeXml(lbl)}</text>`);
+	}
+	if (axis.orientation === "vertical") out.push(`<line x1="${px(f.plotX)}" y1="${px(f.plotY)}" x2="${px(f.plotX)}" y2="${px(f.plotY + f.plotH)}" stroke="${axisColor}" stroke-width="1"/>`);
+	else {
+		const zeroY = f.plotY + f.plotH - (0 - axis.min) / range * f.plotH;
+		const spineY = axis.min <= 0 && axis.max >= 0 ? zeroY : f.plotY + f.plotH;
+		out.push(`<line x1="${px(f.plotX)}" y1="${px(spineY)}" x2="${px(f.plotX + f.plotW)}" y2="${px(spineY)}" stroke="${axisColor}" stroke-width="1"/>`);
+	}
+	return out.join("");
+};
+const renderCategoryAxis = (f, orientation, cats, pointCount, skip = 1, labelStyle, labelRotationDeg, labelAlign, lineColor) => {
+	const labels = [];
+	for (let i = 0; i < pointCount; i++) labels.push(cats[i] ?? (i + 1).toString());
+	const out = [];
+	if (orientation === "horizontal") {
+		const step = pointCount > 1 ? f.plotW / pointCount : 0;
+		const truncLen = labelRotationDeg && Math.abs(labelRotationDeg) >= 30 ? 28 : 14;
+		for (let i = 0; i < pointCount; i++) {
+			if (skip > 1 && i % skip !== 0) continue;
+			const cx = f.plotX + (i + .5) * step;
+			const cy = f.plotY + f.plotH + 12;
+			const truncated = labels[i] !== void 0 && labels[i].length > truncLen ? `${labels[i].slice(0, truncLen - 2)}…` : labels[i] ?? "";
+			const transform = labelRotationDeg && labelRotationDeg !== 0 ? ` transform="rotate(${labelRotationDeg} ${px(cx)} ${px(cy)})"` : "";
+			const anchor = labelAlign === "l" ? "start" : labelAlign === "r" ? "end" : labelAlign === "ctr" ? "middle" : labelRotationDeg && labelRotationDeg > 0 ? "end" : labelRotationDeg && labelRotationDeg < 0 ? "start" : "middle";
+			out.push(`<text x="${px(cx)}" y="${px(cy)}" text-anchor="${anchor}" dominant-baseline="middle" ${axisTickAttrs(labelStyle)}${transform}>${escapeXml(truncated)}</text>`);
+		}
+	} else {
+		const step = pointCount > 0 ? f.plotH / pointCount : 0;
+		const truncLen = labelRotationDeg && Math.abs(labelRotationDeg) >= 30 ? 28 : 14;
+		for (let i = 0; i < pointCount; i++) {
+			if (skip > 1 && i % skip !== 0) continue;
+			const cy = f.plotY + (pointCount - 1 - i + .5) * step;
+			const lx = f.plotX - 4;
+			const truncated = labels[i] !== void 0 && labels[i].length > truncLen ? `${labels[i].slice(0, truncLen - 2)}…` : labels[i] ?? "";
+			const transform = labelRotationDeg && labelRotationDeg !== 0 ? ` transform="rotate(${labelRotationDeg} ${px(lx)} ${px(cy)})"` : "";
+			out.push(`<text x="${px(lx)}" y="${px(cy)}" text-anchor="end" dominant-baseline="middle" ${axisTickAttrs(labelStyle)}${transform}>${escapeXml(truncated)}</text>`);
+		}
+	}
+	const axisColor = lineColor ?? DEFAULT_AXIS_COLOR;
+	if (orientation === "horizontal") {
+		const baseY = f.plotY + f.plotH;
+		out.push(`<line x1="${px(f.plotX)}" y1="${px(baseY)}" x2="${px(f.plotX + f.plotW)}" y2="${px(baseY)}" stroke="${axisColor}" stroke-width="1"/>`);
+		const stepB = pointCount > 0 ? f.plotW / pointCount : 0;
+		for (let i = 0; i <= pointCount; i++) {
+			const bx = f.plotX + i * stepB;
+			out.push(`<line x1="${px(bx)}" y1="${px(baseY)}" x2="${px(bx)}" y2="${px(baseY + AXIS_TICK_LEN)}" stroke="${axisColor}" stroke-width="1"/>`);
+		}
+	} else {
+		out.push(`<line x1="${px(f.plotX)}" y1="${px(f.plotY)}" x2="${px(f.plotX)}" y2="${px(f.plotY + f.plotH)}" stroke="${axisColor}" stroke-width="1"/>`);
+		const stepB = pointCount > 0 ? f.plotH / pointCount : 0;
+		for (let i = 0; i <= pointCount; i++) {
+			const by = f.plotY + i * stepB;
+			out.push(`<line x1="${px(f.plotX - AXIS_TICK_LEN)}" y1="${px(by)}" x2="${px(f.plotX)}" y2="${px(by)}" stroke="${axisColor}" stroke-width="1"/>`);
+		}
+	}
+	return out.join("");
+};
+const seriesMinMax = (spec) => {
+	const isStacked = spec.grouping === "stacked" || spec.grouping === "percentStacked";
+	const isPercent = spec.grouping === "percentStacked";
+	let min = Infinity;
+	let max = -Infinity;
+	if (isPercent) {
+		min = 0;
+		max = 1;
+	} else if (isStacked) {
+		const N = spec.series.reduce((n, s) => Math.max(n, s.values.length), 0);
+		for (let c = 0; c < N; c++) {
+			let pos = 0;
+			let neg = 0;
+			for (const s of spec.series) {
+				const v = s.values[c];
+				if (v !== null && v !== void 0 && Number.isFinite(v)) if (v >= 0) pos += v;
+				else neg += v;
+			}
+			if (pos > max) max = pos;
+			if (neg < min) min = neg;
+		}
+	} else for (const s of spec.series) for (const v of s.values) if (v !== null && Number.isFinite(v)) {
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	if (!Number.isFinite(min)) min = 0;
+	if (!Number.isFinite(max)) max = 1;
+	if (max === min) max = min + 1;
+	if (min > 0) min = 0;
+	if (isPercent) return {
+		min: 0,
+		max: 1,
+		step: .2
+	};
+	const step = niceStep(max - min);
+	max = (Math.floor(max / step) + 1) * step;
+	if (spec.valueAxis?.min !== void 0) min = spec.valueAxis.min;
+	if (spec.valueAxis?.max !== void 0) max = spec.valueAxis.max;
+	if (max === min) max = min + 1;
+	return {
+		min,
+		max,
+		step
+	};
+};
+const renderChartTitle = (f, title, style) => {
+	if (!title) return "";
+	const sz = style?.sizePt ?? 13;
+	const fill = style?.color ?? "#1F2937";
+	const weight = style?.bold === false ? "400" : "600";
+	const fontStyleAttr = style?.italic ? " font-style=\"italic\"" : "";
+	return `<text x="${px(f.x + f.w / 2)}" y="${px(f.titleY)}" text-anchor="middle" dominant-baseline="middle" font-family="sans-serif" font-size="${sz.toFixed(1)}" fill="${fill}" font-weight="${weight}"${fontStyleAttr}>${escapeXml(title)}</text>`;
+};
+const renderChartLegend = (f, names, colors, position = "b", textStyle, markerSymbols) => {
+	if (names.length === 0) return "";
+	const sz = textStyle?.sizePt ?? 11;
+	const fill = textStyle?.color ?? "#374151";
+	const weight = textStyle?.bold ? " font-weight=\"600\"" : "";
+	const italic = textStyle?.italic ? " font-style=\"italic\"" : "";
+	const textAttrs = `font-family="sans-serif" font-size="${sz.toFixed(1)}" fill="${fill}"${weight}${italic}`;
+	const swatch = (i, swatchX, swatchY) => {
+		const color = colors[i % colors.length];
+		const sym = markerSymbols?.[i];
+		if (markerSymbols !== void 0 && sym !== "none") {
+			const r = 4.5;
+			return seriesMarker(autoMarkerSymbol(sym, i), swatchX + r, swatchY + r, r, color);
+		}
+		return `<rect x="${px(swatchX)}" y="${px(swatchY)}" width="9" height="9" fill="${color}"/>`;
+	};
+	const out = [];
+	if (position === "b") {
+		const itemPx = Math.min(140, f.w / names.length);
+		const totalW = itemPx * names.length;
+		const startX = f.x + (f.w - totalW) / 2;
+		for (let i = 0; i < names.length; i++) {
+			const swatchX = startX + i * itemPx + 4;
+			const swatchY = f.legendY - 4;
+			const labelX = swatchX + 14;
+			out.push(swatch(i, swatchX, swatchY), `<text x="${px(labelX)}" y="${px(f.legendY)}" dominant-baseline="middle" ${textAttrs}>${escapeXml(names[i] ?? `Series ${i + 1}`)}</text>`);
+		}
+		return out.join("");
+	}
+	if (position === "t") {
+		const itemPx = Math.min(140, f.w / names.length);
+		const totalW = itemPx * names.length;
+		const startX = f.x + (f.w - totalW) / 2;
+		const yTop = f.y + 4;
+		for (let i = 0; i < names.length; i++) {
+			const cx = startX + i * itemPx;
+			out.push(swatch(i, cx + 4, yTop), `<text x="${px(cx + 18)}" y="${px(yTop + 8)}" dominant-baseline="middle" ${textAttrs}>${escapeXml(names[i] ?? `Series ${i + 1}`)}</text>`);
+		}
+		return out.join("");
+	}
+	const lineH = 14;
+	const totalH = names.length * lineH;
+	const yStart = position === "tr" ? f.y + 12 : Math.max(f.y + 12, f.y + (f.h - totalH) / 2);
+	const xCol = position === "l" ? f.x + 6 : position === "tr" ? f.x + f.w - 100 : f.x + f.w - 100;
+	for (let i = 0; i < names.length; i++) {
+		const yp = yStart + i * lineH;
+		out.push(swatch(i, xCol, yp - 4), `<text x="${px(xCol + 14)}" y="${px(yp + 4)}" dominant-baseline="middle" ${textAttrs}>${escapeXml(names[i] ?? `Series ${i + 1}`)}</text>`);
+	}
+	return out.join("");
+};
+const pointCount = (spec) => {
+	if (spec.categories.length > 0) return spec.categories.length;
+	let n = 0;
+	for (const s of spec.series) if (s.values.length > n) n = s.values.length;
+	return n;
+};
+const renderColumnChart = (f, spec, colors) => {
+	const N = pointCount(spec);
+	if (N === 0 || spec.series.length === 0) return "";
+	const grouping = spec.grouping ?? "clustered";
+	const isStacked = grouping === "stacked" || grouping === "percentStacked";
+	const isPercent = grouping === "percentStacked";
+	const { min, max } = seriesMinMax(spec);
+	const range = max - min || 1;
+	const groupW = f.plotW / N;
+	const gapPctC = (spec.gapWidthPct ?? 150) / 100;
+	const overlapPctC = (spec.overlapPct ?? (isStacked ? 100 : 0)) / 100;
+	const Sc = spec.series.length;
+	const clusterUnitsC = isStacked ? 1 : 1 + (Sc - 1) * (1 - overlapPctC);
+	const barW = groupW / Math.max(.5, clusterUnitsC + gapPctC);
+	const baseY = f.plotY + f.plotH - (0 - min) / range * f.plotH;
+	const showLabelFor = (s) => spec.series[s]?.dataLabels?.showValue ?? spec.dataLabels?.showValue ?? false;
+	const out = [];
+	for (let c = 0; c < N; c++) if (isStacked) {
+		let total = 0;
+		if (isPercent) for (const s of spec.series) total += Math.max(0, s.values[c] ?? 0);
+		let posAcc = 0;
+		let negAcc = 0;
+		for (let s = 0; s < spec.series.length; s++) {
+			let v = spec.series[s]?.values[c] ?? 0;
+			if (isPercent) {
+				if (total === 0) continue;
+				v = Math.max(0, v) / total;
+			}
+			const base = v >= 0 ? posAcc : negAcc;
+			const stackedTop = base + v;
+			const stackedBase = base;
+			const x0 = f.plotX + c * groupW + (groupW - barW) / 2;
+			const y0 = f.plotY + f.plotH - (Math.max(stackedTop, stackedBase) - min) / range * f.plotH;
+			const y1 = f.plotY + f.plotH - (Math.min(stackedTop, stackedBase) - min) / range * f.plotH;
+			const h = Math.abs(y1 - y0);
+			out.push(`<rect x="${px(x0)}" y="${px(y0)}" width="${px(barW)}" height="${px(h)}" fill="${spec.series[s]?.color ?? colors[s % colors.length]}"/>`);
+			if (showLabelFor(s) && Math.abs(v) > 0) {
+				const labelY = (y0 + y1) / 2 + 3;
+				const labelText = isPercent ? `${Math.round(v * 100)}%` : formatDataLabelValue(spec, s, v);
+				out.push(`<text x="${px(x0 + barW / 2)}" y="${px(labelY)}" text-anchor="middle" font-family="sans-serif" font-size="9" fill="#FFFFFF" font-weight="600">${labelText}</text>`);
+			}
+			if (v >= 0) posAcc = stackedTop;
+			else negAcc = stackedTop;
+		}
+	} else {
+		const clusterW = barW * clusterUnitsC;
+		const clusterStartX = f.plotX + c * groupW + (groupW - clusterW) / 2;
+		const stride = barW * (1 - overlapPctC);
+		for (let s = 0; s < spec.series.length; s++) {
+			const v = spec.series[s]?.values[c] ?? 0;
+			const x0 = clusterStartX + s * stride;
+			const top = f.plotY + f.plotH - (v - min) / range * f.plotH;
+			const y0 = Math.min(top, baseY);
+			const h = Math.abs(top - baseY);
+			const baseColor = spec.varyColors && spec.series.length === 1 ? colors[c % colors.length] : spec.series[s]?.color ?? colors[s % colors.length];
+			const fillColor = v < 0 && spec.series[s]?.invertIfNegative ? mixHex(baseColor, "#000000", .55) : baseColor;
+			out.push(`<rect x="${px(x0)}" y="${px(y0)}" width="${px(barW)}" height="${px(h)}" fill="${fillColor}"/>`);
+			if (showLabelFor(s)) {
+				const pos = spec.series[s]?.dataLabels?.position ?? spec.dataLabels?.position;
+				let labelY;
+				let fill = "#374151";
+				if (pos === "ctr") {
+					labelY = y0 + h / 2 + 3;
+					fill = "#FFFFFF";
+				} else if (pos === "inEnd") {
+					labelY = v >= 0 ? y0 + 9 : y0 + h - 3;
+					fill = "#FFFFFF";
+				} else if (pos === "inBase") {
+					labelY = v >= 0 ? y0 + h - 3 : y0 + 9;
+					fill = "#FFFFFF";
+				} else labelY = v >= 0 ? y0 - 2 : y0 + h + 9;
+				out.push(`<text x="${px(x0 + barW / 2)}" y="${px(labelY)}" text-anchor="middle" ${dataLabelTextAttrs(spec, s, fill)}>${formatDataLabelValue(spec, s, v)}</text>`);
+			}
+		}
+	}
+	out.push(`<line x1="${px(f.plotX)}" y1="${px(baseY)}" x2="${px(f.plotX + f.plotW)}" y2="${px(baseY)}" stroke="#9CA3AF" stroke-width="0.5"/>`);
+	for (let s = 0; s < spec.series.length; s++) {
+		const series = spec.series[s];
+		if (!series?.trendline) continue;
+		const tlColor = series.trendline.color ?? series.color ?? colors[s % colors.length];
+		const xs = [];
+		const ys = [];
+		const seriesValues = series.values.slice(0, N);
+		for (let c = 0; c < N; c++) {
+			const v = seriesValues[c];
+			if (v === null || v === void 0 || !Number.isFinite(v)) continue;
+			const cx = f.plotX + (c + .5) * groupW;
+			const cy = f.plotY + f.plotH - (v - min) / range * f.plotH;
+			xs.push(cx);
+			ys.push(cy);
+		}
+		if (xs.length < 2) continue;
+		out.push(trendlinePath(xs, ys, series.trendline, tlColor));
+	}
+	return out.join("");
+};
+const trendlinePath = (xs, ys, tl, color) => {
+	const n = xs.length;
+	const stepX = n >= 2 ? (xs[n - 1] - xs[0]) / (n - 1) : 0;
+	const extendBefore = (tl.backward ?? 0) * stepX;
+	const extendAfter = (tl.forward ?? 0) * stepX;
+	let pts = [];
+	switch (tl.type) {
+		case "movingAvg": {
+			const period = Math.max(2, Math.min(n, tl.period ?? 3));
+			for (let i = period - 1; i < n; i++) {
+				let sum = 0;
+				for (let j = 0; j < period; j++) sum += ys[i - j];
+				pts.push([xs[i], sum / period]);
+			}
+			break;
+		}
+		case "log": {
+			const ix = xs.map((_, i) => i + 1);
+			const sumLn = ix.reduce((a, x) => a + Math.log(x), 0);
+			const sumY = ys.reduce((a, y) => a + y, 0);
+			const sumLnY = ix.reduce((a, x, i) => a + Math.log(x) * ys[i], 0);
+			const sumLn2 = ix.reduce((a, x) => a + Math.log(x) ** 2, 0);
+			const b = (n * sumLnY - sumLn * sumY) / (n * sumLn2 - sumLn ** 2 || 1);
+			const a = (sumY - b * sumLn) / n;
+			pts = xs.map((x, i) => [x, a + b * Math.log(i + 1)]);
+			break;
+		}
+		case "exp":
+			if (ys.every((y) => y > 0)) {
+				const ix = xs.map((_, i) => i);
+				const lnY = ys.map((y) => Math.log(y));
+				const meanX = ix.reduce((a, b) => a + b, 0) / n;
+				const meanLnY = lnY.reduce((a, b) => a + b, 0) / n;
+				let num = 0;
+				let den = 0;
+				for (let i = 0; i < n; i++) {
+					num += (ix[i] - meanX) * (lnY[i] - meanLnY);
+					den += (ix[i] - meanX) ** 2;
+				}
+				const b = den === 0 ? 0 : num / den;
+				const a = Math.exp(meanLnY - b * meanX);
+				pts = xs.map((x, i) => [x, a * Math.exp(b * i)]);
+			}
+			if (pts.length === 0) pts = linearFit(xs, ys, extendBefore, extendAfter);
+			break;
+		default: pts = linearFit(xs, ys, extendBefore, extendAfter);
+	}
+	if (pts.length < 2) return "";
+	const path = `<path d="${pts.map(([x, y], i) => `${i === 0 ? "M" : "L"}${px(x)},${px(y)}`).join(" ")}" fill="none" stroke="${color}" stroke-width="1.5" stroke-dasharray="6 3" stroke-linecap="round"/>`;
+	if (tl.name !== void 0 && tl.name.length > 0) {
+		const [lx, ly] = pts[pts.length - 1];
+		return path + `<text x="${px(lx + 4)}" y="${px(ly)}" dominant-baseline="middle" font-family="sans-serif" font-size="9" fill="${color}">${escapeXml(tl.name)}</text>`;
+	}
+	return path;
+};
+const linearFit = (xs, ys, extendBefore = 0, extendAfter = 0) => {
+	const n = xs.length;
+	const meanX = xs.reduce((a, b) => a + b, 0) / n;
+	const meanY = ys.reduce((a, b) => a + b, 0) / n;
+	let num = 0;
+	let den = 0;
+	for (let i = 0; i < n; i++) {
+		num += (xs[i] - meanX) * (ys[i] - meanY);
+		den += (xs[i] - meanX) ** 2;
+	}
+	const slope = den === 0 ? 0 : num / den;
+	const intercept = meanY - slope * meanX;
+	const xStart = xs[0] - extendBefore;
+	const xEnd = xs[n - 1] + extendAfter;
+	return [[xStart, intercept + slope * xStart], [xEnd, intercept + slope * xEnd]];
+};
+const smoothPath = (pts) => {
+	if (pts.length < 2) return "";
+	const tension = .5;
+	const parts = [];
+	const [x0, y0] = pts[0];
+	parts.push(`M${px(x0)},${px(y0)}`);
+	for (let i = 0; i < pts.length - 1; i++) {
+		const [,] = pts[i];
+		const p0 = pts[i - 1] ?? pts[i];
+		const p1 = pts[i];
+		const p2 = pts[i + 1];
+		const p3 = pts[i + 2] ?? p2;
+		const cp1x = p1[0] + (p2[0] - p0[0]) * tension / 3;
+		const cp1y = p1[1] + (p2[1] - p0[1]) * tension / 3;
+		const cp2x = p2[0] - (p3[0] - p1[0]) * tension / 3;
+		const cp2y = p2[1] - (p3[1] - p1[1]) * tension / 3;
+		parts.push(`C${px(cp1x)},${px(cp1y)} ${px(cp2x)},${px(cp2y)} ${px(p2[0])},${px(p2[1])}`);
+	}
+	return parts.join(" ");
+};
+const AUTO_MARKER_SYMBOLS = [
+	"diamond",
+	"square",
+	"triangle",
+	"x",
+	"star",
+	"dot",
+	"plus",
+	"dash"
+];
+const autoMarkerSymbol = (symbol, seriesIdx) => symbol !== void 0 && symbol !== "auto" ? symbol : AUTO_MARKER_SYMBOLS[seriesIdx % AUTO_MARKER_SYMBOLS.length];
+const seriesMarker = (symbol, cx, cy, r, color) => {
+	switch (symbol) {
+		case "square": return `<rect x="${px(cx - r)}" y="${px(cy - r)}" width="${px(r * 2)}" height="${px(r * 2)}" fill="${color}"/>`;
+		case "diamond": return `<polygon points="${px(cx)},${px(cy - r)} ${px(cx + r)},${px(cy)} ${px(cx)},${px(cy + r)} ${px(cx - r)},${px(cy)}" fill="${color}"/>`;
+		case "triangle": return `<polygon points="${px(cx)},${px(cy - r)} ${px(cx + r)},${px(cy + r)} ${px(cx - r)},${px(cy + r)}" fill="${color}"/>`;
+		case "star": return `<polygon points="${(() => {
+			const pts = [];
+			for (let i = 0; i < 10; i++) {
+				const ang = -Math.PI / 2 + i * Math.PI / 5;
+				const rr = i % 2 === 0 ? r : r * .45;
+				pts.push(`${px(cx + rr * Math.cos(ang))},${px(cy + rr * Math.sin(ang))}`);
+			}
+			return pts.join(" ");
+		})()}" fill="${color}"/>`;
+		case "x": return `<g stroke="${color}" stroke-width="1.2" stroke-linecap="round"><line x1="${px(cx - r)}" y1="${px(cy - r)}" x2="${px(cx + r)}" y2="${px(cy + r)}"/><line x1="${px(cx - r)}" y1="${px(cy + r)}" x2="${px(cx + r)}" y2="${px(cy - r)}"/></g>`;
+		case "plus": return `<g stroke="${color}" stroke-width="1.2" stroke-linecap="round"><line x1="${px(cx - r)}" y1="${px(cy)}" x2="${px(cx + r)}" y2="${px(cy)}"/><line x1="${px(cx)}" y1="${px(cy - r)}" x2="${px(cx)}" y2="${px(cy + r)}"/></g>`;
+		case "dash": return `<line x1="${px(cx - r)}" y1="${px(cy)}" x2="${px(cx + r)}" y2="${px(cy)}" stroke="${color}" stroke-width="${Math.max(1.5, r * .6).toFixed(2)}" stroke-linecap="round"/>`;
+		case "dot": return `<circle cx="${px(cx)}" cy="${px(cy)}" r="${(r * .6).toFixed(2)}" fill="${color}"/>`;
+		default: return `<circle cx="${px(cx)}" cy="${px(cy)}" r="${px(r)}" fill="${color}"/>`;
+	}
+};
+const formatChartValue = (v) => {
+	if (!Number.isFinite(v)) return "";
+	if (Number.isInteger(v)) return String(v);
+	const abs = Math.abs(v);
+	if (abs >= 1e3) return Math.round(v).toString();
+	if (abs >= 10) return v.toFixed(1);
+	return v.toFixed(2).replace(/\.?0+$/, "");
+};
+const formatDataLabelValue = (spec, seriesIdx, v) => {
+	const nf = spec.series[seriesIdx]?.dataLabels?.numberFormat ?? spec.dataLabels?.numberFormat;
+	return nf ? formatAxisLabel(v, nf) : formatChartValue(v);
+};
+const dataLabelTextAttrs = (spec, seriesIdx, fallbackFill, fallbackSizePt = 9, fallbackBold = false) => {
+	const style = spec.series[seriesIdx]?.dataLabels?.textStyle ?? spec.dataLabels?.textStyle;
+	const sz = style?.sizePt ?? fallbackSizePt;
+	const fill = style?.color ?? fallbackFill;
+	const weight = style?.bold ?? fallbackBold ? " font-weight=\"600\"" : "";
+	const italic = style?.italic ? " font-style=\"italic\"" : "";
+	return `font-family="sans-serif" font-size="${sz.toFixed(1)}" fill="${fill}"${weight}${italic}`;
+};
+const renderBarChart = (f, spec, colors) => {
+	const N = pointCount(spec);
+	if (N === 0 || spec.series.length === 0) return "";
+	const grouping = spec.grouping ?? "clustered";
+	const isStacked = grouping === "stacked" || grouping === "percentStacked";
+	const isPercent = grouping === "percentStacked";
+	const { min, max } = seriesMinMax(spec);
+	const range = max - min || 1;
+	const groupH = f.plotH / N;
+	const gapPctB = (spec.gapWidthPct ?? 150) / 100;
+	const overlapPctB = (spec.overlapPct ?? (isStacked ? 100 : 0)) / 100;
+	const Sb = spec.series.length;
+	const clusterUnitsB = isStacked ? 1 : 1 + (Sb - 1) * (1 - overlapPctB);
+	const barH = groupH / Math.max(.5, clusterUnitsB + gapPctB);
+	const baseX = f.plotX + (0 - min) / range * f.plotW;
+	const showLabelForBar = (s) => spec.series[s]?.dataLabels?.showValue ?? spec.dataLabels?.showValue ?? false;
+	const out = [];
+	for (let c = 0; c < N; c++) if (isStacked) {
+		let total = 0;
+		if (isPercent) for (const s of spec.series) total += Math.max(0, s.values[c] ?? 0);
+		let posAcc = 0;
+		let negAcc = 0;
+		for (let s = 0; s < spec.series.length; s++) {
+			let v = spec.series[s]?.values[c] ?? 0;
+			if (isPercent) {
+				if (total === 0) continue;
+				v = Math.max(0, v) / total;
+			}
+			const base = v >= 0 ? posAcc : negAcc;
+			const stackedTop = base + v;
+			const y0 = f.plotY + (N - 1 - c) * groupH + (groupH - barH) / 2;
+			const x0 = f.plotX + (Math.min(base, stackedTop) - min) / range * f.plotW;
+			const x1 = f.plotX + (Math.max(base, stackedTop) - min) / range * f.plotW;
+			const w = Math.abs(x1 - x0);
+			out.push(`<rect x="${px(x0)}" y="${px(y0)}" width="${px(w)}" height="${px(barH)}" fill="${spec.series[s]?.color ?? colors[s % colors.length]}"/>`);
+			if (showLabelForBar(s) && Math.abs(v) > 0) {
+				const labelX = (x0 + x1) / 2;
+				const labelText = isPercent ? `${Math.round(v * 100)}%` : formatDataLabelValue(spec, s, v);
+				out.push(`<text x="${px(labelX)}" y="${px(y0 + barH / 2 + 3)}" text-anchor="middle" font-family="sans-serif" font-size="9" fill="#FFFFFF" font-weight="600">${labelText}</text>`);
+			}
+			if (v >= 0) posAcc = stackedTop;
+			else negAcc = stackedTop;
+		}
+	} else {
+		const clusterH = barH * clusterUnitsB;
+		const clusterStartY = f.plotY + (N - 1 - c) * groupH + (groupH - clusterH) / 2;
+		const strideB = barH * (1 - overlapPctB);
+		for (let s = 0; s < spec.series.length; s++) {
+			const v = spec.series[s]?.values[c] ?? 0;
+			const y0 = clusterStartY + (Sb - 1 - s) * strideB;
+			const tip = f.plotX + (v - min) / range * f.plotW;
+			const x0 = Math.min(tip, baseX);
+			const w = Math.abs(tip - baseX);
+			const baseColor = spec.varyColors && spec.series.length === 1 ? colors[c % colors.length] : spec.series[s]?.color ?? colors[s % colors.length];
+			const fillColor = v < 0 && spec.series[s]?.invertIfNegative ? mixHex(baseColor, "#000000", .55) : baseColor;
+			out.push(`<rect x="${px(x0)}" y="${px(y0)}" width="${px(w)}" height="${px(barH)}" fill="${fillColor}"/>`);
+			if (showLabelForBar(s)) {
+				const pos = spec.series[s]?.dataLabels?.position ?? spec.dataLabels?.position;
+				let labelX;
+				let anchor;
+				let fill = "#374151";
+				if (pos === "ctr") {
+					labelX = x0 + w / 2;
+					anchor = "middle";
+					fill = "#FFFFFF";
+				} else if (pos === "inEnd") {
+					labelX = v >= 0 ? x0 + w - 4 : x0 + 4;
+					anchor = v >= 0 ? "end" : "start";
+					fill = "#FFFFFF";
+				} else if (pos === "inBase") {
+					labelX = v >= 0 ? x0 + 4 : x0 + w - 4;
+					anchor = v >= 0 ? "start" : "end";
+					fill = "#FFFFFF";
+				} else {
+					labelX = v >= 0 ? x0 + w + 2 : x0 - 2;
+					anchor = v >= 0 ? "start" : "end";
+				}
+				out.push(`<text x="${px(labelX)}" y="${px(y0 + barH / 2 + 3)}" text-anchor="${anchor}" ${dataLabelTextAttrs(spec, s, fill)}>${formatDataLabelValue(spec, s, v)}</text>`);
+			}
+		}
+	}
+	out.push(`<line x1="${px(baseX)}" y1="${px(f.plotY)}" x2="${px(baseX)}" y2="${px(f.plotY + f.plotH)}" stroke="#9CA3AF" stroke-width="0.5"/>`);
+	return out.join("");
+};
+const renderLineChart = (f, spec, colors, fill) => {
+	const N = pointCount(spec);
+	if (N === 0 || spec.series.length === 0) return "";
+	const grouping = spec.grouping ?? "clustered";
+	const isStacked = grouping === "stacked" || grouping === "percentStacked";
+	const isPercent = grouping === "percentStacked";
+	const { min, max } = seriesMinMax(spec);
+	const range = max - min || 1;
+	const step = N > 1 ? f.plotW / (N - 1) : 0;
+	const baseY = f.plotY + f.plotH - (0 - min) / range * f.plotH;
+	const out = [];
+	out.push(`<line x1="${px(f.plotX)}" y1="${px(baseY)}" x2="${px(f.plotX + f.plotW)}" y2="${px(baseY)}" stroke="#E5E7EB" stroke-width="0.5"/>`);
+	const accumulated = Array.from({ length: N }, () => 0);
+	for (let s = 0; s < spec.series.length; s++) {
+		const series = spec.series[s];
+		if (!series) continue;
+		const color = series.color ?? colors[s % colors.length];
+		const dba = spec.dispBlanksAs ?? "gap";
+		const ptsRaw = [];
+		const basePtsRaw = [];
+		for (let c = 0; c < N; c++) {
+			const xp = f.plotX + c * step;
+			const rawV = series.values[c];
+			const isNullish = rawV === null || rawV === void 0 || !Number.isFinite(rawV);
+			let v;
+			if (isNullish) if (dba === "zero") v = 0;
+			else {
+				ptsRaw.push(null);
+				basePtsRaw.push(null);
+				continue;
+			}
+			else v = rawV;
+			const baseAt = accumulated[c] ?? 0;
+			if (isPercent) {
+				let total = 0;
+				for (const s2 of spec.series) total += Math.max(0, s2.values[c] ?? 0);
+				v = total === 0 ? 0 : Math.max(0, v) / total;
+			}
+			const top = isStacked ? baseAt + v : v;
+			const yp = f.plotY + f.plotH - (top - min) / range * f.plotH;
+			const yBase = isStacked ? f.plotY + f.plotH - (baseAt - min) / range * f.plotH : baseY;
+			ptsRaw.push([xp, yp]);
+			basePtsRaw.push([xp, yBase]);
+			if (isStacked) accumulated[c] = top;
+		}
+		const pts = dba === "span" ? ptsRaw.filter((p) => p !== null) : ptsRaw.filter((p) => p !== null);
+		const basePts = dba === "span" ? basePtsRaw.filter((p) => p !== null) : basePtsRaw.filter((p) => p !== null);
+		const dPath = series.smooth && pts.length > 2 ? smoothPath(pts) : (() => {
+			let path = "";
+			let starting = true;
+			for (const p of ptsRaw) {
+				if (p === null) {
+					if (dba === "gap") starting = true;
+					continue;
+				}
+				path += `${starting ? "M" : "L"}${px(p[0])},${px(p[1])} `;
+				starting = false;
+			}
+			return path.trim();
+		})();
+		if (fill) {
+			const back = basePts.slice().reverse().map(([xp, yp]) => `L${px(xp)},${px(yp)}`).join(" ");
+			out.push(`<path d="${dPath} ${back} Z" fill="${color}" stroke="none"/>`);
+		}
+		const lineWPx = series.lineWidthEmu ? Math.max(.3, series.lineWidthEmu / EMU_PER_PX) : 1.5;
+		const dashAttr = series.lineDash ? (() => {
+			const sw = lineWPx;
+			const pat = DASH_PATTERNS[series.lineDash];
+			if (!pat) return "";
+			return ` stroke-dasharray="${pat.split(" ").map((n) => (Number.parseFloat(n) * sw).toFixed(2)).join(" ")}"`;
+		})() : "";
+		out.push(`<path d="${dPath}" fill="none" stroke="${color}" stroke-width="${lineWPx.toFixed(2)}" stroke-linejoin="round" stroke-linecap="round"${dashAttr}/>`);
+		if (!isStacked) {
+			const explicitSymbol = series.markerSymbol !== void 0 && series.markerSymbol !== "auto" && series.markerSymbol !== "none";
+			if (series.markerSymbol !== "none" && !fill && (spec.lineMarkers === true || explicitSymbol)) {
+				const symbol = autoMarkerSymbol(series.markerSymbol, s);
+				const size = series.markerSizePt ?? 5;
+				const r = Math.max(1, size * .5);
+				for (const [xp, yp] of pts) out.push(seriesMarker(symbol, xp, yp, r, color));
+			}
+		}
+		if (series.dataLabels?.showValue ?? spec.dataLabels?.showValue ?? false) {
+			const lblPos = series.dataLabels?.position ?? spec.dataLabels?.position;
+			const computeAttrs = (xp, yp) => {
+				switch (lblPos) {
+					case "ctr": return {
+						x: xp,
+						y: yp + 3,
+						anchor: "middle"
+					};
+					case "b": return {
+						x: xp,
+						y: yp + 13,
+						anchor: "middle"
+					};
+					case "l": return {
+						x: xp - 6,
+						y: yp + 3,
+						anchor: "end"
+					};
+					case "r": return {
+						x: xp + 6,
+						y: yp + 3,
+						anchor: "start"
+					};
+					default: return {
+						x: xp,
+						y: yp - 5,
+						anchor: "middle"
+					};
+				}
+			};
+			for (let c = 0; c < N; c++) {
+				const p = ptsRaw[c];
+				if (p == null) continue;
+				const v = series.values[c];
+				if (v === null || v === void 0 || !Number.isFinite(v)) continue;
+				const [xp, yp] = p;
+				const { x: lx, y: ly, anchor } = computeAttrs(xp, yp);
+				out.push(`<text x="${px(lx)}" y="${px(ly)}" text-anchor="${anchor}" ${dataLabelTextAttrs(spec, s, "#374151")}>${formatDataLabelValue(spec, s, v)}</text>`);
+			}
+		}
+		if (!isStacked && series.trendline) {
+			const finiteXs = [];
+			const finiteYs = [];
+			for (const [xp, yp] of pts) if (Number.isFinite(yp)) {
+				finiteXs.push(xp);
+				finiteYs.push(yp);
+			}
+			if (finiteXs.length >= 2) {
+				const tlColor = series.trendline.color ?? color;
+				out.push(trendlinePath(finiteXs, finiteYs, series.trendline, tlColor));
+			}
+		}
+	}
+	if (!isStacked && (spec.dropLines || spec.hiLowLines) && spec.series.length > 0) for (let c = 0; c < N; c++) {
+		const xp = f.plotX + c * step;
+		if (spec.dropLines) {
+			const firstVal = spec.series[0]?.values[c];
+			if (firstVal !== null && firstVal !== void 0 && Number.isFinite(firstVal)) {
+				const yp = f.plotY + f.plotH - (firstVal - min) / range * f.plotH;
+				out.push(`<line x1="${px(xp)}" y1="${px(yp)}" x2="${px(xp)}" y2="${px(baseY)}" stroke="#9CA3AF" stroke-width="0.5" stroke-dasharray="2 2"/>`);
+			}
+		}
+		if (spec.hiLowLines) {
+			let hiV = -Infinity;
+			let loV = Infinity;
+			for (const s of spec.series) {
+				const v = s.values[c];
+				if (v === null || v === void 0 || !Number.isFinite(v)) continue;
+				if (v > hiV) hiV = v;
+				if (v < loV) loV = v;
+			}
+			if (hiV > loV) {
+				const yHi = f.plotY + f.plotH - (hiV - min) / range * f.plotH;
+				const yLo = f.plotY + f.plotH - (loV - min) / range * f.plotH;
+				out.push(`<line x1="${px(xp)}" y1="${px(yHi)}" x2="${px(xp)}" y2="${px(yLo)}" stroke="#4B5563" stroke-width="1"/>`);
+			}
+		}
+	}
+	return out.join("");
+};
+const renderPieChart = (f, spec, colors, doughnut) => {
+	const series = spec.series[0];
+	if (!series) return "";
+	const values = series.values.map((v) => Math.max(0, v ?? 0));
+	const total = values.reduce((a, b) => a + b, 0);
+	if (total === 0) return "";
+	const radius = Math.min(f.plotW, f.plotH) / 2 - 2;
+	const cx = f.plotX + f.plotW / 2;
+	const cy = f.plotY + f.plotH / 2;
+	const innerR = doughnut ? radius * ((spec.holeSizePct ?? 55) / 100) : 0;
+	const startDeg = spec.firstSliceAngleDeg ?? 0;
+	let acc = -Math.PI / 2 + startDeg * Math.PI / 180;
+	const out = [];
+	for (let i = 0; i < values.length; i++) {
+		const v = values[i] ?? 0;
+		const angle = v / total * 2 * Math.PI;
+		const start = acc;
+		const end = acc + angle;
+		acc = end;
+		const largeArc = angle > Math.PI ? 1 : 0;
+		const explOffset = (series.pointExplosions?.[i] ?? 0) / 100 * radius;
+		const midAngle = (start + end) / 2;
+		const sx = cx + Math.cos(midAngle) * explOffset;
+		const sy = cy + Math.sin(midAngle) * explOffset;
+		const ox1 = sx + radius * Math.cos(start);
+		const oy1 = sy + radius * Math.sin(start);
+		const ox2 = sx + radius * Math.cos(end);
+		const oy2 = sy + radius * Math.sin(end);
+		const color = series.pointColors?.[i] ?? series.color ?? colors[i % colors.length];
+		if (doughnut) {
+			const ix1 = sx + innerR * Math.cos(start);
+			const iy1 = sy + innerR * Math.sin(start);
+			const ix2 = sx + innerR * Math.cos(end);
+			const iy2 = sy + innerR * Math.sin(end);
+			const d = `M${px(ox1)},${px(oy1)} A${px(radius)},${px(radius)} 0 ${largeArc} 1 ${px(ox2)},${px(oy2)} L${px(ix2)},${px(iy2)} A${px(innerR)},${px(innerR)} 0 ${largeArc} 0 ${px(ix1)},${px(iy1)} Z`;
+			out.push(`<path d="${d}" fill="${color}" stroke="#FFFFFF" stroke-width="0.6"/>`);
+		} else {
+			const d = `M${px(sx)},${px(sy)} L${px(ox1)},${px(oy1)} A${px(radius)},${px(radius)} 0 ${largeArc} 1 ${px(ox2)},${px(oy2)} Z`;
+			out.push(`<path d="${d}" fill="${color}" stroke="#FFFFFF" stroke-width="0.6"/>`);
+		}
+		const labelMid = (start + end) / 2;
+		const pos = spec.series[0]?.dataLabels?.position ?? spec.dataLabels?.position;
+		let labelR;
+		let labelFill = "#FFFFFF";
+		if (pos === "inEnd") labelR = radius - 12;
+		else if (pos === "outEnd") {
+			labelR = radius + 12;
+			labelFill = "#374151";
+		} else labelR = doughnut ? (radius + innerR) / 2 : radius * .6;
+		const labelX = sx + labelR * Math.cos(labelMid);
+		const labelY = sy + labelR * Math.sin(labelMid);
+		const labels = [];
+		if (spec.dataLabels?.showValue) labels.push(formatDataLabelValue(spec, 0, v));
+		if (spec.dataLabels?.showPercent) labels.push(`${(v / total * 100).toFixed(0)}%`);
+		if (spec.dataLabels?.showCategory) {
+			const catLabel = spec.categories[i];
+			if (catLabel) labels.push(catLabel);
+		}
+		if (labels.length > 0) out.push(`<text x="${px(labelX)}" y="${px(labelY)}" text-anchor="middle" dominant-baseline="middle" ${dataLabelTextAttrs(spec, 0, labelFill, 10, true)}>${escapeXml(labels.join(spec.series[0]?.dataLabels?.separator ?? spec.dataLabels?.separator ?? " "))}</text>`);
+	}
+	return out.join("");
+};
+const scatterAxisBounds = (vals) => {
+	let min = Infinity;
+	let max = -Infinity;
+	for (const v of vals) if (Number.isFinite(v)) {
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	if (!Number.isFinite(min)) return {
+		min: 0,
+		max: 1
+	};
+	if (min === max) return {
+		min: min - 1,
+		max: max + 1
+	};
+	const ticks = niceTicks(min, max);
+	const step = ticks.length >= 2 ? ticks[1] - ticks[0] : (max - min) / 4 || 1;
+	return {
+		min: Math.floor(min / step) * step,
+		max: Math.ceil(max / step) * step
+	};
+};
+const xyPoints = (series) => {
+	const hasX = series.xValues !== void 0 && series.xValues.length > 0;
+	const n = Math.max(series.xValues?.length ?? 0, series.values.length);
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		let x;
+		if (hasX) {
+			const xv = series.xValues[i];
+			if (xv === null || xv === void 0 || !Number.isFinite(xv)) continue;
+			x = xv;
+		} else x = i + 1;
+		const y = series.values[i];
+		if (y === null || y === void 0 || !Number.isFinite(y)) continue;
+		const sz = series.bubbleSizes?.[i];
+		out.push({
+			x,
+			y,
+			size: sz != null && Number.isFinite(sz) ? sz : 0
+		});
+	}
+	return out;
+};
+const renderScatterAxes = (f, spec, xB, yB) => {
+	const yAxis = {
+		orientation: "vertical",
+		min: yB.min,
+		max: yB.max,
+		...spec.valueAxis?.numberFormat !== void 0 ? { numberFormat: spec.valueAxis.numberFormat } : {}
+	};
+	const xAxis = {
+		orientation: "horizontal",
+		min: xB.min,
+		max: xB.max
+	};
+	return renderValueAxis(f, yAxis) + renderValueAxis(f, xAxis);
+};
+const renderScatterChart = (f, spec, colors) => {
+	const perSeries = spec.series.map((s) => xyPoints(s));
+	const allX = [];
+	const allY = [];
+	for (const pts of perSeries) for (const p of pts) {
+		allX.push(p.x);
+		allY.push(p.y);
+	}
+	if (allX.length === 0) return "";
+	const xB = scatterAxisBounds(allX);
+	const yB = scatterAxisBounds(allY);
+	if (spec.valueAxis?.min !== void 0) yB.min = spec.valueAxis.min;
+	if (spec.valueAxis?.max !== void 0) yB.max = spec.valueAxis.max;
+	const xRange = xB.max - xB.min || 1;
+	const yRange = yB.max - yB.min || 1;
+	const projX = (x) => f.plotX + (x - xB.min) / xRange * f.plotW;
+	const projY = (y) => f.plotY + f.plotH - (y - yB.min) / yRange * f.plotH;
+	const out = [renderScatterAxes(f, spec, xB, yB)];
+	const style = spec.scatterStyle;
+	const showLine = style === "line" || style === "lineMarker" || style === "smooth" || style === "smoothMarker";
+	const smooth = style === "smooth" || style === "smoothMarker";
+	const showMarker = style === void 0 || style === "marker" || style === "lineMarker" || style === "smoothMarker";
+	for (let s = 0; s < spec.series.length; s++) {
+		const series = spec.series[s];
+		const pts = perSeries[s];
+		if (pts.length === 0) continue;
+		const color = series.color ?? colors[s % colors.length];
+		const proj = pts.map((p) => [projX(p.x), projY(p.y)]);
+		if (showLine && proj.length >= 2) {
+			const d = smooth && proj.length > 2 ? smoothPath(proj) : proj.map(([xp, yp], i) => `${i === 0 ? "M" : "L"}${px(xp)},${px(yp)}`).join(" ");
+			const lineWPx = series.lineWidthEmu ? Math.max(.3, series.lineWidthEmu / EMU_PER_PX) : 1.5;
+			out.push(`<path d="${d}" fill="none" stroke="${color}" stroke-width="${lineWPx.toFixed(2)}" stroke-linejoin="round" stroke-linecap="round"/>`);
+		}
+		const sym = series.markerSymbol;
+		if (sym === "none" ? false : showMarker || sym !== void 0 && sym !== "auto") {
+			const r = Math.max(1.5, (series.markerSizePt ?? 5) * .5);
+			const glyph = autoMarkerSymbol(sym, s);
+			for (const [xp, yp] of proj) out.push(seriesMarker(glyph, xp, yp, r, color));
+		}
+	}
+	return out.join("");
+};
+const renderBubbleChart = (f, spec, colors) => {
+	const perSeries = spec.series.map((s) => xyPoints(s));
+	const allX = [];
+	const allY = [];
+	let maxSize = 0;
+	for (const pts of perSeries) for (const p of pts) {
+		allX.push(p.x);
+		allY.push(p.y);
+		if (p.size > maxSize) maxSize = p.size;
+	}
+	if (allX.length === 0) return "";
+	const xB = scatterAxisBounds(allX);
+	const yB = scatterAxisBounds(allY);
+	if (spec.valueAxis?.min !== void 0) yB.min = spec.valueAxis.min;
+	if (spec.valueAxis?.max !== void 0) yB.max = spec.valueAxis.max;
+	const xRange = xB.max - xB.min || 1;
+	const yRange = yB.max - yB.min || 1;
+	const projX = (x) => f.plotX + (x - xB.min) / xRange * f.plotW;
+	const projY = (y) => f.plotY + f.plotH - (y - yB.min) / yRange * f.plotH;
+	const out = [renderScatterAxes(f, spec, xB, yB)];
+	const scaleFraction = spec.bubbleScale !== void 0 ? spec.bubbleScale / 100 : .25;
+	const maxRadiusPx = Math.max(2, scaleFraction * Math.min(f.plotW, f.plotH) * .5);
+	const areaMode = (spec.bubbleSizeRepresents ?? "area") === "area";
+	const radiusFor = (size) => {
+		if (maxSize <= 0 || size <= 0) return Math.max(1.5, maxRadiusPx * .15);
+		const frac = areaMode ? Math.sqrt(size / maxSize) : size / maxSize;
+		return Math.max(1.5, maxRadiusPx * frac);
+	};
+	for (let s = 0; s < spec.series.length; s++) {
+		const series = spec.series[s];
+		const pts = perSeries[s];
+		const color = series.color ?? colors[s % colors.length];
+		for (const p of pts) {
+			const cx = projX(p.x);
+			const cy = projY(p.y);
+			const r = radiusFor(p.size);
+			out.push(`<circle cx="${px(cx)}" cy="${px(cy)}" r="${r.toFixed(2)}" fill="${color}" fill-opacity="0.55" stroke="${color}" stroke-width="0.75"/>`);
+		}
+	}
+	return out.join("");
+};
+const renderRadarChart = (f, spec, colors) => {
+	const N = pointCount(spec);
+	if (N === 0 || spec.series.length === 0) return "";
+	let max = -Infinity;
+	let min = 0;
+	for (const sr of spec.series) for (const v of sr.values) if (v !== null && Number.isFinite(v) && v > max) max = v;
+	if (!Number.isFinite(max)) max = 1;
+	if (spec.valueAxis?.min !== void 0) min = spec.valueAxis.min;
+	if (spec.valueAxis?.max !== void 0) max = spec.valueAxis.max;
+	if (max <= min) max = min + 1;
+	const range = max - min;
+	const cx = f.plotX + f.plotW / 2;
+	const cy = f.plotY + f.plotH / 2;
+	const R = Math.max(4, Math.min(f.plotW, f.plotH) / 2 - 14);
+	const angleAt = (i) => -Math.PI / 2 + i * 2 * Math.PI / N;
+	const out = [];
+	for (const t of niceTicks(min, max)) {
+		if (t < min || t > max + 1e-9) continue;
+		const rr = (t - min) / range * R;
+		if (rr <= 0) continue;
+		const ring = [];
+		for (let i = 0; i < N; i++) {
+			const a = angleAt(i);
+			ring.push(`${px(cx + rr * Math.cos(a))},${px(cy + rr * Math.sin(a))}`);
+		}
+		out.push(`<polygon points="${ring.join(" ")}" fill="none" stroke="#E5E7EB" stroke-width="0.5"/>`);
+		out.push(`<text x="${px(cx + 3)}" y="${px(cy - rr)}" dominant-baseline="middle" font-family="sans-serif" font-size="8" fill="#9CA3AF">${escapeXml(formatTick(t))}</text>`);
+	}
+	for (let i = 0; i < N; i++) {
+		const a = angleAt(i);
+		out.push(`<line x1="${px(cx)}" y1="${px(cy)}" x2="${px(cx + R * Math.cos(a))}" y2="${px(cy + R * Math.sin(a))}" stroke="#D1D5DB" stroke-width="0.5"/>`);
+		const cat = spec.categories[i] ?? String(i + 1);
+		const lx = cx + (R + 8) * Math.cos(a);
+		const ly = cy + (R + 8) * Math.sin(a);
+		const cosA = Math.cos(a);
+		const anchor = Math.abs(cosA) < .3 ? "middle" : cosA > 0 ? "start" : "end";
+		const label = cat.length > 12 ? `${cat.slice(0, 11)}…` : cat;
+		out.push(`<text x="${px(lx)}" y="${px(ly)}" text-anchor="${anchor}" dominant-baseline="middle" ${axisTickAttrs(spec.categoryAxisLabelStyle)}>${escapeXml(label)}</text>`);
+	}
+	const filled = spec.radarStyle === "filled";
+	const showMarker = spec.radarStyle === "marker";
+	for (let s = 0; s < spec.series.length; s++) {
+		const series = spec.series[s];
+		const color = series.color ?? colors[s % colors.length];
+		const proj = [];
+		for (let i = 0; i < N; i++) {
+			const v = series.values[i];
+			if (v === null || v === void 0 || !Number.isFinite(v)) continue;
+			const rr = (v - min) / range * R;
+			const a = angleAt(i);
+			proj.push([cx + rr * Math.cos(a), cy + rr * Math.sin(a)]);
+		}
+		if (proj.length < 2) continue;
+		const ptsStr = proj.map(([xp, yp]) => `${px(xp)},${px(yp)}`).join(" ");
+		const lineWPx = series.lineWidthEmu ? Math.max(.3, series.lineWidthEmu / EMU_PER_PX) : 1.8;
+		out.push(filled ? `<polygon points="${ptsStr}" fill="${color}" fill-opacity="0.3" stroke="${color}" stroke-width="${lineWPx.toFixed(2)}" stroke-linejoin="round"/>` : `<polygon points="${ptsStr}" fill="none" stroke="${color}" stroke-width="${lineWPx.toFixed(2)}" stroke-linejoin="round"/>`);
+		if (showMarker) {
+			const r = Math.max(1.5, (series.markerSizePt ?? 5) * .5);
+			const glyph = autoMarkerSymbol(series.markerSymbol, s);
+			for (const [xp, yp] of proj) out.push(seriesMarker(glyph, xp, yp, r, color));
+		}
+	}
+	return out.join("");
+};
+const renderChart = (shape, x, y, w, h, transform, theme) => {
+	let spec = null;
+	try {
+		spec = getShapeChartSpec(shape);
+	} catch {
+		return null;
+	}
+	if (!spec) return null;
+	const colors = accentSequence(theme);
+	const isCartesian = spec.kind === "column" || spec.kind === "bar" || spec.kind === "line" || spec.kind === "area";
+	const hasAxes = isCartesian || spec.kind === "scatter" || spec.kind === "bubble";
+	const hasLegend = spec.legend !== void 0 && spec.legend.position !== null;
+	const f = layoutChart(x, y, w, h, !!spec.title, hasAxes, spec.titleOverlay ?? false, spec.legend?.overlay ?? false, hasLegend);
+	const allNamesForLegend = spec.kind === "pie" || spec.kind === "doughnut" ? Array.from(spec.categories) : spec.series.map((s) => s.name);
+	const allColorsForLegend = spec.kind === "pie" || spec.kind === "doughnut" ? spec.categories.map((_, i) => spec.series[0]?.pointColors?.[i] ?? spec.series[0]?.color ?? colors[i % colors.length] ?? "#888") : spec.series.map((s, i) => s.color ?? colors[i % colors.length] ?? "#888");
+	const hiddenSet = new Set(spec.legend?.hiddenIndices ?? []);
+	const seriesNamesForLegend = allNamesForLegend.filter((_, i) => !hiddenSet.has(i));
+	const seriesColorsForLegend = allColorsForLegend.filter((_, i) => !hiddenSet.has(i));
+	const explicitMarker = (sym) => sym !== void 0 && sym !== "auto" && sym !== "none";
+	const markerSymbolsForLegend = spec.kind === "line" && (spec.lineMarkers === true || spec.series.some((s) => explicitMarker(s.markerSymbol))) ? spec.series.map((s) => s.markerSymbol).filter((_, i) => !hiddenSet.has(i)) : void 0;
+	let finiteCount = 0;
+	for (const s of spec.series) for (const v of s.values) if (v !== null && Number.isFinite(v)) finiteCount++;
+	let plot = "";
+	let axes = "";
+	if (isCartesian) {
+		const { min, max, step } = seriesMinMax(spec);
+		const N = pointCount(spec);
+		const majorUnit = spec.valueAxis?.majorUnit ?? step;
+		const numberFormat = spec.valueAxis?.numberFormat;
+		const axisExtras = {
+			...majorUnit !== void 0 ? { majorUnit } : {},
+			...numberFormat !== void 0 ? { numberFormat } : {},
+			...spec.valueAxisMajorGridlines !== void 0 ? { majorGridlines: spec.valueAxisMajorGridlines } : {},
+			...spec.valueAxisLabelStyle !== void 0 ? { labelStyle: spec.valueAxisLabelStyle } : {},
+			...spec.valueAxisMajorGridlineColor !== void 0 ? { majorGridlineColor: spec.valueAxisMajorGridlineColor } : {},
+			...spec.valueAxisMajorTickMark !== void 0 ? { majorTickMark: spec.valueAxisMajorTickMark } : {},
+			...spec.valueAxisLineColor !== void 0 ? { lineColor: spec.valueAxisLineColor } : {},
+			...spec.valueAxisLabelRotationDeg !== void 0 ? { labelRotationDeg: spec.valueAxisLabelRotationDeg } : {},
+			...spec.valueAxis?.displayUnits !== void 0 ? { displayUnits: spec.valueAxis.displayUnits } : {}
+		};
+		const isPercentStacked = spec.grouping === "percentStacked";
+		const valueAxis = spec.kind === "bar" ? {
+			orientation: "horizontal",
+			min,
+			max,
+			percent: isPercentStacked,
+			...axisExtras
+		} : {
+			orientation: "vertical",
+			min,
+			max,
+			percent: isPercentStacked,
+			...axisExtras
+		};
+		if (!spec.valueAxisHidden) axes = renderValueAxis(f, valueAxis);
+		const labelsHidden = spec.categoryAxisHidden || spec.categoryAxisTickLabelPos === "none";
+		if (N > 0 && !labelsHidden) axes += renderCategoryAxis(f, spec.kind === "bar" ? "vertical" : "horizontal", spec.categories, N, spec.categoryAxisTickLabelSkip ?? 1, spec.categoryAxisLabelStyle, spec.categoryAxisLabelRotationDeg, spec.categoryAxisLabelAlign, spec.categoryAxisLineColor);
+	}
+	switch (spec.kind) {
+		case "column":
+		case "bar":
+			plot = spec.kind === "column" ? renderColumnChart(f, spec, colors) : renderBarChart(f, spec, colors);
+			break;
+		case "line":
+			plot = renderLineChart(f, spec, colors, false);
+			break;
+		case "area":
+			plot = renderLineChart(f, spec, colors, true);
+			break;
+		case "pie":
+			plot = renderPieChart(f, spec, colors, false);
+			break;
+		case "doughnut":
+			plot = renderPieChart(f, spec, colors, true);
+			break;
+		case "scatter":
+			plot = renderScatterChart(f, spec, colors);
+			break;
+		case "radar":
+			plot = renderRadarChart(f, spec, colors);
+			break;
+		case "bubble":
+			plot = renderBubbleChart(f, spec, colors);
+			break;
+		default: return null;
+	}
+	const emptyHint = finiteCount === 0 ? `<text x="${px(f.plotX + f.plotW / 2)}" y="${px(f.plotY + f.plotH / 2)}" text-anchor="middle" dominant-baseline="middle" font-family="sans-serif" font-size="12" fill="#9CA3AF">${escapeXml(`chart (${spec.kind}) — no data`)}</text>` : "";
+	const axisTitleAttrs = (style) => {
+		const sz = style?.sizePt ?? 11;
+		const fill = style?.color ?? "#374151";
+		const weight = style?.bold === false ? "400" : "600";
+		const italicAttr = style?.italic ? " font-style=\"italic\"" : "";
+		return `font-family="sans-serif" font-size="${sz.toFixed(1)}" fill="${fill}" font-weight="${weight}"${italicAttr}`;
+	};
+	const valueAxisTitleRot = spec.valueAxisTitleRotationDeg ?? -90;
+	const valueAxisTitleSvg = spec.valueAxisTitle ? `<text x="${px(f.plotX - 26)}" y="${px(f.plotY + f.plotH / 2)}" text-anchor="middle" ${axisTitleAttrs(spec.valueAxisTitleStyle)} transform="rotate(${valueAxisTitleRot} ${px(f.plotX - 26)} ${px(f.plotY + f.plotH / 2)})">${escapeXml(spec.valueAxisTitle)}</text>` : "";
+	const catTitleRot = spec.categoryAxisTitleRotationDeg ?? 0;
+	const catTitleCx = f.plotX + f.plotW / 2;
+	const catTitleCy = f.plotY + f.plotH + 16;
+	const catTitleTransform = catTitleRot !== 0 ? ` transform="rotate(${catTitleRot} ${px(catTitleCx)} ${px(catTitleCy)})"` : "";
+	const categoryAxisTitleSvg = spec.categoryAxisTitle ? `<text x="${px(catTitleCx)}" y="${px(catTitleCy)}" text-anchor="middle" ${axisTitleAttrs(spec.categoryAxisTitleStyle)}${catTitleTransform}>${escapeXml(spec.categoryAxisTitle)}</text>` : "";
+	return [
+		`<g${transform}>`,
+		`<rect x="${px(f.x)}" y="${px(f.y)}" width="${px(f.w)}" height="${px(f.h)}" fill="${spec.chartAreaFill ?? "#FFFFFF"}" stroke="${spec.chartAreaStrokeColor ?? "none"}" stroke-width="0.6"${spec.roundedCorners ? " rx=\"6\" ry=\"6\"" : ""}/>`,
+		spec.plotAreaFill || spec.plotAreaStrokeColor ? `<rect x="${px(f.plotX)}" y="${px(f.plotY)}" width="${px(f.plotW)}" height="${px(f.plotH)}" fill="${spec.plotAreaFill ?? "none"}" stroke="${spec.plotAreaStrokeColor ?? "none"}" stroke-width="0.6"/>` : "",
+		renderChartTitle(f, spec.title ?? "", spec.titleStyle),
+		axes,
+		valueAxisTitleSvg,
+		categoryAxisTitleSvg,
+		plot,
+		emptyHint,
+		hasLegend ? renderChartLegend(f, seriesNamesForLegend, seriesColorsForLegend, spec.legend?.position ?? "b", spec.legend?.textStyle, markerSymbolsForLegend) : "",
+		"</g>"
+	].join("");
+};
+const cellParaData = (paragraphs) => {
+	let hasText = false;
+	return {
+		paraData: paragraphs.map((para) => {
+			const runs = [];
+			for (const el of para.elements) {
+				if (el.kind === "br") {
+					runs.push({
+						text: "\n",
+						fmt: null,
+						sizePt: DEFAULT_BODY_PT
+					});
+					continue;
+				}
+				if (el.text.trim()) hasText = true;
+				runs.push({
+					text: el.text,
+					fmt: el.format,
+					sizePt: el.format?.size ?? DEFAULT_BODY_PT
+				});
+			}
+			return {
+				align: para.align ?? "left",
+				level: 0,
+				bulletStyle: null,
+				bulletDetail: {
+					color: null,
+					sizePct: null,
+					sizePts: null,
+					font: null
+				},
+				bulletIsPicture: false,
+				bulletImageHref: null,
+				runs,
+				lineSpacing: null,
+				spcBefPts: null,
+				spcAftPts: null,
+				indent: {
+					leftEmu: null,
+					rightEmu: null,
+					firstLineEmu: null
+				}
+			};
+		}),
+		hasText
+	};
+};
+const renderTableCellText = (paragraphs, cx, cy, cw, ch, color, pres, shape, theme, themeFace, ctx, vAnchor, margins) => {
+	const { paraData, hasText } = cellParaData(paragraphs);
+	if (!hasText) return "";
+	const defaultPadPx = 4;
+	const padL = margins.left !== null ? margins.left / EMU_PER_PX : defaultPadPx;
+	const padR = margins.right !== null ? margins.right / EMU_PER_PX : defaultPadPx;
+	const padT = margins.top !== null ? margins.top / EMU_PER_PX : defaultPadPx;
+	const padB = margins.bottom !== null ? margins.bottom / EMU_PER_PX : defaultPadPx;
+	const innerX = cx + padL;
+	const innerY = cy + padT;
+	const innerW = Math.max(0, cw - padL - padR);
+	const innerH = Math.max(0, ch - padT - padB);
+	if (innerW <= 0 || innerH <= 0) return "";
+	if (ctx.mode === "svg") return buildAndLayoutSvgText({
+		pres,
+		shape,
+		theme,
+		paraData,
+		numberLabels: paraData.map(() => null),
+		autoFitScale: 1,
+		lineHeightScale: 1,
+		defaultPt: DEFAULT_BODY_PT,
+		themeFace,
+		defaultColor: color,
+		anchor: vAnchor,
+		wrap: true,
+		innerX: innerX * EMU_PER_PX,
+		innerY: innerY * EMU_PER_PX,
+		innerW: innerW * EMU_PER_PX,
+		innerH: innerH * EMU_PER_PX,
+		measure: ctx.measure,
+		vert: "none",
+		columns: null
+	});
+	const justify = vAnchor === "top" ? "flex-start" : vAnchor === "bottom" ? "flex-end" : "center";
+	const familyFont = themeFace ? `${escapeXml(themeFace)}, ${DEFAULT_FONT}` : DEFAULT_FONT;
+	const body = paraData.map((para) => {
+		const runHtml = para.runs.map((run) => renderRun(run.text, run.fmt, theme, run.sizePt, run.fmt?.size === void 0)).join("");
+		return `<p style="margin:0;padding:0;text-align:${ALIGNMENT_TO_CSS[para.align] ?? "left"};line-height:1.2">${runHtml || "&#8203;"}</p>`;
+	}).join("");
+	return `<foreignObject x="${px(innerX)}" y="${px(innerY)}" width="${px(innerW)}" height="${px(innerH)}"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;flex-direction:column;justify-content:${justify};width:100%;height:100%;box-sizing:border-box;overflow:hidden;font-family:${familyFont};color:${color};word-break:break-word">${body}</div></foreignObject>`;
+};
+const renderTable = (shape, pres, x, y, w, h, transform, theme, ctx) => {
+	let dims;
+	let widths;
+	let heights;
+	let cells;
+	try {
+		dims = getTableDimensions(shape);
+		widths = getTableColumnWidths(shape);
+		heights = getTableRowHeights(shape);
+		cells = getTableCells(shape);
+	} catch {
+		return null;
+	}
+	if (dims.rows === 0 || dims.cols === 0) return null;
+	const xPx = x / EMU_PER_PX;
+	const yPx = y / EMU_PER_PX;
+	const widthsPx = widths.map((w0) => w0 / EMU_PER_PX);
+	const heightsPx = heights.map((h0) => h0 / EMU_PER_PX);
+	const wSum = widthsPx.reduce((a, b) => a + b, 0);
+	const hSum = heightsPx.reduce((a, b) => a + b, 0);
+	const wScale = wSum > 0 ? w / EMU_PER_PX / wSum : 1;
+	const hScale = hSum > 0 ? h / EMU_PER_PX / hSum : 1;
+	const colXs = [xPx];
+	for (let c = 0; c < widthsPx.length; c++) colXs.push((colXs[c] ?? xPx) + (widthsPx[c] ?? 0) * wScale);
+	const rowYs = [yPx];
+	for (let r = 0; r < heightsPx.length; r++) rowYs.push((rowYs[r] ?? yPx) + (heightsPx[r] ?? 0) * hScale);
+	const flags = getTableStyleFlags(shape);
+	const accent = theme ? normalizeHex(theme.accent1) : "#4472C4";
+	const headerFill = accent;
+	const bandFill = mixHex(accent, "#FFFFFF", .92);
+	const textColor = activeDeckTextColor;
+	const tableThemeFace = getPresentationFonts(pres)?.minorLatin ?? null;
+	const out = [];
+	out.push(`<g${transform}>`);
+	out.push(`<rect x="${px(xPx)}" y="${px(yPx)}" width="${px((colXs[widthsPx.length] ?? xPx) - xPx)}" height="${px((rowYs[heightsPx.length] ?? yPx) - yPx)}" fill="#FFFFFF"/>`);
+	const borderEdges = [];
+	for (let r = 0; r < dims.rows; r++) for (let c = 0; c < dims.cols; c++) {
+		const cell = cells[r]?.[c];
+		if (!cell) continue;
+		const typedCell = cell;
+		const span = getTableCellSpan(typedCell);
+		if (span.hMerge || span.vMerge) continue;
+		const cx = colXs[c] ?? xPx;
+		const cy = rowYs[r] ?? yPx;
+		const endCol = Math.min(dims.cols, c + span.gridSpan);
+		const endRow = Math.min(dims.rows, r + span.rowSpan);
+		const cw = (colXs[endCol] ?? cx) - cx;
+		const ch = (rowYs[endRow] ?? cy) - cy;
+		const fill = getTableCellFill(cell);
+		let resolvedFill;
+		if (fill) resolvedFill = resolveColor(fill, theme, "#FFFFFF");
+		else if (flags.firstRow && r === 0) resolvedFill = headerFill;
+		else if (flags.lastRow && r === dims.rows - 1) resolvedFill = headerFill;
+		else if (flags.firstCol && c === 0) resolvedFill = bandFill;
+		else if (flags.lastCol && c === dims.cols - 1) resolvedFill = bandFill;
+		else if (flags.bandRow && r % 2 === (flags.firstRow ? 0 : 1)) resolvedFill = bandFill;
+		else if (flags.bandCol && c % 2 === (flags.firstCol ? 0 : 1)) resolvedFill = bandFill;
+		else resolvedFill = "none";
+		const cellTextColor = resolvedFill === headerFill ? "#FFFFFF" : textColor;
+		out.push(`<rect x="${px(cx)}" y="${px(cy)}" width="${px(cw)}" height="${px(ch)}" fill="${resolvedFill}"/>`);
+		const borders = getTableCellBorders(pres, typedCell);
+		const dashAttr = (dash, widthPx) => {
+			if (!dash || dash === "solid") return "";
+			const pat = DASH_PATTERNS[dash];
+			if (!pat) return "";
+			return ` stroke-dasharray="${pat.split(" ").map((n) => (Number.parseFloat(n) * widthPx).toFixed(2)).join(" ")}"`;
+		};
+		const edge = (side, x1, y1, x2, y2) => {
+			const b = borders[side];
+			if (!b) return;
+			const sw = b.widthEmu ? Math.max(.4, b.widthEmu / EMU_PER_PX) : .5;
+			const col = b.color ?? "#9CA3AF";
+			borderEdges.push(`<line x1="${px(x1)}" y1="${px(y1)}" x2="${px(x2)}" y2="${px(y2)}" stroke="${col}" stroke-width="${px(sw)}"${dashAttr(b.dash, sw)}/>`);
+		};
+		edge("left", cx, cy, cx, cy + ch);
+		edge("right", cx + cw, cy, cx + cw, cy + ch);
+		edge("top", cx, cy, cx + cw, cy);
+		edge("bottom", cx, cy + ch, cx + cw, cy + ch);
+		if (borders.tlToBr) {
+			const sw = borders.tlToBr.widthEmu ? Math.max(.4, borders.tlToBr.widthEmu / EMU_PER_PX) : .5;
+			borderEdges.push(`<line x1="${px(cx)}" y1="${px(cy)}" x2="${px(cx + cw)}" y2="${px(cy + ch)}" stroke="${borders.tlToBr.color ?? "#9CA3AF"}" stroke-width="${px(sw)}"${dashAttr(borders.tlToBr.dash, sw)}/>`);
+		}
+		if (borders.blToTr) {
+			const sw = borders.blToTr.widthEmu ? Math.max(.4, borders.blToTr.widthEmu / EMU_PER_PX) : .5;
+			borderEdges.push(`<line x1="${px(cx)}" y1="${px(cy + ch)}" x2="${px(cx + cw)}" y2="${px(cy)}" stroke="${borders.blToTr.color ?? "#9CA3AF"}" stroke-width="${px(sw)}"${dashAttr(borders.blToTr.dash, sw)}/>`);
+		}
+		const defaultColor = "#9CA3AF";
+		if (!borders.left) borderEdges.push(`<line x1="${px(cx)}" y1="${px(cy)}" x2="${px(cx)}" y2="${px(cy + ch)}" stroke="${defaultColor}" stroke-width="0.4" opacity="0.6"/>`);
+		if (!borders.right) borderEdges.push(`<line x1="${px(cx + cw)}" y1="${px(cy)}" x2="${px(cx + cw)}" y2="${px(cy + ch)}" stroke="${defaultColor}" stroke-width="0.4" opacity="0.6"/>`);
+		if (!borders.top) borderEdges.push(`<line x1="${px(cx)}" y1="${px(cy)}" x2="${px(cx + cw)}" y2="${px(cy)}" stroke="${defaultColor}" stroke-width="0.4" opacity="0.6"/>`);
+		if (!borders.bottom) borderEdges.push(`<line x1="${px(cx)}" y1="${px(cy + ch)}" x2="${px(cx + cw)}" y2="${px(cy + ch)}" stroke="${defaultColor}" stroke-width="0.4" opacity="0.6"/>`);
+		const cellParagraphs = getTableCellParagraphs(cell);
+		const vAnchor = getTableCellAnchor(typedCell) ?? "top";
+		const cellMargins = getTableCellMargins(typedCell);
+		out.push(renderTableCellText(cellParagraphs, cx, cy, cw, ch, cellTextColor, pres, shape, theme, tableThemeFace, ctx, vAnchor, cellMargins));
+	}
+	out.push(borderEdges.join(""));
+	out.push("</g>");
+	return out.join("");
+};
+/**
+* Converts an OOXML `<a:arcTo>` (center-parameterized: start at the pen
+* point, angle `stAng`, sweep `swAng`, both in 60000ths of a degree, on a
+* `wR`×`hR` axis-aligned ellipse) into cubic-Bézier segments in the path's
+* own coordinate space.
+*
+* We approximate with cubics rather than emit an SVG `A` arc because the
+* endpoint-parameterized `A` command can't represent a sweep ≥ 360° (full
+* ellipses appear in custom geometry) and forces large-arc / sweep flag
+* bookkeeping for the signed `swAng`; splitting into ≤ 90° cubic segments
+* sidesteps both and stays accurate.
+*/
+const arcToCubicSegments = (startX, startY, wR, hR, stAng, swAng) => {
+	const toRad = (a) => a / 6e4 * (Math.PI / 180);
+	const st = toRad(stAng);
+	const sw = toRad(swAng);
+	const cx = startX - wR * Math.cos(st);
+	const cy = startY - hR * Math.sin(st);
+	const segCount = Math.max(1, Math.ceil(Math.abs(sw) / (Math.PI / 2)));
+	const delta = sw / segCount;
+	const k = 4 / 3 * Math.tan(delta / 4);
+	const segs = [];
+	let a0 = st;
+	for (let i = 0; i < segCount; i++) {
+		const a1 = a0 + delta;
+		const cos0 = Math.cos(a0);
+		const sin0 = Math.sin(a0);
+		const cos1 = Math.cos(a1);
+		const sin1 = Math.sin(a1);
+		const p1x = cx + wR * cos1;
+		const p1y = cy + hR * sin1;
+		segs.push({
+			c1x: cx + wR * cos0 - k * wR * sin0,
+			c1y: cy + hR * sin0 + k * hR * cos0,
+			c2x: p1x + k * wR * sin1,
+			c2y: p1y - k * hR * cos1,
+			ex: p1x,
+			ey: p1y
+		});
+		a0 = a1;
+	}
+	return segs;
+};
+/**
+* Renders an evaluated {@link CustomGeometry} as one `<path>` per
+* `GeomPath`, scaling each path's coordinate space (its own `w`/`h`, or
+* the shape extents when those are absent) onto the shape's slide box
+* `(x, y, w, h)` in EMU. Returns `''` when nothing drawable remains, so
+* the caller can fall back to the labelled rect.
+*
+* Per-path `fill="none"` paints stroke-only; `stroke="0"` paints
+* fill-only — mirroring `ST_PathFillMode` / the path `stroke` flag.
+*/
+const customGeometryToSvg = (geom, x, y, w, h, fill, stroke, strokeWidthEmu, strokeExtra, markerExtra) => {
+	const out = [];
+	for (const path of geom.paths) {
+		const cw = path.w ?? w;
+		const ch = path.h ?? h;
+		if (cw === 0 || ch === 0) continue;
+		const sx = w / cw;
+		const sy = h / ch;
+		const fx = (gx) => ((x + gx * sx) / EMU_PER_PX).toFixed(2);
+		const fy = (gy) => ((y + gy * sy) / EMU_PER_PX).toFixed(2);
+		const pt = (gx, gy) => `${fx(gx)},${fy(gy)}`;
+		let curX = 0;
+		let curY = 0;
+		let startX = 0;
+		let startY = 0;
+		const d = [];
+		for (const cmd of path.commands) switch (cmd.kind) {
+			case "moveTo":
+				curX = cmd.pt.x;
+				curY = cmd.pt.y;
+				startX = curX;
+				startY = curY;
+				d.push(`M${pt(curX, curY)}`);
+				break;
+			case "lnTo":
+				curX = cmd.pt.x;
+				curY = cmd.pt.y;
+				d.push(`L${pt(curX, curY)}`);
+				break;
+			case "quadBezTo":
+				d.push(`Q${pt(cmd.pts[0].x, cmd.pts[0].y)} ${pt(cmd.pts[1].x, cmd.pts[1].y)}`);
+				curX = cmd.pts[1].x;
+				curY = cmd.pts[1].y;
+				break;
+			case "cubicBezTo":
+				d.push(`C${pt(cmd.pts[0].x, cmd.pts[0].y)} ${pt(cmd.pts[1].x, cmd.pts[1].y)} ${pt(cmd.pts[2].x, cmd.pts[2].y)}`);
+				curX = cmd.pts[2].x;
+				curY = cmd.pts[2].y;
+				break;
+			case "arcTo": {
+				const segs = arcToCubicSegments(curX, curY, cmd.wR, cmd.hR, cmd.stAng, cmd.swAng);
+				for (const s of segs) d.push(`C${pt(s.c1x, s.c1y)} ${pt(s.c2x, s.c2y)} ${pt(s.ex, s.ey)}`);
+				const last = segs[segs.length - 1];
+				if (last) {
+					curX = last.ex;
+					curY = last.ey;
+				}
+				break;
+			}
+			case "close":
+				d.push("Z");
+				curX = startX;
+				curY = startY;
+				break;
+		}
+		if (d.length === 0) continue;
+		const pathFill = path.fill === "none" ? "none" : fill;
+		const strokeAttrs = path.stroke ? ` stroke="${stroke}" stroke-width="${E(strokeWidthEmu)}"${strokeExtra}${markerExtra}` : " stroke=\"none\"";
+		out.push(`<path d="${d.join(" ")}" fill="${pathFill}"${strokeAttrs} fill-rule="evenodd"/>`);
+	}
+	return out.join("");
+};
+const renderShape = (shape, pres, theme, ctx) => {
+	const bounds = getShapeBoundsResolved(pres, shape);
+	if (!bounds) return "";
+	const x = bounds.x;
+	const y = bounds.y;
+	const w = bounds.w;
+	const h = bounds.h;
+	const kind = getShapeKind(shape);
+	if (kind === "connector" ? w <= 0 && h <= 0 : w <= 0 || h <= 0) return "";
+	const fill = getShapeFillEffective(pres, shape);
+	const stroke = getShapeStrokeEffective(pres, shape);
+	const rotation = getShapeRotation(shape);
+	const flip = getShapeFlip(shape) ?? {
+		horizontal: false,
+		vertical: false
+	};
+	const phType = getShapePlaceholderType(shape);
+	const cx = x + w / 2;
+	const cy = y + h / 2;
+	const transforms = [];
+	if (rotation !== 0) transforms.push(`rotate(${rotation} ${E(cx)} ${E(cy)})`);
+	if (flip.horizontal) transforms.push(`translate(${E(2 * cx)} 0) scale(-1 1)`);
+	if (flip.vertical) transforms.push(`translate(0 ${E(2 * cy)}) scale(1 -1)`);
+	const transform = transforms.length > 0 ? ` transform="${transforms.join(" ")}"` : "";
+	const textTransform = rotation !== 0 ? ` transform="rotate(${rotation} ${E(cx)} ${E(cy)})"` : "";
+	const textOverlay = kind === "shape" || kind === "graphicFrame" ? renderTextBody(pres, shape, {
+		x,
+		y,
+		w,
+		h
+	}, theme, phType, ctx) : "";
+	if (kind === "picture") return renderPicture(shape, pres, x, y, w, h, transform, textOverlay, getShapeImageBytes(shape), getShapeImageFormat(shape));
+	if (kind === "shape" && fill.kind === "image") return renderPicture(shape, pres, x, y, w, h, transform, textOverlay, getShapeImageFillBytes(shape), getShapeImageFormat(shape));
+	if (kind === "connector") {
+		const p = paint(shape, fill, stroke, theme, false, pres);
+		const sw = p.strokeWidth || 19050;
+		let x1 = x;
+		let y1 = y;
+		let x2 = x + w;
+		let y2 = y + h;
+		if (flip.horizontal) {
+			x1 = x + w;
+			x2 = x;
+		}
+		if (flip.vertical) {
+			y1 = y + h;
+			y2 = y;
+		}
+		const strokeColor = p.stroke === "none" ? resolveColor("scheme:tx1", theme, "#1F2937") : p.stroke;
+		const sa = p.strokeAttrs ? ` ${p.strokeAttrs}` : "";
+		const ma = p.markerAttrs ?? "";
+		const preset = getShapePreset(shape) ?? "line";
+		if (preset === "straightConnector1" || preset === "line") return `${p.defs}<line x1="${E(x1)}" y1="${E(y1)}" x2="${E(x2)}" y2="${E(y2)}" stroke="${strokeColor}" stroke-width="${E(sw)}" stroke-linecap="round"${sa}${ma}${transform}/>`;
+		const px1 = x1 / EMU_PER_PX;
+		const py1 = y1 / EMU_PER_PX;
+		const px2 = x2 / EMU_PER_PX;
+		const py2 = y2 / EMU_PER_PX;
+		let d = `M${px1.toFixed(2)} ${py1.toFixed(2)}`;
+		if (preset === "bentConnector2") d += ` L${px2.toFixed(2)} ${py1.toFixed(2)} L${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		else if (preset === "bentConnector3") {
+			const midX = (px1 + px2) / 2;
+			d += ` L${midX.toFixed(2)} ${py1.toFixed(2)} L${midX.toFixed(2)} ${py2.toFixed(2)} L${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		} else if (preset === "bentConnector4") {
+			const mx = (px1 + px2) / 2;
+			const my = (py1 + py2) / 2;
+			d += ` L${mx.toFixed(2)} ${py1.toFixed(2)} L${mx.toFixed(2)} ${my.toFixed(2)} L${px2.toFixed(2)} ${my.toFixed(2)} L${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		} else if (preset === "bentConnector5") {
+			const q1x = px1 + (px2 - px1) / 3;
+			const q2x = px1 + 2 * (px2 - px1) / 3;
+			const my = (py1 + py2) / 2;
+			d += ` L${q1x.toFixed(2)} ${py1.toFixed(2)} L${q1x.toFixed(2)} ${my.toFixed(2)} L${q2x.toFixed(2)} ${my.toFixed(2)} L${q2x.toFixed(2)} ${py2.toFixed(2)} L${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		} else if (preset === "curvedConnector2") d += ` Q${px2.toFixed(2)} ${py1.toFixed(2)} ${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		else if (preset === "curvedConnector3" || preset === "curvedConnector4" || preset === "curvedConnector5") {
+			const c1x = px1 + (px2 - px1) / 3;
+			const c2x = px1 + 2 * (px2 - px1) / 3;
+			d += ` C${c1x.toFixed(2)} ${py1.toFixed(2)} ${c2x.toFixed(2)} ${py2.toFixed(2)} ${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		} else d += ` L${px2.toFixed(2)} ${py2.toFixed(2)}`;
+		return `${p.defs}<path d="${d}" fill="none" stroke="${strokeColor}" stroke-width="${E(sw)}" stroke-linecap="round" stroke-linejoin="round"${sa}${ma}${transform}/>`;
+	}
+	if (kind === "group") {
+		const xform = getGroupTransform(shape);
+		const children = getGroupChildren(shape);
+		if (children.length === 0) return "";
+		const tParts = [];
+		if (xform && rotation !== 0) {
+			const cxG = (xform.outer.x + xform.outer.w / 2) / EMU_PER_PX;
+			const cyG = (xform.outer.y + xform.outer.h / 2) / EMU_PER_PX;
+			tParts.push(`rotate(${rotation} ${cxG.toFixed(2)} ${cyG.toFixed(2)})`);
+		}
+		if (xform && flip.horizontal) {
+			const cxG = (xform.outer.x + xform.outer.w / 2) / EMU_PER_PX;
+			tParts.push(`translate(${(2 * cxG).toFixed(2)} 0) scale(-1 1)`);
+		}
+		if (xform && flip.vertical) {
+			const cyG = (xform.outer.y + xform.outer.h / 2) / EMU_PER_PX;
+			tParts.push(`translate(0 ${(2 * cyG).toFixed(2)}) scale(1 -1)`);
+		}
+		if (xform) {
+			const ox = xform.outer.x;
+			const oy = xform.outer.y;
+			const ow = xform.outer.w;
+			const oh = xform.outer.h;
+			const ix = xform.inner.x;
+			const iy = xform.inner.y;
+			const iw = xform.inner.w || 1;
+			const ih = xform.inner.h || 1;
+			const sx = (ow / iw).toFixed(6);
+			const sy = (oh / ih).toFixed(6);
+			const tx = ((ox - ix * (ow / iw)) / EMU_PER_PX).toFixed(2);
+			const ty = ((oy - iy * (oh / ih)) / EMU_PER_PX).toFixed(2);
+			tParts.push(`translate(${tx} ${ty})`, `scale(${sx} ${sy})`);
+		}
+		return `<g${tParts.length > 0 ? ` transform="${tParts.join(" ")}"` : ""}>${children.map((c) => renderShape(c, pres, theme, ctx)).join("")}</g>`;
+	}
+	const p = paint(shape, fill, stroke, theme, phType !== null, pres);
+	if (kind === "graphicFrame") {
+		if (isChartShape(shape)) {
+			const chartSvg = renderChart(shape, x, y, w, h, transform, theme);
+			if (chartSvg) return chartSvg;
+		}
+		if (isTableShape(shape)) {
+			const tableSvg = renderTable(shape, pres, x, y, w, h, transform, theme, ctx);
+			if (tableSvg) return tableSvg;
+		}
+		let label = "graphicFrame";
+		try {
+			if (isChartShape(shape)) label = "chart (unsupported kind)";
+			else if (isTableShape(shape)) {
+				const t = getTableDimensions(shape);
+				label = `table (${t.rows}×${t.cols})`;
+			}
+		} catch {}
+		return `<g data-pptx-fallback="${label.startsWith("chart") ? "chart" : "graphicFrame"}"${transform}><rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}" fill="${p.fill === "none" ? "#F9FAFB" : p.fill}" stroke="#9CA3AF" stroke-width="${E(9525)}" stroke-dasharray="${E(5e4)},${E(3e4)}"/>${renderPicturePlaceholderLabel(x, y, w, h, label)}${textOverlay}</g>`;
+	}
+	const rawPreset = getShapePreset(shape);
+	const preset = rawPreset ?? "rect";
+	const sa = p.strokeAttrs ? ` ${p.strokeAttrs}` : "";
+	const ma = p.markerAttrs ?? "";
+	const customGeom = rawPreset === null ? getShapeCustomGeometry(shape) : null;
+	let geomSvg = customGeom !== null ? customGeometryToSvg(customGeom, x, y, w, h, p.fill, p.stroke, p.strokeWidth, sa, ma) : "";
+	const isCustGeom = geomSvg === "" && rawPreset === null && getShapeXmlString(shape).includes("custGeom");
+	if (geomSvg !== "") {} else if (preset === "rect") geomSvg = `<rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}"${sa}${ma}/>`;
+	else if (preset === "roundRect") {
+		const adjVal = getShapeAdjustValues(shape).adj ?? 16667;
+		const ratio = Math.max(0, Math.min(.5, adjVal / 1e5));
+		const r = E(Math.min(w, h) * ratio);
+		geomSvg = `<rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}" rx="${r}" ry="${r}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}"${sa}${ma}/>`;
+	} else if (preset === "ellipse" || preset === "oval") geomSvg = `<ellipse cx="${E(cx)}" cy="${E(cy)}" rx="${E(w / 2)}" ry="${E(h / 2)}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}"${sa}${ma}/>`;
+	else {
+		const pathFn = PRESET_PATHS[preset];
+		if (pathFn) geomSvg = `<path d="${pathFn(x / EMU_PER_PX, y / EMU_PER_PX, w / EMU_PER_PX, h / EMU_PER_PX)}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}" fill-rule="evenodd"${sa}${ma}/>`;
+		else {
+			const pointsFn = PRESET_POINTS[preset];
+			if (pointsFn) geomSvg = `<polygon points="${pointsFn().map(([nx, ny]) => `${E(x + nx * w)},${E(y + ny * h)}`).join(" ")}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}"${sa}${ma}/>`;
+			else geomSvg = `<rect x="${E(x)}" y="${E(y)}" width="${E(w)}" height="${E(h)}" fill="${p.fill}" stroke="${p.stroke}" stroke-width="${E(p.strokeWidth)}"${sa}${ma} data-pptx-preset="${escapeXml(preset)}"><title>${escapeXml(`preset: ${preset}`)}</title></rect>`;
+		}
+	}
+	const fx = buildEffectsFilter(pres, shape);
+	const filterAttr = fx ? ` filter="url(#${fx.id})"` : "";
+	let fxDefs = fx ? fx.defs : "";
+	const reflection = buildReflection(pres, shape, geomSvg, {
+		x,
+		y,
+		w,
+		h
+	});
+	geomSvg = `<g${filterAttr}>${geomSvg}</g>`;
+	if (reflection) {
+		geomSvg = reflection.svg + geomSvg;
+		fxDefs += reflection.defs;
+	}
+	const url = getShapeHyperlink(shape);
+	const tooltip = getShapeHyperlinkTooltip(shape);
+	const shapeName = (() => {
+		try {
+			return getShapeName(shape);
+		} catch {
+			return null;
+		}
+	})();
+	const altTitle = (() => {
+		try {
+			return getShapeAltTitle(shape);
+		} catch {
+			return null;
+		}
+	})();
+	const altDesc = (() => {
+		try {
+			return getShapeDescription(shape);
+		} catch {
+			return null;
+		}
+	})();
+	const a11yLabel = altTitle ?? altDesc ?? null;
+	const nameAttr = shapeName ? ` data-pptx-shape-name="${escapeXml(shapeName)}"` : "";
+	const ariaAttr = a11yLabel ? ` role="img" aria-label="${escapeXml(a11yLabel)}"` : "";
+	const placedText = textOverlay ? `<g${textTransform}>${textOverlay}</g>` : "";
+	const custGeomAttr = isCustGeom ? " data-pptx-fallback=\"custGeom\"" : "";
+	const inner = `${p.defs}${fxDefs}<g${nameAttr}${ariaAttr}${custGeomAttr}><g${transform}>${geomSvg}</g>${placedText}</g>`;
+	const titleEl = tooltip ? `<title>${escapeXml(tooltip)}</title>` : "";
+	if (url) return `<a href="${escapeXml(url)}" target="_blank" rel="noopener noreferrer">${titleEl}${inner}</a>`;
+	const action = getShapeClickAction(shape);
+	if (action) {
+		let href = null;
+		if (action.kind === "slide") {
+			const idx = getSlideIndex(pres, action.slide);
+			if (idx >= 0) href = `#slide-${idx + 1}`;
+		} else if (action.kind === "url") href = action.url;
+		if (href !== null) {
+			const targetAttrs = href.startsWith("#") ? "" : " target=\"_blank\" rel=\"noopener noreferrer\"";
+			return `<a href="${escapeXml(href)}"${targetAttrs}>${titleEl}${inner}</a>`;
+		}
+	}
+	return inner;
+};
+const buildReflection = (pres, shape, geomRaw, box) => {
+	let effects;
+	try {
+		effects = getShapeEffectsEffective(pres, shape);
+	} catch {
+		return null;
+	}
+	const refl = effects.find((e) => e.kind === "reflection");
+	if (!refl || refl.kind !== "reflection") return null;
+	const f = refl.scaleY ?? -1;
+	const startA = refl.startOpacity ?? 1;
+	const endA = refl.opacity ?? 0;
+	const contactPx = (box.y + box.h) / EMU_PER_PX;
+	const transform = `translate(0 ${(refl.distEmu / EMU_PER_PX + contactPx * (1 - f)).toFixed(2)}) scale(1 ${f})`;
+	const maskId = mintId();
+	const gradId = mintId();
+	const defs = `<defs><linearGradient id="${gradId}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#fff" stop-opacity="${startA.toFixed(3)}"/><stop offset="1" stop-color="#fff" stop-opacity="${endA.toFixed(3)}"/></linearGradient><mask id="${maskId}" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#${gradId})"/></mask></defs>`;
+	return {
+		svg: `<g transform="${transform}" mask="url(#${maskId})" data-pptx-reflection="1">${geomRaw}</g>`,
+		defs
+	};
+};
+const buildEffectsFilter = (pres, shape) => {
+	let effects;
+	try {
+		effects = getShapeEffectsEffective(pres, shape);
+	} catch {
+		return null;
+	}
+	if (effects.length === 0) return null;
+	const id = mintId();
+	const primitives = [];
+	const layers = [];
+	for (const e of effects) if (e.kind === "outerShdw") {
+		const rad = e.angleDeg * Math.PI / 180;
+		const dx = e.distEmu * Math.cos(rad) / EMU_PER_PX;
+		const dy = e.distEmu * Math.sin(rad) / EMU_PER_PX;
+		const blurPx = e.blurEmu / EMU_PER_PX / 2;
+		const opacity = e.opacity ?? 1;
+		const color = e.color || "#000000";
+		const out = `shdwOut${primitives.length}`;
+		primitives.push(`<feDropShadow dx="${dx.toFixed(2)}" dy="${dy.toFixed(2)}" stdDeviation="${blurPx.toFixed(2)}" flood-color="${color}" flood-opacity="${opacity.toFixed(3)}" result="${out}"/>`);
+		layers.push(out);
+	} else if (e.kind === "innerShdw") {
+		const rad = e.angleDeg * Math.PI / 180;
+		const dx = e.distEmu * Math.cos(rad) / EMU_PER_PX;
+		const dy = e.distEmu * Math.sin(rad) / EMU_PER_PX;
+		const blurPx = e.blurEmu / EMU_PER_PX / 2;
+		const color = e.color || "#000000";
+		const opacity = e.opacity ?? 1;
+		const i = primitives.length;
+		primitives.push(`<feGaussianBlur in="SourceAlpha" stdDeviation="${blurPx.toFixed(2)}" result="innerBlur${i}"/>`, `<feOffset in="innerBlur${i}" dx="${dx.toFixed(2)}" dy="${dy.toFixed(2)}" result="innerOff${i}"/>`, `<feComposite in="innerOff${i}" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="innerMask${i}"/>`, `<feFlood flood-color="${color}" flood-opacity="${opacity.toFixed(3)}" result="innerCol${i}"/>`, `<feComposite in="innerCol${i}" in2="innerMask${i}" operator="in" result="innerOut${i}"/>`);
+		layers.push(`innerOut${i}`);
+	} else if (e.kind === "glow") {
+		const blurPx = e.radiusEmu / EMU_PER_PX / 2;
+		const color = e.color || "#FFFFFF";
+		const opacity = e.opacity ?? 1;
+		const i = primitives.length;
+		primitives.push(`<feMorphology in="SourceAlpha" operator="dilate" radius="${(blurPx / 4).toFixed(2)}" result="glowExp${i}"/>`, `<feGaussianBlur in="glowExp${i}" stdDeviation="${blurPx.toFixed(2)}" result="glowBlur${i}"/>`, `<feFlood flood-color="${color}" flood-opacity="${opacity.toFixed(3)}" result="glowCol${i}"/>`, `<feComposite in="glowCol${i}" in2="glowBlur${i}" operator="in" result="glowOut${i}"/>`);
+		layers.push(`glowOut${i}`);
+	} else if (e.kind === "softEdge") {
+		const blurPx = e.radiusEmu / EMU_PER_PX / 2;
+		const i = primitives.length;
+		primitives.push(`<feGaussianBlur in="SourceGraphic" stdDeviation="${blurPx.toFixed(2)}" result="softOut${i}"/>`);
+		layers.length = 0;
+		layers.push(`softOut${i}`);
+	} else if (e.kind === "blur") {
+		const blurPx = e.radiusEmu / EMU_PER_PX / 2;
+		const i = primitives.length;
+		primitives.push(`<feGaussianBlur in="SourceGraphic" stdDeviation="${blurPx.toFixed(2)}" result="blurOut${i}"/>`);
+		layers.length = 0;
+		layers.push(`blurOut${i}`);
+	}
+	if (layers.length === 0) return null;
+	const replacedSource = effects.some((e) => e.kind === "softEdge" || e.kind === "blur");
+	const mergeChildren = layers.map((l) => `<feMergeNode in="${l}"/>`).join("");
+	const sourceMerge = replacedSource ? "" : "<feMergeNode in=\"SourceGraphic\"/>";
+	primitives.push(`<feMerge>${mergeChildren}${sourceMerge}</feMerge>`);
+	return {
+		id,
+		defs: `<defs><filter id="${id}" x="-25%" y="-25%" width="150%" height="150%">${primitives.join("")}</filter></defs>`
+	};
+};
+const renderSlideSvg = (pres, slide, opts = {}) => {
+	const size = getSlideSize(pres) ?? DEFAULT_SIZE;
+	const W = size.width;
+	const H = size.height;
+	const theme = getPresentationTheme(pres);
+	activeColorMap = getEffectiveColorMap(slide);
+	activeDeckTextColor = resolveDeckBodyTextColor(slide) ?? "#000000";
+	const ctx = {
+		mode: opts.textLayout ?? "foreignObject",
+		measure: opts.measureText ?? defaultMeasurer
+	};
+	let bg = getSlideBackground(slide);
+	if (bg.kind === "inherit") {
+		const layout = getSlideLayout(slide);
+		if (layout) {
+			const layoutBg = getSlideLayoutBackground(layout);
+			if (layoutBg.kind !== "inherit") bg = layoutBg;
+			else {
+				const masterBg = getSlideMasterBackground(pres, layout);
+				if (masterBg.kind !== "inherit") bg = masterBg;
+			}
+		}
+	}
+	let bgColor = "#FFFFFF";
+	let bgGradient = "";
+	let bgGradientDefs = "";
+	if (bg.kind === "solid") bgColor = resolveColor(bg.color, theme, "#FFFFFF");
+	else if (bg.kind === "gradient") {
+		let grad = getSlideBackgroundGradientFill(slide);
+		if (!grad) {
+			const layout = getSlideLayout(slide);
+			if (layout) {
+				grad = getSlideLayoutBackgroundGradientFill(layout);
+				if (!grad) grad = getSlideMasterBackgroundGradientFill(pres, layout);
+			}
+		}
+		if (grad) {
+			const built = gradientDef(grad, theme);
+			bgGradientDefs = built.defs;
+			bgGradient = `<rect width="${E(W)}" height="${E(H)}" fill="${built.fillAttr}"/>`;
+		}
+	} else if (bg.kind === "pattern") {
+		let pat = getSlideBackgroundPatternFill(pres, slide);
+		if (!pat) {
+			const layout = getSlideLayout(slide);
+			if (layout) {
+				pat = getSlideLayoutBackgroundPatternFill(pres, layout);
+				if (!pat) pat = getSlideMasterBackgroundPatternFill(pres, layout);
+			}
+		}
+		if (pat) {
+			const built = patternDef(pat);
+			bgGradientDefs += built.defs;
+			bgGradient = `<rect width="${E(W)}" height="${E(H)}" fill="${built.fillAttr}"/>`;
+		}
+	} else if (theme && bg.kind === "inherit") bgColor = normalizeHex(theme.light1);
+	let bgImage = "";
+	if (bg.kind === "image") {
+		let bytes = getSlideBackgroundImageBytes(slide);
+		if (!bytes && pres) {
+			const layout = getSlideLayout(slide);
+			if (layout) {
+				bytes = getSlideLayoutBackgroundImageBytes(pres, layout);
+				if (!bytes) bytes = getSlideMasterBackgroundImageBytes(pres, layout);
+			}
+		}
+		if (bytes) {
+			const fmt = detectImageFormatLocal(bytes);
+			const dataUrl = `data:${fmt ? imageMime[fmt] ?? "image/png" : "image/png"};base64,${u8ToBase64(bytes)}`;
+			bgImage = `<image x="0" y="0" width="${E(W)}" height="${E(H)}" href="${dataUrl}" xlink:href="${dataUrl}" preserveAspectRatio="xMidYMid slice"/>`;
+		}
+	}
+	let layoutBgShapes = "";
+	const layoutForBg = getSlideLayout(slide);
+	if (layoutForBg) try {
+		const masterShapes = getSlideMasterShapes(pres, layoutForBg);
+		const layoutShapes = getSlideLayoutShapes(pres, layoutForBg);
+		layoutBgShapes = [...masterShapes, ...layoutShapes].map((s) => renderShape(s, pres, theme, ctx)).join("");
+	} catch {
+		layoutBgShapes = "";
+	}
+	const shapesSvg = getSlideShapes(slide).map((s) => renderShape(s, pres, theme, ctx)).join("");
+	return [
+		`<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 ${E(W)} ${E(H)}" preserveAspectRatio="xMidYMid meet">`,
+		bgGradientDefs,
+		`<rect width="${E(W)}" height="${E(H)}" fill="${bgColor}"/>`,
+		bgGradient,
+		bgImage,
+		layoutBgShapes,
+		shapesSvg,
+		"</svg>"
+	].join("");
+};
+const detectImageFormatLocal = (bytes) => {
+	if (bytes.length < 4) return null;
+	if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "png";
+	if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "jpeg";
+	if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) return "gif";
+	if (bytes[0] === 66 && bytes[1] === 77) return "bmp";
+	if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "webp";
+	return null;
+};
+//#endregion
+export { SERIF as a, substituteFamily as c, SANS as i, ARIAL as n, TIMES as o, MONO as r, defaultMeasurer as s, renderSlideSvg as t };
+
+//# sourceMappingURL=src-CDTTqUfI.js.map