pptx-react-viewer 2.5.3 → 2.6.1

package/dist/{chunk-23Q3I2LM.js → chunk-T7AMP24E.js}

@@ -12661,9 +12661,9 @@ var PptxEffectDagExtractor = class {
     if (Number.isFinite(endPos)) {
       style.reflectionEndPosition = endPos / 1e5;
     }
-    const dist = parseInt(String(refl["@_dist"] || ""), 10);
-    if (Number.isFinite(dist) && dist >= 0) {
-      style.reflectionDistance = dist / this.context.emuPerPx;
+    const dist2 = parseInt(String(refl["@_dist"] || ""), 10);
+    if (Number.isFinite(dist2) && dist2 >= 0) {
+      style.reflectionDistance = dist2 / this.context.emuPerPx;
     }
   }
   extractDagBlur(dag, style) {
@@ -13810,10 +13810,7 @@ var PptxShapeStyleExtractor = class {
     }
     const lineNode = shapeProps["a:ln"];
     if (lineNode) {
-      const earlyReturn = applyLineProperties(lineNode, style, this.context);
-      if (earlyReturn) {
-        return style;
-      }
+      applyLineProperties(lineNode, style, this.context);
     } else if (styleNode?.["a:lnRef"]) {
       this.context.resolveThemeLineRef(styleNode["a:lnRef"], style);
     }
@@ -20394,6 +20391,11 @@ var STANDARD_TRANSITION_TYPES = /* @__PURE__ */ new Set([
 ]);
 var SPEEDS = /* @__PURE__ */ new Set(["slow", "med", "fast"]);
 var UINT_MAX = 4294967295;
+var MORPH_OPTIONS = /* @__PURE__ */ new Set(["byObject", "byWord", "byChar"]);
+function normalizeMorphOption(value) {
+  const candidate = token(value);
+  return MORPH_OPTIONS.has(candidate) ? candidate : void 0;
+}
 function parseTransitionDetails(node, localName22) {
   const result = { type: "cut" };
   for (const [key, value] of Object.entries(node)) {
@@ -20409,6 +20411,11 @@ function parseTransitionDetails(node, localName22) {
       result.rawExtLst = value;
       continue;
     }
+    if (name === "morph") {
+      result.type = "morph";
+      result.morphOption = normalizeMorphOption(value?.["@_option"]);
+      continue;
+    }
     if (STANDARD_TRANSITION_TYPES.has(name)) {
       result.type = name;
     }
@@ -20608,6 +20615,7 @@ var PptxSlideTransitionService = class {
     let transitionType = details.type;
     let { direction, orient, pattern } = details;
     const { spokes, thruBlk, rawSoundAction, rawExtLst } = details;
+    let { morphOption } = details;
     if (rawExtLst && transitionType === "cut") {
       const p14Result = parseP14FromExtLst(rawExtLst, this.xmlLookupService, this.getXmlLocalName);
       const p15Result = p14Result ? void 0 : parseP15FromExtLst(rawExtLst, this.xmlLookupService, this.getXmlLocalName);
@@ -20624,8 +20632,12 @@ var PptxSlideTransitionService = class {
         }
       } else if (p15Result) {
         transitionType = p15Result.type;
-      } else if (this.parseMorphFromExtLst(rawExtLst)) {
-        transitionType = "morph";
+      } else {
+        const morphResult = this.parseMorphFromExtLst(rawExtLst);
+        if (morphResult) {
+          transitionType = "morph";
+          morphOption = morphResult.morphOption;
+        }
       }
     }
     const attributes = parseTransitionAttributes(transitionNode);
@@ -20638,6 +20650,7 @@ var PptxSlideTransitionService = class {
       spokes,
       pattern,
       thruBlk,
+      morphOption,
       ...sound,
       rawSoundAction,
       rawExtLst,
@@ -20683,21 +20696,18 @@ var PptxSlideTransitionService = class {
       if (!ext) {
         continue;
       }
-      const uri = String(ext["@_uri"] || "").trim();
-      const matchesUri = uri.toUpperCase() === MORPH_EXT_URI.toUpperCase();
-      for (const key of Object.keys(ext)) {
+      for (const [key, value] of Object.entries(ext)) {
         if (key.startsWith("@_")) {
           continue;
         }
         if (this.getXmlLocalName(key) === "morph") {
-          if (matchesUri || uri.length === 0) {
-            return true;
-          }
-          return true;
+          return {
+            morphOption: normalizeMorphOption(value?.["@_option"])
+          };
         }
       }
     }
-    return false;
+    return void 0;
   }
   buildSlideTransitionXml(transition) {
     if (!transition || transition.type === "none") {
@@ -20721,7 +20731,9 @@ var PptxSlideTransitionService = class {
     } else if (isP15Type) {
       node["p:extLst"] = transition.rawExtLst ?? buildP15ExtLst(transitionType);
     } else if (isMorphType) {
-      node["p:extLst"] = this.buildMorphExtLst(transition.rawExtLst);
+      if (!this.hasDirectMorphChild(node)) {
+        node["p:extLst"] = this.buildMorphExtLst(transition.rawExtLst, transition.morphOption);
+      }
     } else {
       node[`p:${transitionType}`] = buildStandardTransitionChild(transition);
     }
@@ -20735,16 +20747,32 @@ var PptxSlideTransitionService = class {
     }
     return node;
   }
+  /**
+   * True when the (preserved) transition node already carries a `morph`
+   * element as a direct child, in any namespace prefix.
+   */
+  hasDirectMorphChild(node) {
+    for (const key of Object.keys(node)) {
+      if (!key.startsWith("@_") && this.getXmlLocalName(key) === "morph") {
+        return true;
+      }
+    }
+    return false;
+  }
   /**
    * Build the extLst XML node for a morph (p159) transition, preserving any
    * non-morph extensions from rawExtLst.
    */
-  buildMorphExtLst(rawExtLst) {
+  buildMorphExtLst(rawExtLst, morphOption) {
+    const morphNode = {
+      "@_xmlns:p159": "http://schemas.microsoft.com/office/powerpoint/2015/09/main"
+    };
+    if (morphOption) {
+      morphNode["@_option"] = morphOption;
+    }
     const morphExt = {
       "@_uri": MORPH_EXT_URI,
-      "p159:morph": {
-        "@_xmlns:p159": "http://schemas.microsoft.com/office/powerpoint/2015/09/main"
-      }
+      "p159:morph": morphNode
     };
     if (!rawExtLst) {
       return { "p:ext": morphExt };
@@ -49665,17 +49693,17 @@ function buildShadowColorNode(hex10, opacity2) {
   };
 }
 function distAndDir(ox, oy) {
-  const dist = Math.sqrt(ox * ox + oy * oy);
+  const dist2 = Math.sqrt(ox * ox + oy * oy);
   const dir = Math.atan2(oy, ox) * 180 / Math.PI;
-  return { dist, dir };
+  return { dist: dist2, dir };
 }
 function buildOuterShadowNode(style) {
   const ox = style.textShadowOffsetX ?? 0;
   const oy = style.textShadowOffsetY ?? 0;
-  const { dist, dir } = distAndDir(ox, oy);
+  const { dist: dist2, dir } = distAndDir(ox, oy);
   return {
     "@_blurRad": String(Math.round((style.textShadowBlur ?? 4) * EMU_PER_PX8)),
-    "@_dist": String(Math.round(dist * EMU_PER_PX8)),
+    "@_dist": String(Math.round(dist2 * EMU_PER_PX8)),
     "@_dir": String(Math.round(dir * 6e4)),
     "a:srgbClr": buildShadowColorNode(style.textShadowColor || "#000000", style.textShadowOpacity)
   };
@@ -49683,10 +49711,10 @@ function buildOuterShadowNode(style) {
 function buildInnerShadowNode(style) {
   const ox = style.textInnerShadowOffsetX ?? 0;
   const oy = style.textInnerShadowOffsetY ?? 0;
-  const { dist, dir } = distAndDir(ox, oy);
+  const { dist: dist2, dir } = distAndDir(ox, oy);
   return {
     "@_blurRad": String(Math.round((style.textInnerShadowBlur ?? 3) * EMU_PER_PX8)),
-    "@_dist": String(Math.round(dist * EMU_PER_PX8)),
+    "@_dist": String(Math.round(dist2 * EMU_PER_PX8)),
     "@_dir": String(Math.round(dir * 6e4)),
     "a:srgbClr": buildShadowColorNode(
       style.textInnerShadowColor || "#000000",
@@ -51312,10 +51340,10 @@ var PptxHandlerRuntime18 = class extends PptxHandlerRuntime17 {
       const distRaw = Number.parseInt(String(outerShdw["@_dist"] || ""), 10);
       const dirRaw = Number.parseInt(String(outerShdw["@_dir"] || ""), 10);
       if (Number.isFinite(distRaw) && distRaw >= 0) {
-        const dist = distRaw / PptxHandlerRuntime17.EMU_PER_PX;
+        const dist2 = distRaw / PptxHandlerRuntime17.EMU_PER_PX;
         const dirRad = (Number.isFinite(dirRaw) ? dirRaw / 6e4 : 0) * Math.PI / 180;
-        style.textShadowOffsetX = Math.round(Math.cos(dirRad) * dist * 100) / 100;
-        style.textShadowOffsetY = Math.round(Math.sin(dirRad) * dist * 100) / 100;
+        style.textShadowOffsetX = Math.round(Math.cos(dirRad) * dist2 * 100) / 100;
+        style.textShadowOffsetY = Math.round(Math.sin(dirRad) * dist2 * 100) / 100;
       }
     }
     const glowNode = runEffectList["a:glow"];
@@ -62905,6 +62933,12 @@ var PptxHandlerRuntime62 = class _PptxHandlerRuntime26 extends PptxHandlerRuntim
       ...endParagraphStyle,
       ...defaultRunStyle
     };
+    if (mergedDefaultRunStyle.color === void 0 && ctx.styleFontRefColor !== void 0) {
+      mergedDefaultRunStyle.color = ctx.styleFontRefColor;
+    }
+    if (mergedDefaultRunStyle.fontFamily === void 0 && ctx.styleFontRefTypeface !== void 0) {
+      mergedDefaultRunStyle.fontFamily = ctx.styleFontRefTypeface;
+    }
     if (ctx.effectiveLevelStyles) {
       const normalizedLevel = level === -1 ? -1 : Number.isFinite(level) ? Math.min(Math.max(level, 0), 8) : 0;
       const phLevel = ctx.effectiveLevelStyles[normalizedLevel] ?? ctx.effectiveLevelStyles[-1] ?? (normalizedLevel === -1 ? ctx.effectiveLevelStyles[0] : void 0);
@@ -62977,10 +63011,17 @@ var PptxHandlerRuntime63 = class extends PptxHandlerRuntime62 {
       } else {
         bulletText = "\u2022 ";
       }
+      const bulletStyle = { ...mergedDefaultRunStyle };
+      if (paragraphBulletInfo.sizePercent === void 0 && paragraphBulletInfo.sizePts === void 0) {
+        const firstRunSize = this.resolveFirstRunFontSize(p, paraAlign, ctx);
+        if (firstRunSize !== void 0) {
+          bulletStyle.fontSize = firstRunSize;
+        }
+      }
       parts.push(bulletText);
       segments.push({
         text: bulletText,
-        style: { ...mergedDefaultRunStyle },
+        style: bulletStyle,
         bulletInfo: paragraphBulletInfo
       });
       maybeSeed(mergedDefaultRunStyle);
@@ -63190,6 +63231,32 @@ var PptxHandlerRuntime63 = class extends PptxHandlerRuntime62 {
     }
     return { parts, segments, seedStyle };
   }
+  /**
+   * Font size (px) of the first text run in a paragraph, or `undefined` when
+   * the paragraph has no run that declares one.
+   *
+   * Used to size an unsized bullet the way PowerPoint does: `a:buChar` /
+   * `a:buAutoNum` with no `a:buSzPct`/`a:buSzPts` inherits the first run's
+   * size. Only `a:r` and `a:fld` carry renderable text; `a:br` does not.
+   */
+  resolveFirstRunFontSize(p, paraAlign, ctx) {
+    for (const key of ["a:r", "a:fld"]) {
+      const node = p[key];
+      if (!node) {
+        continue;
+      }
+      const first = this.ensureArray(node)[0];
+      const runProps = first?.["a:rPr"];
+      if (!runProps) {
+        continue;
+      }
+      const style = this.extractTextRunStyle(runProps, paraAlign, ctx.slideRelationshipMap);
+      if (typeof style.fontSize === "number") {
+        return style.fontSize;
+      }
+    }
+    return void 0;
+  }
   /**
    * Parse an `a:ruby` element into a {@link TextSegment} with ruby annotation metadata.
    *
@@ -63411,15 +63478,13 @@ var PptxHandlerRuntime64 = class _PptxHandlerRuntime27 extends PptxHandlerRuntim
       Object.assign(textStyle, bodyDefaultRunStyle);
       const fontRef = styleNode?.["a:fontRef"];
       const fontRefIdx = String(fontRef?.["@_idx"] || "").toLowerCase();
-      if (!textStyle.fontFamily && fontRefIdx.length > 0) {
-        const token2 = fontRefIdx.includes("minor") ? "+mn-lt" : "+mj-lt";
-        const resolved = this.resolveThemeTypeface(token2);
-        if (resolved) {
-          textStyle.fontFamily = resolved;
-        }
+      const styleFontRefTypeface = fontRefIdx.length > 0 ? this.resolveThemeTypeface(fontRefIdx.includes("minor") ? "+mn-lt" : "+mj-lt") : void 0;
+      const styleFontRefColor = fontRef ? this.parseColor(fontRef) : void 0;
+      if (!textStyle.fontFamily && styleFontRefTypeface) {
+        textStyle.fontFamily = styleFontRefTypeface;
       }
       if (!textStyle.color) {
-        textStyle.color = this.parseColor(fontRef);
+        textStyle.color = styleFontRefColor;
       }
       const bodyPr = txBody?.["a:bodyPr"] || inheritedTxBody?.["a:bodyPr"];
       const bodyPropResult = this.applyBodyProperties(
@@ -63450,7 +63515,9 @@ var PptxHandlerRuntime64 = class _PptxHandlerRuntime27 extends PptxHandlerRuntim
           placeholderInfo: placeholderInfo ?? void 0,
           phDefaults,
           slidePath,
-          effectiveLevelStyles
+          effectiveLevelStyles,
+          styleFontRefColor,
+          styleFontRefTypeface
         };
         paras.forEach((p, pIdx) => {
           const styleResult = this.resolveShapeParagraphStyle(p, textStyle, ctx);
@@ -64299,18 +64366,6 @@ var PptxHandlerRuntime67 = class _PptxHandlerRuntime30 extends PptxHandlerRuntim
       if (hasShapeProperties(el) && el.shapeStyle?.strokeWidth) {
         el.shapeStyle.strokeWidth *= avgScale;
       }
-      if (hasTextProperties(el)) {
-        if (el.textStyle?.fontSize) {
-          el.textStyle.fontSize *= Math.abs(scaleY);
-        }
-        if (el.textSegments) {
-          el.textSegments.forEach((seg) => {
-            if (seg.style.fontSize) {
-              seg.style.fontSize *= Math.abs(scaleY);
-            }
-          });
-        }
-      }
       return el;
     };
     this.unwrapAlternateContent(group);
@@ -66360,12 +66415,12 @@ var PptxHandlerRuntime77 = class _PptxHandlerRuntime33 extends PptxHandlerRuntim
         if (Number.isFinite(blurRad) && blurRad > 0) {
           result.shadowBlur = blurRad / _PptxHandlerRuntime33.EMU_PER_PX;
         }
-        const dist = parseInt(String(outerShdw["@_dist"] || "0"));
+        const dist2 = parseInt(String(outerShdw["@_dist"] || "0"));
         const dir = parseInt(String(outerShdw["@_dir"] || "0"));
-        if (Number.isFinite(dist) && dist > 0 && Number.isFinite(dir)) {
+        if (Number.isFinite(dist2) && dist2 > 0 && Number.isFinite(dir)) {
           const angleRad = dir / 6e4 * (Math.PI / 180);
-          result.shadowOffsetX = Math.cos(angleRad) * dist / _PptxHandlerRuntime33.EMU_PER_PX;
-          result.shadowOffsetY = Math.sin(angleRad) * dist / _PptxHandlerRuntime33.EMU_PER_PX;
+          result.shadowOffsetX = Math.cos(angleRad) * dist2 / _PptxHandlerRuntime33.EMU_PER_PX;
+          result.shadowOffsetY = Math.sin(angleRad) * dist2 / _PptxHandlerRuntime33.EMU_PER_PX;
         }
       }
       const innerShdw = effectLst["a:innerShdw"];
@@ -66376,12 +66431,12 @@ var PptxHandlerRuntime77 = class _PptxHandlerRuntime33 extends PptxHandlerRuntim
         if (Number.isFinite(blurRad) && blurRad > 0) {
           result.innerShadowBlur = blurRad / _PptxHandlerRuntime33.EMU_PER_PX;
         }
-        const dist = parseInt(String(innerShdw["@_dist"] || "0"));
+        const dist2 = parseInt(String(innerShdw["@_dist"] || "0"));
         const dir = parseInt(String(innerShdw["@_dir"] || "0"));
-        if (Number.isFinite(dist) && dist > 0 && Number.isFinite(dir)) {
+        if (Number.isFinite(dist2) && dist2 > 0 && Number.isFinite(dir)) {
           const angleRad = dir / 6e4 * (Math.PI / 180);
-          result.innerShadowOffsetX = Math.cos(angleRad) * dist / _PptxHandlerRuntime33.EMU_PER_PX;
-          result.innerShadowOffsetY = Math.sin(angleRad) * dist / _PptxHandlerRuntime33.EMU_PER_PX;
+          result.innerShadowOffsetX = Math.cos(angleRad) * dist2 / _PptxHandlerRuntime33.EMU_PER_PX;
+          result.innerShadowOffsetY = Math.sin(angleRad) * dist2 / _PptxHandlerRuntime33.EMU_PER_PX;
         }
       }
       const glow = effectLst["a:glow"];
@@ -66426,9 +66481,9 @@ var PptxHandlerRuntime77 = class _PptxHandlerRuntime33 extends PptxHandlerRuntim
         if (Number.isFinite(rot)) {
           result.reflectionRotation = rot / 6e4;
         }
-        const dist = parseInt(String(reflection["@_dist"] || "0"));
-        if (Number.isFinite(dist) && dist >= 0) {
-          result.reflectionDistance = dist / _PptxHandlerRuntime33.EMU_PER_PX;
+        const dist2 = parseInt(String(reflection["@_dist"] || "0"));
+        if (Number.isFinite(dist2) && dist2 >= 0) {
+          result.reflectionDistance = dist2 / _PptxHandlerRuntime33.EMU_PER_PX;
         }
       }
       const scene3dNode = es["a:scene3d"];
@@ -97948,6 +98003,851 @@ function sanitizeMathMl(markup) {
   }
   return sanitized;
 }
+function resolveParagraphStrutFontSize(segments, bodyFontSize) {
+  let largest;
+  for (const segment of segments) {
+    if (segment.bulletInfo) {
+      continue;
+    }
+    const size = segment.style?.fontSize;
+    if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
+      continue;
+    }
+    if (largest === void 0 || size > largest) {
+      largest = size;
+    }
+  }
+  if (largest === void 0) {
+    return void 0;
+  }
+  if (typeof bodyFontSize === "number" && Math.abs(largest - bodyFontSize) < 0.01) {
+    return void 0;
+  }
+  return largest;
+}
+function parseHexColor(hex10) {
+  if (!hex10 || typeof hex10 !== "string") {
+    return null;
+  }
+  let cleaned = hex10.replace(/^#/u, "");
+  if (cleaned.length === 3) {
+    cleaned = cleaned[0] + cleaned[0] + cleaned[1] + cleaned[1] + cleaned[2] + cleaned[2];
+  } else if (cleaned.length === 4) {
+    cleaned = cleaned[0] + cleaned[0] + cleaned[1] + cleaned[1] + cleaned[2] + cleaned[2] + cleaned[3] + cleaned[3];
+  }
+  if (cleaned.length !== 6 && cleaned.length !== 8) {
+    return null;
+  }
+  const r = Number.parseInt(cleaned.slice(0, 2), 16);
+  const g = Number.parseInt(cleaned.slice(2, 4), 16);
+  const b = Number.parseInt(cleaned.slice(4, 6), 16);
+  const a = cleaned.length === 8 ? Number.parseInt(cleaned.slice(6, 8), 16) / 255 : 1;
+  if ([r, g, b].some((v) => Number.isNaN(v))) {
+    return null;
+  }
+  return { r, g, b, a: Number.isNaN(a) ? 1 : a };
+}
+function lerpColor2(from, to, t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const r = Math.round(from.r + (to.r - from.r) * clamped);
+  const g = Math.round(from.g + (to.g - from.g) * clamped);
+  const b = Math.round(from.b + (to.b - from.b) * clamped);
+  const a = Number((from.a + (to.a - from.a) * clamped).toFixed(3));
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+var OUTLINE_SAMPLE_COUNT = 64;
+var ELLIPSE_SAMPLE_COUNT = 48;
+function resolveLength(token2, axis) {
+  const trimmed = token2.trim();
+  if (trimmed.endsWith("%")) {
+    const pct = Number.parseFloat(trimmed.slice(0, -1));
+    return Number.isFinite(pct) ? pct / 100 * axis : 0;
+  }
+  const px3 = Number.parseFloat(trimmed.replace(/px$/u, ""));
+  return Number.isFinite(px3) ? px3 : 0;
+}
+function polygonClipToPoints(value, width, height) {
+  const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")"));
+  const points3 = [];
+  for (const pairStr of inner.split(",")) {
+    const parts = pairStr.trim().split(/\s+/u);
+    if (parts.length < 2) {
+      continue;
+    }
+    points3.push({
+      x: resolveLength(parts[0], width),
+      y: resolveLength(parts[1], height)
+    });
+  }
+  return points3;
+}
+function insetClipToPoints(value, width, height) {
+  const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")"));
+  const tokens = inner.split(/round/u)[0].trim().split(/\s+/u);
+  const top = resolveLength(tokens[0] ?? "0", height);
+  const right = resolveLength(tokens[1] ?? tokens[0] ?? "0", width);
+  const bottom = resolveLength(tokens[2] ?? tokens[0] ?? "0", height);
+  const left = resolveLength(tokens[3] ?? tokens[1] ?? tokens[0] ?? "0", width);
+  return [
+    { x: left, y: top },
+    { x: width - right, y: top },
+    { x: width - right, y: height - bottom },
+    { x: left, y: height - bottom }
+  ];
+}
+function ellipseClipToPoints(value, width, height) {
+  const isCircle = value.startsWith("circle");
+  const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")"));
+  const [radii, position2] = inner.split(/\s+at\s+/u);
+  const radiusTokens = radii.trim().split(/\s+/u).filter(Boolean);
+  let rx = width / 2;
+  let ry = height / 2;
+  if (isCircle) {
+    const r = resolveLength(radiusTokens[0] ?? "50%", Math.min(width, height));
+    rx = r;
+    ry = r;
+  } else {
+    rx = resolveLength(radiusTokens[0] ?? "50%", width);
+    ry = resolveLength(radiusTokens[1] ?? radiusTokens[0] ?? "50%", height);
+  }
+  let cx = width / 2;
+  let cy = height / 2;
+  if (position2) {
+    const posTokens = position2.trim().split(/\s+/u);
+    cx = resolveLength(posTokens[0] ?? "50%", width);
+    cy = resolveLength(posTokens[1] ?? posTokens[0] ?? "50%", height);
+  }
+  const points3 = [];
+  for (let i = 0; i < ELLIPSE_SAMPLE_COUNT; i++) {
+    const a = i / ELLIPSE_SAMPLE_COUNT * Math.PI * 2;
+    points3.push({ x: cx + Math.cos(a) * rx, y: cy + Math.sin(a) * ry });
+  }
+  return points3;
+}
+function clipPathToPolygon(value, width, height) {
+  const v = value.trim();
+  if (v.startsWith("polygon")) {
+    return polygonClipToPoints(v, width, height);
+  }
+  if (v.startsWith("inset")) {
+    return insetClipToPoints(v, width, height);
+  }
+  if (v.startsWith("ellipse") || v.startsWith("circle")) {
+    return ellipseClipToPoints(v, width, height);
+  }
+  if (v.startsWith("path")) {
+    const start = v.indexOf("'") >= 0 ? v.indexOf("'") : v.indexOf('"');
+    const end = v.lastIndexOf("'") >= 0 ? v.lastIndexOf("'") : v.lastIndexOf('"');
+    if (start >= 0 && end > start) {
+      const d = v.slice(start + 1, end);
+      const polys = svgPathToPolygons(d);
+      if (polys.length === 0) {
+        return [];
+      }
+      return polys.reduce((a, b) => b.length > a.length ? b : a);
+    }
+  }
+  return [];
+}
+function resolveElementOutline(element) {
+  const width = Math.max(element.width, 1);
+  const height = Math.max(element.height, 1);
+  const shapeType = element.shapeType;
+  const adjustments = element.shapeAdjustments;
+  const clip = getResolvedShapeClipPathFor(shapeType, width, height, adjustments);
+  if (clip) {
+    const poly = clipPathToPolygon(clip, width, height);
+    if (poly.length >= 3) {
+      return poly;
+    }
+  }
+  return [
+    { x: 0, y: 0 },
+    { x: width, y: 0 },
+    { x: width, y: height },
+    { x: 0, y: height }
+  ];
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function resamplePolygon(poly, count) {
+  if (poly.length < 2) {
+    return Array.from({ length: count }, () => ({ x: poly[0]?.x ?? 0, y: poly[0]?.y ?? 0 }));
+  }
+  const ring = [...poly, poly[0]];
+  const segLen = [];
+  let total = 0;
+  for (let i = 0; i < ring.length - 1; i++) {
+    const d = dist(ring[i], ring[i + 1]);
+    segLen.push(d);
+    total += d;
+  }
+  if (total === 0) {
+    return Array.from({ length: count }, () => ({ x: poly[0].x, y: poly[0].y }));
+  }
+  const result = [];
+  const step = total / count;
+  let seg = 0;
+  let segStart = 0;
+  for (let i = 0; i < count; i++) {
+    const target = i * step;
+    while (seg < segLen.length - 1 && segStart + segLen[seg] < target) {
+      segStart += segLen[seg];
+      seg++;
+    }
+    const within = segLen[seg] > 0 ? (target - segStart) / segLen[seg] : 0;
+    const a = ring[seg];
+    const b = ring[seg + 1];
+    result.push({ x: a.x + (b.x - a.x) * within, y: a.y + (b.y - a.y) * within });
+  }
+  return result;
+}
+function signedArea2(poly) {
+  let area = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % poly.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area / 2;
+}
+function rotateRing(poly, offset) {
+  const n = poly.length;
+  const o = (offset % n + n) % n;
+  return poly.slice(o).concat(poly.slice(0, o));
+}
+function bestRotation(from, to) {
+  let bestOffset = 0;
+  let bestCost = Infinity;
+  for (let offset = 0; offset < to.length; offset++) {
+    let cost = 0;
+    for (let i = 0; i < from.length; i++) {
+      const t = to[(i + offset) % to.length];
+      const dx = from[i].x - t.x;
+      const dy = from[i].y - t.y;
+      cost += dx * dx + dy * dy;
+      if (cost >= bestCost) {
+        break;
+      }
+    }
+    if (cost < bestCost) {
+      bestCost = cost;
+      bestOffset = offset;
+    }
+  }
+  return bestOffset;
+}
+function normalizeOutlinePair(fromPoly, toPoly, count = OUTLINE_SAMPLE_COUNT) {
+  const from = resamplePolygon(fromPoly, count);
+  let to = resamplePolygon(toPoly, count);
+  if (Math.sign(signedArea2(from)) !== Math.sign(signedArea2(to))) {
+    to = [...to].reverse();
+  }
+  const offset = bestRotation(from, to);
+  to = rotateRing(to, offset);
+  return [from, to];
+}
+function interpolateOutline(from, to, t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const len = Math.min(from.length, to.length);
+  if (len === 0) {
+    return "";
+  }
+  const parts = [];
+  for (let i = 0; i < len; i++) {
+    const x = from[i].x + (to[i].x - from[i].x) * clamped;
+    const y = from[i].y + (to[i].y - from[i].y) * clamped;
+    parts.push(`${i === 0 ? "M" : "L"}${Number(x.toFixed(2))} ${Number(y.toFixed(2))}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+var MORPH_EASING = "cubic-bezier(0.4, 0, 0.2, 1)";
+var PROXIMITY_THRESHOLD = 300;
+var GEOMETRY_MORPH_STEPS = 8;
+function shouldGeometryMorph(pair) {
+  const fromType = pair.fromElement.shapeType;
+  const toType = pair.toElement.shapeType;
+  if (!fromType || !toType) {
+    return false;
+  }
+  if (fromType.toLowerCase() !== toType.toLowerCase()) {
+    return true;
+  }
+  const fromAdj = JSON.stringify(
+    pair.fromElement.shapeAdjustments ?? {}
+  );
+  const toAdj = JSON.stringify(
+    pair.toElement.shapeAdjustments ?? {}
+  );
+  return fromAdj !== toAdj;
+}
+function buildClipKeyframeBody(from, to, steps) {
+  const [fromRing, toRing] = normalizeOutlinePair(
+    resolveElementOutline(from),
+    resolveElementOutline(to)
+  );
+  if (fromRing.length === 0 || toRing.length === 0) {
+    return null;
+  }
+  const lines = [];
+  for (let s = 0; s <= steps; s++) {
+    const t = s / steps;
+    const d = interpolateOutline(fromRing, toRing, t);
+    if (!d) {
+      return null;
+    }
+    const pct = Number((s / steps * 100).toFixed(2));
+    lines.push(`	${pct}% {
+		clip-path: path('${d}');
+	}`);
+  }
+  return lines.join("\n");
+}
+function generateGeometryMorphAnimation(pair, durationMs, pairIndex, steps = GEOMETRY_MORPH_STEPS) {
+  if (!shouldGeometryMorph(pair)) {
+    return null;
+  }
+  const body = buildClipKeyframeBody(pair.fromElement, pair.toElement, steps);
+  if (!body) {
+    return null;
+  }
+  const safeName = `pptx-morph-geo-${pairIndex}-${pair.toElement.id.replace(/[^a-zA-Z0-9]/gu, "")}`;
+  const keyframes = `
+@keyframes ${safeName} {
+${body}
+}`;
+  return {
+    elementId: pair.toElement.id,
+    animation: `${safeName} ${durationMs}ms ${MORPH_EASING} forwards`,
+    keyframes
+  };
+}
+function getElementMorphName(element) {
+  if (element.name) {
+    const name = element.name.trim();
+    if (name.startsWith("!!")) {
+      return name;
+    }
+  }
+  if (hasTextProperties(element) && element.text) {
+    const text2 = element.text.trim();
+    if (text2.startsWith("!!")) {
+      return text2;
+    }
+  }
+  return void 0;
+}
+function matchMorphElementsFull(fromSlide, toSlide) {
+  const pairs2 = [];
+  const usedFrom = /* @__PURE__ */ new Set();
+  const usedTo = /* @__PURE__ */ new Set();
+  for (const fromEl of fromSlide.elements) {
+    const fromName = getElementMorphName(fromEl);
+    if (!fromName) {
+      continue;
+    }
+    for (const toEl of toSlide.elements) {
+      if (usedTo.has(toEl.id)) {
+        continue;
+      }
+      const toName = getElementMorphName(toEl);
+      if (toName === fromName) {
+        pairs2.push({ fromElement: fromEl, toElement: toEl });
+        usedFrom.add(fromEl.id);
+        usedTo.add(toEl.id);
+        break;
+      }
+    }
+  }
+  for (const fromEl of fromSlide.elements) {
+    if (usedFrom.has(fromEl.id) || !fromEl.shapeId) {
+      continue;
+    }
+    for (const toEl of toSlide.elements) {
+      if (usedTo.has(toEl.id)) {
+        continue;
+      }
+      if (toEl.shapeId && fromEl.shapeId === toEl.shapeId && fromEl.type === toEl.type) {
+        pairs2.push({ fromElement: fromEl, toElement: toEl });
+        usedFrom.add(fromEl.id);
+        usedTo.add(toEl.id);
+        break;
+      }
+    }
+  }
+  for (const fromEl of fromSlide.elements) {
+    if (usedFrom.has(fromEl.id)) {
+      continue;
+    }
+    let bestMatch = null;
+    let bestDist = Infinity;
+    for (const toEl of toSlide.elements) {
+      if (usedTo.has(toEl.id)) {
+        continue;
+      }
+      if (fromEl.type !== toEl.type) {
+        continue;
+      }
+      const dx = fromEl.x - toEl.x;
+      const dy = fromEl.y - toEl.y;
+      const dist2 = Math.sqrt(dx * dx + dy * dy);
+      if (dist2 < bestDist && dist2 < PROXIMITY_THRESHOLD) {
+        bestDist = dist2;
+        bestMatch = toEl;
+      }
+    }
+    if (bestMatch) {
+      pairs2.push({ fromElement: fromEl, toElement: bestMatch });
+      usedFrom.add(fromEl.id);
+      usedTo.add(bestMatch.id);
+    }
+  }
+  const unmatchedFrom = fromSlide.elements.filter((el) => !usedFrom.has(el.id));
+  const unmatchedTo = toSlide.elements.filter((el) => !usedTo.has(el.id));
+  return { pairs: pairs2, unmatchedFrom, unmatchedTo };
+}
+function tokenizeText(element, mode) {
+  if (!hasTextProperties(element) || !element.text) {
+    return [];
+  }
+  const text2 = element.text;
+  const style = element.textStyle;
+  const fontSize = style?.fontSize ?? 14;
+  const fontWeight = style?.bold ? "bold" : "normal";
+  const color2 = style?.color ?? "#000000";
+  const tokens = [];
+  if (mode === "character") {
+    const chars = Array.from(text2);
+    const totalChars = chars.length;
+    if (totalChars === 0) {
+      return [];
+    }
+    for (let i = 0; i < chars.length; i++) {
+      if (chars[i] === "\n") {
+        continue;
+      }
+      tokens.push({
+        text: chars[i],
+        x: totalChars > 1 ? i / (totalChars - 1) : 0.5,
+        y: 0.5,
+        fontSize,
+        fontWeight,
+        color: color2
+      });
+    }
+  } else {
+    const words = text2.split(/\s+/u);
+    const nonEmptyWords = words.filter((w) => w.trim().length > 0);
+    const totalWords = nonEmptyWords.length;
+    if (totalWords === 0) {
+      return [];
+    }
+    let wordIndex = 0;
+    for (const word of words) {
+      if (word.trim().length === 0) {
+        continue;
+      }
+      tokens.push({
+        text: word,
+        x: totalWords > 1 ? wordIndex / (totalWords - 1) : 0.5,
+        y: 0.5,
+        fontSize,
+        fontWeight,
+        color: color2
+      });
+      wordIndex++;
+    }
+  }
+  return tokens;
+}
+function diffTokens(fromTokens, toTokens) {
+  const n = fromTokens.length;
+  const m = toTokens.length;
+  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = fromTokens[i2].text === toTokens[j2].text ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (fromTokens[i].text === toTokens[j].text) {
+      ops.push({
+        change: "shared",
+        from: fromTokens[i],
+        to: toTokens[j],
+        fromIndex: i,
+        toIndex: j
+      });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      ops.push({ change: "removed", from: fromTokens[i], to: null, fromIndex: i, toIndex: -1 });
+      i++;
+    } else {
+      ops.push({ change: "added", from: null, to: toTokens[j], fromIndex: -1, toIndex: j });
+      j++;
+    }
+  }
+  while (i < n) {
+    ops.push({ change: "removed", from: fromTokens[i], to: null, fromIndex: i, toIndex: -1 });
+    i++;
+  }
+  while (j < m) {
+    ops.push({ change: "added", from: null, to: toTokens[j], fromIndex: -1, toIndex: j });
+    j++;
+  }
+  return ops;
+}
+function tokenColor(token2) {
+  const parsed = parseHexColor(token2.color);
+  return parsed ? lerpColor2(parsed, parsed, 0) : token2.color;
+}
+function sharedKeyframes(name, op) {
+  const from = op.from;
+  const to = op.to;
+  return `
+@keyframes ${name} {
+	from {
+		left: ${Number((from.x * 100).toFixed(2))}%;
+		top: ${Number((from.y * 100).toFixed(2))}%;
+		font-size: ${from.fontSize}pt;
+		font-weight: ${from.fontWeight};
+		color: ${tokenColor(from)};
+		opacity: 1;
+	}
+	to {
+		left: ${Number((to.x * 100).toFixed(2))}%;
+		top: ${Number((to.y * 100).toFixed(2))}%;
+		font-size: ${to.fontSize}pt;
+		font-weight: ${to.fontWeight};
+		color: ${tokenColor(to)};
+		opacity: 1;
+	}
+}`;
+}
+function fadeKeyframes(name, fadeIn) {
+  const a = fadeIn ? 0 : 1;
+  const b = fadeIn ? 1 : 0;
+  return `
+@keyframes ${name} {
+	from { opacity: ${a}; }
+	to { opacity: ${b}; }
+}`;
+}
+function buildTokenMorphAnimations(ops, fromId, toId, durationMs, pairIndex) {
+  const animations = [];
+  for (let k = 0; k < ops.length; k++) {
+    const op = ops[k];
+    const name = `pptx-morph-tok-${pairIndex}-${k}`;
+    const anim = `${name} ${durationMs}ms ${MORPH_EASING} forwards`;
+    if (op.change === "shared") {
+      animations.push({
+        elementId: `${toId}__token_${op.toIndex}`,
+        animation: anim,
+        keyframes: sharedKeyframes(name, op)
+      });
+    } else if (op.change === "added") {
+      animations.push({
+        elementId: `${toId}__token_${op.toIndex}`,
+        animation: anim,
+        keyframes: fadeKeyframes(name, true)
+      });
+    } else {
+      animations.push({
+        elementId: `${fromId}__token_${op.fromIndex}`,
+        animation: anim,
+        keyframes: fadeKeyframes(name, false)
+      });
+    }
+  }
+  return animations;
+}
+function buildColorInterpolationProps(fromElement, toElement) {
+  const fromFill = hasShapeProperties(fromElement) ? fromElement.shapeStyle?.fillColor : void 0;
+  const toFill = hasShapeProperties(toElement) ? toElement.shapeStyle?.fillColor : void 0;
+  if (!fromFill && !toFill) {
+    return null;
+  }
+  if (fromFill === toFill) {
+    return null;
+  }
+  const fromColor = parseHexColor(fromFill);
+  const toColor = parseHexColor(toFill);
+  if (!fromColor && !toColor) {
+    return null;
+  }
+  const from = fromColor ?? { r: 255, g: 255, b: 255, a: 0 };
+  const to = toColor ?? { r: 255, g: 255, b: 255, a: 0 };
+  return {
+    fromBg: lerpColor2(from, from, 0),
+    toBg: lerpColor2(to, to, 0)
+  };
+}
+function buildStrokeInterpolationProps(fromElement, toElement) {
+  const fromStyle = hasShapeProperties(fromElement) ? fromElement.shapeStyle : void 0;
+  const toStyle = hasShapeProperties(toElement) ? toElement.shapeStyle : void 0;
+  const fromColor = fromStyle?.strokeColor;
+  const toColor = toStyle?.strokeColor;
+  const fromWidth = fromStyle?.strokeWidth ?? 0;
+  const toWidth = toStyle?.strokeWidth ?? 0;
+  if (!fromColor && !toColor && fromWidth === 0 && toWidth === 0) {
+    return null;
+  }
+  if (fromColor === toColor && fromWidth === toWidth) {
+    return null;
+  }
+  const fc = parseHexColor(fromColor) ?? { r: 0, g: 0, b: 0, a: 1 };
+  const tc = parseHexColor(toColor) ?? { r: 0, g: 0, b: 0, a: 1 };
+  return {
+    fromStroke: lerpColor2(fc, fc, 0),
+    toStroke: lerpColor2(tc, tc, 0),
+    fromWidth,
+    toWidth
+  };
+}
+function appearanceSignature(element) {
+  const parts = [element.type];
+  if (hasShapeProperties(element)) {
+    const style = element.shapeStyle;
+    parts.push(
+      element.shapeType ?? "",
+      style?.fillMode ?? "",
+      style?.fillColor ?? "",
+      style?.fillGradient ?? "",
+      String(style?.fillOpacity ?? ""),
+      style?.strokeColor ?? "",
+      String(style?.strokeWidth ?? "")
+    );
+  }
+  const image = element;
+  parts.push(image.imagePath ?? "", image.svgPath ?? "");
+  if (hasTextProperties(element)) {
+    parts.push(element.text ?? "", element.textStyle?.color ?? "");
+  }
+  return parts.join("
");
+}
+function morphPairNeedsCrossfade(fromElement, toElement) {
+  return appearanceSignature(fromElement) !== appearanceSignature(toElement);
+}
+function generateMorphAnimations(pairs2, durationMs, _mode = "object") {
+  const animations = [];
+  for (let index = 0; index < pairs2.length; index++) {
+    const { fromElement, toElement } = pairs2[index];
+    const safeName = `pptx-morph-${index}-${toElement.id.replace(/[^a-zA-Z0-9]/gu, "")}`;
+    const dx = fromElement.x - toElement.x;
+    const dy = fromElement.y - toElement.y;
+    const sx = Math.max(fromElement.width, 1) / Math.max(toElement.width, 1);
+    const sy = Math.max(fromElement.height, 1) / Math.max(toElement.height, 1);
+    const dr = (fromElement.rotation ?? 0) - (toElement.rotation ?? 0);
+    const fromOpacity = fromElement.opacity ?? 1;
+    const toOpacity = toElement.opacity ?? 1;
+    const crossfades = morphPairNeedsCrossfade(fromElement, toElement);
+    const fromProps = [
+      `		transform: translate(${dx}px, ${dy}px) scale(${sx}, ${sy}) rotate(${dr}deg);`,
+      `		opacity: ${crossfades ? 0 : fromOpacity};`
+    ];
+    const toProps = [
+      "		transform: translate(0, 0) scale(1, 1) rotate(0deg);",
+      `		opacity: ${toOpacity};`
+    ];
+    const colorInterp = buildColorInterpolationProps(fromElement, toElement);
+    if (colorInterp) {
+      fromProps.push(`		background-color: ${colorInterp.fromBg};`);
+      toProps.push(`		background-color: ${colorInterp.toBg};`);
+    }
+    const strokeInterp = buildStrokeInterpolationProps(fromElement, toElement);
+    if (strokeInterp) {
+      fromProps.push(`		outline: ${strokeInterp.fromWidth}px solid ${strokeInterp.fromStroke};`);
+      toProps.push(`		outline: ${strokeInterp.toWidth}px solid ${strokeInterp.toStroke};`);
+    }
+    const keyframes = `
+@keyframes ${safeName} {
+	from {
+${fromProps.join("\n")}
+	}
+	to {
+${toProps.join("\n")}
+	}
+}`;
+    animations.push({
+      elementId: toElement.id,
+      animation: `${safeName} ${durationMs}ms ${MORPH_EASING} forwards`,
+      keyframes
+    });
+  }
+  return animations;
+}
+function generateMorphGhostAnimations(pairs2, durationMs, startIndex) {
+  const animations = [];
+  for (let index = 0; index < pairs2.length; index++) {
+    const { fromElement, toElement } = pairs2[index];
+    const fadesOut = morphPairNeedsCrossfade(fromElement, toElement);
+    const safeName = `pptx-morph-ghost-${startIndex + index}-${fromElement.id.replace(/[^a-zA-Z0-9]/gu, "")}`;
+    const dx = toElement.x - fromElement.x;
+    const dy = toElement.y - fromElement.y;
+    const sx = Math.max(toElement.width, 1) / Math.max(fromElement.width, 1);
+    const sy = Math.max(toElement.height, 1) / Math.max(fromElement.height, 1);
+    const dr = (toElement.rotation ?? 0) - (fromElement.rotation ?? 0);
+    const originX = fromElement.x + fromElement.width / 2;
+    const originY = fromElement.y + fromElement.height / 2;
+    const keyframes = `
+@keyframes ${safeName} {
+	from {
+		transform-origin: ${originX}px ${originY}px;
+		transform: translate(0, 0) scale(1, 1) rotate(0deg);
+		opacity: ${fromElement.opacity ?? 1};
+	}
+	to {
+		transform-origin: ${originX}px ${originY}px;
+		transform: translate(${dx}px, ${dy}px) scale(${sx}, ${sy}) rotate(${dr}deg);
+		opacity: ${fadesOut ? 0 : fromElement.opacity ?? 1};
+	}
+}`;
+    animations.push({
+      elementId: fromElement.id,
+      animation: `${safeName} ${durationMs}ms ${MORPH_EASING} forwards`,
+      keyframes
+    });
+  }
+  return animations;
+}
+function generateUnmatchedFadeOutAnimations(elements, durationMs, startIndex) {
+  return elements.map((el, i) => {
+    const safeName = `pptx-morph-fadeout-${startIndex + i}-${el.id.replace(/[^a-zA-Z0-9]/gu, "")}`;
+    const keyframes = `
+@keyframes ${safeName} {
+	from {
+		opacity: ${el.opacity ?? 1};
+		transform: scale(1);
+	}
+	to {
+		opacity: 0;
+		transform: scale(0.95);
+	}
+}`;
+    return {
+      elementId: el.id,
+      animation: `${safeName} ${durationMs}ms ${MORPH_EASING} forwards`,
+      keyframes
+    };
+  });
+}
+function generateUnmatchedFadeInAnimations(elements, durationMs, startIndex) {
+  return elements.map((el, i) => {
+    const safeName = `pptx-morph-fadein-${startIndex + i}-${el.id.replace(/[^a-zA-Z0-9]/gu, "")}`;
+    const keyframes = `
+@keyframes ${safeName} {
+	from {
+		opacity: 0;
+		transform: scale(0.95);
+	}
+	to {
+		opacity: ${el.opacity ?? 1};
+		transform: scale(1);
+	}
+}`;
+    return {
+      elementId: el.id,
+      animation: `${safeName} ${durationMs}ms ${MORPH_EASING} forwards`,
+      keyframes
+    };
+  });
+}
+function generateTextMorphAnimations(pair, durationMs, mode, pairIndex) {
+  const fromTokens = tokenizeText(pair.fromElement, mode);
+  const toTokens = tokenizeText(pair.toElement, mode);
+  if (fromTokens.length === 0 && toTokens.length === 0) {
+    return [];
+  }
+  const ops = diffTokens(fromTokens, toTokens);
+  return buildTokenMorphAnimations(
+    ops,
+    pair.fromElement.id,
+    pair.toElement.id,
+    durationMs,
+    pairIndex
+  );
+}
+function generateFullMorphTransition(fromSlide, toSlide, durationMs, mode = "object") {
+  const matchResult = matchMorphElementsFull(fromSlide, toSlide);
+  const allAnimations = [];
+  const pairAnims = generateMorphAnimations(matchResult.pairs, durationMs, mode);
+  allAnimations.push(...pairAnims);
+  for (let i = 0; i < matchResult.pairs.length; i++) {
+    const geo = generateGeometryMorphAnimation(matchResult.pairs[i], durationMs, i);
+    if (geo) {
+      allAnimations.push(geo);
+    }
+  }
+  if (mode === "word" || mode === "character") {
+    for (let i = 0; i < matchResult.pairs.length; i++) {
+      const pair = matchResult.pairs[i];
+      if (hasTextProperties(pair.fromElement) && hasTextProperties(pair.toElement)) {
+        const textAnims = generateTextMorphAnimations(pair, durationMs, mode, i);
+        allAnimations.push(...textAnims);
+      }
+    }
+  }
+  const ghosts = generateMorphGhostAnimations(matchResult.pairs, durationMs, pairAnims.length);
+  allAnimations.push(...ghosts);
+  const fadeOuts = generateUnmatchedFadeOutAnimations(
+    matchResult.unmatchedFrom,
+    durationMs,
+    pairAnims.length + ghosts.length
+  );
+  allAnimations.push(...fadeOuts);
+  const fadeIns = generateUnmatchedFadeInAnimations(
+    matchResult.unmatchedTo,
+    durationMs,
+    pairAnims.length + ghosts.length + fadeOuts.length
+  );
+  allAnimations.push(...fadeIns);
+  return allAnimations;
+}
+function morphOptionToMode(option) {
+  if (option === "byWord") {
+    return "word";
+  }
+  if (option === "byChar") {
+    return "character";
+  }
+  return "object";
+}
+function buildMorphTransitionPlan(fromSlide, toSlide, durationMs, mode = "object") {
+  if (!fromSlide || !toSlide) {
+    return void 0;
+  }
+  const match = matchMorphElementsFull(fromSlide, toSlide);
+  if (match.pairs.length === 0 && match.unmatchedFrom.length === 0 && match.unmatchedTo.length === 0) {
+    return void 0;
+  }
+  const animations = generateFullMorphTransition(fromSlide, toSlide, durationMs, mode);
+  const outgoingElements = [...fromSlide.elements];
+  const outgoingIds = new Set(outgoingElements.map((element) => element.id));
+  const incomingAnimations = /* @__PURE__ */ new Map();
+  const outgoingAnimations = /* @__PURE__ */ new Map();
+  const keyframes = [];
+  for (const animation of animations) {
+    keyframes.push(animation.keyframes);
+    if (outgoingIds.has(animation.elementId)) {
+      outgoingAnimations.set(animation.elementId, animation.animation);
+    } else {
+      incomingAnimations.set(animation.elementId, animation.animation);
+    }
+  }
+  return {
+    keyframesCss: keyframes.join("\n"),
+    incomingAnimations,
+    outgoingAnimations,
+    outgoingElements,
+    durationMs
+  };
+}
 function hexToRgb6(hex10) {
   const clean = hex10.replace(/^#/u, "");
   return {
@@ -109835,6 +110735,7 @@ exports.buildHandoutsHtml = buildHandoutsHtml;
 exports.buildInitialGuides = buildInitialGuides;
 exports.buildInnerShadowCssFromShapeStyle = buildInnerShadowCssFromShapeStyle;
 exports.buildJoinCollaborationConfig = buildJoinCollaborationConfig;
+exports.buildMorphTransitionPlan = buildMorphTransitionPlan;
 exports.buildMultiLayerShadowCss = buildMultiLayerShadowCss;
 exports.buildNotesHtml = buildNotesHtml;
 exports.buildNotesPdfBytes = buildNotesPdfBytes;
@@ -110071,6 +110972,7 @@ exports.mergePresentationSnapshot = mergePresentationSnapshot;
 exports.mergeShapes = mergeShapes;
 exports.mobileElapsedSince = mobileElapsedSince;
 exports.mobileSlideCounter = mobileSlideCounter;
+exports.morphOptionToMode = morphOptionToMode;
 exports.mountModel3D = mountModel3D;
 exports.mountSurfaceChart3D = mountSurfaceChart3D;
 exports.movePresenterPointer = movePresenterPointer;
@@ -110139,6 +111041,7 @@ exports.resolveLineHeight = resolveLineHeight;
 exports.resolveOleType = resolveOleType;
 exports.resolveParagraphAlign = resolveParagraphAlign;
 exports.resolveParagraphRtl = resolveParagraphRtl;
+exports.resolveParagraphStrutFontSize = resolveParagraphStrutFontSize;
 exports.resolvePictureBullet = resolvePictureBullet;
 exports.resolveProfileInitial = resolveProfileInitial;
 exports.resolveRegionCode = resolveRegionCode;