pptx-react-viewer 1.25.5 → 2.0.0

package/dist/{chunk-TEN35NUX.js → chunk-OKOJVSKJ.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkIPYAN574_js = require('./chunk-IPYAN574.js');
+var chunkCLNGAVNH_js = require('./chunk-CLNGAVNH.js');
 var DOMPurify = require('dompurify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -237,6 +237,113 @@ var THEME_CATALOG = [
 function resolveThemeCatalogEntry(key, catalog = THEME_CATALOG) {
   return catalog.find((entry) => entry.key === key)?.theme;
 }
+function corePreset(id) {
+  const preset = chunkCLNGAVNH_js.THEME_PRESETS.find((p) => p.id === id);
+  if (!preset) {
+    throw new Error(`theme-gallery-presets: core THEME_PRESETS is missing "${id}"`);
+  }
+  return preset;
+}
+var WISP_PRESET = {
+  id: "wisp",
+  name: "Wisp",
+  colorScheme: {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#46393B",
+    lt2: "#E8DCD8",
+    accent1: "#A53010",
+    accent2: "#DE7E18",
+    accent3: "#9F8351",
+    accent4: "#728653",
+    accent5: "#92AA4C",
+    accent6: "#6AAC91",
+    hlink: "#FB4F14",
+    folHlink: "#E25839"
+  },
+  fontScheme: {
+    majorFont: { latin: "Century Gothic" },
+    minorFont: { latin: "Century Gothic" }
+  }
+};
+var BERLIN_PRESET = {
+  id: "berlin",
+  name: "Berlin",
+  colorScheme: {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#3E5C61",
+    lt2: "#D5E0D0",
+    accent1: "#F09415",
+    accent2: "#C1B56B",
+    accent3: "#89C2A3",
+    accent4: "#729BBE",
+    accent5: "#9A90C2",
+    accent6: "#BE8DBE",
+    hlink: "#25A0DA",
+    folHlink: "#FF7F00"
+  },
+  fontScheme: {
+    majorFont: { latin: "Trebuchet MS" },
+    minorFont: { latin: "Trebuchet MS" }
+  }
+};
+var SLICE_PRESET = {
+  id: "slice",
+  name: "Slice",
+  colorScheme: {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#2E3B4C",
+    lt2: "#C7CDD3",
+    accent1: "#E2751D",
+    accent2: "#C53B23",
+    accent3: "#A13D69",
+    accent4: "#58599E",
+    accent5: "#36749D",
+    accent6: "#4EA39A",
+    hlink: "#FD6B32",
+    folHlink: "#D14D0F"
+  },
+  fontScheme: {
+    majorFont: { latin: "Century Gothic" },
+    minorFont: { latin: "Century Gothic" }
+  }
+};
+var DIVIDEND_PRESET = {
+  id: "dividend",
+  name: "Dividend",
+  colorScheme: {
+    dk1: "#000000",
+    lt1: "#FFFFFF",
+    dk2: "#3D3D3D",
+    lt2: "#E1E1E1",
+    accent1: "#4D1434",
+    accent2: "#903163",
+    accent3: "#B2324B",
+    accent4: "#D34817",
+    accent5: "#E8971C",
+    accent6: "#FDCB00",
+    hlink: "#A03068",
+    folHlink: "#C34882"
+  },
+  fontScheme: {
+    majorFont: { latin: "Gill Sans MT" },
+    minorFont: { latin: "Gill Sans MT" }
+  }
+};
+[
+  corePreset("office"),
+  corePreset("facet"),
+  corePreset("integral"),
+  corePreset("ion"),
+  corePreset("retrospect"),
+  corePreset("organic"),
+  WISP_PRESET,
+  BERLIN_PRESET,
+  SLICE_PRESET,
+  DIVIDEND_PRESET
+];
 function collectMediaElements(elements, collector) {
   for (const element of elements) {
     if (element.type === "media") {
@@ -307,7 +414,7 @@ function buildInitialGuides(presentationGuides, firstSlideGuides) {
       guides.push({
         id: g.id,
         axis: g.orientation === "horz" ? "h" : "v",
-        position: chunkIPYAN574_js.guideEmuToPx(g.positionEmu)
+        position: chunkCLNGAVNH_js.guideEmuToPx(g.positionEmu)
       });
     }
   }
@@ -316,7 +423,7 @@ function buildInitialGuides(presentationGuides, firstSlideGuides) {
       guides.push({
         id: g.id,
         axis: g.orientation === "horz" ? "h" : "v",
-        position: chunkIPYAN574_js.guideEmuToPx(g.positionEmu)
+        position: chunkCLNGAVNH_js.guideEmuToPx(g.positionEmu)
       });
     }
   }
@@ -329,23 +436,23 @@ function getResolvedShapeClipPathFor(shapeType, width, height, adjustments) {
     return void 0;
   }
   if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
-    return chunkIPYAN574_js.getShapeClipPath(shapeType);
+    return chunkCLNGAVNH_js.getShapeClipPath(shapeType);
   }
   if (adjustments && Object.keys(adjustments).length > 0) {
-    const adjusted = chunkIPYAN574_js.getAdjustmentAwareShapeClipPath(shapeType, width, height, adjustments);
+    const adjusted = chunkCLNGAVNH_js.getAdjustmentAwareShapeClipPath(shapeType, width, height, adjustments);
     if (adjusted !== void 0) {
       return adjusted;
     }
   }
-  const fromPreset = chunkIPYAN574_js.getShapeClipPathFromPreset(shapeType, width, height, adjustments);
+  const fromPreset = chunkCLNGAVNH_js.getShapeClipPathFromPreset(shapeType, width, height, adjustments);
   if (fromPreset !== void 0) {
     return fromPreset;
   }
-  const cloud = chunkIPYAN574_js.getCloudPathForRendering(shapeType, width, height);
+  const cloud = chunkCLNGAVNH_js.getCloudPathForRendering(shapeType, width, height);
   if (cloud !== void 0) {
     return cloud;
   }
-  return chunkIPYAN574_js.getShapeClipPath(shapeType);
+  return chunkCLNGAVNH_js.getShapeClipPath(shapeType);
 }
 function buildCustomGeometryClipPath(pathData, pathWidth, pathHeight, elemWidth, elemHeight) {
   if (!pathData || !Number.isFinite(pathWidth) || !Number.isFinite(pathHeight) || pathWidth <= 0 || pathHeight <= 0 || !Number.isFinite(elemWidth) || !Number.isFinite(elemHeight) || elemWidth <= 0 || elemHeight <= 0) {
@@ -548,6 +655,42 @@ function buildShapePathGradient(stops, focalPoint, fillToRect) {
   const posY = focalPoint ? `${Math.round(cy)}%` : "center";
   return `radial-gradient(farthest-side at ${posX} ${posY}, ${stopStr})`;
 }
+function getGradientTileFlipCss(mode) {
+  if (!mode || mode === "none") {
+    return void 0;
+  }
+  switch (mode) {
+    case "x":
+      return { backgroundSize: "50% 100%", backgroundRepeat: "repeat-x" };
+    case "y":
+      return { backgroundSize: "100% 50%", backgroundRepeat: "repeat-y" };
+    case "xy":
+      return { backgroundSize: "50% 50%", backgroundRepeat: "repeat" };
+    default:
+      return void 0;
+  }
+}
+function getGradientTileRectCss(tileRect) {
+  if (!tileRect) {
+    return void 0;
+  }
+  const { l, t, r, b } = tileRect;
+  const sizeW = 1 - l - r;
+  const sizeH = 1 - t - b;
+  if (sizeW <= 0 || sizeH <= 0) {
+    return void 0;
+  }
+  if (Math.abs(sizeW - 1) < 1e-3 && Math.abs(sizeH - 1) < 1e-3) {
+    return void 0;
+  }
+  const posX = 1 - sizeW > 1e-3 ? l / (1 - sizeW) * 100 : 0;
+  const posY = 1 - sizeH > 1e-3 ? t / (1 - sizeH) * 100 : 0;
+  return {
+    backgroundSize: `${Math.round(sizeW * 100)}% ${Math.round(sizeH * 100)}%`,
+    backgroundPosition: `${Math.round(posX)}% ${Math.round(posY)}%`,
+    backgroundRepeat: "no-repeat"
+  };
+}
 function buildReflectedGradientStops(stops) {
   if (stops.length === 0) {
     return [];
@@ -866,6 +1009,23 @@ function getPatternSvg(preset, fg, bg) {
       return null;
   }
 }
+function buildPatternFill(pattern, elementId) {
+  if (!pattern || pattern.fillMode !== "pattern" || !pattern.fillPatternPreset) {
+    return void 0;
+  }
+  const fg = normalizeHexColor(pattern.fillColor, "#000000");
+  const bg = normalizeHexColor(pattern.fillPatternBackgroundColor, "#ffffff");
+  const preset = pattern.fillPatternPreset;
+  const svgPattern = getPatternSvg(preset, fg, bg);
+  if (!svgPattern) {
+    return void 0;
+  }
+  const encoded = encodeURIComponent(svgPattern);
+  return {
+    backgroundImage: `url("data:image/svg+xml,${encoded}")`,
+    backgroundColor: bg
+  };
+}
 function buildPatternFillCss(style) {
   if (!style || style.fillMode !== "pattern" || !style.fillPatternPreset) {
     return void 0;
@@ -940,6 +1100,81 @@ var OOXML_PATTERN_PRESETS = [
   "trellis",
   "zigZag"
 ];
+function getComputedFillStyle(element, parentGroupFill) {
+  if (!chunkCLNGAVNH_js.hasShapeProperties(element)) {
+    return void 0;
+  }
+  const ss = element.shapeStyle;
+  if (!ss) {
+    return {};
+  }
+  if (ss.fillMode === "group") {
+    return parentGroupFill ? resolveComputedFill(parentGroupFill, element) : {};
+  }
+  return resolveComputedFill(ss, element);
+}
+function resolveComputedFill(ss, element) {
+  const imageFillUrl = ss.fillMode === "image" && ss.fillImageUrl ? ss.fillImageUrl : void 0;
+  if (imageFillUrl) {
+    const tile = ss.fillImageMode === "tile";
+    return {
+      backgroundColor: "transparent",
+      backgroundImage: `url(${imageFillUrl})`,
+      backgroundRepeat: tile ? "repeat" : "no-repeat",
+      backgroundSize: tile ? "auto" : "100% 100%"
+    };
+  }
+  const geometry = {
+    rotation: element.rotation,
+    width: element.width,
+    height: element.height
+  };
+  const gradient = buildGradientCss(ss, geometry) ?? (ss.fillMode === "gradient" ? ss.fillGradient : void 0);
+  if (gradient) {
+    const isStructuredLinear = ss.fillMode === "gradient" && (ss.fillGradientType || "linear") === "linear" && sanitizeGradientStops(ss.fillGradientStops).length > 0;
+    const tileFlip = isStructuredLinear ? getGradientTileFlipCss(ss.fillGradientFlip) : void 0;
+    if (tileFlip) {
+      return {
+        backgroundImage: gradient,
+        backgroundSize: tileFlip.backgroundSize,
+        backgroundRepeat: tileFlip.backgroundRepeat
+      };
+    }
+    const tileRect = ss.fillMode === "gradient" ? getGradientTileRectCss(ss.fillGradientTileRect) : void 0;
+    if (tileRect) {
+      return {
+        backgroundImage: gradient,
+        backgroundSize: tileRect.backgroundSize,
+        backgroundPosition: tileRect.backgroundPosition,
+        backgroundRepeat: tileRect.backgroundRepeat
+      };
+    }
+    return { backgroundImage: gradient };
+  }
+  const pattern = buildPatternFill(ss, element.id);
+  if (pattern) {
+    return {
+      backgroundColor: pattern.backgroundColor,
+      backgroundImage: pattern.backgroundImage,
+      backgroundRepeat: "repeat",
+      backgroundSize: "auto",
+      svgFilter: pattern.svgFilter
+    };
+  }
+  if (ss.fillColor && ss.fillColor !== "transparent" && ss.fillMode !== "none") {
+    return { backgroundColor: colorWithOpacity(ss.fillColor, ss.fillOpacity) };
+  }
+  return {};
+}
+function getGroupChildParentFill(group) {
+  return group.type === "group" ? group.groupFill : void 0;
+}
+function resolveGroupChildFill(child2, parentGroupFill) {
+  if (!parentGroupFill || !chunkCLNGAVNH_js.hasShapeProperties(child2) || child2.shapeStyle?.fillMode !== "group") {
+    return void 0;
+  }
+  return getComputedFillStyle(child2, parentGroupFill);
+}
 function normalizeStrokeDashType(value) {
   const normalized = String(value || "").trim().toLowerCase();
   if (!normalized) {
@@ -1138,7 +1373,7 @@ var DEFAULT_SCHEME_COLOR_MAP = {
   phclr: "#4472C4"
 };
 function applyDrawingColorTransforms2(baseColor, colorNode) {
-  return chunkIPYAN574_js.applyDrawingColorTransforms(baseColor, colorNode);
+  return chunkCLNGAVNH_js.applyDrawingColorTransforms(baseColor, colorNode);
 }
 function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
   if (!colorNode) {
@@ -1150,8 +1385,8 @@ function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
     const green = parseDrawingPercent(scrgb["@_g"]);
     const blue = parseDrawingPercent(scrgb["@_b"]);
     if (red !== void 0 && green !== void 0 && blue !== void 0) {
-      const toHex = (value) => Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
-      const base = `#${toHex(red * 255)}${toHex(green * 255)}${toHex(blue * 255)}`;
+      const toHex2 = (value) => Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+      const base = `#${toHex2(red * 255)}${toHex2(green * 255)}${toHex2(blue * 255)}`;
       return applyDrawingColorTransforms2(base, scrgb);
     }
   }
@@ -1190,9 +1425,9 @@ function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
       const h = hueRaw / 6e4;
       const s = clampUnitInterval(satRaw / 1e5);
       const l = clampUnitInterval(lumRaw / 1e5);
-      const rgb = chunkIPYAN574_js.hslToRgb(h, s, l);
-      const toHex = (value) => Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
-      const base = `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+      const rgb = chunkCLNGAVNH_js.hslToRgb(h, s, l);
+      const toHex2 = (value) => Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+      const base = `#${toHex2(rgb.r)}${toHex2(rgb.g)}${toHex2(rgb.b)}`;
       return applyDrawingColorTransforms2(base, hslNode);
     }
   }
@@ -1200,7 +1435,7 @@ function parseDrawingColorChoice(colorNode, schemeColorOverrides) {
     const preset = String(
       colorNode["a:prstClr"]?.["@_val"] || ""
     ).toLowerCase();
-    const mapped = chunkIPYAN574_js.PRESET_COLOR_MAP[preset];
+    const mapped = chunkCLNGAVNH_js.PRESET_COLOR_MAP[preset];
     if (!mapped) {
       return void 0;
     }
@@ -1364,6 +1599,9 @@ function hasDistinctScriptFonts(fonts) {
 }
 var DEFAULT_SHADOW_COLOR = "#000000";
 var DEFAULT_GLOW_COLOR = "#ffff00";
+function escapeSvgAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 function clampUnitInterval2(value) {
   return Math.min(1, Math.max(0, value));
 }
@@ -1411,10 +1649,23 @@ function getOuterShadowCss(style) {
   }
   const blur = typeof style.shadowBlur === "number" && Number.isFinite(style.shadowBlur) ? Math.max(0, style.shadowBlur) : 6;
   const opacity = typeof style.shadowOpacity === "number" && Number.isFinite(style.shadowOpacity) ? clampUnitInterval2(style.shadowOpacity) : 0.35;
-  return `${Math.round(offsetX)}px ${Math.round(offsetY)}px ${Math.round(blur)}px ${colorWithOpacity2(
+  const spread = getShadowScaleSpread(style.shadowScaleX, style.shadowScaleY, blur);
+  const color = colorWithOpacity2(
     normalizeHexColor2(style.shadowColor, DEFAULT_SHADOW_COLOR),
     opacity
-  )}`;
+  );
+  const geometry = `${Math.round(offsetX)}px ${Math.round(offsetY)}px ${Math.round(blur)}px`;
+  return spread === 0 ? `${geometry} ${color}` : `${geometry} ${spread}px ${color}`;
+}
+function getShadowScaleSpread(scaleX, scaleY, blur) {
+  const sx = typeof scaleX === "number" && Number.isFinite(scaleX) ? scaleX / 1e5 : 1;
+  const sy = typeof scaleY === "number" && Number.isFinite(scaleY) ? scaleY / 1e5 : 1;
+  const avgScale = (sx + sy) / 2;
+  if (avgScale === 1) {
+    return 0;
+  }
+  const base = Math.max(blur, 4);
+  return Math.round(base * (avgScale - 1));
 }
 function getInnerShadowCss(style) {
   if (!style?.innerShadowColor || style.innerShadowColor === "transparent") {
@@ -1463,6 +1714,32 @@ function getGlowBoxShadowCss(color, radius, opacity) {
   const c3 = colorWithOpacity2(normalizedColor, baseOpacity * 0.3);
   return `0 0 ${r1}px ${c1}, 0 0 ${r2}px ${c2}, 0 0 ${r3}px ${c3}`;
 }
+function getBoxShadowCss(style, options = {}) {
+  if (!style) {
+    return void 0;
+  }
+  const parts = [];
+  const multiLayer = getMultiLayerShadowCss(style);
+  if (multiLayer) {
+    parts.push(multiLayer);
+  } else {
+    const outer = getOuterShadowCss(style);
+    if (outer) {
+      parts.push(outer);
+    }
+  }
+  const inner = getInnerShadowCss(style);
+  if (inner) {
+    parts.push(inner);
+  }
+  if (options.includeGlow !== false) {
+    const glow = getGlowBoxShadowCss(style.glowColor, style.glowRadius, style.glowOpacity);
+    if (glow) {
+      parts.push(glow);
+    }
+  }
+  return parts.length > 0 ? parts.join(", ") : void 0;
+}
 var buildShadowCssFromShapeStyle = getOuterShadowCss;
 var buildInnerShadowCssFromShapeStyle = getInnerShadowCss;
 var buildMultiLayerShadowCss = getMultiLayerShadowCss;
@@ -1514,18 +1791,164 @@ function getEffectDagCssFilter(style, elementId) {
   return filters.length > 0 ? filters.join(" ") : void 0;
 }
 var getEffectDagFilter = getEffectDagCssFilter;
-function buildReflectionCssValue(distance, startOpacity, endOpacity, fadeLength, blurRadius = 0) {
+function getEffectFilterCss(style, elementId) {
+  if (!style) {
+    return void 0;
+  }
+  const parts = [];
+  if (style.glowColor && style.glowColor !== "transparent" && style.glowRadius) {
+    const glowOpacity = typeof style.glowOpacity === "number" ? style.glowOpacity : 0.75;
+    const glowRad = Math.round(Math.max(0, style.glowRadius));
+    const glowCol = colorWithOpacity2(
+      normalizeHexColor2(style.glowColor, DEFAULT_GLOW_COLOR),
+      glowOpacity
+    );
+    parts.push(`drop-shadow(0 0 ${glowRad}px ${glowCol})`);
+  }
+  if (typeof style.softEdgeRadius === "number" && style.softEdgeRadius > 0) {
+    if (elementId) {
+      parts.push(`url(#${getSoftEdgeFilterId(elementId)})`);
+    } else {
+      parts.push(`blur(${Math.min(2, Math.round(style.softEdgeRadius))}px)`);
+    }
+  }
+  if (typeof style.blurRadius === "number" && style.blurRadius > 0) {
+    parts.push(`blur(${Math.round(style.blurRadius)}px)`);
+  }
+  const dagFilter = getEffectDagCssFilter(style, elementId);
+  if (dagFilter) {
+    parts.push(dagFilter);
+  }
+  return parts.length > 0 ? parts.join(" ") : void 0;
+}
+function buildReflectionCssValue(distance, startOpacity, endOpacity, fadeLength, blurRadius = 0, startOffset = 0) {
   const effectiveFadeLength = fadeLength + blurRadius * 2;
   const midOpacity = (startOpacity + endOpacity) / 2;
   const midPoint = Math.round(effectiveFadeLength * 0.5);
+  const holdPx = Math.round(Math.max(0, Math.min(startOffset, effectiveFadeLength - 1)));
+  const holdStop = holdPx > 0 ? `rgba(255,255,255,${startOpacity}) ${holdPx}px, ` : "";
   if (blurRadius > 0) {
-    return `below ${Math.round(distance)}px linear-gradient(to bottom, rgba(255,255,255,${startOpacity}), rgba(255,255,255,${midOpacity}) ${midPoint}px, rgba(255,255,255,${endOpacity}) ${effectiveFadeLength}px)`;
+    return `below ${Math.round(distance)}px linear-gradient(to bottom, rgba(255,255,255,${startOpacity}), ${holdStop}rgba(255,255,255,${midOpacity}) ${midPoint}px, rgba(255,255,255,${endOpacity}) ${effectiveFadeLength}px)`;
+  }
+  return `below ${Math.round(distance)}px linear-gradient(to bottom, rgba(255,255,255,${startOpacity}), ${holdStop}rgba(255,255,255,${endOpacity}) ${fadeLength}px)`;
+}
+function getReflectionCss(style, elementHeight) {
+  if (!style) {
+    return void 0;
+  }
+  const hasReflection = typeof style.reflectionStartOpacity === "number" && style.reflectionStartOpacity > 0 || typeof style.reflectionDistance === "number" && style.reflectionDistance > 0 || typeof style.reflectionBlurRadius === "number" && style.reflectionBlurRadius > 0;
+  if (!hasReflection) {
+    return void 0;
+  }
+  const distance = style.reflectionDistance ?? 0;
+  const startOpacity = typeof style.reflectionStartOpacity === "number" ? style.reflectionStartOpacity : 0.5;
+  const endOpacity = typeof style.reflectionEndOpacity === "number" ? style.reflectionEndOpacity : 0;
+  const fadeLength = typeof style.reflectionEndPosition === "number" ? Math.round(style.reflectionEndPosition * Math.max(elementHeight, 1)) : 100;
+  const blurRadius = typeof style.reflectionBlurRadius === "number" ? style.reflectionBlurRadius : 0;
+  const startOffset = typeof style.reflectionStartPosition === "number" && style.reflectionStartPosition > 0 ? Math.round(clampUnitInterval2(style.reflectionStartPosition) * fadeLength) : 0;
+  return {
+    webkitBoxReflect: buildReflectionCssValue(
+      distance,
+      startOpacity,
+      endOpacity,
+      fadeLength,
+      blurRadius,
+      startOffset
+    ),
+    distance,
+    startOpacity,
+    endOpacity,
+    fadeLength,
+    blurRadius
+  };
+}
+function getEffectDagOpacity(style) {
+  if (!style || typeof style.dagAlphaModFix !== "number") {
+    return void 0;
+  }
+  return clampUnitInterval2(style.dagAlphaModFix / 100);
+}
+function getEffectDagBlendMode(blend) {
+  switch (blend) {
+    case "mult":
+      return "multiply";
+    case "screen":
+      return "screen";
+    case "darken":
+      return "darken";
+    case "lighten":
+      return "lighten";
+    default:
+      return void 0;
+  }
+}
+function getEffectDagFillOverlay(style) {
+  if (!style?.dagFillOverlayColor || style.dagFillOverlayColor === "transparent") {
+    return void 0;
   }
-  return `below ${Math.round(distance)}px linear-gradient(to bottom, rgba(255,255,255,${startOpacity}), rgba(255,255,255,${endOpacity}) ${fadeLength}px)`;
+  const blendMode = getEffectDagBlendMode(style.dagFillOverlayBlend) ?? "normal";
+  const color = colorWithOpacity2(
+    normalizeHexColor2(style.dagFillOverlayColor, DEFAULT_SHADOW_COLOR),
+    style.dagFillOverlayOpacity
+  );
+  return { color, blendMode };
 }
 function getDuotoneFilterId(elementId) {
   return `dag-duotone-${elementId}`;
 }
+function getSoftEdgeFilterId(elementId) {
+  return `soft-edge-${elementId}`;
+}
+function getSoftEdgeSvgFilter(style, elementId) {
+  if (!style || typeof style.softEdgeRadius !== "number" || style.softEdgeRadius <= 0) {
+    return void 0;
+  }
+  const id = getSoftEdgeFilterId(elementId);
+  const radius = Math.round(style.softEdgeRadius);
+  const filterMarkup = [
+    `<filter id="${escapeSvgAttr(id)}" x="-20%" y="-20%" width="140%" height="140%" color-interpolation-filters="sRGB">`,
+    `<feGaussianBlur in="SourceAlpha" stdDeviation="${radius}" result="softEdgeAlpha"/>`,
+    `<feComposite in="SourceGraphic" in2="softEdgeAlpha" operator="in"/>`,
+    `</filter>`
+  ].join("");
+  return { id, cssReference: `url(#${id})`, filterMarkup };
+}
+function getComputedEffectStyle(element, options = {}) {
+  const style = "shapeStyle" in element ? element.shapeStyle : void 0;
+  const result = {};
+  if (!style) {
+    return result;
+  }
+  const boxShadow = getBoxShadowCss(style, { includeGlow: options.includeGlowBoxShadow });
+  if (boxShadow) {
+    result.boxShadow = boxShadow;
+  }
+  const filter = getEffectFilterCss(style, element.id);
+  if (filter) {
+    result.filter = filter;
+  }
+  const reflection = getReflectionCss(style, element.height);
+  if (reflection) {
+    result.webkitBoxReflect = reflection.webkitBoxReflect;
+  }
+  const opacity = getEffectDagOpacity(style);
+  if (opacity !== void 0) {
+    result.opacity = opacity;
+  }
+  const overlay = getEffectDagFillOverlay(style);
+  if (overlay) {
+    result.fillOverlay = overlay;
+  } else {
+    const blend = getEffectDagBlendMode(style.dagFillOverlayBlend);
+    if (blend) {
+      result.mixBlendMode = blend;
+    }
+  }
+  if (style.blurGrow && typeof style.blurRadius === "number" && style.blurRadius > 0) {
+    result.overflowVisible = true;
+  }
+  return result;
+}
 function clamp(value, minimum, maximum) {
   return Math.min(maximum, Math.max(minimum, value));
 }
@@ -1555,7 +1978,7 @@ function hexToRgbUnit2(hex) {
   };
 }
 function getEffects(element) {
-  if (!chunkIPYAN574_js.isImageLikeElement(element)) {
+  if (!chunkCLNGAVNH_js.isImageLikeElement(element)) {
     return void 0;
   }
   return element.imageEffects;
@@ -1744,7 +2167,7 @@ function buildDuotoneFilterMarkup(color1, color2) {
   const c2 = hexToRgbUnit2(color2);
   return `<feColorMatrix type="matrix" values="${GRAYSCALE_LUMINANCE_MATRIX}"/><feComponentTransfer><feFuncR type="linear" slope="${c2.r - c1.r}" intercept="${c1.r}"/><feFuncG type="linear" slope="${c2.g - c1.g}" intercept="${c1.g}"/><feFuncB type="linear" slope="${c2.b - c1.b}" intercept="${c1.b}"/></feComponentTransfer>`;
 }
-function getDuotoneImageFilter(element, elementId = chunkIPYAN574_js.isImageLikeElement(element) ? element.id : "") {
+function getDuotoneImageFilter(element, elementId = chunkCLNGAVNH_js.isImageLikeElement(element) ? element.id : "") {
   const effects = getEffects(element);
   if (!effects?.duotone) {
     return void 0;
@@ -1846,7 +2269,7 @@ function buildImageAlphaFilterMarkup(effects) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-function getImageAlphaFilter(element, elementId = chunkIPYAN574_js.isImageLikeElement(element) ? element.id : "") {
+function getImageAlphaFilter(element, elementId = chunkCLNGAVNH_js.isImageLikeElement(element) ? element.id : "") {
   const effects = getEffects(element);
   if (!effects || !hasAdvancedImageAlphaEffects(element)) {
     return void 0;
@@ -1936,7 +2359,7 @@ function buildArtisticFilterMarkup(effectName, radius) {
       return void 0;
   }
 }
-function getArtisticImageFilter(element, elementId = chunkIPYAN574_js.isImageLikeElement(element) ? element.id : "") {
+function getArtisticImageFilter(element, elementId = chunkCLNGAVNH_js.isImageLikeElement(element) ? element.id : "") {
   const effects = getEffects(element);
   if (!effects?.artisticEffect || !needsSvgArtisticFilter(effects.artisticEffect)) {
     return void 0;
@@ -2895,7 +3318,7 @@ function convertChildren(node) {
     if (key.startsWith("@_")) {
       continue;
     }
-    const tag = chunkIPYAN574_js.stripXmlOrderSuffix(key);
+    const tag = chunkCLNGAVNH_js.stripXmlOrderSuffix(key);
     if (tag === "m:oMathPara") {
       continue;
     }
@@ -2967,7 +3390,7 @@ function findOmathRoots(node) {
     }
   }
   const contentTags = /* @__PURE__ */ new Set(["m:r", "m:f", "m:rad", "m:sSup", "m:sSub", "m:box"]);
-  if (Object.keys(node).some((key) => contentTags.has(chunkIPYAN574_js.stripXmlOrderSuffix(key)))) {
+  if (Object.keys(node).some((key) => contentTags.has(chunkCLNGAVNH_js.stripXmlOrderSuffix(key)))) {
     return [node];
   }
   return [];
@@ -3175,11 +3598,11 @@ function mergeSiblings(nodes) {
     for (const [key] of entries) {
       counts.set(key, (counts.get(key) ?? 0) + 1);
     }
-    const ordered = {};
+    const ordered2 = {};
     for (const [position, [key, value]] of entries.entries()) {
-      ordered[(counts.get(key) ?? 0) > 1 ? chunkIPYAN574_js.orderedXmlKey(key, position) : key] = value;
+      ordered2[(counts.get(key) ?? 0) > 1 ? chunkCLNGAVNH_js.orderedXmlKey(key, position) : key] = value;
     }
-    return ordered;
+    return ordered2;
   }
   const result = {};
   for (const [key, value] of entries) {
@@ -3581,7 +4004,7 @@ function ommlChildrenToLatex(node) {
     if (key.startsWith("@_")) {
       continue;
     }
-    const tag = chunkIPYAN574_js.stripXmlOrderSuffix(key);
+    const tag = chunkCLNGAVNH_js.stripXmlOrderSuffix(key);
     const items = ensureArr(node[key]);
     for (const item of items) {
       const result = ommlElementToLatex(tag, item);
@@ -3795,8 +4218,8 @@ function hexToRgb(hex) {
   ];
 }
 function rgbToHex(r, g, b) {
-  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp7(r).toString(16).padStart(2, "0")}${clamp7(g).toString(16).padStart(2, "0")}${clamp7(b).toString(16).padStart(2, "0")}`;
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp8(r).toString(16).padStart(2, "0")}${clamp8(g).toString(16).padStart(2, "0")}${clamp8(b).toString(16).padStart(2, "0")}`;
 }
 function tint(hex, amount) {
   const [r, g, b] = hexToRgb(hex);
@@ -4190,6 +4613,26 @@ function splitSeriesByAxis(series, axes) {
   }
   return { primary, secondary };
 }
+function hexToRgb2(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.substring(0, 2), 16),
+    parseInt(h.substring(2, 4), 16),
+    parseInt(h.substring(4, 6), 16)
+  ];
+}
+function rgbToHex2(r, g, b) {
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp8(r).toString(16).padStart(2, "0")}${clamp8(g).toString(16).padStart(2, "0")}${clamp8(b).toString(16).padStart(2, "0")}`;
+}
+function tint2(hex, amount) {
+  const [r, g, b] = hexToRgb2(hex);
+  return rgbToHex2(r + (255 - r) * amount, g + (255 - g) * amount, b + (255 - b) * amount);
+}
+function shade2(hex, amount) {
+  const [r, g, b] = hexToRgb2(hex);
+  return rgbToHex2(r * (1 - amount), g * (1 - amount), b * (1 - amount));
+}
 function findDataPoint(series, pointIndex) {
   return series.dataPoints?.find((p) => p.idx === pointIndex);
 }
@@ -4204,6 +4647,134 @@ function resolveDataPointExplosion(series, pointIndex) {
   const point = findDataPoint(series, pointIndex);
   return point?.explosion ?? series.explosion ?? 0;
 }
+var DEFAULT_ROT_X = 15;
+var DEFAULT_ROT_Y = 20;
+var MIN_DEPTH_PX = 5;
+var MAX_DEPTH_PX = 22;
+function computeDepthVector(view3D) {
+  const rotX = view3D?.rotX ?? DEFAULT_ROT_X;
+  const rotY = view3D?.rotY ?? DEFAULT_ROT_Y;
+  const depthScale = Math.min(Math.max((view3D?.depthPercent ?? 100) / 100, 0.4), 2);
+  const magnitude = Math.min(Math.max(13 * depthScale, MIN_DEPTH_PX), MAX_DEPTH_PX);
+  const rx = rotX * Math.PI / 180;
+  const ry = rotY * Math.PI / 180;
+  return {
+    dx: Math.sin(ry) * magnitude,
+    dy: -Math.sin(rx) * magnitude,
+    magnitude
+  };
+}
+function barExtrusion(rect, depth) {
+  const { x, y, w, h, fill } = rect;
+  const { dx, dy } = depth;
+  const topFace = {
+    kind: "polygon",
+    points: `${x},${y} ${x + w},${y} ${x + w + dx},${y + dy} ${x + dx},${y + dy}`,
+    fill: tint2(fill, 0.22),
+    stroke: "none",
+    strokeWidth: 0
+  };
+  const sideFace = {
+    kind: "polygon",
+    points: `${x + w},${y} ${x + w},${y + h} ${x + w + dx},${y + h + dy} ${x + w + dx},${y + dy}`,
+    fill: shade2(fill, 0.25),
+    stroke: "none",
+    strokeWidth: 0
+  };
+  return [topFace, sideFace];
+}
+function translateSlicePath(d, dx, dy) {
+  const tokens = d.match(/[MLAZ][^MLAZ]*/gu);
+  if (!tokens) {
+    return d;
+  }
+  return tokens.map((token) => {
+    const cmd = token[0];
+    const nums = token.slice(1).trim().split(/[ ,]+/u).filter((s) => s.length > 0).map(Number);
+    if (cmd === "M" || cmd === "L") {
+      const out = [];
+      for (let i = 0; i < nums.length; i += 2) {
+        out.push(nums[i] + dx, nums[i + 1] + dy);
+      }
+      return `${cmd}${pairs(out)}`;
+    }
+    if (cmd === "A") {
+      const head = nums.slice(0, 5);
+      const ex = nums[5] + dx;
+      const ey = nums[6] + dy;
+      return `A${head.join(",")},${ex},${ey}`;
+    }
+    return "Z";
+  }).join("");
+}
+function pairs(nums) {
+  const out = [];
+  for (let i = 0; i < nums.length; i += 2) {
+    out.push(`${nums[i]},${nums[i + 1]}`);
+  }
+  return out.join(" ");
+}
+function pieExtrusion(paths, depth) {
+  const offsetY = Math.max(depth.magnitude, 6);
+  return paths.map((p) => ({
+    kind: "path",
+    d: translateSlicePath(p.d, 0, offsetY),
+    fill: shade2(p.fill, 0.32),
+    stroke: shade2(p.fill, 0.4),
+    strokeWidth: 0.5
+  }));
+}
+function ribbonExtrusion(prims, depth) {
+  const out = [];
+  for (const prim of prims) {
+    if (prim.kind === "polyline") {
+      const pl = prim;
+      out.push({
+        ...pl,
+        points: shiftPoints(pl.points, depth.dx, depth.dy),
+        stroke: shade2(pl.stroke, 0.3),
+        fill: "none",
+        part: void 0
+      });
+    } else if (prim.kind === "polygon") {
+      const pg = prim;
+      out.push({
+        ...pg,
+        points: shiftPoints(pg.points, depth.dx, depth.dy),
+        fill: shade2(pg.fill === "none" ? "#888888" : pg.fill, 0.3),
+        part: void 0
+      });
+    }
+  }
+  return out;
+}
+function shiftPoints(points, dx, dy) {
+  return points.trim().split(/\s+/u).map((pair) => {
+    const [px3, py] = pair.split(",").map(Number);
+    return `${px3 + dx},${py + dy}`;
+  }).join(" ");
+}
+function applyChart3DDepth(vm, chartType, view3D) {
+  const depth = computeDepthVector(view3D);
+  let extrusion = [];
+  if (chartType === "bar3D") {
+    const bars = vm.primitives.filter(
+      (p) => p.kind === "rect" && p.part?.role === "dataPoint"
+    );
+    extrusion = bars.flatMap((r) => barExtrusion(r, depth));
+  } else if (chartType === "pie3D") {
+    const slices = vm.primitives.filter((p) => p.kind === "path");
+    extrusion = pieExtrusion(slices, depth);
+  } else if (chartType === "line3D" || chartType === "area3D") {
+    extrusion = ribbonExtrusion(vm.primitives, depth);
+  } else {
+    return vm;
+  }
+  if (extrusion.length === 0) {
+    return vm;
+  }
+  return { ...vm, primitives: [...extrusion, ...vm.primitives] };
+}
 function clamp3(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
@@ -4225,7 +4796,7 @@ function horizontalAxisY(valueAxis, range, layout, fallback) {
   }
   return fallback === "top" ? layout.plotTop : layout.plotBottom;
 }
-function verticalAxisX(categoryAxis, categoryCount, layout, fallback, dateValues) {
+function verticalAxisX(categoryAxis, categoryCount2, layout, fallback, dateValues) {
   if (categoryAxis?.crosses === "max") {
     return layout.plotRight;
   }
@@ -4239,8 +4810,8 @@ function verticalAxisX(categoryAxis, categoryCount, layout, fallback, dateValues
       const ratio2 = max === min ? 0.5 : (clamp3(categoryAxis.crossesAt, min, max) - min) / (max - min);
       return layout.plotLeft + ratio2 * layout.plotWidth;
     }
-    const index = clamp3(categoryAxis.crossesAt - 1, 0, Math.max(categoryCount - 1, 0));
-    const ratio = categoryCount <= 1 ? 0.5 : index / (categoryCount - 1);
+    const index = clamp3(categoryAxis.crossesAt - 1, 0, Math.max(categoryCount2 - 1, 0));
+    const ratio = categoryCount2 <= 1 ? 0.5 : index / (categoryCount2 - 1);
     return layout.plotLeft + ratio * layout.plotWidth;
   }
   return fallback === "right" ? layout.plotRight : layout.plotLeft;
@@ -4532,7 +5103,7 @@ function hasRicherAxisFeatures(chartData) {
     )
   );
 }
-function buildCartesianAxes(chartData, layout, primaryRange, secondaryRange, categoryCount) {
+function buildCartesianAxes(chartData, layout, primaryRange, secondaryRange, categoryCount2) {
   if (!hasRicherAxisFeatures(chartData)) {
     const { gridlines, axisLabels } = buildGridlinesAndLabels(primaryRange, layout);
     return { gridlines, axisLabels, secondaryGridlines: void 0, secondaryAxisLabels: void 0 };
@@ -4543,7 +5114,7 @@ function buildCartesianAxes(chartData, layout, primaryRange, secondaryRange, cat
   );
   const axisX = (axisId, fallback) => verticalAxisX(
     categoryAxisFor(axisId),
-    categoryCount,
+    categoryCount2,
     layout,
     fallback,
     chartData.dateCategories?.values
@@ -4750,6 +5321,62 @@ function pushClusteredStackedLabels(series, sourceIndices2, catCount, layout, ra
     }
   }
 }
+function interpolate(values, blank) {
+  const out = [...values];
+  for (let i = 0; i < out.length; i++) {
+    if (!blank[i]) {
+      continue;
+    }
+    let prev = i - 1;
+    while (prev >= 0 && blank[prev]) {
+      prev--;
+    }
+    let next = i + 1;
+    while (next < out.length && blank[next]) {
+      next++;
+    }
+    const hasPrev = prev >= 0;
+    const hasNext = next < out.length;
+    if (hasPrev && hasNext) {
+      const t = (i - prev) / (next - prev);
+      out[i] = values[prev] + (values[next] - values[prev]) * t;
+    } else if (hasPrev) {
+      out[i] = values[prev];
+    } else if (hasNext) {
+      out[i] = values[next];
+    }
+  }
+  return out;
+}
+function resolveBlankDisplay(values, blanks, mode) {
+  const visible = values.map(() => true);
+  if (!blanks || !blanks.some(Boolean) || mode === void 0 || mode === "zero") {
+    return { values: [...values], visible };
+  }
+  if (mode === "span") {
+    return { values: interpolate(values, blanks), visible };
+  }
+  return {
+    values: [...values],
+    visible: values.map((_v, i) => !blanks[i])
+  };
+}
+function visibleRuns(visible) {
+  const runs = [];
+  let current = [];
+  for (let i = 0; i < visible.length; i++) {
+    if (visible[i]) {
+      current.push(i);
+    } else if (current.length > 0) {
+      runs.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) {
+    runs.push(current);
+  }
+  return runs;
+}
 function smoothLinePath(points) {
   if (points.length === 0) {
     return "";
@@ -4893,7 +5520,13 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
       continue;
     }
     const activeRange = secondaryIdx.has(si) && secondaryRange ? secondaryRange : primaryRange;
-    const displayValues = sourceIndices2.map((sourceIndex) => series.values[sourceIndex] ?? 0);
+    const rawValues = sourceIndices2.map((sourceIndex) => series.values[sourceIndex] ?? 0);
+    const displayBlanks = sourceIndices2.map((sourceIndex) => series.blanks?.[sourceIndex] ?? false);
+    const { values: displayValues, visible } = resolveBlankDisplay(
+      rawValues,
+      displayBlanks,
+      chartData.chartChrome?.dispBlanksAs
+    );
     const pts = computeLinePoints(displayValues, catCount, layout, activeRange).map(
       (point, index) => ({
         ...point,
@@ -4902,24 +5535,44 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
     );
     const c = seriesColor2(series, si, chartData.colorPalette);
     const seriesPart = { role: "series", seriesIndex: si };
-    primitives.push(
-      series.smooth ? {
-        kind: "path",
-        d: smoothLinePath(pts),
-        stroke: c,
-        strokeWidth: 2.4,
-        fill: "none",
-        part: seriesPart
-      } : {
-        kind: "polyline",
-        points: linePointsToSvgString(pts),
-        stroke: c,
-        strokeWidth: 2.4,
-        fill: "none",
-        part: seriesPart
+    const allVisible = visible.every(Boolean);
+    if (allVisible) {
+      primitives.push(
+        series.smooth ? {
+          kind: "path",
+          d: smoothLinePath(pts),
+          stroke: c,
+          strokeWidth: 2.4,
+          fill: "none",
+          part: seriesPart
+        } : {
+          kind: "polyline",
+          points: linePointsToSvgString(pts),
+          stroke: c,
+          strokeWidth: 2.4,
+          fill: "none",
+          part: seriesPart
+        }
+      );
+    } else {
+      for (const run of visibleRuns(visible)) {
+        if (run.length < 2) {
+          continue;
+        }
+        primitives.push({
+          kind: "polyline",
+          points: linePointsToSvgString(run.map((i) => pts[i])),
+          stroke: c,
+          strokeWidth: 2.4,
+          fill: "none",
+          part: seriesPart
+        });
       }
-    );
+    }
     pts.forEach((pt, displayIndex) => {
+      if (!visible[displayIndex]) {
+        return;
+      }
       const idx = sourceIndices2[displayIndex] ?? displayIndex;
       const part = { role: "dataPoint", seriesIndex: si, pointIndex: idx };
       pushMarker(
@@ -4935,7 +5588,7 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
     if (showLabels) {
       displayValues.forEach((val2, displayIndex) => {
         const pt = pts[displayIndex];
-        if (!pt) {
+        if (!pt || !visible[displayIndex]) {
           return;
         }
         dataLabels.push({
@@ -5922,9 +6575,9 @@ function computeTrendlinePoints2(trendline, values, catCount, layout, range, mod
           sum += yVals[j];
         }
         const avgVal = sum / period;
-        const px2 = xToPixel2(i, catCount, layout, mode);
+        const px3 = xToPixel2(i, catCount, layout, mode);
         const py = valueToY2(avgVal, range, layout.plotTop, layout.plotBottom);
-        maPoints.push({ x: px2, y: py });
+        maPoints.push({ x: px3, y: py });
       }
       return {
         points: maPoints,
@@ -5942,9 +6595,9 @@ function computeTrendlinePoints2(trendline, values, catCount, layout, range, mod
     if (!Number.isFinite(yVal)) {
       continue;
     }
-    const px2 = xToPixel2(xVal, catCount, layout, mode);
+    const px3 = xToPixel2(xVal, catCount, layout, mode);
     const py = valueToY2(yVal, range, layout.plotTop, layout.plotBottom);
-    points.push({ x: px2, y: py });
+    points.push({ x: px3, y: py });
   }
   return { points, equation, rSquared };
 }
@@ -7375,27 +8028,312 @@ function buildSunburstViewModel(element, chartData, categoryLabels) {
     legendAnchor: "middle"
   };
 }
-function normalizedLevels(levels, pointCount) {
-  return levels.map((level) => {
-    let previous = "";
-    return Array.from({ length: pointCount }, (_, index) => {
-      const label = level[index]?.trim() ?? "";
-      if (label) {
-        previous = label;
+function resolveSecondaryIndices(values, options) {
+  const n = values.length;
+  const result = /* @__PURE__ */ new Set();
+  if (n <= 1) {
+    return result;
+  }
+  const splitType = options.splitType ?? "auto";
+  if (splitType === "cust") {
+    for (const idx of options.custSplit ?? []) {
+      if (idx >= 0 && idx < n) {
+        result.add(idx);
+      }
+    }
+  } else if (splitType === "val") {
+    const threshold = options.splitPos ?? 0;
+    values.forEach((v, i) => {
+      if (v < threshold) {
+        result.add(i);
+      }
+    });
+  } else if (splitType === "percent") {
+    const total = values.reduce((s, v) => s + Math.abs(v), 0) || 1;
+    const threshold = options.splitPos ?? 0;
+    values.forEach((v, i) => {
+      if (Math.abs(v) / total * 100 < threshold) {
+        result.add(i);
       }
-      return label || previous;
     });
+  } else {
+    const count = Math.min(Math.max(Math.round(options.splitPos ?? 2), 1), n - 1);
+    for (let i = n - count; i < n; i++) {
+      result.add(i);
+    }
+  }
+  if (result.size >= n) {
+    result.delete(0);
+  }
+  return result;
+}
+function sliceAngles(values) {
+  const total = values.reduce((s, v) => s + Math.abs(v), 0) || 1;
+  let cursor = -Math.PI / 2;
+  return values.map((v) => {
+    const span = Math.abs(v) / total * Math.PI * 2;
+    const start = cursor;
+    cursor += span;
+    return { start, end: cursor, mid: (start + cursor) / 2 };
   });
 }
-function findOrAddParent(children, label, colorIndex, parentLabelLayout) {
-  const existing = children.find((child2) => child2.children && child2.label === label);
-  if (existing) {
-    return existing;
-  }
-  const parent = {
-    label,
-    weight: 0,
-    children: [],
+function computeOfPieGeom(element, secondPieSize) {
+  const svgWidth = Math.max(element.width, 320);
+  const svgHeight = Math.max(element.height, 180);
+  const primaryR = Math.max(Math.min(svgWidth * 0.28, svgHeight * 0.4), 4);
+  const secScale = Math.min(Math.max(secondPieSize / 100, 0.3), 1.4);
+  return {
+    svgWidth,
+    svgHeight,
+    primaryCx: svgWidth * 0.3,
+    primaryCy: svgHeight * 0.52,
+    primaryR,
+    secondaryCx: svgWidth * 0.76,
+    secondaryCy: svgHeight * 0.52,
+    secondaryR: Math.max(primaryR * secScale, 4)
+  };
+}
+function sliceLabel(x, y, value) {
+  return {
+    kind: "text",
+    x,
+    y,
+    text: formatAxisValue2(value),
+    fontSize: 8,
+    fill: "#ffffff",
+    textAnchor: "middle",
+    fontWeight: "bold",
+    dominantBaseline: "central"
+  };
+}
+function buildSecondaryPie(geom, secondaryValues, fills, showLabels) {
+  const angles = sliceAngles(secondaryValues);
+  const primitives = [];
+  const labels = [];
+  angles.forEach((a, i) => {
+    const geoSlice = computePieSlicePath(
+      geom.secondaryCx,
+      geom.secondaryCy,
+      geom.secondaryR,
+      0,
+      a.start,
+      a.end
+    );
+    primitives.push({
+      kind: "path",
+      d: geoSlice.d,
+      fill: fills[i],
+      stroke: "#ffffff",
+      strokeWidth: 1.5
+    });
+    if (showLabels) {
+      labels.push(sliceLabel(geoSlice.labelX, geoSlice.labelY, secondaryValues[i]));
+    }
+  });
+  return { primitives, labels };
+}
+function buildSecondaryBar(geom, secondaryValues, fills, showLabels) {
+  const total = secondaryValues.reduce((s, v) => s + Math.abs(v), 0) || 1;
+  const barW = geom.secondaryR * 1.1;
+  const barH = geom.secondaryR * 2;
+  const barX = geom.secondaryCx - barW / 2;
+  const barTop = geom.secondaryCy - barH / 2;
+  const primitives = [];
+  const labels = [];
+  let cursorY = barTop;
+  secondaryValues.forEach((v, i) => {
+    const h = Math.max(Math.abs(v) / total * barH, 1);
+    primitives.push({ kind: "rect", x: barX, y: cursorY, w: barW, h, fill: fills[i] });
+    if (showLabels) {
+      labels.push(sliceLabel(geom.secondaryCx, cursorY + h / 2, v));
+    }
+    cursorY += h;
+  });
+  return { primitives, labels };
+}
+function buildSerLines(geom, otherAngle) {
+  const rimStart = {
+    x: geom.primaryCx + geom.primaryR * Math.cos(otherAngle.start),
+    y: geom.primaryCy + geom.primaryR * Math.sin(otherAngle.start)
+  };
+  const rimEnd = {
+    x: geom.primaryCx + geom.primaryR * Math.cos(otherAngle.end),
+    y: geom.primaryCy + geom.primaryR * Math.sin(otherAngle.end)
+  };
+  const targetX = geom.secondaryCx - geom.secondaryR * 1.05;
+  const line2 = (from, ty) => ({
+    kind: "line",
+    x1: from.x,
+    y1: from.y,
+    x2: targetX,
+    y2: ty,
+    stroke: "#94a3b8",
+    strokeWidth: 1,
+    dashArray: "3 2"
+  });
+  return [
+    line2(rimStart, geom.secondaryCy - geom.secondaryR),
+    line2(rimEnd, geom.secondaryCy + geom.secondaryR)
+  ];
+}
+function buildPrimarySlices(geom, primaryValues, fills, showLabels) {
+  const angles = sliceAngles(primaryValues);
+  const primitives = [];
+  const labels = [];
+  angles.forEach((a, i) => {
+    const geoSlice = computePieSlicePath(
+      geom.primaryCx,
+      geom.primaryCy,
+      geom.primaryR,
+      0,
+      a.start,
+      a.end
+    );
+    primitives.push({
+      kind: "path",
+      d: geoSlice.d,
+      fill: fills[i],
+      stroke: "#ffffff",
+      strokeWidth: 1.5,
+      part: { role: "dataPoint", seriesIndex: 0, pointIndex: i }
+    });
+    if (showLabels) {
+      labels.push(sliceLabel(geoSlice.labelX, geoSlice.labelY, primaryValues[i]));
+    }
+  });
+  return { primitives, labels };
+}
+function buildOfPieViewModel(element, chartData, categoryLabels) {
+  const options = chartData.ofPieOptions ?? { ofPieType: "pie" };
+  const series = chartData.series[0];
+  const values = series?.values ?? [];
+  const palette = chartData.colorPalette;
+  const showLabels = chartData.style?.hasDataLabels === true;
+  const secondaryIdx = resolveSecondaryIndices(values, options);
+  const keptIndices = values.map((_v, i) => i).filter((i) => !secondaryIdx.has(i));
+  const secondaryIndices = values.map((_v, i) => i).filter((i) => secondaryIdx.has(i));
+  const geom = computeOfPieGeom(element, options.secondPieSize ?? 75);
+  const pointFill = (i) => series ? resolveVaryColorFill(series, i, paletteColor2(i, palette)) : paletteColor2(i, palette);
+  const keptFills = keptIndices.map(pointFill);
+  const secondaryFills = secondaryIndices.map(pointFill);
+  const otherFill = paletteColor2(values.length, palette);
+  const otherSum = secondaryIndices.reduce((s, i) => s + Math.abs(values[i]), 0);
+  const primaryValues = [...keptIndices.map((i) => Math.abs(values[i])), otherSum];
+  const primaryFills = [...keptFills, otherFill];
+  const primary = buildPrimarySlices(geom, primaryValues, primaryFills, showLabels);
+  const secondaryValues = secondaryIndices.map((i) => Math.abs(values[i]));
+  const toBar = options.ofPieType === "bar";
+  const secondary = secondaryValues.length > 0 ? toBar ? buildSecondaryBar(geom, secondaryValues, secondaryFills, showLabels) : buildSecondaryPie(geom, secondaryValues, secondaryFills, showLabels) : { primitives: [], labels: [] };
+  const primitives = [];
+  if (options.serLines !== false && secondaryValues.length > 0) {
+    const primaryAngles = sliceAngles(primaryValues);
+    primitives.push(...buildSerLines(geom, primaryAngles[primaryAngles.length - 1]));
+  }
+  primitives.push(...primary.primitives, ...secondary.primitives);
+  const dataLabels = [...primary.labels, ...secondary.labels];
+  const legend = categoryLabels.map((label, i) => ({
+    color: paletteColor2(i, palette),
+    label
+  }));
+  const title = chartData.style?.hasTitle && chartData.title ? chartData.title : void 0;
+  return {
+    svgWidth: geom.svgWidth,
+    svgHeight: geom.svgHeight,
+    title,
+    titleX: geom.svgWidth / 2,
+    titleY: 14,
+    gridlines: [],
+    axisLabels: [],
+    zeroLine: void 0,
+    categoryLabels: [],
+    primitives,
+    dataLabels,
+    legend: chartData.style?.hasLegend ? legend : [],
+    legendX: geom.svgWidth / 2,
+    legendY: geom.svgHeight - 8,
+    legendAnchor: "middle"
+  };
+}
+var LEADER_LENGTH = 14;
+function isOutsidePosition(position) {
+  return position === "outEnd" || position === "bestFit";
+}
+function buildPieDataLabels(params) {
+  const { slices, values, cx, cy, outerR, position, showLeaderLines } = params;
+  const outside = isOutsidePosition(position);
+  const labels = [];
+  const leaderLines = [];
+  slices.forEach((slice, i) => {
+    const val2 = values[i];
+    if (val2 === void 0) {
+      return;
+    }
+    if (!outside) {
+      labels.push({
+        kind: "text",
+        x: slice.labelX,
+        y: slice.labelY,
+        text: formatAxisValue2(val2),
+        fontSize: 8,
+        fill: "#ffffff",
+        textAnchor: "middle",
+        fontWeight: "bold",
+        dominantBaseline: "central"
+      });
+      return;
+    }
+    const cos = Math.cos(slice.midAngle);
+    const sin = Math.sin(slice.midAngle);
+    const rimX = cx + outerR * cos;
+    const rimY = cy + outerR * sin;
+    const labelX = cx + (outerR + LEADER_LENGTH) * cos;
+    const labelY = cy + (outerR + LEADER_LENGTH) * sin;
+    const anchor = cos >= 0 ? "start" : "end";
+    labels.push({
+      kind: "text",
+      x: labelX + (cos >= 0 ? 2 : -2),
+      y: labelY,
+      text: formatAxisValue2(val2),
+      fontSize: 8,
+      fill: "#334155",
+      textAnchor: anchor,
+      dominantBaseline: "central"
+    });
+    if (showLeaderLines !== false) {
+      leaderLines.push({
+        kind: "line",
+        x1: rimX,
+        y1: rimY,
+        x2: labelX,
+        y2: labelY,
+        stroke: "#94a3b8",
+        strokeWidth: 0.75
+      });
+    }
+  });
+  return { labels, leaderLines };
+}
+function normalizedLevels(levels, pointCount) {
+  return levels.map((level) => {
+    let previous = "";
+    return Array.from({ length: pointCount }, (_, index) => {
+      const label = level[index]?.trim() ?? "";
+      if (label) {
+        previous = label;
+      }
+      return label || previous;
+    });
+  });
+}
+function findOrAddParent(children, label, colorIndex, parentLabelLayout) {
+  const existing = children.find((child2) => child2.children && child2.label === label);
+  if (existing) {
+    return existing;
+  }
+  const parent = {
+    label,
+    weight: 0,
+    children: [],
     colorIndex,
     parentLabelLayout
   };
@@ -7761,6 +8699,84 @@ function buildTreemapViewModel(element, chartData, categoryLabels) {
     legendAnchor
   };
 }
+var EMU_PER_PIXEL = 9525;
+function shapeBox(shape, svgWidth, svgHeight) {
+  const x = shape.from.x * svgWidth;
+  const y = shape.from.y * svgHeight;
+  if (shape.anchor === "rel" && shape.to) {
+    return {
+      x,
+      y,
+      w: Math.max((shape.to.x - shape.from.x) * svgWidth, 0),
+      h: Math.max((shape.to.y - shape.from.y) * svgHeight, 0)
+    };
+  }
+  const ext = shape.ext ?? { cx: 0, cy: 0 };
+  return { x, y, w: ext.cx / EMU_PER_PIXEL, h: ext.cy / EMU_PER_PIXEL };
+}
+function textPrimitives(shape, box) {
+  if (!shape.paragraphs || shape.paragraphs.length === 0) {
+    return [];
+  }
+  const lineH = 12;
+  const totalH = shape.paragraphs.length * lineH;
+  let cursorY = box.y + Math.max((box.h - totalH) / 2, 0) + lineH * 0.75;
+  const out = [];
+  for (const para of shape.paragraphs) {
+    if (para.text.length === 0) {
+      cursorY += lineH;
+      continue;
+    }
+    const align = para.align ?? "ctr";
+    const anchor = align === "l" ? "start" : align === "r" ? "end" : "middle";
+    const tx = align === "l" ? box.x + 2 : align === "r" ? box.x + box.w - 2 : box.x + box.w / 2;
+    out.push({
+      kind: "text",
+      x: tx,
+      y: cursorY,
+      text: para.text,
+      fontSize: para.fontSize ?? 9,
+      fill: para.color ?? "#1e293b",
+      textAnchor: anchor,
+      fontWeight: para.bold ? "bold" : "normal"
+    });
+    cursorY += lineH;
+  }
+  return out;
+}
+function projectShape(shape, svgWidth, svgHeight) {
+  const box = shapeBox(shape, svgWidth, svgHeight);
+  const primitives = [];
+  if (shape.kind === "cxnSp") {
+    primitives.push({
+      kind: "line",
+      x1: box.x,
+      y1: box.y,
+      x2: box.x + box.w,
+      y2: box.y + box.h,
+      stroke: shape.stroke ?? "#000000",
+      strokeWidth: shape.strokeWidth ?? 1
+    });
+    return primitives;
+  }
+  if ((shape.fill || shape.stroke) && box.w > 0 && box.h > 0) {
+    primitives.push({
+      kind: "polygon",
+      points: `${box.x},${box.y} ${box.x + box.w},${box.y} ${box.x + box.w},${box.y + box.h} ${box.x},${box.y + box.h}`,
+      fill: shape.fill ?? "none",
+      stroke: shape.stroke ?? "none",
+      strokeWidth: shape.strokeWidth ?? (shape.stroke ? 1 : 0)
+    });
+  }
+  primitives.push(...textPrimitives(shape, box));
+  return primitives;
+}
+function buildChartUserShapeOverlay(userShapes, svgWidth, svgHeight) {
+  if (!userShapes || userShapes.length === 0) {
+    return [];
+  }
+  return userShapes.flatMap((shape) => projectShape(shape, svgWidth, svgHeight));
+}
 function sourceIndices(indices, length) {
   return Array.from({ length }, (_, position) => indices?.[position] ?? position);
 }
@@ -8041,7 +9057,7 @@ function resolveRegionCode(label) {
   return REGION_ALIAS_MAP[normalized];
 }
 function lerpColor(a, b, t) {
-  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
   const ha = a.replace("#", "");
   const hb = b.replace("#", "");
   const r1 = parseInt(ha.substring(0, 2), 16);
@@ -8050,11 +9066,11 @@ function lerpColor(a, b, t) {
   const r2 = parseInt(hb.substring(0, 2), 16);
   const g2 = parseInt(hb.substring(2, 4), 16);
   const b2 = parseInt(hb.substring(4, 6), 16);
-  const r = clamp7(r1 + (r2 - r1) * t);
-  const g = clamp7(g1 + (g2 - g1) * t);
-  const bl = clamp7(b1 + (b2 - b1) * t);
-  const toHex = (n) => n.toString(16).padStart(2, "0");
-  return `#${toHex(r)}${toHex(g)}${toHex(bl)}`;
+  const r = clamp8(r1 + (r2 - r1) * t);
+  const g = clamp8(g1 + (g2 - g1) * t);
+  const bl = clamp8(b1 + (b2 - b1) * t);
+  const toHex2 = (n) => n.toString(16).padStart(2, "0");
+  return `#${toHex2(r)}${toHex2(g)}${toHex2(bl)}`;
 }
 function sequentialColorScale(t) {
   const clamped = Math.max(0, Math.min(1, t));
@@ -8970,6 +9986,30 @@ function buildChartViewModel(element) {
   }
   const longestLen = chartData.series.reduce((m, s) => Math.max(m, s.values.length), 0);
   const categoryLabels = chartData.categories.length > 0 ? chartData.categories : Array.from({ length: longestLen }, (_, i) => String(i + 1));
+  if (chartType === "ofPie") {
+    return withUserShapeOverlay(buildOfPieViewModel(element, chartData, categoryLabels), chartData);
+  }
+  const flat = buildFlatViewModel(element, chartData, categoryLabels, kind);
+  if (is3DChartType(chartType)) {
+    return withUserShapeOverlay(applyChart3DDepth(flat, chartType, chartData.view3D), chartData);
+  }
+  return withUserShapeOverlay(flat, chartData);
+}
+function withUserShapeOverlay(vm, chartData) {
+  const overlay = buildChartUserShapeOverlay(chartData.userShapes, vm.svgWidth, vm.svgHeight);
+  if (overlay.length === 0) {
+    return vm;
+  }
+  return {
+    ...vm,
+    primitives: [...vm.primitives, ...overlay],
+    userShapes: overlay
+  };
+}
+function is3DChartType(chartType) {
+  return chartType === "bar3D" || chartType === "pie3D" || chartType === "line3D" || chartType === "area3D";
+}
+function buildFlatViewModel(element, chartData, categoryLabels, kind) {
   if (kind === "pie" || kind === "doughnut") {
     return buildPieViewModel(element, chartData, categoryLabels, kind === "doughnut");
   }
@@ -9078,23 +10118,17 @@ function buildPieViewModel(element, chartData, categoryLabels, isDoughnut) {
   );
   const dataLabels = [];
   if (chartData.style?.hasDataLabels) {
-    slices.forEach(({ labelX, labelY }, i) => {
-      const val2 = values[i];
-      if (val2 === void 0) {
-        return;
-      }
-      dataLabels.push({
-        kind: "text",
-        x: labelX,
-        y: labelY,
-        text: formatAxisValue2(val2),
-        fontSize: 8,
-        fill: "#ffffff",
-        textAnchor: "middle",
-        fontWeight: "bold",
-        dominantBaseline: "central"
-      });
+    const labelResult = buildPieDataLabels({
+      slices,
+      values,
+      cx,
+      cy,
+      outerR,
+      position: chartData.style.dataLabels?.position,
+      showLeaderLines: chartData.style.dataLabels?.showLeaderLines
     });
+    dataLabels.push(...labelResult.labels);
+    primitives.push(...labelResult.leaderLines);
   }
   const legendPos = chartData.style?.legendPosition ?? "b";
   const legend = categoryLabels.map((label, i) => ({
@@ -9363,8 +10397,12 @@ var PRESET_ID_TO_EFFECT = {
     9: "dissolveIn",
     10: "fadeIn",
     12: "flashIn",
+    14: "randomBarsIn",
     16: "peekIn",
-    17: "randomBarsIn",
+    // entr.17 = Split per MS-OI29500 / the catalog. (Previously this id was
+    // mislabelled randomBarsIn, so imported Split entrances rendered as
+    // Random Bars.) entr.14 above is Random Bars.
+    17: "splitIn",
     22: "wipeIn",
     23: "zoomIn",
     26: "riseUp",
@@ -9390,12 +10428,33 @@ var PRESET_ID_TO_EFFECT = {
     1: "boldFlash",
     2: "wave",
     6: "growShrink",
+    7: "flash",
+    // Blink: an opacity blink, closest existing keyframe.
     8: "spin",
     9: "transparency",
     14: "teeter",
     26: "pulse"
   }
 };
+var EMPH_FILTER_PRESETS = {
+  3: { name: "desaturate", filterMid: "saturate(0.15)" },
+  4: { name: "darken", filterMid: "brightness(0.55)" },
+  5: { name: "lighten", filterMid: "brightness(1.6)" }
+};
+function emphasisFilterKeyframeCss(presetId, name) {
+  if (presetId === void 0) {
+    return void 0;
+  }
+  const preset = EMPH_FILTER_PRESETS[presetId];
+  if (!preset) {
+    return void 0;
+  }
+  return `@keyframes ${name} {
+	0% { filter: none; }
+	50% { filter: ${preset.filterMid}; }
+	100% { filter: none; }
+}`;
+}
 var FLY_SUBTYPE_TO_EDGE = {
   1: "top",
   2: "right",
@@ -9640,8 +10699,8 @@ function hexToRgb3(hex) {
   };
 }
 function rgbToHex3(r, g, b) {
-  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp7(r).toString(16).padStart(2, "0")}${clamp7(g).toString(16).padStart(2, "0")}${clamp7(b).toString(16).padStart(2, "0")}`;
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp8(r).toString(16).padStart(2, "0")}${clamp8(g).toString(16).padStart(2, "0")}${clamp8(b).toString(16).padStart(2, "0")}`;
 }
 function rgbToHsl(r, g, b) {
   const rn = r / 255;
@@ -9727,22 +10786,33 @@ function interpolateColor(from, to, t, colorSpace, direction) {
   const rgb = hslToRgb2(h, s, l);
   return rgbToHex3(rgb.r, rgb.g, rgb.b);
 }
-var ATTR_NAME_TO_CSS_PROPERTY = {
-  fillcolor: "backgroundColor",
-  "fill.color": "backgroundColor",
-  "style.color": "color",
-  "stroke.color": "borderColor",
-  "stroke.dashstyle": "borderColor",
-  "style.visibility": "color",
-  ppt_c: "color",
-  ppt_x: "color",
-  ppt_y: "color"
+var ATTR_NAME_TO_CSS_PROPERTIES = {
+  fillcolor: ["fill", "background-color", "backgroundColor"],
+  "fill.color": ["fill", "background-color", "backgroundColor"],
+  "style.color": ["color"],
+  "stroke.color": ["stroke", "border-color", "borderColor"],
+  "stroke.dashstyle": ["stroke", "border-color", "borderColor"],
+  "style.visibility": ["color"],
+  ppt_c: ["color"],
+  ppt_x: ["color"],
+  ppt_y: ["color"]
 };
-function resolveCssProperty(attrName) {
+function resolveCssProperties(attrName) {
   if (!attrName) {
-    return "color";
+    return ["color"];
+  }
+  return ATTR_NAME_TO_CSS_PROPERTIES[attrName] ?? ["color"];
+}
+function resolveColorAnimationTargets(targetAttribute) {
+  const cssProperties = resolveCssProperties(targetAttribute);
+  const targets = [];
+  if (cssProperties.includes("fill")) {
+    targets.push("fill");
+  }
+  if (cssProperties.includes("stroke")) {
+    targets.push("stroke");
   }
-  return ATTR_NAME_TO_CSS_PROPERTY[attrName] ?? "color";
+  return targets;
 }
 function buildColorAnimationKeyframes(colorAnim, keyframeName, steps = 10) {
   const { colorSpace, direction, fromColor, toColor, byColor, targetAttribute } = colorAnim;
@@ -9762,96 +10832,332 @@ function buildColorAnimationKeyframes(colorAnim, keyframeName, steps = 10) {
   } else {
     return void 0;
   }
-  const cssProperty = resolveCssProperty(targetAttribute);
+  const cssProperties = resolveCssProperties(targetAttribute);
   const lines = [];
   const actualSteps = Math.max(2, steps);
   for (let i = 0; i <= actualSteps; i++) {
     const t = i / actualSteps;
     const pct = Math.round(t * 100);
     const color = interpolateColor(effectiveFrom, effectiveTo, t, colorSpace, direction);
-    lines.push(`	${pct}% { ${cssProperty}: ${color}; }`);
+    const decls = cssProperties.map((prop) => `${prop}: ${color};`).join(" ");
+    lines.push(`	${pct}% { ${decls} }`);
   }
   return `@keyframes ${keyframeName} {
 ${lines.join("\n")}
 }`;
 }
-function resolveEffect(anim) {
-  const cls = anim.presetClass;
-  const id = anim.presetId;
-  if (cls === void 0 || id === void 0) {
-    return void 0;
+function resolveChartBuildMode(token) {
+  switch (token) {
+    case "series":
+      return "bySeries";
+    case "category":
+      return "byCategory";
+    case "seriesElement":
+    case "seriesEl":
+    case "categoryElement":
+    case "categoryEl":
+      return "byElement";
+    default:
+      return "asOne";
+  }
+}
+function resolveDiagramBuildMode(token) {
+  switch (token) {
+    case void 0:
+    case "whole":
+    case "allAtOnce":
+      return "asOne";
+    case "lvlOne":
+      return "byLvl";
+    case "lvlAtOnce":
+      return "byLvlAtOnce";
+    default:
+      return "byOne";
   }
-  if (cls === "entr") {
-    return applyFlyDirection(PRESET_ID_TO_EFFECT.entr[id], anim.presetSubtype);
+}
+function resolveStepBuildDescriptor(anim) {
+  const graphic = anim.graphicBuildProperties;
+  if (graphic && graphic.mode === "sub") {
+    if (graphic.kind === "chart") {
+      const mode2 = resolveChartBuildMode(graphic.build);
+      return mode2 === "asOne" ? void 0 : { kind: "chart", mode: mode2 };
+    }
+    const mode = resolveDiagramBuildMode(graphic.build);
+    return mode === "asOne" ? void 0 : { kind: "diagram", mode };
   }
-  if (cls === "exit") {
-    return applyFlyDirection(PRESET_ID_TO_EFFECT.exit[id], anim.presetSubtype);
+  if (anim.oleChartBuild !== void 0) {
+    const mode = resolveChartBuildMode(anim.oleChartBuild);
+    return mode === "asOne" ? void 0 : { kind: "chart", mode };
   }
-  if (cls === "emph") {
-    return PRESET_ID_TO_EFFECT.emph[id];
+  if (anim.smartArtBuild !== void 0) {
+    const mode = resolveDiagramBuildMode(anim.smartArtBuild);
+    return mode === "asOne" ? void 0 : { kind: "diagram", mode };
   }
   return void 0;
 }
-function applyFlyDirection(effect, subtype) {
-  if (effect !== "flyInBottom" && effect !== "flyOutBottom") {
-    return effect;
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function computeBuildProgress(timing, elapsedMs) {
+  if (timing.durationMs <= 0) {
+    return elapsedMs >= timing.delayMs ? 1 : 0;
   }
-  if (subtype === void 0) {
-    return effect;
+  return clamp01((elapsedMs - timing.delayMs) / timing.durationMs);
+}
+function revealedStageCount(progress, totalStages) {
+  if (totalStages <= 0) {
+    return 0;
   }
-  const edge = FLY_SUBTYPE_TO_EDGE[subtype];
-  if (!edge) {
-    return effect;
+  const p = clamp01(progress);
+  if (p <= 0) {
+    return 0;
   }
-  const prefix = effect === "flyInBottom" ? "flyIn" : "flyOut";
-  const suffix = `${edge.charAt(0).toUpperCase()}${edge.slice(1)}`;
-  return `${prefix}${suffix}`;
+  return Math.min(totalStages, Math.ceil(p * totalStages));
 }
-function parseMotionPathPoints(motionPath) {
-  const cmds = motionPath.replace(/\s+/gu, " ").trim().split(/(?=[MLCZ])/iu).filter(Boolean);
-  const points = [];
-  for (const cmd of cmds) {
-    const type = cmd.charAt(0).toUpperCase();
-    if (type === "Z") {
-      continue;
+function applyStepBuildMetadata(state, step, options) {
+  if (!step) {
+    return;
+  }
+  if (step.build) {
+    const progress = options?.elapsedMs === void 0 ? 1 : computeBuildProgress(step, options.elapsedMs);
+    state.build = { ...step.build, progress };
+  }
+  if (step.colorTargets) {
+    if (step.colorTargets.includes("fill")) {
+      state.animatesFill = true;
     }
-    const nums = cmd.slice(1).trim().split(/[\s,]+/u).map(Number);
-    for (let i = 0; i + 1 < nums.length; i += 2) {
-      points.push({ x: nums[i] * 100, y: nums[i + 1] * 100 });
+    if (step.colorTargets.includes("stroke")) {
+      state.animatesStroke = true;
     }
   }
-  return points;
 }
-function buildDynamicKeyframe(anim, uid) {
-  if (anim.motionPath) {
-    const name = `pptx-tl-motion-${uid}`;
-    const points = parseMotionPathPoints(anim.motionPath);
-    if (points.length < 2) {
-      return void 0;
+function categoryCount(chartData) {
+  const longest = chartData.series.reduce((max, s) => Math.max(max, s.values.length), 0);
+  return Math.max(chartData.categories.length, longest);
+}
+function applyChartBuildReveal(chartData, build) {
+  const { series } = chartData;
+  if (build.mode === "asOne" || series.length === 0) {
+    return chartData;
+  }
+  if (build.mode === "bySeries") {
+    const shown = revealedStageCount(build.progress, series.length);
+    if (shown >= series.length) {
+      return chartData;
     }
-    const lines = [];
-    for (let i = 0; i < points.length; i++) {
-      const pct = Math.round(i / (points.length - 1) * 100);
-      const tx = points[i].x.toFixed(2);
-      const ty = points[i].y.toFixed(2);
-      if (anim.motionPathRotateAuto) {
-        const next = i < points.length - 1 ? points[i + 1] : points[i];
-        const prev = i > 0 ? points[i - 1] : points[i];
-        const dx = i < points.length - 1 ? next.x - points[i].x : points[i].x - prev.x;
-        const dy = i < points.length - 1 ? next.y - points[i].y : points[i].y - prev.y;
-        const angleDeg = Math.atan2(dy, dx) * (180 / Math.PI);
-        lines.push(
-          `	${pct}% { transform: translate(${tx}%, ${ty}%) rotate(${angleDeg.toFixed(2)}deg); }`
-        );
-      } else {
-        lines.push(`	${pct}% { transform: translate(${tx}%, ${ty}%); }`);
-      }
+    return { ...chartData, series: series.slice(0, shown) };
+  }
+  const catCount = categoryCount(chartData);
+  if (catCount === 0) {
+    return chartData;
+  }
+  if (build.mode === "byCategory") {
+    const shown = revealedStageCount(build.progress, catCount);
+    if (shown >= catCount) {
+      return chartData;
     }
     return {
-      keyframeName: name,
-      css: `@keyframes ${name} {
-${lines.join("\n")}
-}`
+      ...chartData,
+      series: series.map((s) => ({ ...s, values: s.values.slice(0, shown) }))
+    };
+  }
+  const total = series.length * catCount;
+  const shownCells = revealedStageCount(build.progress, total);
+  if (shownCells >= total) {
+    return chartData;
+  }
+  return {
+    ...chartData,
+    series: series.map((s, si) => {
+      const visibleInSeries = Math.max(0, Math.min(catCount, shownCells - si * catCount));
+      return { ...s, values: s.values.slice(0, visibleInSeries) };
+    })
+  };
+}
+function nodeLevels(nodes) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    byId.set(node.id, node);
+  }
+  return nodes.map((node) => {
+    let depth = 0;
+    let current = node;
+    const seen = /* @__PURE__ */ new Set();
+    while (current?.parentId && !seen.has(current.id)) {
+      seen.add(current.id);
+      const parent = byId.get(current.parentId);
+      if (!parent) {
+        break;
+      }
+      depth++;
+      current = parent;
+    }
+    return depth;
+  });
+}
+function revealedSmartArtNodeCount(nodes, build) {
+  if (build.mode === "asOne" || nodes.length === 0) {
+    return nodes.length;
+  }
+  if (build.mode === "byLvlAtOnce") {
+    const levels = nodeLevels(nodes);
+    const uniqueLevels = [...new Set(levels)].sort((a, b) => a - b);
+    const shownLevels = revealedStageCount(build.progress, uniqueLevels.length);
+    if (shownLevels >= uniqueLevels.length) {
+      return nodes.length;
+    }
+    const allowed = new Set(uniqueLevels.slice(0, shownLevels));
+    return levels.filter((level) => allowed.has(level)).length;
+  }
+  return revealedStageCount(build.progress, nodes.length);
+}
+var BEZIER_SAMPLES = 8;
+function cubicAt(p0, c1, c2, p3, t) {
+  const mt = 1 - t;
+  return mt * mt * mt * p0 + 3 * mt * mt * t * c1 + 3 * mt * t * t * c2 + t * t * t * p3;
+}
+function allFinite(values) {
+  return values.every((v) => Number.isFinite(v));
+}
+function parseMotionPathPoints(motionPath) {
+  const tokens = motionPath.match(/[MLCZmlcz]|-?\d*\.?\d+(?:[eE][-+]?\d+)?/gu);
+  if (!tokens) {
+    return [];
+  }
+  const points = [];
+  let curX = 0;
+  let curY = 0;
+  let startX = 0;
+  let startY = 0;
+  let i = 0;
+  let cmd = "";
+  const nextNum = () => Number(tokens[i++]);
+  const push = (x, y) => {
+    points.push({ x: x * 100, y: y * 100 });
+  };
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (/^[MLCZmlcz]$/u.test(tok)) {
+      cmd = tok;
+      i++;
+      if (cmd === "Z" || cmd === "z") {
+        curX = startX;
+        curY = startY;
+      }
+      continue;
+    }
+    const rel = cmd === cmd.toLowerCase();
+    const upper = cmd.toUpperCase();
+    if (upper === "M" || upper === "L") {
+      let x = nextNum();
+      let y = nextNum();
+      if (!allFinite([x, y])) {
+        break;
+      }
+      if (rel) {
+        x += curX;
+        y += curY;
+      }
+      curX = x;
+      curY = y;
+      if (upper === "M") {
+        startX = x;
+        startY = y;
+        cmd = rel ? "l" : "L";
+      }
+      push(x, y);
+    } else if (upper === "C") {
+      let c1x = nextNum();
+      let c1y = nextNum();
+      let c2x = nextNum();
+      let c2y = nextNum();
+      let ex = nextNum();
+      let ey = nextNum();
+      if (!allFinite([c1x, c1y, c2x, c2y, ex, ey])) {
+        break;
+      }
+      if (rel) {
+        c1x += curX;
+        c1y += curY;
+        c2x += curX;
+        c2y += curY;
+        ex += curX;
+        ey += curY;
+      }
+      for (let s = 1; s <= BEZIER_SAMPLES; s++) {
+        const t = s / BEZIER_SAMPLES;
+        push(cubicAt(curX, c1x, c2x, ex, t), cubicAt(curY, c1y, c2y, ey, t));
+      }
+      curX = ex;
+      curY = ey;
+    } else {
+      i++;
+    }
+  }
+  return points;
+}
+function resolveEffect(anim) {
+  const cls = anim.presetClass;
+  const id = anim.presetId;
+  if (cls === void 0 || id === void 0) {
+    return void 0;
+  }
+  if (cls === "entr") {
+    return applyFlyDirection(PRESET_ID_TO_EFFECT.entr[id], anim.presetSubtype);
+  }
+  if (cls === "exit") {
+    return applyFlyDirection(PRESET_ID_TO_EFFECT.exit[id], anim.presetSubtype);
+  }
+  if (cls === "emph") {
+    return PRESET_ID_TO_EFFECT.emph[id];
+  }
+  return void 0;
+}
+function applyFlyDirection(effect, subtype) {
+  if (effect !== "flyInBottom" && effect !== "flyOutBottom") {
+    return effect;
+  }
+  if (subtype === void 0) {
+    return effect;
+  }
+  const edge = FLY_SUBTYPE_TO_EDGE[subtype];
+  if (!edge) {
+    return effect;
+  }
+  const prefix = effect === "flyInBottom" ? "flyIn" : "flyOut";
+  const suffix = `${edge.charAt(0).toUpperCase()}${edge.slice(1)}`;
+  return `${prefix}${suffix}`;
+}
+function buildDynamicKeyframe(anim, uid) {
+  if (anim.motionPath) {
+    const name = `pptx-tl-motion-${uid}`;
+    const points = parseMotionPathPoints(anim.motionPath);
+    if (points.length < 2) {
+      return void 0;
+    }
+    const lines = [];
+    for (let i = 0; i < points.length; i++) {
+      const pct = Math.round(i / (points.length - 1) * 100);
+      const tx = points[i].x.toFixed(2);
+      const ty = points[i].y.toFixed(2);
+      if (anim.motionPathRotateAuto) {
+        const next = i < points.length - 1 ? points[i + 1] : points[i];
+        const prev = i > 0 ? points[i - 1] : points[i];
+        const dx = i < points.length - 1 ? next.x - points[i].x : points[i].x - prev.x;
+        const dy = i < points.length - 1 ? next.y - points[i].y : points[i].y - prev.y;
+        const angleDeg = Math.atan2(dy, dx) * (180 / Math.PI);
+        lines.push(
+          `	${pct}% { transform: translate(${tx}%, ${ty}%) rotate(${angleDeg.toFixed(2)}deg); }`
+        );
+      } else {
+        lines.push(`	${pct}% { transform: translate(${tx}%, ${ty}%); }`);
+      }
+    }
+    return {
+      keyframeName: name,
+      css: `@keyframes ${name} {
+${lines.join("\n")}
+}`
     };
   }
   if (anim.rotationBy !== void 0) {
@@ -9883,6 +11189,13 @@ ${lines.join("\n")}
       return { keyframeName: name, css };
     }
   }
+  if (anim.presetClass === "emph") {
+    const filterName = `pptx-tl-emph-${uid}`;
+    const filterCss = emphasisFilterKeyframeCss(anim.presetId, filterName);
+    if (filterCss) {
+      return { keyframeName: filterName, css: filterCss };
+    }
+  }
   return void 0;
 }
 function cssKeyframeName(effect) {
@@ -10208,19 +11521,122 @@ function getAnimationInitialStyle(preset, nativeAnimation) {
   }
   return {};
 }
-function cssEasingForAnimation(anim) {
-  const hasAccel = anim.accel !== void 0 && anim.accel > 0;
-  const hasDecel = anim.decel !== void 0 && anim.decel > 0;
-  if (hasAccel && hasDecel) {
-    return "ease-in-out";
+var WIPE_LIKE = /* @__PURE__ */ new Set([
+  "wipeIn",
+  "peekIn",
+  "blindsIn",
+  "wipeOut"
+]);
+var SPLIT_LIKE = /* @__PURE__ */ new Set(["splitIn"]);
+function wipeStartInset(edge) {
+  switch (edge) {
+    case "left":
+      return "inset(0 100% 0 0)";
+    case "right":
+      return "inset(0 0 0 100%)";
+    case "top":
+      return "inset(0 0 100% 0)";
+    case "bottom":
+    default:
+      return "inset(100% 0 0 0)";
+  }
+}
+function wipeRevealCss(name, edge) {
+  return `@keyframes ${name} {
+	from { clip-path: ${wipeStartInset(edge)}; opacity: 1; }
+	to { clip-path: inset(0 0 0 0); opacity: 1; }
+}`;
+}
+function wipeHideCss(name, edge) {
+  return `@keyframes ${name} {
+	from { clip-path: inset(0 0 0 0); opacity: 1; }
+	to { clip-path: ${wipeStartInset(edge)}; opacity: 0; }
+}`;
+}
+function splitRevealCss(name, orientation) {
+  const start = orientation === "vertical" ? "inset(0 50% 0 50%)" : "inset(50% 0 50% 0)";
+  return `@keyframes ${name} {
+	from { clip-path: ${start}; opacity: 1; }
+	to { clip-path: inset(0 0 0 0); opacity: 1; }
+}`;
+}
+function buildDirectionalKeyframe(effect, subtype, uid) {
+  if (subtype === void 0) {
+    return void 0;
+  }
+  const edge = FLY_SUBTYPE_TO_EDGE[subtype];
+  if (!edge) {
+    return void 0;
+  }
+  const name = `pptx-tl-dir-${uid}`;
+  if (SPLIT_LIKE.has(effect)) {
+    const orientation = edge === "left" || edge === "right" ? "vertical" : "horizontal";
+    return { keyframeName: name, css: splitRevealCss(name, orientation) };
+  }
+  if (WIPE_LIKE.has(effect)) {
+    const css = effect === "wipeOut" ? wipeHideCss(name, edge) : wipeRevealCss(name, edge);
+    return { keyframeName: name, css };
+  }
+  return void 0;
+}
+function isMediaCommandAnimation(anim) {
+  return typeof anim.commandString === "string" && anim.commandString.trim().length > 0;
+}
+function buildStepCommand(anim) {
+  if (!isMediaCommandAnimation(anim)) {
+    return void 0;
+  }
+  const command = (anim.commandString ?? "").trim();
+  return {
+    type: anim.commandType,
+    command,
+    targetId: anim.targetId ?? ""
+  };
+}
+function parseMediaCommand(commandString) {
+  const raw = commandString.trim();
+  if (!raw) {
+    return void 0;
+  }
+  const playFromMatch = raw.match(/^playfrom\s*\(\s*(-?\d*\.?\d+)?\s*\)$/i);
+  if (playFromMatch) {
+    const seconds = playFromMatch[1] !== void 0 ? Number.parseFloat(playFromMatch[1]) : 0;
+    return { verb: "playFrom", seekSeconds: Number.isFinite(seconds) ? Math.max(0, seconds) : 0 };
+  }
+  const lower = raw.toLowerCase();
+  if (lower === "play" || lower === "resume") {
+    return { verb: "play" };
   }
-  if (hasAccel) {
-    return "ease-in";
+  if (lower === "pause") {
+    return { verb: "pause" };
   }
-  if (hasDecel) {
-    return "ease-out";
+  if (lower === "stop" || lower === "stopmedia") {
+    return { verb: "stop" };
+  }
+  if (lower === "toggleplay") {
+    return { verb: "togglePlay" };
+  }
+  return void 0;
+}
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function cssEasingForAnimation(anim) {
+  const accel = anim.accel !== void 0 && anim.accel > 0 ? clamp012(anim.accel) : 0;
+  const decel = anim.decel !== void 0 && anim.decel > 0 ? clamp012(anim.decel) : 0;
+  if (accel === 0 && decel === 0) {
+    return "ease";
+  }
+  const x1 = accel.toFixed(3);
+  const x2 = (1 - decel).toFixed(3);
+  return `cubic-bezier(${x1}, 0, ${x2}, 1)`;
+}
+function stepColorTargets(anim) {
+  if (!anim.colorAnimation) {
+    return void 0;
   }
-  return "ease";
+  const targets = resolveColorAnimationTargets(anim.colorAnimation.targetAttribute);
+  return targets.length > 0 ? targets : void 0;
 }
 function fallbackEffectForClass(presetClass) {
   if (presetClass === "entr") {
@@ -10229,6 +11645,9 @@ function fallbackEffectForClass(presetClass) {
   if (presetClass === "exit") {
     return "fadeOut";
   }
+  if (presetClass === "emph") {
+    return "pulse";
+  }
   return void 0;
 }
 function buildTimeline(nativeAnimations) {
@@ -10266,27 +11685,39 @@ function buildTimeline(nativeAnimations) {
     const expandedSteps = expandIterateAnimation(anim);
     for (const singleAnim of expandedSteps) {
       let effect = resolveEffect(singleAnim);
-      const dynamic = effect ? void 0 : buildDynamicKeyframe(singleAnim, dynamicUid++);
-      if (!effect && !dynamic) {
+      let dynamic = effect ? void 0 : buildDynamicKeyframe(singleAnim, dynamicUid++);
+      if (effect) {
+        const directional = buildDirectionalKeyframe(effect, singleAnim.presetSubtype, dynamicUid);
+        if (directional) {
+          dynamic = directional;
+          effect = void 0;
+          dynamicUid++;
+        }
+      }
+      const isCommand = !effect && !dynamic && isMediaCommandAnimation(singleAnim);
+      if (!effect && !dynamic && !isCommand) {
         effect = fallbackEffectForClass(singleAnim.presetClass);
         if (!effect) {
           continue;
         }
       }
-      const keyframe = effect ? cssKeyframeName(effect) : dynamic.keyframeName;
+      let keyframe = "";
+      if (!isCommand) {
+        keyframe = effect ? cssKeyframeName(effect) : dynamic.keyframeName;
+      }
       if (effect) {
         neededKeyframes.add(effect);
       }
       if (dynamic) {
         dynamicBlocks.push(dynamic.css);
       }
-      const elementId = singleAnim.targetId ?? "";
+      const elementId = isCommand ? "" : singleAnim.targetId ?? "";
       const effective = resolveAnimationStart(singleAnim);
       const trigger = effective.trigger;
-      const duration = singleAnim.durationMs ?? defaultDuration(singleAnim.presetClass);
+      const duration = isCommand ? 0 : singleAnim.durationMs ?? defaultDuration(singleAnim.presetClass);
       const animDelay = singleAnim.delayMs ?? 0;
       const triggerDelay = singleAnim.startConditions && singleAnim.startConditions.length > 0 ? effective.delayMs : singleAnim.triggerDelayMs ?? 0;
-      const presetClass = singleAnim.presetClass ?? "entr";
+      const presetClass = isCommand ? "emph" : singleAnim.presetClass ?? "entr";
       const fill = fillModeForClass(singleAnim.presetClass);
       const iterCount = singleAnim.repeatCount ?? 1;
       const direction = singleAnim.autoReverse ? "alternate" : "normal";
@@ -10318,7 +11749,7 @@ function buildTimeline(nativeAnimations) {
       }
       const iterStr = iterCount === Infinity ? "infinite" : String(iterCount);
       const easing = cssEasingForAnimation(singleAnim);
-      const cssAnimation = `${keyframe} ${duration}ms ${easing} ${delayMs}ms ${iterStr} ${direction} ${fill}`;
+      const cssAnimation = isCommand ? "" : `${keyframe} ${duration}ms ${easing} ${delayMs}ms ${iterStr} ${direction} ${fill}`;
       currentGroup.push({
         elementId,
         cssAnimation,
@@ -10329,7 +11760,10 @@ function buildTimeline(nativeAnimations) {
         fillMode: fill,
         presetClass,
         soundPath: singleAnim.soundPath,
-        stopSound: singleAnim.stopSound
+        stopSound: singleAnim.stopSound,
+        command: isCommand ? buildStepCommand(singleAnim) : void 0,
+        build: isCommand ? void 0 : resolveStepBuildDescriptor(singleAnim),
+        colorTargets: isCommand ? void 0 : stepColorTargets(singleAnim)
       });
     }
   }
@@ -10456,7 +11890,9 @@ function buildSequenceGroups(animsByKey, entranceIds, neededKeyframes, dynamicBl
         fillMode: fill,
         presetClass,
         soundPath: anim.soundPath,
-        stopSound: anim.stopSound
+        stopSound: anim.stopSound,
+        build: resolveStepBuildDescriptor(anim),
+        colorTargets: stepColorTargets(anim)
       });
     }
     if (seqGroup.length > 0) {
@@ -10505,6 +11941,12 @@ var TimelineEngine = class _TimelineEngine {
    * that have been triggered so far (cumulative).
    */
   activeAnimations;
+  /**
+   * Map of elementId → the most recently applied step carrying a staged-build
+   * or colour-target descriptor. Used to surface `build` / `animatesFill` /
+   * `animatesStroke` on {@link ElementAnimationState}.
+   */
+  activeSteps;
   /**
    * Set of element IDs whose entrance animation has played.
    * These elements become visible.
@@ -10529,6 +11971,7 @@ var TimelineEngine = class _TimelineEngine {
     this.timeline = timeline;
     this.currentGroupIndex = -1;
     this.activeAnimations = /* @__PURE__ */ new Map();
+    this.activeSteps = /* @__PURE__ */ new Map();
     this.revealedElements = /* @__PURE__ */ new Set();
     this.exitedElements = /* @__PURE__ */ new Set();
     this.interactiveGroupIndexes = /* @__PURE__ */ new Map();
@@ -10626,13 +12069,15 @@ var TimelineEngine = class _TimelineEngine {
    * Build a snapshot of the current animation state for all elements.
    * Returns a map: elementId → { visible, cssAnimation }.
    */
-  getElementStates(elementIds) {
+  getElementStates(elementIds, options) {
     const states = /* @__PURE__ */ new Map();
     for (const id of elementIds) {
-      states.set(id, {
+      const state = {
         visible: this.isElementVisible(id),
         cssAnimation: this.activeAnimations.get(id)
-      });
+      };
+      applyStepBuildMetadata(state, this.activeSteps.get(id), options);
+      states.set(id, state);
     }
     return states;
   }
@@ -10711,6 +12156,7 @@ var TimelineEngine = class _TimelineEngine {
   reset() {
     this.currentGroupIndex = -1;
     this.activeAnimations.clear();
+    this.activeSteps.clear();
     this.revealedElements.clear();
     this.exitedElements.clear();
     this.interactiveGroupIndexes.clear();
@@ -10722,6 +12168,9 @@ var TimelineEngine = class _TimelineEngine {
   applyGroupSteps(group) {
     for (const step of group.steps) {
       this.activeAnimations.set(step.elementId, step.cssAnimation);
+      if (step.build || step.colorTargets) {
+        this.activeSteps.set(step.elementId, step);
+      }
       if (step.presetClass === "entr") {
         this.revealedElements.add(step.elementId);
       }
@@ -10731,6 +12180,151 @@ var TimelineEngine = class _TimelineEngine {
     }
   }
 };
+function buildSegmentCounts(slide, nativeAnims) {
+  const segmentCounts = /* @__PURE__ */ new Map();
+  for (const anim of nativeAnims) {
+    if (anim.buildType && anim.buildType !== "allAtOnce" && anim.targetId) {
+      const el = slide.elements.find((e) => e.id === anim.targetId);
+      if (el && chunkCLNGAVNH_js.hasTextProperties(el) && el.textSegments && el.textSegments.length > 0) {
+        segmentCounts.set(anim.targetId, countTextSegments(el.textSegments));
+      }
+    }
+  }
+  return segmentCounts;
+}
+var PresentationAnimationController = class _PresentationAnimationController {
+  engine;
+  keyframes;
+  interactiveIds;
+  hoverIds;
+  ids;
+  constructor(engine, elementIds) {
+    this.engine = engine;
+    this.keyframes = engine.getTimeline().keyframesCss;
+    this.interactiveIds = engine.getInteractiveTriggerShapeIds();
+    this.hoverIds = engine.getHoverTriggerShapeIds();
+    this.ids = elementIds;
+  }
+  /**
+   * Build a controller from a slide. Expands staged text-build animations into
+   * per-segment sub-animations before constructing the {@link TimelineEngine},
+   * then caches the keyframes CSS, trigger-shape id sets, and the full element
+   * id list (base element ids + text-build sub-element ids) to track.
+   */
+  static fromSlide(slide) {
+    const nativeAnims = slide.nativeAnimations ?? [];
+    const segmentCounts = buildSegmentCounts(slide, nativeAnims);
+    const expandedAnims = segmentCounts.size > 0 ? expandTextBuildAnimations(nativeAnims, segmentCounts) : nativeAnims;
+    const engine = TimelineEngine.fromAnimations(expandedAnims);
+    const elementIds = slide.elements.map((element) => element.id);
+    for (const anim of expandedAnims) {
+      if (anim.targetId && anim.targetId.includes(TEXT_BUILD_ID_SEP)) {
+        elementIds.push(anim.targetId);
+      }
+    }
+    return new _PresentationAnimationController(engine, elementIds);
+  }
+  /** The `@keyframes` CSS blocks a binding injects once per slide. */
+  get keyframesCss() {
+    return this.keyframes;
+  }
+  /** Shape ids that trigger an interactive (`onShapeClick`) sequence. */
+  get interactiveTriggerShapeIds() {
+    return this.interactiveIds;
+  }
+  /** Shape ids that trigger a hover (`onHover`) sequence. */
+  get hoverTriggerShapeIds() {
+    return this.hoverIds;
+  }
+  /** Every element id (plus text-build sub-element ids) tracked for state. */
+  get elementIds() {
+    return this.ids;
+  }
+  // -----------------------------------------------------------------------
+  // Main click-group stepping (delegated to the engine)
+  // -----------------------------------------------------------------------
+  /** True when more click-groups remain to play. */
+  hasMoreSteps() {
+    return this.engine.hasMoreSteps();
+  }
+  /** Advance to the next click-group; `null` when none remain. */
+  advance() {
+    return this.engine.advance();
+  }
+  /** Peek at the next click-group without advancing. */
+  peekNext() {
+    return this.engine.peekNext();
+  }
+  /** True when the next click-group should auto-play without a click. */
+  shouldAutoAdvance() {
+    return this.engine.shouldAutoAdvance();
+  }
+  /** Auto-advance delay (ms) for the next group; 0 when not applicable. */
+  getAutoAdvanceDelay() {
+    return this.engine.getAutoAdvanceDelay();
+  }
+  /** Reset all playback state to the slide's initial (nothing played). */
+  reset() {
+    this.engine.reset();
+  }
+  // -----------------------------------------------------------------------
+  // Interactive + hover sequences (delegated to the engine)
+  // -----------------------------------------------------------------------
+  /** True when `shapeId` triggers an interactive sequence. */
+  hasInteractiveSequence(shapeId) {
+    return this.engine.hasInteractiveSequence(shapeId);
+  }
+  /** Advance the interactive sequence for `shapeId`; `null` when exhausted. */
+  advanceInteractive(shapeId) {
+    return this.engine.advanceInteractive(shapeId);
+  }
+  /** True when `shapeId` triggers a hover sequence. */
+  hasHoverSequence(shapeId) {
+    return this.engine.hasHoverSequence(shapeId);
+  }
+  /** Advance the hover sequence for `shapeId`; `null` when exhausted. */
+  advanceHover(shapeId) {
+    return this.engine.advanceHover(shapeId);
+  }
+  /** Reset the hover sequence for `shapeId` so the next hover replays it. */
+  resetHover(shapeId) {
+    this.engine.resetHover(shapeId);
+  }
+  // -----------------------------------------------------------------------
+  // State snapshots
+  // -----------------------------------------------------------------------
+  /**
+   * Snapshot the current animation state for every tracked element id.
+   * Pass `{ elapsedMs }` to project staged-build `progress` at that playback
+   * time (see the module header's build-reveal contract).
+   */
+  computeStates(options) {
+    return this.engine.getElementStates(this.ids, options);
+  }
+  /**
+   * Snapshot the animation state for a specific subset of element ids. Used by
+   * a binding's staged-build requestAnimationFrame loop to re-read only the
+   * build elements' `build` descriptor at the current `elapsedMs`.
+   */
+  computeStatesFor(elementIds, options) {
+    return this.engine.getElementStates(elementIds, options);
+  }
+  /**
+   * Element ids of the steps in a click-group that reveal a staged chart /
+   * SmartArt build (`p:bldChart` / `p:bldDgm`). A non-empty result tells a
+   * binding the group needs a requestAnimationFrame reveal loop; an empty result
+   * means ordinary discrete click-advance is enough.
+   */
+  static collectBuildStepIds(group) {
+    const ids = [];
+    for (const step of group.steps) {
+      if (step.build) {
+        ids.push(step.elementId);
+      }
+    }
+    return ids;
+  }
+};
 var PRESET_TO_EFFECT = {
   fadeIn: "fadeIn",
   flyIn: "flyInBottom",
@@ -11295,6 +12889,21 @@ var LIGHT_RIG_MAP = {
     filter: "contrast(1.1)"
   }
 };
+function safeHexColor(color) {
+  if (!color) {
+    return void 0;
+  }
+  const candidate = color.startsWith("#") ? color : `#${color}`;
+  if (/^#[0-9a-fA-F]{6}$/u.test(candidate)) {
+    return candidate;
+  }
+  const short = /^#(?<r>[0-9a-fA-F])(?<g>[0-9a-fA-F])(?<b>[0-9a-fA-F])$/u.exec(candidate);
+  if (short?.groups) {
+    const { r, g, b } = short.groups;
+    return `#${r}${r}${g}${g}${b}${b}`;
+  }
+  return void 0;
+}
 function getLightDirectionAngle(direction) {
   switch (direction) {
     case "t":
@@ -11454,7 +13063,7 @@ function getExtrusionDirection(rotateX, rotateY) {
   }
   return { dx, dy };
 }
-function getExtrusionBoxShadow(shape3d, cameraRotX = 0, cameraRotY = 0) {
+function getExtrusionBoxShadow(shape3d, cameraRotX = 0, cameraRotY = 0, fillColorFallback) {
   if (!shape3d?.extrusionHeight || shape3d.extrusionHeight <= 0) {
     return void 0;
   }
@@ -11464,7 +13073,7 @@ function getExtrusionBoxShadow(shape3d, cameraRotX = 0, cameraRotY = 0) {
   }
   const layerCount = Math.min(rawDepthPx, MAX_EXTRUSION_LAYERS);
   const step = rawDepthPx / layerCount;
-  const extColor = shape3d.extrusionColor || "#888888";
+  const extColor = safeHexColor(shape3d.extrusionColor) ?? safeHexColor(fillColorFallback) ?? "#888888";
   const { dx, dy } = getExtrusionDirection(cameraRotX, cameraRotY);
   const depthShadows = [];
   for (let i = 1; i <= layerCount; i++) {
@@ -11480,12 +13089,12 @@ function getExtrusionBoxShadow(shape3d, cameraRotX = 0, cameraRotY = 0) {
   );
   return depthShadows.join(", ");
 }
-function getContourBoxShadow(shape3d) {
+function getContourBoxShadow(shape3d, lineColorFallback) {
   if (!shape3d?.contourWidth || shape3d.contourWidth <= 0) {
     return void 0;
   }
   const widthPx = Math.max(1, Math.round(shape3d.contourWidth / EMU_PER_PX));
-  const color = shape3d.contourColor || "#000000";
+  const color = safeHexColor(shape3d.contourColor) ?? safeHexColor(lineColorFallback) ?? "#000000";
   return `0 0 0 ${widthPx}px ${color}`;
 }
 function get3DBevelShadow(shape3d) {
@@ -11505,7 +13114,7 @@ function get3DBevelShadow(shape3d) {
   }
   return parts.length > 0 ? parts.join(", ") : void 0;
 }
-function apply3dEffects(base, scene3d, shape3d) {
+function apply3dEffects(base, scene3d, shape3d, fillColorFallback) {
   if (!scene3d && !shape3d) {
     return;
   }
@@ -11538,11 +13147,11 @@ function apply3dEffects(base, scene3d, shape3d) {
     base.willChange = "transform";
     base.transformStyle = "preserve-3d";
   }
-  const extrusionShadow = getExtrusionBoxShadow(shape3d, rotateX, rotateY);
+  const extrusionShadow = getExtrusionBoxShadow(shape3d, rotateX, rotateY, fillColorFallback);
   if (extrusionShadow) {
     base.boxShadow = base.boxShadow ? `${base.boxShadow}, ${extrusionShadow}` : extrusionShadow;
   }
-  const contourShadow = getContourBoxShadow(shape3d);
+  const contourShadow = getContourBoxShadow(shape3d, fillColorFallback);
   if (contourShadow) {
     base.boxShadow = base.boxShadow ? `${base.boxShadow}, ${contourShadow}` : contourShadow;
   }
@@ -11577,32 +13186,245 @@ function apply3dEffects(base, scene3d, shape3d) {
     base.backgroundImage = base.backgroundImage ? `${lightRig.backgroundImage}, ${base.backgroundImage}` : lightRig.backgroundImage;
   }
 }
-function ooxmlDashToCssBorderStyle(dashVal) {
-  if (!dashVal) {
-    return "solid";
+function collectSections(entry, tableData, pos) {
+  const { rowIndex, cellIndex, rowCount, columnCount } = pos;
+  const isTop = rowIndex === 0;
+  const isBottom = rowIndex === rowCount - 1;
+  const isLeft = cellIndex === 0;
+  const isRight = cellIndex === columnCount - 1;
+  const sections = [];
+  const push = (borders, regionTop, regionBottom, regionLeft, regionRight) => {
+    if (borders) {
+      sections.push({ borders, regionTop, regionBottom, regionLeft, regionRight });
+    }
+  };
+  push(entry.wholeTblBorders, isTop, isBottom, isLeft, isRight);
+  if (tableData.bandedRows) {
+    const bandStartRow = tableData.firstRowHeader ? 1 : 0;
+    const bandEndRow = tableData.lastRow ? rowCount - 1 : rowCount;
+    if (rowIndex >= bandStartRow && rowIndex < bandEndRow) {
+      const rowCycle = Math.max(tableData.bandRowCycle ?? 1, 1);
+      const bandGroup = Math.floor((rowIndex - bandStartRow) / rowCycle) % 2;
+      push(
+        bandGroup === 0 ? entry.band1HBorders : entry.band2HBorders,
+        true,
+        true,
+        isLeft,
+        isRight
+      );
+    }
   }
-  switch (dashVal) {
-    case "dot":
-    case "sysDot":
-      return "dotted";
-    case "dash":
-    case "sysDash":
-    case "lgDash":
-    case "dashDot":
-    case "lgDashDot":
-    case "sysDashDot":
-    case "lgDashDotDot":
-    case "sysDashDotDot":
-      return "dashed";
-    default:
-      return "solid";
+  if (tableData.bandedColumns) {
+    const colStart = tableData.firstCol ? 1 : 0;
+    const colEnd = tableData.lastCol ? columnCount - 1 : columnCount;
+    if (cellIndex >= colStart && cellIndex < colEnd) {
+      const colCycle = Math.max(tableData.bandColCycle ?? 1, 1);
+      const colGroup = Math.floor((cellIndex - colStart) / colCycle) % 2;
+      push(colGroup === 0 ? entry.band1VBorders : entry.band2VBorders, isTop, isBottom, true, true);
+    }
+  }
+  if (tableData.firstRowHeader && isTop) {
+    push(entry.firstRowBorders, true, true, isLeft, isRight);
+  }
+  if (tableData.lastRow && isBottom) {
+    push(entry.lastRowBorders, true, true, isLeft, isRight);
+  }
+  if (tableData.firstCol && isLeft) {
+    push(entry.firstColBorders, isTop, isBottom, true, true);
   }
+  if (tableData.lastCol && isRight) {
+    push(entry.lastColBorders, isTop, isBottom, true, true);
+  }
+  return sections;
 }
-function computeBoundingRect(cells) {
-  if (cells.length === 0) {
+function resolveStyleDiagonalBorders(entry, tableData, pos, resolve) {
+  if (!entry) {
     return void 0;
   }
-  let startRow = cells[0].row;
+  const sections = collectSections(entry, tableData, pos);
+  if (sections.length === 0) {
+    return void 0;
+  }
+  let tl2br;
+  let bl2tr;
+  for (const section of sections) {
+    if (section.borders.tl2br) {
+      tl2br = section.borders.tl2br;
+    }
+    if (section.borders.bl2tr) {
+      bl2tr = section.borders.bl2tr;
+    }
+  }
+  const info = {};
+  let applied = false;
+  if (tl2br && !tl2br.noFill) {
+    info.diagDownColor = tl2br.color ?? resolve(tl2br.fill) ?? "#000000";
+    info.diagDownWidth = tl2br.width ?? 1;
+    applied = true;
+  }
+  if (bl2tr && !bl2tr.noFill) {
+    info.diagUpColor = bl2tr.color ?? resolve(bl2tr.fill) ?? "#000000";
+    info.diagUpWidth = bl2tr.width ?? 1;
+    applied = true;
+  }
+  return applied ? info : void 0;
+}
+function hexToRgb4(hex) {
+  const clean = hex.replace(/^#/u, "");
+  return {
+    r: parseInt(clean.substring(0, 2), 16),
+    g: parseInt(clean.substring(2, 4), 16),
+    b: parseInt(clean.substring(4, 6), 16)
+  };
+}
+function rgbToHex4(r, g, b) {
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp8(r).toString(16).padStart(2, "0").toUpperCase()}${clamp8(g).toString(16).padStart(2, "0").toUpperCase()}${clamp8(b).toString(16).padStart(2, "0").toUpperCase()}`;
+}
+function tintColor(hex, tintFactor) {
+  const { r, g, b } = hexToRgb4(hex);
+  return rgbToHex4(
+    r + (255 - r) * tintFactor,
+    g + (255 - g) * tintFactor,
+    b + (255 - b) * tintFactor
+  );
+}
+function shadeColor(hex, shadeFactor) {
+  const { r, g, b } = hexToRgb4(hex);
+  return rgbToHex4(r * (1 - shadeFactor), g * (1 - shadeFactor), b * (1 - shadeFactor));
+}
+function applyTintShade(base, fill) {
+  let color = base;
+  if (fill.tint !== void 0 && fill.tint > 0) {
+    color = tintColor(color, fill.tint / 1e5);
+  }
+  if (fill.shade !== void 0 && fill.shade > 0) {
+    color = shadeColor(color, 1 - fill.shade / 1e5);
+  }
+  return color;
+}
+function resolveStyleFillColor(fill, colorScheme) {
+  if (!fill) {
+    return void 0;
+  }
+  let base;
+  if (fill.schemeColor && colorScheme) {
+    base = colorScheme[fill.schemeColor];
+  }
+  if (!base && fill.color) {
+    base = fill.color;
+  }
+  if (!base) {
+    return void 0;
+  }
+  return applyTintShade(base, fill);
+}
+function resolveFontRefIdx(idx, fontScheme) {
+  if (!idx || !fontScheme) {
+    return void 0;
+  }
+  if (idx === "minor") {
+    return fontScheme.minorFont?.latin;
+  }
+  if (idx === "major") {
+    return fontScheme.majorFont?.latin;
+  }
+  return void 0;
+}
+var BEVEL_LIGHT_OFFSETS = {
+  tl: { x: 1, y: 1 },
+  t: { x: 0, y: 1 },
+  tr: { x: -1, y: 1 },
+  r: { x: -1, y: 0 },
+  br: { x: -1, y: -1 },
+  b: { x: 0, y: -1 },
+  bl: { x: 1, y: -1 },
+  l: { x: 1, y: 0 }
+};
+function cell3DBevelCss(cell3D) {
+  const size = Math.max(cell3D.bevelHeight ?? cell3D.bevelWidth ?? 4, 1);
+  const dir = cell3D.lightRigDirection ?? "tl";
+  const off = BEVEL_LIGHT_OFFSETS[dir] ?? BEVEL_LIGHT_OFFSETS.tl;
+  const highlight = `inset ${off.x * size}px ${off.y * size}px ${size}px rgba(255,255,255,0.55)`;
+  const shadow = `inset ${-off.x * size}px ${-off.y * size}px ${size}px rgba(0,0,0,0.4)`;
+  return { boxShadow: `${highlight}, ${shadow}` };
+}
+function resolveTableStyleEntry(tableStyleId, tableStyleMap) {
+  if (!tableStyleId || !tableStyleMap) {
+    return void 0;
+  }
+  const direct = tableStyleMap[tableStyleId];
+  if (direct) {
+    return direct;
+  }
+  const normalised = tableStyleId.trim().toUpperCase();
+  const withBraces = normalised.startsWith("{") ? normalised : `{${normalised}}`;
+  return tableStyleMap[withBraces];
+}
+function ooxmlDashToCssBorderStyle(dashVal) {
+  if (!dashVal) {
+    return "solid";
+  }
+  switch (dashVal) {
+    case "dot":
+    case "sysDot":
+      return "dotted";
+    case "dash":
+    case "sysDash":
+    case "lgDash":
+    case "dashDot":
+    case "lgDashDot":
+    case "sysDashDot":
+    case "lgDashDotDot":
+    case "sysDashDotDot":
+      return "dashed";
+    default:
+      return "solid";
+  }
+}
+function getDiagonalBorders(style, styleDiagonals) {
+  const cellHasDown = Boolean(style?.borderDiagDownColor && style?.borderDiagDownWidth);
+  const cellHasUp = Boolean(style?.borderDiagUpColor && style?.borderDiagUpWidth);
+  const styleHasDown = Boolean(styleDiagonals?.diagDownColor && styleDiagonals?.diagDownWidth);
+  const styleHasUp = Boolean(styleDiagonals?.diagUpColor && styleDiagonals?.diagUpWidth);
+  if (!cellHasDown && !cellHasUp && !styleHasDown && !styleHasUp) {
+    return null;
+  }
+  const info = {};
+  if (cellHasDown) {
+    info.diagDownColor = style?.borderDiagDownColor;
+    info.diagDownWidth = style?.borderDiagDownWidth;
+  } else if (styleHasDown) {
+    info.diagDownColor = styleDiagonals?.diagDownColor;
+    info.diagDownWidth = styleDiagonals?.diagDownWidth;
+  }
+  if (cellHasUp) {
+    info.diagUpColor = style?.borderDiagUpColor;
+    info.diagUpWidth = style?.borderDiagUpWidth;
+  } else if (styleHasUp) {
+    info.diagUpColor = styleDiagonals?.diagUpColor;
+    info.diagUpWidth = styleDiagonals?.diagUpWidth;
+  }
+  return info;
+}
+function getCellDiagonalBorders(style, tableData, pos, styleCtx) {
+  let styleDiagonals;
+  if (tableData) {
+    const entry = resolveTableStyleEntry(tableData.tableStyleId, styleCtx?.tableStyleMap);
+    styleDiagonals = resolveStyleDiagonalBorders(
+      entry,
+      tableData,
+      pos,
+      (fill) => resolveStyleFillColor(fill, styleCtx?.colorScheme)
+    );
+  }
+  return getDiagonalBorders(style, styleDiagonals);
+}
+function computeBoundingRect(cells) {
+  if (cells.length === 0) {
+    return void 0;
+  }
+  let startRow = cells[0].row;
   let startCol = cells[0].col;
   let endRow = cells[0].row;
   let endCol = cells[0].col;
@@ -12581,7 +14403,7 @@ function rotateDelta(dx, dy, rotationDeg) {
 }
 function applyResize(box, handle, dxScreen, dyScreen, zoom, opts = {}) {
   const scale = zoom || 1;
-  const minSize = opts.minSize ?? chunkIPYAN574_js.MIN_ELEMENT_SIZE;
+  const minSize = opts.minSize ?? chunkCLNGAVNH_js.MIN_ELEMENT_SIZE;
   const rotation = rotationOf(box);
   const local = rotateDelta(dxScreen / scale, dyScreen / scale, rotation);
   const dx = local.x;
@@ -12608,7 +14430,7 @@ function applyResize(box, handle, dxScreen, dyScreen, zoom, opts = {}) {
   }
   return { x: newX, y: newY, width: newW, height: newH, rotation };
 }
-function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkIPYAN574_js.MIN_ELEMENT_SIZE) {
+function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkCLNGAVNH_js.MIN_ELEMENT_SIZE) {
   if (handle === null || gridSpacingPx <= 0) {
     return box;
   }
@@ -12638,7 +14460,7 @@ function snapBoxToGrid(box, handle, gridSpacingPx, minSize = chunkIPYAN574_js.MI
   }
   return { x, y, width, height };
 }
-function computeMarqueeHitIds(marquee, elements, minSize = chunkIPYAN574_js.MIN_ELEMENT_SIZE) {
+function computeMarqueeHitIds(marquee, elements, minSize = chunkCLNGAVNH_js.MIN_ELEMENT_SIZE) {
   const minX = Math.min(marquee.startX, marquee.currentX);
   const minY = Math.min(marquee.startY, marquee.currentY);
   const maxX = Math.max(marquee.startX, marquee.currentX);
@@ -13315,6 +15137,7 @@ function generateTicks(slideLengthPx, scale, unit) {
   }
   return ticks;
 }
+Array.from({ length: 46 }, (_v, i) => i).filter((i) => i !== 3620 - 3585 && i !== 3622 - 3585).map((i) => String.fromCodePoint(3585 + i));
 function resolvePictureBullet(info, baseFontSize) {
   if (!info.imageDataUrl && !info.imageRelId && !info.imageBlipFillXml) {
     return void 0;
@@ -14154,8 +15977,8 @@ function hexToRgb6(hex) {
   };
 }
 function rgbToHex5(r, g, b) {
-  const clamp7 = (v) => Math.max(0, Math.min(255, Math.round(v)));
-  return `#${clamp7(r).toString(16).padStart(2, "0").toUpperCase()}${clamp7(g).toString(16).padStart(2, "0").toUpperCase()}${clamp7(b).toString(16).padStart(2, "0").toUpperCase()}`;
+  const clamp8 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp8(r).toString(16).padStart(2, "0").toUpperCase()}${clamp8(g).toString(16).padStart(2, "0").toUpperCase()}${clamp8(b).toString(16).padStart(2, "0").toUpperCase()}`;
 }
 function tintColor2(hex, tintFactor) {
   const { r, g, b } = hexToRgb6(hex);
@@ -14193,7 +16016,7 @@ var THEME_COLOR_LABELS = {
 };
 function buildThemeColorGrid(colorScheme) {
   return THEME_COLOR_TINT_ROWS.map(
-    (row) => chunkIPYAN574_js.THEME_COLOR_SCHEME_KEYS.map((key) => ({
+    (row) => chunkCLNGAVNH_js.THEME_COLOR_SCHEME_KEYS.map((key) => ({
       hex: row.transform(colorScheme[key]),
       schemeKey: key,
       rowLabel: row.label,
@@ -14529,12 +16352,12 @@ function getShapeConnectionSites(shape) {
   }
   const pathW = geo.pathWidth && geo.pathWidth > 0 ? geo.pathWidth : shape.width;
   const pathH = geo.pathHeight && geo.pathHeight > 0 ? geo.pathHeight : shape.height;
-  const vars = chunkIPYAN574_js.createBuiltinVariables({ w: pathW, h: pathH });
+  const vars = chunkCLNGAVNH_js.createBuiltinVariables({ w: pathW, h: pathH });
   const scaleX = pathW > 0 ? shape.width / pathW : 1;
   const scaleY = pathH > 0 ? shape.height / pathH : 1;
   return cxn.map((site, index) => ({
-    x: chunkIPYAN574_js.resolveCoordinate(site.posX, vars) * scaleX,
-    y: chunkIPYAN574_js.resolveCoordinate(site.posY, vars) * scaleY,
+    x: chunkCLNGAVNH_js.resolveCoordinate(site.posX, vars) * scaleX,
+    y: chunkCLNGAVNH_js.resolveCoordinate(site.posY, vars) * scaleY,
     index
   }));
 }
@@ -14573,7 +16396,7 @@ function rerouteConnectorsForMovedElements(elements, movedElementIds) {
   }
   return rerouted;
 }
-function computeConnectorGeometry(connector, startConn, endConn, elementMap) {
+function computeConnectorGeometry(connector2, startConn, endConn, elementMap) {
   let sx;
   let sy;
   if (startConn?.shapeId) {
@@ -14587,8 +16410,8 @@ function computeConnectorGeometry(connector, startConn, endConn, elementMap) {
     sx = startShape.x + site.x;
     sy = startShape.y + site.y;
   } else {
-    sx = connector.x;
-    sy = connector.y;
+    sx = connector2.x;
+    sy = connector2.y;
   }
   let ex;
   let ey;
@@ -14603,13 +16426,13 @@ function computeConnectorGeometry(connector, startConn, endConn, elementMap) {
     ex = endShape.x + site.x;
     ey = endShape.y + site.y;
   } else {
-    ex = connector.x + connector.width;
-    ey = connector.y + connector.height;
+    ex = connector2.x + connector2.width;
+    ey = connector2.y + connector2.height;
   }
   const flipHorizontal = ex < sx;
   const flipVertical = ey < sy;
   return {
-    id: connector.id,
+    id: connector2.id,
     x: Math.min(sx, ex),
     y: Math.min(sy, ey),
     width: Math.abs(ex - sx) || 1,
@@ -14697,7 +16520,7 @@ function svgLineCap(lineCap) {
 }
 function copyFormatFromElement(element) {
   const result = {};
-  if (chunkIPYAN574_js.hasShapeProperties(element) && element.shapeStyle) {
+  if (chunkCLNGAVNH_js.hasShapeProperties(element) && element.shapeStyle) {
     const s = element.shapeStyle;
     result.shapeStyle = {
       fillColor: s.fillColor,
@@ -14726,7 +16549,7 @@ function copyFormatFromElement(element) {
       softEdgeRadius: s.softEdgeRadius
     };
   }
-  if (chunkIPYAN574_js.hasTextProperties(element) && element.textStyle) {
+  if (chunkCLNGAVNH_js.hasTextProperties(element) && element.textStyle) {
     const t = element.textStyle;
     result.textStyle = {
       fontFamily: t.fontFamily,
@@ -14757,7 +16580,7 @@ function definedEntries(obj) {
 }
 function applyFormatToElement(element, format) {
   let updated = { ...element };
-  if (format.shapeStyle && chunkIPYAN574_js.hasShapeProperties(updated)) {
+  if (format.shapeStyle && chunkCLNGAVNH_js.hasShapeProperties(updated)) {
     updated = {
       ...updated,
       shapeStyle: {
@@ -14766,7 +16589,7 @@ function applyFormatToElement(element, format) {
       }
     };
   }
-  if (format.textStyle && chunkIPYAN574_js.hasTextProperties(updated)) {
+  if (format.textStyle && chunkCLNGAVNH_js.hasTextProperties(updated)) {
     updated = {
       ...updated,
       textStyle: {
@@ -14781,7 +16604,7 @@ function hasCopyableFormat(element) {
   if (!element) {
     return false;
   }
-  return chunkIPYAN574_js.hasShapeProperties(element) || chunkIPYAN574_js.hasTextProperties(element);
+  return chunkCLNGAVNH_js.hasShapeProperties(element) || chunkCLNGAVNH_js.hasTextProperties(element);
 }
 function copySegmentMetadata(from, to) {
   if (from.equationXml !== void 0) {
@@ -14918,7 +16741,7 @@ function getRoundRectRadiusPx(element) {
   return Math.min(Math.max(element.width, 1), Math.max(element.height, 1)) * 0.5 * normalizedAdjustment;
 }
 function getShapeAdjustmentHandleDescriptor(element) {
-  if (!chunkIPYAN574_js.hasShapeProperties(element)) {
+  if (!chunkCLNGAVNH_js.hasShapeProperties(element)) {
     return null;
   }
   const normalizedShapeType = String(element.shapeType || "").toLowerCase();
@@ -15091,6 +16914,16 @@ var ASSET_REF_KEYS = {
 var REV_ASSET_REF_KEYS = Object.fromEntries(
   Object.entries(ASSET_REF_KEYS).map(([field, ref]) => [ref, field])
 );
+var ASSET_VERSION_SUFFIX = "__v";
+function assetVersionKey(fieldName) {
+  return `${fieldName}${ASSET_VERSION_SUFFIX}`;
+}
+function isAssetVersionKey(key) {
+  if (!key.endsWith(ASSET_VERSION_SUFFIX)) {
+    return false;
+  }
+  return ASSET_ELEMENT_FIELDS.has(key.slice(0, -ASSET_VERSION_SUFFIX.length));
+}
 function assetKey(elementId, fieldName) {
   return `${elementId}:${fieldName}`;
 }
@@ -15120,6 +16953,9 @@ function reconcileAssetFields(elementId, rec, ymap, assets) {
       const key = assetKey(elementId, field);
       if (assets.get(key) !== value) {
         assets.set(key, value);
+        const vKey = assetVersionKey(field);
+        const currentVersion = ymap.get(vKey);
+        ymap.set(vKey, (typeof currentVersion === "number" ? currentVersion : 0) + 1);
       }
       if (ymap.get(refKey) !== key) {
         ymap.set(refKey, key);
@@ -15494,6 +17330,7 @@ var COMPLEX_SLIDE_FIELDS = {
   guides: "_gu",
   customerData: "_cu",
   activeXControls: "_ax",
+  legacyVmlElements: "_lvml",
   backgroundPattern: "_bp",
   modernCommentPart: "_mc",
   headerFooterFlags: "_hff",
@@ -15529,7 +17366,7 @@ function readElementFromYMap(ymap, assets) {
       if (isYTextLike(value)) {
         element.textSegments = decodeTextBody(value);
       }
-    } else if (isAssetRefKey(key)) ;
+    } else if (isAssetRefKey(key) || isAssetVersionKey(key)) ;
     else if (REV_COMPLEX_ELEMENT[key]) {
       try {
         element[REV_COMPLEX_ELEMENT[key]] = JSON.parse(value);
@@ -15603,6 +17440,9 @@ function observeYDocSlides(ydoc, onChange) {
   arr.observeDeep(onChange);
   return () => arr.unobserveDeep(onChange);
 }
+function shouldAutoFollowBroadcaster(input) {
+  return input.localRole === "viewer" && input.broadcasterRole === "owner";
+}
 function isYTextEditable(value) {
   return isYTextLike(value) && typeof value.delete === "function" && typeof value.format === "function";
 }
@@ -15910,7 +17750,7 @@ function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
 var POSITION_THRESHOLD = 2;
 var SIZE_THRESHOLD = 2;
 function getElementText(element) {
-  if (!chunkIPYAN574_js.hasTextProperties(element)) {
+  if (!chunkCLNGAVNH_js.hasTextProperties(element)) {
     return "";
   }
   if (element.textSegments && element.textSegments.length > 0) {
@@ -16479,6 +18319,186 @@ var P14_TRANSITION_KEYFRAMES_2 = `
 `;
 var P14_TRANSITION_KEYFRAMES_ALL = `${P14_TRANSITION_KEYFRAMES}
 ${P14_TRANSITION_KEYFRAMES_2}`;
+function threeDPair(prefix, dir, dur, outgoingOnTop) {
+  return {
+    outgoing: `${prefix}-out-${dir} ${dur} ${EASE} forwards`,
+    incoming: `${prefix}-in-${dir} ${dur} ${EASE} forwards`,
+    outgoingOnTop
+  };
+}
+function getCinematicTransitionAnimations(type, durationMs, direction, orient) {
+  const dur = `${durationMs}ms`;
+  switch (type) {
+    case "cube":
+      return threeDPair("pptx-tr-cube", resolveDirection(direction, "left"), dur, false);
+    case "orbit":
+      return threeDPair("pptx-tr-orbit", resolveDirection(direction, "left"), dur, false);
+    case "flip":
+      return threeDPair("pptx-tr-flip", resolveDirection(direction, "left"), dur, true);
+    case "rotate": {
+      const d = resolveDirection(direction, "left");
+      const spin = d === "right" || d === "down" ? "cw" : "ccw";
+      return {
+        outgoing: `pptx-tr-rotate-out-${spin} ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-rotate-in-${spin} ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    }
+    case "fallOver":
+      return {
+        outgoing: `pptx-tr-fallover-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-fallover-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: false
+      };
+    case "drape":
+      return {
+        outgoing: "none",
+        incoming: `pptx-tr-drape-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: false
+      };
+    case "curtains":
+      return {
+        outgoing: `pptx-tr-curtains-out ${dur} ${EASE} forwards`,
+        incoming: "none",
+        outgoingOnTop: true
+      };
+    case "wind": {
+      const d = resolveDirection(direction, "left");
+      const side = d === "right" ? "right" : "left";
+      return {
+        outgoing: `pptx-tr-wind-out-${side} ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-fade-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    }
+    case "prestige":
+      return {
+        outgoing: `pptx-tr-prestige-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-prestige-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    case "fracture":
+      return {
+        outgoing: `pptx-tr-fracture-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-fade-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    case "crush":
+      return {
+        outgoing: `pptx-tr-crush-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-crush-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    case "peelOff":
+      return {
+        outgoing: `pptx-tr-peeloff-out ${dur} ${EASE} forwards`,
+        incoming: "none",
+        outgoingOnTop: true
+      };
+    case "pageCurlSingle":
+      return {
+        outgoing: `pptx-tr-pagecurl-out ${dur} ${EASE} forwards`,
+        incoming: "none",
+        outgoingOnTop: true
+      };
+    case "pageCurlDouble":
+      return {
+        outgoing: `pptx-tr-pagecurl-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-pagecurl-double-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    case "airplane":
+      return {
+        outgoing: `pptx-tr-airplane-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-fade-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    case "origami":
+      return {
+        outgoing: `pptx-tr-origami-out ${dur} ${EASE} forwards`,
+        incoming: `pptx-tr-origami-in ${dur} ${EASE} forwards`,
+        outgoingOnTop: true
+      };
+    default:
+      return void 0;
+  }
+}
+var CINEMATIC_TRANSITION_KEYFRAMES = `
+/* \u2500\u2500 Cube (rotate off one edge onto the next face) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-cube-out-left { from { transform: perspective(1400px) translateX(0) rotateY(0deg); } to { transform: perspective(1400px) translateX(-50%) rotateY(-90deg); opacity: .5; } }
+@keyframes pptx-tr-cube-in-left { from { transform: perspective(1400px) translateX(50%) rotateY(90deg); opacity: .5; } to { transform: perspective(1400px) translateX(0) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-cube-out-right { from { transform: perspective(1400px) translateX(0) rotateY(0deg); } to { transform: perspective(1400px) translateX(50%) rotateY(90deg); opacity: .5; } }
+@keyframes pptx-tr-cube-in-right { from { transform: perspective(1400px) translateX(-50%) rotateY(-90deg); opacity: .5; } to { transform: perspective(1400px) translateX(0) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-cube-out-up { from { transform: perspective(1400px) translateY(0) rotateX(0deg); } to { transform: perspective(1400px) translateY(-50%) rotateX(90deg); opacity: .5; } }
+@keyframes pptx-tr-cube-in-up { from { transform: perspective(1400px) translateY(50%) rotateX(-90deg); opacity: .5; } to { transform: perspective(1400px) translateY(0) rotateX(0deg); opacity: 1; } }
+@keyframes pptx-tr-cube-out-down { from { transform: perspective(1400px) translateY(0) rotateX(0deg); } to { transform: perspective(1400px) translateY(50%) rotateX(-90deg); opacity: .5; } }
+@keyframes pptx-tr-cube-in-down { from { transform: perspective(1400px) translateY(-50%) rotateX(90deg); opacity: .5; } to { transform: perspective(1400px) translateY(0) rotateX(0deg); opacity: 1; } }
+
+/* \u2500\u2500 Orbit (swing the faces through depth) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-orbit-out-left { from { transform: perspective(1600px) translateZ(0) rotateY(0deg); opacity: 1; } to { transform: perspective(1600px) translateZ(-700px) rotateY(-105deg); opacity: 0; } }
+@keyframes pptx-tr-orbit-in-left { from { transform: perspective(1600px) translateZ(-700px) rotateY(105deg); opacity: 0; } to { transform: perspective(1600px) translateZ(0) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-orbit-out-right { from { transform: perspective(1600px) translateZ(0) rotateY(0deg); opacity: 1; } to { transform: perspective(1600px) translateZ(-700px) rotateY(105deg); opacity: 0; } }
+@keyframes pptx-tr-orbit-in-right { from { transform: perspective(1600px) translateZ(-700px) rotateY(-105deg); opacity: 0; } to { transform: perspective(1600px) translateZ(0) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-orbit-out-up { from { transform: perspective(1600px) translateZ(0) rotateX(0deg); opacity: 1; } to { transform: perspective(1600px) translateZ(-700px) rotateX(105deg); opacity: 0; } }
+@keyframes pptx-tr-orbit-in-up { from { transform: perspective(1600px) translateZ(-700px) rotateX(-105deg); opacity: 0; } to { transform: perspective(1600px) translateZ(0) rotateX(0deg); opacity: 1; } }
+@keyframes pptx-tr-orbit-out-down { from { transform: perspective(1600px) translateZ(0) rotateX(0deg); opacity: 1; } to { transform: perspective(1600px) translateZ(-700px) rotateX(-105deg); opacity: 0; } }
+@keyframes pptx-tr-orbit-in-down { from { transform: perspective(1600px) translateZ(-700px) rotateX(105deg); opacity: 0; } to { transform: perspective(1600px) translateZ(0) rotateX(0deg); opacity: 1; } }
+
+/* \u2500\u2500 Flip (card flip; opacity hides the back face) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-flip-out-left { from { transform: perspective(1400px) rotateY(0deg); opacity: 1; } to { transform: perspective(1400px) rotateY(90deg); opacity: 0; } }
+@keyframes pptx-tr-flip-in-left { from { transform: perspective(1400px) rotateY(-90deg); opacity: 0; } to { transform: perspective(1400px) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-flip-out-right { from { transform: perspective(1400px) rotateY(0deg); opacity: 1; } to { transform: perspective(1400px) rotateY(-90deg); opacity: 0; } }
+@keyframes pptx-tr-flip-in-right { from { transform: perspective(1400px) rotateY(90deg); opacity: 0; } to { transform: perspective(1400px) rotateY(0deg); opacity: 1; } }
+@keyframes pptx-tr-flip-out-up { from { transform: perspective(1400px) rotateX(0deg); opacity: 1; } to { transform: perspective(1400px) rotateX(-90deg); opacity: 0; } }
+@keyframes pptx-tr-flip-in-up { from { transform: perspective(1400px) rotateX(90deg); opacity: 0; } to { transform: perspective(1400px) rotateX(0deg); opacity: 1; } }
+@keyframes pptx-tr-flip-out-down { from { transform: perspective(1400px) rotateX(0deg); opacity: 1; } to { transform: perspective(1400px) rotateX(90deg); opacity: 0; } }
+@keyframes pptx-tr-flip-in-down { from { transform: perspective(1400px) rotateX(-90deg); opacity: 0; } to { transform: perspective(1400px) rotateX(0deg); opacity: 1; } }
+
+/* \u2500\u2500 Rotate (in-plane spin + zoom) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-rotate-out-cw { from { transform: rotate(0deg) scale(1); opacity: 1; } to { transform: rotate(90deg) scale(.4); opacity: 0; } }
+@keyframes pptx-tr-rotate-in-cw { from { transform: rotate(-90deg) scale(.4); opacity: 0; } to { transform: rotate(0deg) scale(1); opacity: 1; } }
+@keyframes pptx-tr-rotate-out-ccw { from { transform: rotate(0deg) scale(1); opacity: 1; } to { transform: rotate(-90deg) scale(.4); opacity: 0; } }
+@keyframes pptx-tr-rotate-in-ccw { from { transform: rotate(90deg) scale(.4); opacity: 0; } to { transform: rotate(0deg) scale(1); opacity: 1; } }
+
+/* \u2500\u2500 Fall Over (incoming board topples down over outgoing) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-fallover-out { from { transform: translateZ(0); opacity: 1; } to { transform: perspective(1400px) rotateX(5deg) scale(.94); opacity: .25; } }
+@keyframes pptx-tr-fallover-in { 0% { transform: perspective(1400px) rotateX(-100deg); transform-origin: top center; opacity: .4; } 70% { transform: perspective(1400px) rotateX(8deg); transform-origin: top center; opacity: 1; } 100% { transform: perspective(1400px) rotateX(0deg); transform-origin: top center; opacity: 1; } }
+
+/* \u2500\u2500 Drape (fabric draping down into place) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-drape-in { from { transform: perspective(1600px) rotateX(-55deg) scale(1.15); transform-origin: top center; opacity: 0; } to { transform: perspective(1600px) rotateX(0deg) scale(1); transform-origin: top center; opacity: 1; } }
+
+/* \u2500\u2500 Curtains (outgoing lifts to reveal incoming) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-curtains-out { from { transform: scaleY(1); transform-origin: top center; opacity: 1; } to { transform: scaleY(0); transform-origin: top center; opacity: .3; } }
+
+/* \u2500\u2500 Wind (outgoing blows away with skew + blur) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-wind-out-left { from { transform: translateX(0) skewX(0deg); opacity: 1; filter: blur(0); } to { transform: translateX(-120%) skewX(25deg); opacity: 0; filter: blur(6px); } }
+@keyframes pptx-tr-wind-out-right { from { transform: translateX(0) skewX(0deg); opacity: 1; filter: blur(0); } to { transform: translateX(120%) skewX(-25deg); opacity: 0; filter: blur(6px); } }
+
+/* \u2500\u2500 Prestige (magic vanish then reappear) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-prestige-out { from { transform: scale(1) rotate(0deg); opacity: 1; filter: blur(0); } to { transform: scale(1.4) rotate(6deg); opacity: 0; filter: blur(8px); } }
+@keyframes pptx-tr-prestige-in { from { transform: scale(.6) rotate(-6deg); opacity: 0; filter: blur(8px); } to { transform: scale(1) rotate(0deg); opacity: 1; filter: blur(0); } }
+
+/* \u2500\u2500 Fracture (shatter into contrast + blur) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-fracture-out { 0% { transform: scale(1); opacity: 1; filter: contrast(1) blur(0); } 55% { transform: scale(1.04) rotate(1deg); opacity: 1; filter: contrast(1.7) brightness(1.15); } 100% { transform: scale(1.15) rotate(-2deg); opacity: 0; filter: contrast(2.2) blur(4px); } }
+
+/* \u2500\u2500 Crush (squash flat, then new slide expands) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-crush-out { from { transform: scaleY(1); transform-origin: bottom; opacity: 1; } to { transform: scaleY(0); transform-origin: bottom; opacity: .2; } }
+@keyframes pptx-tr-crush-in { from { transform: scaleY(0); transform-origin: bottom; opacity: .2; } to { transform: scaleY(1); transform-origin: bottom; opacity: 1; } }
+
+/* \u2500\u2500 Peel Off (peel away from a corner) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-peeloff-out { from { transform: perspective(1400px) rotate3d(1, 1, 0, 0deg); transform-origin: top right; opacity: 1; } to { transform: perspective(1400px) rotate3d(1, 1, 0, 110deg); transform-origin: top right; opacity: .15; } }
+
+/* \u2500\u2500 Page Curl (curl off the right edge; double curls new in) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-pagecurl-out { from { transform: perspective(1600px) rotateY(0deg); transform-origin: right center; opacity: 1; } to { transform: perspective(1600px) rotateY(-155deg); transform-origin: right center; opacity: .25; } }
+@keyframes pptx-tr-pagecurl-double-in { from { transform: perspective(1600px) rotateY(155deg); transform-origin: left center; opacity: .25; } to { transform: perspective(1600px) rotateY(0deg); transform-origin: left center; opacity: 1; } }
+
+/* \u2500\u2500 Airplane (fly off like a paper plane) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-airplane-out { 0% { transform: perspective(1200px) translate3d(0, 0, 0) rotate3d(1, -1, 0, 0deg) scale(1); opacity: 1; } 40% { transform: perspective(1200px) translate3d(10%, -10%, 0) rotate3d(1, -1, 0, 25deg) scale(.85); opacity: 1; } 100% { transform: perspective(1200px) translate3d(150%, -70%, 0) rotate3d(1, -1, 1, 70deg) scale(.05); opacity: 0; } }
+
+/* \u2500\u2500 Origami (fold out / unfold in) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
+@keyframes pptx-tr-origami-out { from { transform: perspective(1600px) rotateY(0deg) scaleX(1); transform-origin: left center; opacity: 1; } to { transform: perspective(1600px) rotateY(75deg) scaleX(.25); transform-origin: left center; opacity: .2; } }
+@keyframes pptx-tr-origami-in { from { transform: perspective(1600px) rotateY(-75deg) scaleX(.25); transform-origin: right center; opacity: .2; } to { transform: perspective(1600px) rotateY(0deg) scaleX(1); transform-origin: right center; opacity: 1; } }
+`;
 var CORE_SLIDE_TRANSITION_KEYFRAMES = `
 /* \u2500\u2500 Fade \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */
 @keyframes pptx-tr-fade-in {
@@ -16743,7 +18763,8 @@ var CORE_SLIDE_TRANSITION_KEYFRAMES = `
 }
 `;
 var SLIDE_TRANSITION_KEYFRAMES = `${CORE_SLIDE_TRANSITION_KEYFRAMES}
-${P14_TRANSITION_KEYFRAMES_ALL}`;
+${P14_TRANSITION_KEYFRAMES_ALL}
+${CINEMATIC_TRANSITION_KEYFRAMES}`;
 function resolveLR(direction) {
   if (direction === "l" || direction === "r") {
     return direction;
@@ -16979,6 +19000,10 @@ function getSlideTransitionAnimations(type, durationMs, direction, orient, spoke
   if (p14) {
     return p14;
   }
+  const cinematic = getCinematicTransitionAnimations(type, durationMs, direction);
+  if (cinematic) {
+    return cinematic;
+  }
   switch (type) {
     case "none":
     case "cut":
@@ -17184,9 +19209,9 @@ function getSlideTransitionAnimations(type, durationMs, direction, orient, spoke
     // flythrough/gallery/glitter/honeycomb/pan/prism/reveal/ripple/shred/
     // switch/vortex/warp/wheelReverse/window) is handled faithfully above via
     // `getP14TransitionAnimations` and never reaches this switch.
-    // Fallback (unknown / not-yet-mapped type, e.g. the p15 cinematic set:
-    // cube/flip/rotate/orbit/fracture/peelOff/pageCurl*/airplane/origami)
-    // — symmetrical cross-fade.
+    // Fallback (genuinely unknown / not-yet-mapped type). The p14 exotic set
+    // and the p15 cinematic set are handled above and never reach here.
+    // Symmetrical cross-fade.
     default:
       return {
         outgoing: `pptx-tr-fade-out ${dur} ${EASE} forwards`,
@@ -17292,14 +19317,14 @@ function treeDepth(t) {
 }
 function flattenNodes(roots) {
   const out = [];
-  const walk = (n) => {
+  const walk2 = (n) => {
     out.push(n);
     for (const c of n.children ?? []) {
-      walk(c);
+      walk2(c);
     }
   };
   for (const r of roots) {
-    walk(r);
+    walk2(r);
   }
   return out;
 }
@@ -17763,154 +19788,1078 @@ function computePyramidLayout(nodes, box, palette, style, elementId) {
   return {
     nodes: renderedNodes,
     connectors: [],
-    shadowFilter: styleShadow(style),
-    viewBox: `0 0 ${w} ${h}`,
-    family: "pyramid"
+    shadowFilter: styleShadow(style),
+    viewBox: `0 0 ${w} ${h}`,
+    family: "pyramid"
+  };
+}
+function computeVennLayout(nodes, box, palette, style, elementId) {
+  const { width: w, height: h } = box;
+  const shadow = styleShadow(style);
+  if (nodes.length <= 4) {
+    const cx = w / 2;
+    const cy2 = h / 2;
+    const r2 = Math.min(w, h) * 0.28;
+    const spread = r2 * 0.55;
+    const renderedNodes2 = nodes.map((node, i) => {
+      const angle = i / Math.max(1, nodes.length) * Math.PI * 2 - Math.PI / 2;
+      const nx = cx + spread * Math.cos(angle);
+      const ny = cy2 + spread * Math.sin(angle);
+      const fontSize = fitFontSize(node.text, r2 * 1.2, r2 * 2, 11);
+      const result = {
+        kind: "circle",
+        key: `${elementId}-venn-${node.id}-${i}`,
+        cx: nx,
+        cy: ny,
+        r: r2,
+        fill: nodeFill(node, i, palette),
+        stroke: "none",
+        strokeWidth: 0,
+        opacity: 0.35,
+        text: truncate(node.text, 20),
+        fontSize
+      };
+      return result;
+    });
+    return {
+      nodes: renderedNodes2,
+      connectors: [],
+      shadowFilter: shadow,
+      viewBox: `0 0 ${w} ${h}`,
+      family: "venn"
+    };
+  }
+  const r = Math.min(h * 0.38, w / (nodes.length * 0.9));
+  const overlap = r * 0.5;
+  const totalW = nodes.length * (r * 2 - overlap) + overlap;
+  const offsetX = (w - totalW) / 2 + r;
+  const cy = h / 2;
+  const renderedNodes = nodes.map((node, i) => {
+    const nx = offsetX + i * (r * 2 - overlap);
+    const fontSize = fitFontSize(node.text, r * 1.2, r * 2, 10);
+    const result = {
+      kind: "circle",
+      key: `${elementId}-venn-${node.id}-${i}`,
+      cx: nx,
+      cy,
+      r,
+      fill: nodeFill(node, i, palette),
+      stroke: "none",
+      strokeWidth: 0,
+      opacity: 0.35,
+      text: truncate(node.text, 20),
+      fontSize
+    };
+    return result;
+  });
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: shadow,
+    viewBox: `0 0 ${w} ${h}`,
+    family: "venn"
+  };
+}
+function computeFunnelLayout(nodes, box, palette, style, elementId) {
+  const { width: w, height: h } = box;
+  const pad = 8;
+  const usableW = w - pad * 2;
+  const stageH = nodes.length > 0 ? (h - pad * 2) / nodes.length : h - pad * 2;
+  const sw = styleStroke(style);
+  const stroke = strokeFor(sw);
+  const renderedNodes = nodes.map((node, i) => {
+    const topWidth = usableW * (1 - i / Math.max(1, nodes.length));
+    const bottomWidth = usableW * (1 - (i + 1) / Math.max(1, nodes.length));
+    const y = pad + i * stageH;
+    const topLeft = (w - topWidth) / 2;
+    const topRight = topLeft + topWidth;
+    const bottomLeft = (w - bottomWidth) / 2;
+    const bottomRight = bottomLeft + bottomWidth;
+    const points = [
+      `${topLeft},${y}`,
+      `${topRight},${y}`,
+      `${bottomRight},${y + stageH}`,
+      `${bottomLeft},${y + stageH}`
+    ].join(" ");
+    const fontSize = fitFontSize(node.text, topWidth * 0.85, stageH, 11);
+    const result = {
+      kind: "polygon",
+      key: `${elementId}-funnel-${node.id}-${i}`,
+      points,
+      fill: nodeFill(node, i, palette),
+      stroke: nodeStroke(node, stroke),
+      strokeWidth: sw,
+      opacity: nodeOpacity(i, nodes.length, style),
+      text: truncate(node.text, 30),
+      fontSize,
+      textX: w / 2,
+      textY: y + stageH / 2
+    };
+    return result;
+  });
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: styleShadow(style),
+    viewBox: `0 0 ${w} ${h}`,
+    family: "funnel"
+  };
+}
+function computeTargetLayout(nodes, box, palette, style, elementId) {
+  const { width: w, height: h } = box;
+  const cx = w * 0.4;
+  const cy = h / 2;
+  const maxR = Math.min(cx - 8, cy - 8);
+  const shadow = styleShadow(style);
+  const renderedNodes = nodes.map((node, i) => {
+    const r = maxR * ((nodes.length - i) / Math.max(1, nodes.length));
+    const result = {
+      kind: "circle",
+      key: `${elementId}-target-${node.id}-${i}`,
+      cx,
+      cy,
+      r: Math.max(r, 4),
+      fill: nodeFill(node, i, palette),
+      stroke: "none",
+      strokeWidth: 0,
+      opacity: nodeOpacity(i, nodes.length, style),
+      text: truncate(node.text, 30),
+      fontSize: Math.max(7, Math.min(10, maxR / Math.max(1, nodes.length + 1)))
+    };
+    return result;
+  });
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: shadow,
+    viewBox: `0 0 ${w} ${h}`,
+    family: "target"
+  };
+}
+var localName = (key) => key.split(":").pop() ?? key;
+var NODE_POINT_TYPES = /* @__PURE__ */ new Set(["node", "norm", "nonNorm", "asst", "nonAsst", "doc", "all"]);
+var CHOOSE_ALG_TYPES = /* @__PURE__ */ new Set(["lin", "cycle", "pyra", "snake"]);
+function firstNumber(values) {
+  const value = values?.[0];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function drivingIterator(node) {
+  const list = node.forEach;
+  if (!list || list.length === 0) {
+    return void 0;
+  }
+  const nodeIter = list.find((each) => each.pointTypes?.some((type) => NODE_POINT_TYPES.has(type)));
+  if (nodeIter) {
+    return nodeIter;
+  }
+  const axisIter = list.find(
+    (each) => each.axis?.some((axis) => axis === "ch" || axis === "des" || axis === "self")
+  );
+  return axisIter ?? list[0];
+}
+function selectArrangedNodes(node, flat) {
+  const iter = drivingIterator(node);
+  if (!iter) {
+    return flat;
+  }
+  const start = firstNumber(iter.start);
+  const st0 = start !== void 0 ? Math.max(0, start - 1) : 0;
+  const stepRaw = firstNumber(iter.step);
+  const step = stepRaw !== void 0 && stepRaw > 0 ? stepRaw : 1;
+  const cnt = firstNumber(iter.count) ?? 0;
+  const selected = [];
+  for (let i = st0; i < flat.length; i += step) {
+    selected.push(flat[i]);
+    if (cnt > 0 && selected.length >= cnt) {
+      break;
+    }
+  }
+  if (iter.hideLastTransition?.[0] === true && selected.length > 0) {
+    selected.pop();
+  }
+  return selected;
+}
+function toNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function evaluateWhen(when, nodeCount) {
+  if (when.function !== "cnt") {
+    return void 0;
+  }
+  const threshold = toNumber(when.value);
+  if (threshold === void 0) {
+    return void 0;
+  }
+  switch (when.operator) {
+    case "equ":
+      return nodeCount === threshold;
+    case "neq":
+      return nodeCount !== threshold;
+    case "gt":
+      return nodeCount > threshold;
+    case "lt":
+      return nodeCount < threshold;
+    case "gte":
+      return nodeCount >= threshold;
+    case "lte":
+      return nodeCount <= threshold;
+    default:
+      return void 0;
+  }
+}
+function activeBranch(choose, nodeCount) {
+  for (const when of choose.when) {
+    const result = evaluateWhen(when, nodeCount);
+    if (result === void 0) {
+      return void 0;
+    }
+    if (result) {
+      return when.rawXml;
+    }
+  }
+  return choose.otherwise?.rawXml ?? void 0;
+}
+function branchAlgType(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  let found;
+  const visit = (value) => {
+    if (found !== void 0 || !value || typeof value !== "object") {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+      if (found !== void 0) {
+        return;
+      }
+      if (key.startsWith("@_")) {
+        continue;
+      }
+      if (localName(key) === "alg") {
+        for (const candidate of Array.isArray(entry) ? entry : [entry]) {
+          const type = candidate && typeof candidate === "object" ? String(candidate["@_type"] ?? "") : "";
+          if (CHOOSE_ALG_TYPES.has(type)) {
+            found = type;
+            return;
+          }
+        }
+      } else {
+        visit(entry);
+      }
+    }
+  };
+  visit(raw);
+  return found;
+}
+function chooseAlgType(node, nodeCount) {
+  if (!node.choose || node.choose.length === 0) {
+    return void 0;
+  }
+  for (const choose of node.choose) {
+    const type = branchAlgType(activeBranch(choose, nodeCount));
+    if (type !== void 0) {
+      return type;
+    }
+  }
+  return void 0;
+}
+var PRIMARY_ALG = {
+  lin: "linear",
+  cycle: "cycle",
+  pyra: "pyramid",
+  snake: "snake",
+  composite: "composite",
+  conn: "conn",
+  sp: "spacer",
+  tx: "text"
+};
+var STRUCTURAL = /* @__PURE__ */ new Set(["linear", "cycle", "pyramid", "snake"]);
+var SLOT_CONSTRAINTS = /* @__PURE__ */ new Set(["l", "t", "w", "h", "ctrX", "ctrY"]);
+function mapsSlots(node) {
+  return (node.children ?? []).some(
+    (child2) => (child2.constraints ?? []).some((constraint) => SLOT_CONSTRAINTS.has(constraint.type))
+  );
+}
+function isMeaningfulAux(node) {
+  return (node.constraints?.length ?? 0) > 0 || (node.children?.length ?? 0) > 0;
+}
+function walk(node, visit) {
+  visit(node);
+  for (const child2 of node.children ?? []) {
+    walk(child2, visit);
+  }
+}
+function discoverArrangement(definition, nodeCount) {
+  let hierarchy;
+  let chosen;
+  let compositeSlot;
+  let structural;
+  let aux;
+  walk(definition.rootNode, (node) => {
+    if (!chosen && nodeCount !== void 0 && node.choose && node.choose.length > 0) {
+      const type2 = chooseAlgType(node, nodeCount);
+      const kind2 = type2 ? PRIMARY_ALG[type2] : void 0;
+      if (kind2 && STRUCTURAL.has(kind2)) {
+        const arranger = node.children?.find((child2) => child2.algorithm?.type === type2) ?? node;
+        chosen = { kind: kind2, node: arranger };
+      }
+    }
+    const type = node.algorithm?.type;
+    if (!type) {
+      return;
+    }
+    if (type === "hierRoot" || type === "hierChild") {
+      hierarchy ??= node;
+      return;
+    }
+    const kind = PRIMARY_ALG[type];
+    if (!kind) {
+      return;
+    }
+    if (kind === "composite") {
+      if (!compositeSlot && mapsSlots(node)) {
+        compositeSlot = node;
+      }
+      return;
+    }
+    if (STRUCTURAL.has(kind)) {
+      structural ??= { kind, node };
+      return;
+    }
+    if (!aux && isMeaningfulAux(node)) {
+      aux = { kind, node };
+    }
+  });
+  if (hierarchy) {
+    return { kind: "hierarchy", node: hierarchy };
+  }
+  if (chosen) {
+    return chosen;
+  }
+  if (compositeSlot) {
+    return { kind: "composite", node: compositeSlot };
+  }
+  return structural ?? aux;
+}
+function itemNode(arranger) {
+  return arranger.children?.[0];
+}
+function findConstraint(constraints, type, forRel) {
+  return constraints?.find(
+    (constraint) => constraint.type === type && (forRel === void 0)
+  );
+}
+function constraintRatio(constraint) {
+  if (typeof constraint.factor === "number" && Number.isFinite(constraint.factor)) {
+    return Math.max(0, constraint.factor);
+  }
+  if (typeof constraint.value === "number" && Number.isFinite(constraint.value) && constraint.value >= 0 && constraint.value < 1) {
+    return constraint.value;
+  }
+  return void 0;
+}
+function clampByRules(value, rules, type) {
+  return value;
+}
+function ratioConstraint(constraints, types, fallback, rules) {
+  for (const type of types) {
+    const matches = (constraints ?? []).filter((constraint) => constraint.type === type);
+    const ordered2 = [
+      ...matches.filter((constraint) => constraint.for === "ch"),
+      ...matches.filter((constraint) => constraint.for !== "ch")
+    ];
+    for (const constraint of ordered2) {
+      const ratio = constraintRatio(constraint);
+      if (ratio !== void 0) {
+        return clampByRules(ratio);
+      }
+    }
+  }
+  return fallback;
+}
+function algorithmParam(node, type) {
+  return node.algorithm?.parameters?.find((param) => param.type === type)?.value;
+}
+function numericParam(node, type, fallback) {
+  const raw = algorithmParam(node, type);
+  if (raw === void 0) {
+    return fallback;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function resolveFlowDirection(arranger, presLayoutVars) {
+  const linDir = algorithmParam(arranger, "linDir");
+  const vertical = linDir === "fromT" || linDir === "fromB";
+  let reverse = linDir === "fromR" || linDir === "fromB";
+  if (presLayoutVars?.direction === "rev") {
+    reverse = !reverse;
+  }
+  return { orientation: vertical ? "vertical" : "horizontal", reverse };
+}
+function styleContext(style) {
+  const strokeWidth = styleStroke(style);
+  return { strokeWidth, stroke: strokeFor(strokeWidth), shadow: styleShadow(style) };
+}
+function rectNode(params) {
+  const { x, y, width, height, node, index, total, palette, style, ctx } = params;
+  return {
+    kind: "rect",
+    key: params.key,
+    x,
+    y,
+    width,
+    height,
+    rx: Math.min(6, height * 0.15),
+    fill: nodeFill(node, index, palette),
+    stroke: nodeStroke(node, ctx.stroke),
+    strokeWidth: ctx.strokeWidth,
+    opacity: nodeOpacity(index, total, style),
+    text: truncate(node.text, 40),
+    fontSize: fitFontSize(node.text, width * 0.9, height, 12),
+    textX: x + width / 2,
+    textY: y + height / 2
+  };
+}
+function circleNode(params) {
+  const { cx, cy, r, node, index, total, palette, style, ctx } = params;
+  return {
+    kind: "circle",
+    key: params.key,
+    cx,
+    cy,
+    r,
+    fill: nodeFill(node, index, palette),
+    stroke: nodeStroke(node, ctx.stroke),
+    strokeWidth: ctx.strokeWidth,
+    opacity: nodeOpacity(index, total, style),
+    text: truncate(node.text, 20),
+    fontSize: fitFontSize(node.text, r * 1.4, r * 2, 11)
+  };
+}
+function polygonNode(params) {
+  const { points, textX, textY, node, index, total, palette, style, ctx } = params;
+  return {
+    kind: "polygon",
+    key: params.key,
+    points,
+    fill: nodeFill(node, index, palette),
+    stroke: nodeStroke(node, ctx.stroke),
+    strokeWidth: ctx.strokeWidth,
+    opacity: nodeOpacity(index, total, style),
+    text: truncate(node.text, 25),
+    fontSize: fitFontSize(node.text, params.fontWidth, params.fontHeight, 12),
+    textX,
+    textY
+  };
+}
+var INSET = 6;
+function itemAspect(plan) {
+  const item = itemNode(plan.node);
+  const constraints = item?.constraints;
+  const height = findConstraint(constraints, "h");
+  if (height?.referenceType === "w" && typeof height.factor === "number" && height.factor > 0) {
+    return height.factor;
+  }
+  const width = findConstraint(constraints, "w");
+  if (typeof height?.value === "number" && typeof width?.value === "number" && width.value > 0 && height.value > 0) {
+    return height.value / width.value;
+  }
+  return void 0;
+}
+function ordered(nodes, flow) {
+  return flow.reverse ? [...nodes].reverse() : nodes;
+}
+function arrangeLinear(plan, flow, nodes, box, palette, style, elementId) {
+  const { width: w, height: h } = box;
+  const ctx = styleContext(style);
+  const constraints = plan.node.constraints;
+  const sib = ratioConstraint(constraints, ["sibSp", "sp"], 0.25);
+  const begPad = ratioConstraint(constraints, ["begPad"], 0);
+  const endPad = ratioConstraint(constraints, ["endPad"], 0);
+  const aspect = itemAspect(plan);
+  const flow2 = ordered(nodes, flow);
+  const n = flow2.length;
+  const horizontal = flow.orientation === "horizontal";
+  const usableMain = (horizontal ? w : h) - INSET * 2;
+  const usableCross = (horizontal ? h : w) - INSET * 2;
+  const denom = begPad + endPad + n + Math.max(0, n - 1) * sib;
+  const mainExtent = n > 0 ? usableMain / denom : usableMain;
+  const gap = sib * mainExtent;
+  const crossDefault = Math.min(usableCross, mainExtent * 0.62);
+  const crossExtent = aspect ? Math.min(usableCross, Math.max(12, mainExtent * aspect)) : crossDefault;
+  const crossPos = INSET + (usableCross - crossExtent) / 2;
+  const start = INSET + begPad * mainExtent;
+  const renderedNodes = flow2.map((node, i) => {
+    const mainPos = start + i * (mainExtent + gap);
+    return rectNode({
+      key: `${elementId}-lin-${node.id}-${i}`,
+      x: horizontal ? mainPos : crossPos,
+      y: horizontal ? crossPos : mainPos,
+      width: horizontal ? mainExtent : crossExtent,
+      height: horizontal ? crossExtent : mainExtent,
+      node,
+      index: i,
+      total: n,
+      palette,
+      style,
+      ctx
+    });
+  });
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${w} ${h}`,
+    family: "list"
+  };
+}
+function arrangeSnake(plan, nodes, box, palette, style, elementId) {
+  const { width: w, height: h } = box;
+  const ctx = styleContext(style);
+  const n = nodes.length;
+  const sib = ratioConstraint(plan.node.constraints, ["sibSp", "sp"], 0.15);
+  const cols = Math.max(1, Math.round(Math.sqrt(n * Math.max(0.2, w / Math.max(1, h)))));
+  const rows = Math.max(1, Math.ceil(n / cols));
+  const usableW = w - INSET * 2;
+  const usableH = h - INSET * 2;
+  const cellW = usableW / (cols + Math.max(0, cols - 1) * sib);
+  const cellH = usableH / (rows + Math.max(0, rows - 1) * sib);
+  const gapX = sib * cellW;
+  const gapY = sib * cellH;
+  const renderedNodes = nodes.map((node, i) => {
+    const row = Math.floor(i / cols);
+    const posInRow = i % cols;
+    const col = row % 2 === 1 ? cols - 1 - posInRow : posInRow;
+    return rectNode({
+      key: `${elementId}-snake-${node.id}-${i}`,
+      x: INSET + col * (cellW + gapX),
+      y: INSET + row * (cellH + gapY),
+      width: cellW,
+      height: cellH,
+      node,
+      index: i,
+      total: n,
+      palette,
+      style,
+      ctx
+    });
+  });
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${w} ${h}`,
+    family: "matrix"
+  };
+}
+var INSET2 = 6;
+var ARROW_WING = 4;
+var ARROW_HEAD = 7;
+function arrowPath(x0, y0, x1, y1) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const len = Math.hypot(dx, dy);
+  const line2 = `M${x0},${y0} L${x1},${y1}`;
+  if (len < 1e-6) {
+    return line2;
+  }
+  const ux = dx / len;
+  const uy = dy / len;
+  const bx = x1 - ux * ARROW_HEAD;
+  const by = y1 - uy * ARROW_HEAD;
+  const px3 = -uy;
+  const py = ux;
+  const w1x = bx + px3 * ARROW_WING;
+  const w1y = by + py * ARROW_WING;
+  const w2x = bx - px3 * ARROW_WING;
+  const w2y = by - py * ARROW_WING;
+  return `${line2} M${w1x},${w1y} L${x1},${y1} L${w2x},${w2y}`;
+}
+function connectPoints(from, to, horizontal) {
+  const fromCx = from.x + from.width / 2;
+  const fromCy = from.y + from.height / 2;
+  const toCx = to.x + to.width / 2;
+  const toCy = to.y + to.height / 2;
+  if (horizontal) {
+    const leftFirst = fromCx <= toCx;
+    return leftFirst ? { x0: from.x + from.width, y0: fromCy, x1: to.x, y1: toCy } : { x0: from.x, y0: fromCy, x1: to.x + to.width, y1: toCy };
+  }
+  const topFirst = fromCy <= toCy;
+  return topFirst ? { x0: fromCx, y0: from.y + from.height, x1: toCx, y1: to.y } : { x0: fromCx, y0: from.y, x1: toCx, y1: to.y + to.height };
+}
+function arrangeConn(plan, nodes, box, palette, style, elementId) {
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  const flow = resolveFlowDirection(plan.node, void 0);
+  const base = arrangeLinear(plan, flow, nodes, box, palette, style, elementId);
+  const rects = base.nodes.filter((node) => node.kind === "rect");
+  const horizontal = flow.orientation === "horizontal";
+  const connectors = [];
+  for (let i = 0; i < rects.length - 1; i++) {
+    const { x0, y0, x1, y1 } = connectPoints(rects[i], rects[i + 1], horizontal);
+    connectors.push({ key: `${elementId}-conn-${i}`, d: arrowPath(x0, y0, x1, y1) });
+  }
+  return { ...base, connectors, family: "process" };
+}
+function arrangeSpacer(_plan, _nodes, box, _palette, style, _elementId) {
+  const ctx = styleContext(style);
+  return {
+    nodes: [],
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${box.width} ${box.height}`,
+    family: "list"
+  };
+}
+function arrangeText(_plan, nodes, box, palette, style, elementId) {
+  const node = nodes[0];
+  if (!node) {
+    return void 0;
+  }
+  const { width: w, height: h } = box;
+  const ctx = styleContext(style);
+  const rect = rectNode({
+    key: `${elementId}-tx-${node.id}`,
+    x: INSET2,
+    y: INSET2,
+    width: Math.max(0, w - INSET2 * 2),
+    height: Math.max(0, h - INSET2 * 2),
+    node,
+    index: 0,
+    total: 1,
+    palette,
+    style,
+    ctx
+  });
+  return {
+    nodes: [rect],
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${w} ${h}`,
+    family: "list"
+  };
+}
+function axisExtent(referenceType, box, fallback) {
+  if (referenceType === "w") {
+    return box.width;
+  }
+  if (referenceType === "h") {
+    return box.height;
+  }
+  return fallback;
+}
+function defaultExtent(type, box) {
+  return type === "h" || type === "t" || type === "ctrY" || type === "b" ? box.height : box.width;
+}
+function dimOf(constraints, type, box) {
+  const constraint = findConstraint(constraints, type);
+  if (!constraint) {
+    return void 0;
+  }
+  const extent = axisExtent(constraint.referenceType, box, defaultExtent(type, box));
+  if (typeof constraint.factor === "number" && Number.isFinite(constraint.factor)) {
+    return { px: constraint.factor * extent };
+  }
+  if (typeof constraint.value === "number" && Number.isFinite(constraint.value)) {
+    if (constraint.value >= 0 && constraint.value <= 1) {
+      return { px: constraint.value * extent };
+    }
+    if (constraint.value > 1) {
+      return { abs: constraint.value };
+    }
+  }
+  return void 0;
+}
+function isPositioned(dims) {
+  return dims.l !== void 0 || dims.t !== void 0 || dims.w !== void 0 || dims.h !== void 0 || dims.ctrX !== void 0 || dims.ctrY !== void 0;
+}
+function readSlots(children, box) {
+  const slots = [];
+  for (const child2 of children) {
+    const c = child2.constraints;
+    const dims = {
+      l: dimOf(c, "l", box),
+      t: dimOf(c, "t", box),
+      w: dimOf(c, "w", box),
+      h: dimOf(c, "h", box),
+      ctrX: dimOf(c, "ctrX", box),
+      ctrY: dimOf(c, "ctrY", box)
+    };
+    if (isPositioned(dims)) {
+      slots.push(dims);
+    }
+  }
+  return slots;
+}
+function absOf(dim) {
+  return typeof dim?.abs === "number" ? dim.abs : 0;
+}
+function axisAbsMax(slots, pos, ctr, size) {
+  let max = 0;
+  for (const slot of slots) {
+    const s = absOf(slot[size]);
+    const edge = Math.max(absOf(slot[pos]) + s, absOf(slot[ctr]) + s / 2, s);
+    if (edge > max) {
+      max = edge;
+    }
+  }
+  return max;
+}
+function px2(dim, absScale) {
+  if (!dim) {
+    return void 0;
+  }
+  if (typeof dim.px === "number") {
+    return dim.px;
+  }
+  if (typeof dim.abs === "number") {
+    return dim.abs * absScale;
+  }
+  return void 0;
+}
+function clamp5(v, min, max) {
+  if (max <= min) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, v));
+}
+function resolveSlot(dims, box, absX, absY) {
+  const rawW = px2(dims.w, absX);
+  const rawH = px2(dims.h, absY);
+  const width = clamp5(rawW ?? box.width, 1, box.width);
+  const height = clamp5(rawH ?? box.height, 1, box.height);
+  const l = px2(dims.l, absX);
+  const ctrX = px2(dims.ctrX, absX);
+  let x;
+  if (l !== void 0) {
+    x = l;
+  } else if (ctrX !== void 0) {
+    x = ctrX - width / 2;
+  } else {
+    x = (box.width - width) / 2;
+  }
+  const t = px2(dims.t, absY);
+  const ctrY = px2(dims.ctrY, absY);
+  let y;
+  if (t !== void 0) {
+    y = t;
+  } else if (ctrY !== void 0) {
+    y = ctrY - height / 2;
+  } else {
+    y = (box.height - height) / 2;
+  }
+  return {
+    x: clamp5(x, 0, box.width - width),
+    y: clamp5(y, 0, box.height - height),
+    width,
+    height
+  };
+}
+function arrangeComposite(plan, nodes, box, palette, style, elementId) {
+  const children = plan.node.children;
+  if (!children || children.length === 0 || nodes.length === 0) {
+    return void 0;
+  }
+  const slotDims = readSlots(children, box);
+  if (slotDims.length === 0) {
+    return void 0;
+  }
+  const absMaxX = axisAbsMax(slotDims, "l", "ctrX", "w");
+  const absMaxY = axisAbsMax(slotDims, "t", "ctrY", "h");
+  const absX = absMaxX > 0 ? box.width / absMaxX : 1;
+  const absY = absMaxY > 0 ? box.height / absMaxY : 1;
+  const slots = slotDims.map((dims) => resolveSlot(dims, box, absX, absY));
+  const ctx = styleContext(style);
+  const count = Math.min(slots.length, nodes.length);
+  const renderedNodes = [];
+  for (let i = 0; i < count; i++) {
+    const slot = slots[i];
+    const node = nodes[i];
+    renderedNodes.push(
+      rectNode({
+        key: `${elementId}-comp-${node.id}-${i}`,
+        x: slot.x,
+        y: slot.y,
+        width: slot.width,
+        height: slot.height,
+        node,
+        index: i,
+        total: count,
+        palette,
+        style,
+        ctx
+      })
+    );
+  }
+  return {
+    nodes: renderedNodes,
+    connectors: [],
+    shadowFilter: ctx.shadow,
+    viewBox: `0 0 ${box.width} ${box.height}`,
+    family: "list"
   };
 }
-function computeVennLayout(nodes, box, palette, style, elementId) {
+var DEG_TO_RAD2 = Math.PI / 180;
+function pointAngle(index, count, startDeg, spanDeg) {
+  const full = Math.abs(spanDeg) >= 360;
+  const step = full ? spanDeg / count : count > 1 ? spanDeg / (count - 1) : 0;
+  return (startDeg + index * step - 90) * DEG_TO_RAD2;
+}
+function arrangeCycle(plan, nodes, box, palette, style, elementId) {
   const { width: w, height: h } = box;
-  const shadow = styleShadow(style);
-  if (nodes.length <= 4) {
-    const cx = w / 2;
-    const cy2 = h / 2;
-    const r2 = Math.min(w, h) * 0.28;
-    const spread = r2 * 0.55;
-    const renderedNodes2 = nodes.map((node, i) => {
-      const angle = i / Math.max(1, nodes.length) * Math.PI * 2 - Math.PI / 2;
-      const nx = cx + spread * Math.cos(angle);
-      const ny = cy2 + spread * Math.sin(angle);
-      const fontSize = fitFontSize(node.text, r2 * 1.2, r2 * 2, 11);
-      const result = {
-        kind: "circle",
-        key: `${elementId}-venn-${node.id}-${i}`,
-        cx: nx,
-        cy: ny,
-        r: r2,
-        fill: nodeFill(node, i, palette),
-        stroke: "none",
-        strokeWidth: 0,
-        opacity: 0.35,
-        text: truncate(node.text, 20),
-        fontSize
-      };
-      return result;
-    });
+  const ctx = styleContext(style);
+  const n = nodes.length;
+  const size = Math.min(w, h);
+  const cx = w / 2;
+  const cy = h / 2;
+  const startDeg = numericParam(plan.node, "stAng", 0);
+  const spanDeg = numericParam(plan.node, "spanAng", 360);
+  const nodeR = Math.max(size * 0.06, Math.min(size * 0.12, 200 / Math.max(1, n)));
+  const radius = Math.max(nodeR, size * 0.5 - nodeR - 4);
+  const centre = (index) => {
+    const angle = pointAngle(index, n, startDeg, spanDeg);
+    return { x: cx + radius * Math.cos(angle), y: cy + radius * Math.sin(angle) };
+  };
+  const full = Math.abs(spanDeg) >= 360;
+  const connectorCount = full ? n : Math.max(0, n - 1);
+  const connectors = Array.from({ length: connectorCount }, (_, i) => {
+    const from = centre(i);
+    const to = centre((i + 1) % n);
+    const midX = (from.x + to.x) / 2;
+    const midY = (from.y + to.y) / 2;
+    const pull = 1 + radius * 0.15 / Math.max(1, Math.hypot(midX - cx, midY - cy));
+    const controlX = cx + (midX - cx) * pull;
+    const controlY = cy + (midY - cy) * pull;
     return {
-      nodes: renderedNodes2,
-      connectors: [],
-      shadowFilter: shadow,
-      viewBox: `0 0 ${w} ${h}`,
-      family: "venn"
+      key: `${elementId}-cycle-conn-${i}`,
+      d: `M${from.x},${from.y} Q${controlX},${controlY} ${to.x},${to.y}`
     };
-  }
-  const r = Math.min(h * 0.38, w / (nodes.length * 0.9));
-  const overlap = r * 0.5;
-  const totalW = nodes.length * (r * 2 - overlap) + overlap;
-  const offsetX = (w - totalW) / 2 + r;
-  const cy = h / 2;
+  });
   const renderedNodes = nodes.map((node, i) => {
-    const nx = offsetX + i * (r * 2 - overlap);
-    const fontSize = fitFontSize(node.text, r * 1.2, r * 2, 10);
-    const result = {
-      kind: "circle",
-      key: `${elementId}-venn-${node.id}-${i}`,
-      cx: nx,
-      cy,
-      r,
-      fill: nodeFill(node, i, palette),
-      stroke: "none",
-      strokeWidth: 0,
-      opacity: 0.35,
-      text: truncate(node.text, 20),
-      fontSize
-    };
-    return result;
+    const { x, y } = centre(i);
+    return circleNode({
+      key: `${elementId}-cycle-${node.id}-${i}`,
+      cx: x,
+      cy: y,
+      r: nodeR,
+      node,
+      index: i,
+      total: n,
+      palette,
+      style,
+      ctx
+    });
   });
   return {
     nodes: renderedNodes,
-    connectors: [],
-    shadowFilter: shadow,
+    connectors,
+    shadowFilter: ctx.shadow,
     viewBox: `0 0 ${w} ${h}`,
-    family: "venn"
+    family: "cycle"
   };
 }
-function computeFunnelLayout(nodes, box, palette, style, elementId) {
-  const { width: w, height: h } = box;
-  const pad = 8;
-  const usableW = w - pad * 2;
-  const stageH = nodes.length > 0 ? (h - pad * 2) / nodes.length : h - pad * 2;
-  const sw = styleStroke(style);
-  const stroke = strokeFor(sw);
-  const renderedNodes = nodes.map((node, i) => {
-    const topWidth = usableW * (1 - i / Math.max(1, nodes.length));
-    const bottomWidth = usableW * (1 - (i + 1) / Math.max(1, nodes.length));
-    const y = pad + i * stageH;
-    const topLeft = (w - topWidth) / 2;
-    const topRight = topLeft + topWidth;
-    const bottomLeft = (w - bottomWidth) / 2;
-    const bottomRight = bottomLeft + bottomWidth;
-    const points = [
-      `${topLeft},${y}`,
-      `${topRight},${y}`,
-      `${bottomRight},${y + stageH}`,
-      `${bottomLeft},${y + stageH}`
-    ].join(" ");
-    const fontSize = fitFontSize(node.text, topWidth * 0.85, stageH, 11);
-    const result = {
-      kind: "polygon",
-      key: `${elementId}-funnel-${node.id}-${i}`,
-      points,
-      fill: nodeFill(node, i, palette),
-      stroke: nodeStroke(node, stroke),
-      strokeWidth: sw,
-      opacity: nodeOpacity(i, nodes.length, style),
-      text: truncate(node.text, 30),
-      fontSize,
-      textX: w / 2,
-      textY: y + stageH / 2
-    };
-    return result;
+var INSET3 = 6;
+function isHanging(presLayoutVars) {
+  const branch = presLayoutVars?.hierarchyBranch;
+  return branch === "l" || branch === "r" || branch === "hang";
+}
+function connector(hc, from, fx, fy, cx, cy) {
+  const midY = fy + (cy - fy) / 2;
+  hc.connectors.push({
+    key: `${hc.elementId}-hier-conn-${from.node.id}-${cx}-${cy}`,
+    d: `M${fx},${fy} L${fx},${midY} L${cx},${midY} L${cx},${cy}`
   });
+}
+function pushNode(hc, node, x, y) {
+  const index = hc.counter.value++;
+  hc.nodes.push(
+    rectNode({
+      key: `${hc.elementId}-hier-${node.id}-${index}`,
+      x,
+      y,
+      width: hc.boxW,
+      height: hc.boxH,
+      node,
+      index,
+      total: hc.total,
+      palette: hc.palette,
+      style: hc.style,
+      ctx: hc.ctx
+    })
+  );
+  return index;
+}
+function placeStandard(hc, t, xOffset, level, cellW, cellH) {
+  const spanW = treeWidth(t);
+  const cx = (xOffset + spanW / 2) * cellW;
+  const cy = level * cellH + cellH / 2;
+  pushNode(hc, t.node, cx - hc.boxW / 2, cy - hc.boxH / 2);
+  let childOffset = xOffset;
+  for (const child2 of t.children) {
+    const childW = treeWidth(child2);
+    const childCx = (childOffset + childW / 2) * cellW;
+    const childCy = (level + 1) * cellH + cellH / 2;
+    connector(hc, t, cx, cy + hc.boxH / 2, childCx, childCy - hc.boxH / 2);
+    placeStandard(hc, child2, childOffset, level + 1, cellW, cellH);
+    childOffset += childW;
+  }
+}
+function placeHanging(hc, t, x, indent, vGap, cursor) {
+  const y = cursor.y;
+  cursor.y += hc.boxH + vGap;
+  pushNode(hc, t.node, x, y);
+  for (const child2 of t.children) {
+    const childY = cursor.y;
+    connector(hc, t, x + hc.boxH / 2, y + hc.boxH, x + indent, childY + hc.boxH / 2);
+    placeHanging(hc, child2, x + indent, indent, vGap, cursor);
+  }
+}
+function baseContext(nodeCount, elementId, palette, style, boxW, boxH) {
   return {
-    nodes: renderedNodes,
+    elementId,
+    palette,
+    style,
+    ctx: styleContext(style),
+    total: nodeCount,
+    boxW,
+    boxH,
+    nodes: [],
     connectors: [],
-    shadowFilter: styleShadow(style),
+    counter: { value: 0 }
+  };
+}
+function arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars) {
+  const { width: w, height: h } = box;
+  const roots = buildTree(nodes);
+  if (isHanging(presLayoutVars)) {
+    const boxW2 = Math.min(w * 0.42, 160);
+    const boxH2 = Math.min(h * 0.16, 30);
+    const indent = boxW2 * 0.35;
+    const vGap = boxH2 * 0.55;
+    const hc2 = baseContext(nodes.length, elementId, palette, style, boxW2, boxH2);
+    const cursor = { y: INSET3 };
+    for (const root of roots) {
+      placeHanging(hc2, root, INSET3, indent, vGap, cursor);
+    }
+    return {
+      nodes: hc2.nodes,
+      connectors: hc2.connectors,
+      shadowFilter: hc2.ctx.shadow,
+      viewBox: `0 0 ${w} ${h}`,
+      family: "hierarchy"
+    };
+  }
+  const totalLeaves = roots.reduce((sum, r) => sum + treeWidth(r), 0);
+  const depth = roots.length > 0 ? Math.max(...roots.map(treeDepth)) : 1;
+  const cellW = w / Math.max(1, totalLeaves);
+  const cellH = h / Math.max(1, depth);
+  const boxW = Math.min(cellW * 0.8, 150);
+  const boxH = Math.min(cellH * 0.4, 40);
+  const hc = baseContext(nodes.length, elementId, palette, style, boxW, boxH);
+  let offset = 0;
+  for (const root of roots) {
+    placeStandard(hc, root, offset, 0, cellW, cellH);
+    offset += treeWidth(root);
+  }
+  return {
+    nodes: hc.nodes,
+    connectors: hc.connectors,
+    shadowFilter: hc.ctx.shadow,
     viewBox: `0 0 ${w} ${h}`,
-    family: "funnel"
+    family: "hierarchy"
   };
 }
-function computeTargetLayout(nodes, box, palette, style, elementId) {
+var INSET4 = 8;
+function arrangePyramid(plan, nodes, box, palette, style, elementId) {
   const { width: w, height: h } = box;
-  const cx = w * 0.4;
-  const cy = h / 2;
-  const maxR = Math.min(cx - 8, cy - 8);
-  const shadow = styleShadow(style);
+  const ctx = styleContext(style);
+  const n = nodes.length;
+  const cx = w / 2;
+  const maxW = w - INSET4 * 2;
+  const gapRatio = ratioConstraint(plan.node.constraints, ["sibSp", "sp"], 0.06);
+  const usableH = h - INSET4 * 2;
+  const bandH = n > 0 ? usableH / (n + Math.max(0, n - 1) * gapRatio) : usableH;
+  const gap = gapRatio * bandH;
   const renderedNodes = nodes.map((node, i) => {
-    const r = maxR * ((nodes.length - i) / Math.max(1, nodes.length));
-    const result = {
-      kind: "circle",
-      key: `${elementId}-target-${node.id}-${i}`,
-      cx,
-      cy,
-      r: Math.max(r, 4),
-      fill: nodeFill(node, i, palette),
-      stroke: "none",
-      strokeWidth: 0,
-      opacity: nodeOpacity(i, nodes.length, style),
-      text: truncate(node.text, 30),
-      fontSize: Math.max(7, Math.min(10, maxR / Math.max(1, nodes.length + 1)))
-    };
-    return result;
+    const yTop = INSET4 + i * (bandH + gap);
+    const yBot = yTop + bandH;
+    const fTop = i / n;
+    const fBot = (i + 1) / n;
+    const halfTop = maxW * fTop / 2;
+    const halfBot = maxW * fBot / 2;
+    const points = [
+      `${cx - halfTop},${yTop}`,
+      `${cx + halfTop},${yTop}`,
+      `${cx + halfBot},${yBot}`,
+      `${cx - halfBot},${yBot}`
+    ].join(" ");
+    return polygonNode({
+      key: `${elementId}-pyra-${node.id}-${i}`,
+      points,
+      textX: cx,
+      textY: (yTop + yBot) / 2,
+      fontWidth: Math.max(20, halfBot * 1.4),
+      fontHeight: bandH,
+      node,
+      index: i,
+      total: n,
+      palette,
+      style,
+      ctx
+    });
   });
   return {
     nodes: renderedNodes,
     connectors: [],
-    shadowFilter: shadow,
+    shadowFilter: ctx.shadow,
     viewBox: `0 0 ${w} ${h}`,
-    family: "target"
+    family: "pyramid"
   };
 }
+function interpretSmartArtLayout(input) {
+  const { layoutDefinition, nodes, flat, box, palette, style, elementId, presLayoutVars } = input;
+  if (!layoutDefinition || flat.length === 0) {
+    return void 0;
+  }
+  const plan = discoverArrangement(layoutDefinition, flat.length);
+  if (!plan) {
+    return void 0;
+  }
+  if (plan.kind === "hierarchy") {
+    return arrangeHierarchy(nodes, box, palette, style, elementId, presLayoutVars);
+  }
+  const arranged = selectArrangedNodes(plan.node, flat);
+  if (arranged.length === 0) {
+    return void 0;
+  }
+  switch (plan.kind) {
+    case "linear": {
+      const flow = resolveFlowDirection(plan.node, presLayoutVars);
+      return arrangeLinear(plan, flow, arranged, box, palette, style, elementId);
+    }
+    case "snake":
+      return arrangeSnake(plan, arranged, box, palette, style, elementId);
+    case "cycle":
+      return arrangeCycle(plan, arranged, box, palette, style, elementId);
+    case "pyramid":
+      return arrangePyramid(plan, arranged, box, palette, style, elementId);
+    case "composite":
+      return arrangeComposite(plan, arranged, box, palette, style, elementId);
+    case "conn":
+      return arrangeConn(plan, arranged, box, palette, style, elementId);
+    case "spacer":
+      return arrangeSpacer(plan, arranged, box, palette, style);
+    case "text":
+      return arrangeText(plan, arranged, box, palette, style, elementId);
+  }
+}
 function interpolateSmartArtPalette(palette, count, method, hueDirection) {
   if (count <= 0 || palette.length === 0) {
     return [];
@@ -17926,10 +20875,23 @@ function interpolateSmartArtPalette(palette, count, method, hueDirection) {
     return interpolateColor(palette[lower], palette[lower + 1], frac, "hsl", hueDirection);
   });
 }
-function computeSmartArtLayout(nodes, box, palette, style, elementId, resolvedLayoutType, layout, interpolation) {
+function computeSmartArtLayout(nodes, box, palette, style, elementId, resolvedLayoutType, layout, interpolation, layoutDefinition, presLayoutVars) {
   const flat = flattenNodes(nodes);
   const family = resolveLayoutFamily(nodes, resolvedLayoutType, layout);
   const pal = interpolation?.method === "span" ? interpolateSmartArtPalette(palette, flat.length, "span", interpolation.hueDirection) : palette;
+  const interpreted = interpretSmartArtLayout({
+    layoutDefinition,
+    nodes,
+    flat,
+    box,
+    palette: pal,
+    style,
+    elementId,
+    presLayoutVars
+  });
+  if (interpreted) {
+    return interpreted;
+  }
   switch (family) {
     case "list":
       return computeListLayout(flat, box, pal, style, elementId);
@@ -18299,14 +21261,14 @@ function smartArtLayoutLabel(type) {
 }
 function flattenSmartArtNodes(nodes) {
   const out = [];
-  const walk = (n) => {
+  const walk2 = (n) => {
     out.push(n);
     for (const child2 of n.children ?? []) {
-      walk(child2);
+      walk2(child2);
     }
   };
   for (const n of nodes) {
-    walk(n);
+    walk2(n);
   }
   return out;
 }
@@ -18357,14 +21319,14 @@ var THREE_UNAVAILABLE = {
 var FOV = 50;
 async function loadThree() {
   try {
-    return await import('./three.module-CPZZFD2Q.js');
+    return await import('./three.module-GNNNRIMK.js');
   } catch {
     return null;
   }
 }
 async function loadGltfLoaderCtor() {
   try {
-    const mod = await import('./GLTFLoader-GP55DVVS.js');
+    const mod = await import('./GLTFLoader-Q7BHCGAW.js');
     return mod.GLTFLoader;
   } catch {
     return null;
@@ -18372,7 +21334,7 @@ async function loadGltfLoaderCtor() {
 }
 async function loadOrbitControlsCtor() {
   try {
-    const mod = await import('./OrbitControls-VH6KILH7.js');
+    const mod = await import('./OrbitControls-SMYCPLXO.js');
     return mod.OrbitControls;
   } catch {
     return null;
@@ -18596,14 +21558,14 @@ var SURFACE_THREE_UNAVAILABLE = {
 var FOV2 = 45;
 async function loadThree2() {
   try {
-    return await import('./three.module-CPZZFD2Q.js');
+    return await import('./three.module-GNNNRIMK.js');
   } catch {
     return null;
   }
 }
 async function loadOrbitControlsCtor2() {
   try {
-    const mod = await import('./OrbitControls-VH6KILH7.js');
+    const mod = await import('./OrbitControls-SMYCPLXO.js');
     return mod.OrbitControls;
   } catch {
     return null;
@@ -19211,6 +22173,26 @@ function presentationInkPath(points) {
     ""
   );
 }
+var HANDOUT_SLIDES_PER_PAGE = [1, 2, 3, 4, 6, 9];
+function printPropertiesSlidesPerPage(printProperties) {
+  const match = printProperties?.printWhat?.match(/^handouts([123469])$/u);
+  return match ? Number.parseInt(match[1], 10) : 1;
+}
+function printPropertiesFrameSlides(printProperties) {
+  return Boolean(printProperties?.frameSlides);
+}
+function nearestHandoutCount(value) {
+  return HANDOUT_SLIDES_PER_PAGE.reduce(
+    (best, candidate) => Math.abs(candidate - value) < Math.abs(best - value) ? candidate : best
+  );
+}
+function withFrameSlides(printProperties, value) {
+  return { ...printProperties ?? {}, frameSlides: value };
+}
+function withSlidesPerPage(printProperties, value) {
+  const count = nearestHandoutCount(value);
+  return { ...printProperties ?? {}, printWhat: `handouts${count}` };
+}
 var PRESENTATION_CHANNEL_NAME = "pptx-viewer-presenter";
 var PRESENTATION_HASH = "#pptx-audience";
 var PRESENTATION_NONCE_KEY = "nonce";
@@ -19403,6 +22385,108 @@ async function clearPresentationDeck(sessionId) {
   } catch {
   }
 }
+var DB_NAME2 = "pptx-viewer-audience";
+var DB_VERSION2 = 1;
+var STORE_NAME2 = "content";
+var CONTENT_KEY = "pptx-bytes";
+var MAX_CONTENT_AGE_MS = 5 * 60 * 1e3;
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME2, DB_VERSION2);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME2)) {
+        db.createObjectStore(STORE_NAME2);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function storeAudienceContent(content, sessionId) {
+  if (sessionId) {
+    return storePresentationDeck(sessionId, content);
+  }
+  const db = await openDb();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME2, "readwrite");
+    const store = tx.objectStore(STORE_NAME2);
+    const bytes = content instanceof Uint8Array ? content : new Uint8Array(content);
+    const record = { bytes, createdAt: Date.now() };
+    store.put(record, CONTENT_KEY);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error);
+    };
+  });
+}
+async function loadAudienceContent(sessionId) {
+  if (sessionId) {
+    return loadPresentationDeck(sessionId);
+  }
+  try {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME2, "readonly");
+      const store = tx.objectStore(STORE_NAME2);
+      const request = store.get(CONTENT_KEY);
+      request.onsuccess = () => {
+        db.close();
+        const result = request.result;
+        if (result && typeof result === "object" && "bytes" in result && "createdAt" in result) {
+          const record = result;
+          const age = Date.now() - record.createdAt;
+          if (age > MAX_CONTENT_AGE_MS) {
+            resolve(null);
+            return;
+          }
+          const raw = record.bytes;
+          if (raw instanceof Uint8Array) {
+            resolve(raw);
+          } else if (raw instanceof ArrayBuffer) {
+            resolve(new Uint8Array(raw));
+          } else {
+            resolve(null);
+          }
+          return;
+        }
+        resolve(null);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(request.error);
+      };
+    });
+  } catch {
+    return null;
+  }
+}
+async function clearAudienceContent(sessionId) {
+  if (sessionId) {
+    return clearPresentationDeck(sessionId);
+  }
+  try {
+    const db = await openDb();
+    return new Promise((resolve) => {
+      const tx = db.transaction(STORE_NAME2, "readwrite");
+      const store = tx.objectStore(STORE_NAME2);
+      store.delete(CONTENT_KEY);
+      tx.oncomplete = () => {
+        db.close();
+        resolve();
+      };
+      tx.onerror = () => {
+        db.close();
+        resolve();
+      };
+    });
+  } catch {
+  }
+}
 function formatSlideCounter(currentSlide, totalSlides) {
   return `${currentSlide + 1} / ${totalSlides}`;
 }
@@ -19816,12 +22900,12 @@ function replacePixels(data, fromColor, toColor, threshold, toTransparent) {
   }
 }
 var DEFAULT_COLOR_CHANGE_TOLERANCE = 12;
-function applyColorChange(imageDataUrl, fromHex, toHex, tolerancePct = DEFAULT_COLOR_CHANGE_TOLERANCE, toTransparent = false) {
+function applyColorChange(imageDataUrl, fromHex, toHex2, tolerancePct = DEFAULT_COLOR_CHANGE_TOLERANCE, toTransparent = false) {
   return new Promise((resolve, reject) => {
     const fromColor = parseHexToRgb(fromHex);
-    const toColor = parseHexToRgb(toHex);
+    const toColor = parseHexToRgb(toHex2);
     if (!fromColor || !toColor) {
-      reject(new Error(`Invalid hex colour: from="${fromHex}" to="${toHex}"`));
+      reject(new Error(`Invalid hex colour: from="${fromHex}" to="${toHex2}"`));
       return;
     }
     const img = new Image();
@@ -19859,9 +22943,9 @@ function applyColorChange(imageDataUrl, fromHex, toHex, tolerancePct = DEFAULT_C
 }
 var colorChangeCache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 64;
-function buildCacheKey(src, fromHex, toHex, tolerancePct, toTransparent) {
+function buildCacheKey(src, fromHex, toHex2, tolerancePct, toTransparent) {
   const srcKey = src.length > 64 ? src.slice(0, 64) : src;
-  return `${srcKey}|${fromHex}|${toHex}|${tolerancePct}|${toTransparent}`;
+  return `${srcKey}|${fromHex}|${toHex2}|${tolerancePct}|${toTransparent}`;
 }
 function getCachedResult(key) {
   return colorChangeCache.get(key);
@@ -20018,7 +23102,7 @@ function getAriaRole(element) {
     case "model3d":
       return "img";
     case "shape": {
-      if (chunkIPYAN574_js.hasTextProperties(element) && element.text) {
+      if (chunkCLNGAVNH_js.hasTextProperties(element) && element.text) {
         return "group";
       }
       return "img";
@@ -20031,7 +23115,7 @@ function getAriaLabel(element) {
   if ((element.type === "image" || element.type === "picture") && "altText" in element && typeof element.altText === "string" && element.altText.trim()) {
     return element.altText.trim();
   }
-  if (chunkIPYAN574_js.hasTextProperties(element) && element.text) {
+  if (chunkCLNGAVNH_js.hasTextProperties(element) && element.text) {
     const text = element.text.trim();
     if (text) {
       return text.length > 120 ? `${text.slice(0, 117)}...` : text;
@@ -20438,7 +23522,7 @@ var DEFAULT_CHART_POSITION = { x: 120, y: 120, width: 480, height: 320 };
 var DEFAULT_CATEGORIES = ["Category 1", "Category 2", "Category 3"];
 var DEFAULT_SERIES_VALUES = [4, 3, 5];
 function createDefaultChartElement(chartType = DEFAULT_INSERT_CHART_TYPE, position) {
-  return chunkIPYAN574_js.createChartElement(
+  return chunkCLNGAVNH_js.createChartElement(
     chartType,
     {
       categories: [...DEFAULT_CATEGORIES],
@@ -20455,12 +23539,12 @@ function createDefaultChartElement(chartType = DEFAULT_INSERT_CHART_TYPE, positi
   );
 }
 function polygonBounds(points) {
-  const pairs = points.trim().split(/\s+/u);
+  const pairs2 = points.trim().split(/\s+/u);
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
-  for (const pair of pairs) {
+  for (const pair of pairs2) {
     const comma = pair.indexOf(",");
     if (comma < 0) {
       continue;
@@ -20672,6 +23756,15 @@ function cloneElementForPaste(element, options = {}) {
   clone.y += options.offsetY ?? PASTE_OFFSET_PX;
   return clone;
 }
+var DEFAULT_PREVIEW_ELEMENT_CAP = 500;
+function buildPreviewElements(slide, templateElements = [], options) {
+  const cap = options?.cap ?? DEFAULT_PREVIEW_ELEMENT_CAP;
+  const merged = [...templateElements, ...slide.elements];
+  if (cap > 0 && merged.length > cap) {
+    return merged.slice(0, cap);
+  }
+  return merged;
+}
 var SHAPE_PRESET_DEFS = [
   {
     type: "rect",
@@ -21458,7 +24551,7 @@ function computeVirtualRange(totalItems, itemHeight, scrollTop, viewportHeight,
   };
 }
 function collectFontsFromElement(element, fonts) {
-  if (chunkIPYAN574_js.hasTextProperties(element)) {
+  if (chunkCLNGAVNH_js.hasTextProperties(element)) {
     if (element.textStyle?.fontFamily) {
       fonts.add(element.textStyle.fontFamily);
     }
@@ -24154,6 +27247,7 @@ exports.PRESENTATION_HASH = PRESENTATION_HASH;
 exports.PRESENTATION_MESSAGE_ORIGIN = PRESENTATION_MESSAGE_ORIGIN;
 exports.PRESENTATION_NONCE_KEY = PRESENTATION_NONCE_KEY;
 exports.PRESETS = PRESETS;
+exports.PresentationAnimationController = PresentationAnimationController;
 exports.QUICK_ACCESS_COMMAND_CATALOG = QUICK_ACCESS_COMMAND_CATALOG;
 exports.RULER_FONT_SIZE = RULER_FONT_SIZE;
 exports.RULER_THICKNESS = RULER_THICKNESS;
@@ -24172,7 +27266,6 @@ exports.THEME_COLOR_LABELS = THEME_COLOR_LABELS;
 exports.TITLE_BAR_CLASSES = TITLE_BAR_CLASSES;
 exports.TITLE_BAR_DEFAULT_FILE_KEY = TITLE_BAR_DEFAULT_FILE_KEY;
 exports.TOOLBAR_TABS = TOOLBAR_TABS;
-exports.TimelineEngine = TimelineEngine;
 exports.VIEWER_OPTIONS_TABS = VIEWER_OPTIONS_TABS;
 exports.VIEWER_PREFS_STORAGE_KEY = VIEWER_PREFS_STORAGE_KEY;
 exports.WEBM_MIME_CANDIDATES = WEBM_MIME_CANDIDATES;
@@ -24185,6 +27278,7 @@ exports.apply3dEffects = apply3dEffects;
 exports.applyAcceptAllSlides = applyAcceptAllSlides;
 exports.applyAcceptSlide = applyAcceptSlide;
 exports.applyCaseTransformToSegments = applyCaseTransformToSegments;
+exports.applyChartBuildReveal = applyChartBuildReveal;
 exports.applyColorChange = applyColorChange;
 exports.applyDuotone = applyDuotone;
 exports.applyFormatToElement = applyFormatToElement;
@@ -24217,6 +27311,7 @@ exports.buildOutlineHtml = buildOutlineHtml;
 exports.buildPatternFillCss = buildPatternFillCss;
 exports.buildPresentationAudienceUrl = buildPresentationAudienceUrl;
 exports.buildPreviewAnimation = buildPreviewAnimation;
+exports.buildPreviewElements = buildPreviewElements;
 exports.buildPrintDocument = buildPrintDocument;
 exports.buildPrintHtmlDocument = buildPrintHtmlDocument;
 exports.buildReflectionCss = buildReflectionCss;
@@ -24235,13 +27330,14 @@ exports.buildTextShadowCss = buildTextShadowCss;
 exports.buildThemeColorGrid = buildThemeColorGrid;
 exports.buildUserFontFaceStyles = buildUserFontFaceStyles;
 exports.canvasToJpegData = canvasToJpegData;
+exports.cell3DBevelCss = cell3DBevelCss;
 exports.chartPartToAttrs = chartPartToAttrs;
 exports.clampCropValue = clampCropValue;
 exports.clampNotesFontSize = clampNotesFontSize;
 exports.clampPercent = clampPercent;
 exports.clampUnitInterval = clampUnitInterval;
 exports.clearAllLocalViewerData = clearAllLocalViewerData;
-exports.clearPresentationDeck = clearPresentationDeck;
+exports.clearAudienceContent = clearAudienceContent;
 exports.clearStoredViewerPrefs = clearStoredViewerPrefs;
 exports.cloneElementForPaste = cloneElementForPaste;
 exports.cloneHistorySnapshot = cloneHistorySnapshot;
@@ -24278,7 +27374,6 @@ exports.convertLatexToOmml = convertLatexToOmml;
 exports.convertOmmlToLatex = convertOmmlToLatex;
 exports.convertOmmlToMathMl = convertOmmlToMathMl;
 exports.copyFormatFromElement = copyFormatFromElement;
-exports.countTextSegments = countTextSegments;
 exports.createBackstagePresentation = createBackstagePresentation;
 exports.createBlankSlide = createBlankSlide;
 exports.createDefaultChartElement = createDefaultChartElement;
@@ -24305,7 +27400,6 @@ exports.dragAnchorViewY = dragAnchorViewY;
 exports.dragValueForPart = dragValueForPart;
 exports.encodeGif = encodeGif;
 exports.erasePresentationInkAt = erasePresentationInkAt;
-exports.expandTextBuildAnimations = expandTextBuildAnimations;
 exports.extractPathPoints = extractPathPoints;
 exports.filterCommands = filterCommands;
 exports.findChartPartTarget = findChartPartTarget;
@@ -24335,12 +27429,14 @@ exports.getAriaLabel = getAriaLabel;
 exports.getAriaRole = getAriaRole;
 exports.getAriaRoleDescription = getAriaRoleDescription;
 exports.getCachedResult = getCachedResult;
+exports.getCellDiagonalBorders = getCellDiagonalBorders;
 exports.getChartStylePalette = getChartStylePalette;
 exports.getCommentMarkerPosition = getCommentMarkerPosition;
 exports.getCompoundLineBorderWidth = getCompoundLineBorderWidth;
 exports.getCompoundLineBoxShadow = getCompoundLineBoxShadow;
 exports.getCompoundLineOffsets = getCompoundLineOffsets;
 exports.getCompoundLineWidths = getCompoundLineWidths;
+exports.getComputedEffectStyle = getComputedEffectStyle;
 exports.getConnectionSites = getConnectionSites;
 exports.getContentPartReplayStyles = getContentPartReplayStyles;
 exports.getCssBorderDashStyle = getCssBorderDashStyle;
@@ -24350,6 +27446,7 @@ exports.getEffectDagFilter = getEffectDagFilter;
 exports.getElementLabel = getElementLabel;
 exports.getElementTransform = getElementTransform;
 exports.getElementTransformWithoutRotation = getElementTransformWithoutRotation;
+exports.getGroupChildParentFill = getGroupChildParentFill;
 exports.getImageColorWashStyle = getImageColorWashStyle;
 exports.getImageEffectsFilter = getImageEffectsFilter;
 exports.getImageEffectsOpacity = getImageEffectsOpacity;
@@ -24371,6 +27468,8 @@ exports.getSecondaryValueAxis = getSecondaryValueAxis;
 exports.getShapeAdjustmentHandleDescriptor = getShapeAdjustmentHandleDescriptor;
 exports.getSlideBackgroundStyle = getSlideBackgroundStyle;
 exports.getSlideTransitionAnimations = getSlideTransitionAnimations;
+exports.getSoftEdgeFilterId = getSoftEdgeFilterId;
+exports.getSoftEdgeSvgFilter = getSoftEdgeSvgFilter;
 exports.getSvgStrokeDasharray = getSvgStrokeDasharray;
 exports.getTextAlphaOpacity = getTextAlphaOpacity;
 exports.getTextCompensationTransform = getTextCompensationTransform;
@@ -24381,6 +27480,7 @@ exports.groupSlidesBySection = groupSlidesBySection;
 exports.hasCopyableFormat = hasCopyableFormat;
 exports.hasDistinctScriptFonts = hasDistinctScriptFonts;
 exports.hasPressureVariation = hasPressureVariation;
+exports.hexToRgbChannels = hexToRgbChannels;
 exports.insertTableColumn = insertTableColumn;
 exports.insertTableRow = insertTableRow;
 exports.isActionHidden = isActionHidden;
@@ -24400,7 +27500,7 @@ exports.isTemplateElementId = isTemplateElementId;
 exports.isUrlSafe = isUrlSafe;
 exports.listAutosaveSnapshots = listAutosaveSnapshots;
 exports.listBackstageRecentFiles = listBackstageRecentFiles;
-exports.loadPresentationDeck = loadPresentationDeck;
+exports.loadAudienceContent = loadAudienceContent;
 exports.makeCloneId = makeCloneId;
 exports.makeSlideId = makeSlideId;
 exports.mergeAdditiveSelection = mergeAdditiveSelection;
@@ -24428,6 +27528,7 @@ exports.openUrlInNewTab = openUrlInNewTab;
 exports.paletteColor = paletteColor;
 exports.parseDrawingColor = parseDrawingColor;
 exports.parseDrawingColorOpacity = parseDrawingColorOpacity;
+exports.parseMediaCommand = parseMediaCommand;
 exports.parsePpactionUrl = parsePpactionUrl;
 exports.pickSupportedMimeType = pickSupportedMimeType;
 exports.placeAudienceWindow = placeAudienceWindow;
@@ -24435,6 +27536,8 @@ exports.preprocessCssForCapture = preprocessCssForCapture;
 exports.presentationInkPath = presentationInkPath;
 exports.presenterElapsed = presenterElapsed;
 exports.pressuresToWidths = pressuresToWidths;
+exports.printPropertiesFrameSlides = printPropertiesFrameSlides;
+exports.printPropertiesSlidesPerPage = printPropertiesSlidesPerPage;
 exports.readBackstageRecentFile = readBackstageRecentFile;
 exports.readSlidesFromYDoc = readSlidesFromYDoc;
 exports.readStoredViewerPrefs = readStoredViewerPrefs;
@@ -24452,6 +27555,8 @@ exports.resolveAudienceScreenPlacement = resolveAudienceScreenPlacement;
 exports.resolveCssTextAlign = resolveCssTextAlign;
 exports.resolveDrawingShapeNodeId = resolveDrawingShapeNodeId;
 exports.resolveFontForScript = resolveFontForScript;
+exports.resolveFontRefIdx = resolveFontRefIdx;
+exports.resolveGroupChildFill = resolveGroupChildFill;
 exports.resolveInkColor = resolveInkColor;
 exports.resolveInkOpacity = resolveInkOpacity;
 exports.resolveInkWidth = resolveInkWidth;
@@ -24469,6 +27574,7 @@ exports.resolveTransportForServerUrl = resolveTransportForServerUrl;
 exports.resolveUnderlineDecorationStyle = resolveUnderlineDecorationStyle;
 exports.resolveViewerAddinRows = resolveViewerAddinRows;
 exports.restoreSegmentSelection = restoreSegmentSelection;
+exports.revealedSmartArtNodeCount = revealedSmartArtNodeCount;
 exports.safeOpenUrl = safeOpenUrl;
 exports.sanitizeColor = sanitizeColor;
 exports.sanitizeDownloadFilename = sanitizeDownloadFilename;
@@ -24486,6 +27592,7 @@ exports.setCachedResult = setCachedResult;
 exports.setDuotoneCachedResult = setDuotoneCachedResult;
 exports.setPendingSelectionRestore = setPendingSelectionRestore;
 exports.shadeColor2 = shadeColor2;
+exports.shouldAutoFollowBroadcaster = shouldAutoFollowBroadcaster;
 exports.shouldCommitSmartArtNodeText = shouldCommitSmartArtNodeText;
 exports.shouldConfirmExternalHyperlink = shouldConfirmExternalHyperlink;
 exports.shouldLoopContinuously = shouldLoopContinuously;
@@ -24496,7 +27603,7 @@ exports.snapBoxToGrid = snapBoxToGrid;
 exports.splitCell = splitCell;
 exports.splitSeriesByAxis = splitSeriesByAxis;
 exports.stepPresenterZoom = stepPresenterZoom;
-exports.storePresentationDeck = storePresentationDeck;
+exports.storeAudienceContent = storeAudienceContent;
 exports.substituteFieldText = substituteFieldText;
 exports.svgLineCap = svgLineCap;
 exports.swapPresentationWindows = swapPresentationWindows;
@@ -24517,4 +27624,6 @@ exports.vermilionRadius = vermilionRadius;
 exports.viewerOptionsToPreferences = viewerOptionsToPreferences;
 exports.withChartPointValue = withChartPointValue;
 exports.withChartTitle = withChartTitle;
+exports.withFrameSlides = withFrameSlides;
+exports.withSlidesPerPage = withSlidesPerPage;
 exports.writeStoredViewerPrefs = writeStoredViewerPrefs;