pptx-react-viewer 2.9.0 → 2.11.0

package/dist/{chunk-IKISUZKE.js → chunk-HMQVOPQH.js}

@@ -46608,8 +46608,8 @@ function applyImageColorEffects(blip, effects, parseColor, extractOpacity) {
     const rawFrom = child19(change.rawXml, "clrFrom");
     const rawTo = child19(change.rawXml, "clrTo");
     const rawTransparent = rawTo ? (opacity(rawTo, extractOpacity) ?? 1) <= 0 : void 0;
-    const unchanged = sameRawColor(rawFrom, change.clrFrom, parseColor) && sameRawColor(rawTo, change.clrTo, parseColor) && (rawTransparent === void 0 || change.clrToTransparent === rawTransparent);
-    if (unchanged && change.rawXml) {
+    const unchanged2 = sameRawColor(rawFrom, change.clrFrom, parseColor) && sameRawColor(rawTo, change.clrTo, parseColor) && (rawTransparent === void 0 || change.clrToTransparent === rawTransparent);
+    if (unchanged2 && change.rawXml) {
       setChild6(blip, "clrChange", change.rawXml);
     } else {
       const fromChoice = sameRawColor(rawFrom, change.clrFrom, parseColor) ? extractColorChoiceXml(rawFrom) : buildSrgbColorChoice(change.clrFrom);
@@ -50614,8 +50614,8 @@ var PptxHandlerRuntime14 = class extends PptxHandlerRuntime13 {
     }
     const notesBodyShape = shapes.find((shape) => {
       const placeholder = shape?.["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"];
-      const placeholderType = String(placeholder?.["@_type"] || "").trim().toLowerCase();
-      return placeholderType === "body";
+      const placeholderType2 = String(placeholder?.["@_type"] || "").trim().toLowerCase();
+      return placeholderType2 === "body";
     }) || shapes.find((shape) => Boolean(shape?.["p:txBody"])) || shapes[0];
     if (!notesBodyShape) {
       return false;
@@ -51453,10 +51453,16 @@ var PptxHandlerRuntime17 = class extends PptxHandlerRuntime16 {
    * survive a save: collapsing them to the plain-text path silently downgrades
    * a field to static text (e.g. a slide-number field becomes a frozen number)
    * or drops the equation, ruby, or bullet.
+   *
+   * `paragraphLevel` (`a:pPr/@lvl`) belongs on this list for the same reason
+   * and used to be missing from it: a nested bullet whose runs all share one
+   * style looked "uniform", so the save path discarded its segments and rebuilt
+   * the paragraph from the flat string, which carries no indent level. Every
+   * such paragraph came back from a round-trip flattened to the top level.
    */
   isStructuralTextSegment(segment) {
     return Boolean(
-      segment.fieldType || segment.equationXml || segment.rubyText || segment.bulletInfo
+      segment.fieldType || segment.equationXml || segment.rubyText || segment.bulletInfo || segment.paragraphLevel
     );
   }
   areTextSegmentsUniform(textSegments) {
@@ -86655,6 +86661,43 @@ var EQUATION_TEMPLATES = [
     i18nKey: "pptx.equation.template.trigIdentity"
   }
 ];
+function purifyFn() {
+  const purify = DOMPurify__default.default;
+  return typeof purify.sanitize === "function" ? purify.sanitize : void 0;
+}
+function sanitizeMarkupOrEmpty(markup, config) {
+  const sanitize = purifyFn();
+  return sanitize ? sanitize(markup, config) : "";
+}
+function sanitizeMathMl(markup) {
+  const sanitized = sanitizeMarkupOrEmpty(markup, { USE_PROFILES: { mathMl: true, svg: true } });
+  if (/<math(?:\s|>)/iu.test(markup) && !/<math(?:\s|>)/iu.test(sanitized) && sanitized) {
+    return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${sanitized}</math>`;
+  }
+  return sanitized;
+}
+function emptyResult() {
+  return { mathml: "", omml: {} };
+}
+function compileLatexEquation(source) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    return emptyResult();
+  }
+  try {
+    const omml = convertLatexToOmml(trimmed);
+    const raw = convertOmmlToMathMl(omml);
+    return { mathml: raw ? sanitizeMathMl(raw) : "", omml };
+  } catch {
+    return emptyResult();
+  }
+}
+function latexToMathMl(source) {
+  return compileLatexEquation(source).mathml;
+}
+function compileEquationTemplateMathMl() {
+  return EQUATION_TEMPLATES.map((tmpl) => latexToMathMl(tmpl.latex));
+}
 var ACCENT1 = "#4472C4";
 var ACCENT2 = "#ED7D31";
 var ACCENT3 = "#A5A5A5";
@@ -87110,6 +87153,14 @@ function resolveDataPointExplosion(series, pointIndex) {
   const point = findDataPoint(series, pointIndex);
   return point?.explosion ?? series.explosion ?? 0;
 }
+function resolveDataPointMarker(series, pointIndex) {
+  const point = findDataPoint(series, pointIndex)?.marker;
+  return {
+    symbol: point?.symbol ?? series.marker?.symbol,
+    size: point?.size ?? series.marker?.size,
+    fill: point?.spPr?.fillColor ?? series.marker?.spPr?.fillColor
+  };
+}
 function addChartSeries(data) {
   return chartDataAddSeries(data, {
     name: `Series ${data.series.length + 1}`,
@@ -87997,13 +88048,16 @@ function buildMarkerPrimitive(input) {
       return { kind: "circle", cx, cy, r, fill, part };
   }
 }
-function pushMarker(out, series, cx, cy, fill, defaultRadius2, part, opacity2) {
+function pushMarker(out, series, pointIndex, cx, cy, fill, defaultRadius2, part, opacity2) {
+  const marker = resolveDataPointMarker(series, pointIndex);
   const m = buildMarkerPrimitive({
-    symbol: series.marker?.symbol,
-    size: series.marker?.size,
+    symbol: marker.symbol,
+    size: marker.size,
     cx,
     cy,
-    fill,
+    // A marker fill (series or per-point) wins over the plot fill, which is
+    // what the line/area body is drawn with.
+    fill: marker.fill ?? fill,
     defaultRadius: defaultRadius2,
     part
   });
@@ -88083,6 +88137,7 @@ function buildLines(chartData, catCount, layout, primaryRange, secondaryRange, s
       pushMarker(
         primitives,
         series,
+        idx,
         pt.x,
         pt.y,
         resolveDataPointFill(series, idx, c) ?? c,
@@ -88154,6 +88209,7 @@ function buildAreas(chartData, catCount, layout, range, sourceIndices2, xPositio
       pushMarker(
         primitives,
         series,
+        idx,
         pt.x,
         pt.y,
         resolveDataPointFill(series, idx, c) ?? c,
@@ -88197,6 +88253,7 @@ function buildScatter(chartData, layout, range) {
       pushMarker(
         primitives,
         series,
+        vi,
         dot.cx,
         dot.cy,
         resolveDataPointFill(series, vi, c) ?? c,
@@ -93666,6 +93723,10 @@ function applyFlyDirection(effect, subtype) {
   const suffix = `${edge.charAt(0).toUpperCase()}${edge.slice(1)}`;
   return `${prefix}${suffix}`;
 }
+function slideOffset(percent2, axis) {
+  const fallback = axis === "w" ? "1280px" : "720px";
+  return `calc(var(--pptx-slide-${axis}, ${fallback}) * ${(percent2 / 100).toFixed(4)})`;
+}
 function buildDynamicKeyframe(anim, uid) {
   if (anim.motionPath) {
     const name = `pptx-tl-motion-${uid}`;
@@ -93676,8 +93737,8 @@ function buildDynamicKeyframe(anim, uid) {
     const lines = [];
     for (let i = 0; i < points3.length; i++) {
       const pct = Math.round(i / (points3.length - 1) * 100);
-      const tx = points3[i].x.toFixed(2);
-      const ty = points3[i].y.toFixed(2);
+      const tx = slideOffset(points3[i].x, "w");
+      const ty = slideOffset(points3[i].y, "h");
       if (anim.motionPathRotateAuto) {
         const next = i < points3.length - 1 ? points3[i + 1] : points3[i];
         const prev = i > 0 ? points3[i - 1] : points3[i];
@@ -93685,10 +93746,10 @@ function buildDynamicKeyframe(anim, uid) {
         const dy = i < points3.length - 1 ? next.y - points3[i].y : points3[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); }`
+          `	${pct}% { transform: translate(${tx}, ${ty}) rotate(${angleDeg.toFixed(2)}deg); }`
         );
       } else {
-        lines.push(`	${pct}% { transform: translate(${tx}%, ${ty}%); }`);
+        lines.push(`	${pct}% { transform: translate(${tx}, ${ty}); }`);
       }
     }
     return {
@@ -94823,6 +94884,422 @@ var TimelineEngine = class _TimelineEngine {
     }
   }
 };
+var PRESET_TO_EFFECT = {
+  fadeIn: "fadeIn",
+  flyIn: "flyInBottom",
+  zoomIn: "zoomIn",
+  fadeOut: "fadeOut",
+  flyOut: "flyOutBottom",
+  zoomOut: "zoomOut",
+  spin: "spin",
+  pulse: "pulse",
+  colorWave: "colorWave",
+  bounce: "bounce",
+  flash: "flash"
+};
+var DIRECTION_FLY_MAP = {
+  fromLeft: { flyIn: "flyInLeft", flyOut: "flyOutLeft" },
+  fromRight: { flyIn: "flyInRight", flyOut: "flyOutRight" },
+  fromTop: { flyIn: "flyInTop", flyOut: "flyOutTop" },
+  fromBottom: { flyIn: "flyInBottom", flyOut: "flyOutBottom" },
+  fromTopLeft: { flyIn: "flyInTop", flyOut: "flyOutTop" },
+  fromTopRight: { flyIn: "flyInTop", flyOut: "flyOutTop" },
+  fromBottomLeft: { flyIn: "flyInBottom", flyOut: "flyOutBottom" },
+  fromBottomRight: { flyIn: "flyInBottom", flyOut: "flyOutBottom" }
+};
+function resolvePreviewEffect(preset, direction) {
+  if ((preset === "flyIn" || preset === "flyOut") && direction) {
+    const dirMap = DIRECTION_FLY_MAP[direction];
+    if (dirMap) {
+      return preset === "flyIn" ? dirMap.flyIn : dirMap.flyOut;
+    }
+  }
+  return PRESET_TO_EFFECT[preset];
+}
+function timingCurveToCss(curve, cubicBezierValues) {
+  if (cubicBezierValues) {
+    const parts = cubicBezierValues.split(",").map((s) => s.trim());
+    if (parts.length === 4 && parts.every((p) => !Number.isNaN(Number(p)))) {
+      return `cubic-bezier(${parts.join(", ")})`;
+    }
+  }
+  switch (curve) {
+    case "ease":
+      return "ease";
+    case "ease-in":
+      return "ease-in";
+    case "ease-out":
+      return "ease-out";
+    case "linear":
+      return "linear";
+    default:
+      return "ease";
+  }
+}
+function buildPreviewAnimation(preset, options) {
+  if (preset === "none") {
+    return void 0;
+  }
+  const effectName = resolvePreviewEffect(preset, options?.direction);
+  if (!effectName) {
+    return void 0;
+  }
+  const keyframeName = `pptx-${effectName}`;
+  const keyframesCss = getEffectKeyframes(effectName);
+  if (!keyframesCss) {
+    return void 0;
+  }
+  const duration = options?.durationMs ?? 600;
+  const easing = timingCurveToCss(options?.timingCurve, options?.cubicBezier);
+  return {
+    keyframeName,
+    keyframesCss,
+    cssAnimation: `${keyframeName} ${duration}ms ${easing} 0ms 1 normal both`,
+    durationMs: duration
+  };
+}
+var EDITABLE = /* @__PURE__ */ new Set(["M", "L", "C", "Z", "m", "l", "c", "z"]);
+var ARITY = { m: 2, l: 2, c: 6, z: 0 };
+function scanPath(path) {
+  const tokens = path.match(/[A-Za-z]|-?\d*\.?\d+(?:[eE][-+]?\d+)?/gu);
+  if (!tokens) {
+    return void 0;
+  }
+  const segments = [];
+  let i = 0;
+  let cmd = "";
+  while (i < tokens.length) {
+    if (/^[A-Za-z]$/u.test(tokens[i])) {
+      cmd = tokens[i];
+      i++;
+      if (!EDITABLE.has(cmd)) {
+        return void 0;
+      }
+      if (cmd === "Z" || cmd === "z") {
+        segments.push({ cmd, coords: [] });
+      }
+      continue;
+    }
+    const arity = ARITY[cmd.toLowerCase()];
+    if (!arity) {
+      return void 0;
+    }
+    const coords = [];
+    for (let n = 0; n < arity; n++) {
+      const value = Number(tokens[i++]);
+      if (!Number.isFinite(value)) {
+        return void 0;
+      }
+      coords.push(value);
+    }
+    segments.push({ cmd, coords });
+    if (cmd === "M") {
+      cmd = "L";
+    } else if (cmd === "m") {
+      cmd = "l";
+    }
+  }
+  return segments.length > 0 ? segments : void 0;
+}
+function formatPath(segments) {
+  return segments.map(
+    (segment) => segment.coords.length === 0 ? segment.cmd : `${segment.cmd} ${segment.coords.map((n) => trimNumber(n)).join(" ")}`
+  ).join(" ");
+}
+function trimNumber(value) {
+  return String(Number(value.toFixed(4)));
+}
+function motionPathFractionPoints(path) {
+  return parseMotionPathPoints(path).map((point) => ({ x: point.x / 100, y: point.y / 100 }));
+}
+function toPixels(point, frame2) {
+  return {
+    x: frame2.originX + point.x * frame2.slideWidth,
+    y: frame2.originY + point.y * frame2.slideHeight
+  };
+}
+function motionPathToSvgD(path, frame2) {
+  const points3 = motionPathFractionPoints(path).map((point) => toPixels(point, frame2));
+  if (points3.length === 0) {
+    return "";
+  }
+  const head = `M ${trimNumber(frame2.originX)} ${trimNumber(frame2.originY)}`;
+  const rest = points3.map((point) => `L ${trimNumber(point.x)} ${trimNumber(point.y)}`);
+  return [head, ...rest].join(" ");
+}
+function motionPathEndPixel(path, frame2) {
+  const points3 = motionPathFractionPoints(path);
+  const last = points3.length > 0 ? points3[points3.length - 1] : void 0;
+  return last ? toPixels(last, frame2) : { x: frame2.originX, y: frame2.originY };
+}
+function setMotionPathEnd(path, x, y) {
+  const segments = scanPath(path);
+  if (!segments) {
+    return path;
+  }
+  let lastIndex = -1;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (segments[i].coords.length > 0) {
+      lastIndex = i;
+      break;
+    }
+  }
+  if (lastIndex < 0 || segments.some((segment) => segment.cmd === "Z" || segment.cmd === "z")) {
+    return path;
+  }
+  const last = segments[lastIndex];
+  if (last.cmd === last.cmd.toLowerCase()) {
+    return path;
+  }
+  const coords = [...last.coords];
+  const endX = coords[coords.length - 2];
+  const endY = coords[coords.length - 1];
+  const dx = x - endX;
+  const dy = y - endY;
+  coords[coords.length - 2] = x;
+  coords[coords.length - 1] = y;
+  if (last.cmd === "C") {
+    coords[2] += dx;
+    coords[3] += dy;
+  }
+  const next = segments.map(
+    (segment, index) => index === lastIndex ? { ...last, coords } : segment
+  );
+  return formatPath(next);
+}
+function isEditableMotionPath(path) {
+  const segments = scanPath(path);
+  if (!segments) {
+    return false;
+  }
+  return !segments.some((segment) => segment.cmd === "Z" || segment.cmd === "z");
+}
+function buildMotionPathKeyframes(args) {
+  const points3 = motionPathFractionPoints(args.path);
+  if (points3.length < 2) {
+    return void 0;
+  }
+  const frames = points3.map((point, index) => {
+    const percent2 = Math.round(index / (points3.length - 1) * 100);
+    const x = trimNumber(point.x * args.slideWidth);
+    const y = trimNumber(point.y * args.slideHeight);
+    return `	${percent2}% { transform: translate(${x}px, ${y}px); }`;
+  });
+  return {
+    keyframeName: args.keyframeName,
+    css: `@keyframes ${args.keyframeName} {
+${frames.join("\n")}
+}`
+  };
+}
+var K = 0.5523;
+var RX = 0.125;
+var RY = 0.2222;
+var CIRCLE = [
+  "M 0 0",
+  `C ${-K * RX} 0 ${-RX} ${-RY + K * RY} ${-RX} ${-RY}`,
+  `C ${-RX} ${-RY - K * RY} ${-K * RX} ${ -2 * RY} 0 ${ -2 * RY}`,
+  `C ${K * RX} ${ -2 * RY} ${RX} ${-RY - K * RY} ${RX} ${-RY}`,
+  `C ${RX} ${-RY + K * RY} ${K * RX} 0 0 0`
+].join(" ").replace(/(\d\.\d{4})\d+/gu, "$1");
+var MOTION_PATH_PRESETS2 = [
+  // -- Lines ---------------------------------------------------------------
+  { id: "lineRight", family: "lines", path: "M 0 0 L 0.25 0" },
+  { id: "lineLeft", family: "lines", path: "M 0 0 L -0.25 0" },
+  { id: "lineDown", family: "lines", path: "M 0 0 L 0 0.25" },
+  { id: "lineUp", family: "lines", path: "M 0 0 L 0 -0.25" },
+  { id: "lineDiagonalUpRight", family: "lines", path: "M 0 0 L 0.25 -0.25" },
+  { id: "lineDiagonalDownRight", family: "lines", path: "M 0 0 L 0.25 0.25" },
+  { id: "lineDiagonalUpLeft", family: "lines", path: "M 0 0 L -0.25 -0.25" },
+  { id: "lineDiagonalDownLeft", family: "lines", path: "M 0 0 L -0.25 0.25" },
+  // -- Arcs ----------------------------------------------------------------
+  {
+    id: "arcUp",
+    family: "arcs",
+    path: "M 0 0 C 0 -0.1227 0.0559 -0.2222 0.125 -0.2222 C 0.1941 -0.2222 0.25 -0.1227 0.25 0"
+  },
+  {
+    id: "arcDown",
+    family: "arcs",
+    path: "M 0 0 C 0 0.1227 0.0559 0.2222 0.125 0.2222 C 0.1941 0.2222 0.25 0.1227 0.25 0"
+  },
+  {
+    id: "arcRight",
+    family: "arcs",
+    path: "M 0 0 C 0.069 0 0.125 0.0995 0.125 0.2222 C 0.125 0.3449 0.069 0.4444 0 0.4444"
+  },
+  {
+    id: "arcLeft",
+    family: "arcs",
+    path: "M 0 0 C -0.069 0 -0.125 0.0995 -0.125 0.2222 C -0.125 0.3449 -0.069 0.4444 0 0.4444"
+  },
+  // -- Turns ---------------------------------------------------------------
+  { id: "turnUp", family: "turns", path: "M 0 0 L 0.25 0 L 0.25 -0.25" },
+  { id: "turnDown", family: "turns", path: "M 0 0 L 0.25 0 L 0.25 0.25" },
+  { id: "turnRight", family: "turns", path: "M 0 0 L 0 0.25 L 0.25 0.25" },
+  { id: "turnLeft", family: "turns", path: "M 0 0 L 0 0.25 L -0.25 0.25" },
+  {
+    id: "sCurve",
+    family: "turns",
+    path: "M 0 0 C 0.0833 -0.1111 0.1667 0.1111 0.25 0"
+  },
+  {
+    id: "zigzag",
+    family: "turns",
+    path: "M 0 0 L 0.0625 -0.1111 L 0.125 0 L 0.1875 -0.1111 L 0.25 0"
+  },
+  // -- Shapes --------------------------------------------------------------
+  { id: "circle", family: "shapes", path: CIRCLE },
+  { id: "square", family: "shapes", path: "M 0 0 L 0.125 0 L 0.125 -0.2222 L 0 -0.2222 Z" },
+  { id: "triangle", family: "shapes", path: "M 0 0 L 0.0625 -0.2222 L 0.125 0 Z" },
+  {
+    id: "diamond",
+    family: "shapes",
+    path: "M 0 0 L 0.0625 -0.1111 L 0.125 0 L 0.0625 0.1111 Z"
+  },
+  {
+    id: "hexagon",
+    family: "shapes",
+    path: "M 0 0 L 0.0417 -0.1111 L 0.125 -0.1111 L 0.1667 0 L 0.125 0.1111 L 0.0417 0.1111 Z"
+  },
+  // -- Loops ---------------------------------------------------------------
+  {
+    id: "loopDeLoop",
+    family: "loops",
+    path: "M 0 0 C 0.0625 0 0.0972 -0.2222 0.1667 -0.2222 C 0.2361 -0.2222 0.2708 0 0.1667 0 L 0.3333 0"
+  },
+  {
+    id: "figureEight",
+    family: "loops",
+    path: "M 0 0 C -0.0833 0 -0.0833 -0.2222 0 -0.2222 C 0.0833 -0.2222 0.0833 0 0.1667 0 C 0.25 0 0.25 -0.2222 0.1667 -0.2222 C 0.0833 -0.2222 0.0833 0 0 0"
+  },
+  {
+    id: "spiral",
+    family: "loops",
+    path: "M 0 0 C 0.0417 0 0.0417 -0.0741 0 -0.0741 C -0.0625 -0.0741 -0.0625 -0.1852 0 -0.1852 C 0.0833 -0.1852 0.0833 -0.3333 0 -0.3333"
+  }
+];
+var MOTION_PATH_FAMILIES = [
+  "lines",
+  "arcs",
+  "turns",
+  "shapes",
+  "loops"
+];
+function motionPathFamilyLabelKey(family) {
+  return `pptx.animation.motionPath.family.${family}`;
+}
+function motionPathPresetLabelKey(presetId) {
+  return `pptx.animation.motionPath.preset.${presetId}`;
+}
+function motionPathPresetById(presetId) {
+  return MOTION_PATH_PRESETS2.find((preset) => preset.id === presetId);
+}
+function motionPathPresetsByFamily(family) {
+  return MOTION_PATH_PRESETS2.filter((preset) => preset.family === family);
+}
+function motionPathPresetIdForPath(path) {
+  if (!path) {
+    return void 0;
+  }
+  const normalized = path.trim().replace(/\s+/gu, " ");
+  return MOTION_PATH_PRESETS2.find(
+    (preset) => preset.path.trim().replace(/\s+/gu, " ") === normalized
+  )?.id;
+}
+var DEFAULT_MOTION_PATH_PRESET_ID = "lineRight";
+var DEFAULT_MOTION_PATH_DURATION_MS = 2e3;
+var DEFAULT_TRIGGER2 = "onClick";
+function motionPathFor(animations, elementId) {
+  return animations.find((animation) => animation.elementId === elementId)?.motionPath;
+}
+function setMotionPath(animations, elementId, path) {
+  const index = animations.findIndex((animation) => animation.elementId === elementId);
+  if (index >= 0) {
+    return animations.map(
+      (animation, i) => i === index ? {
+        ...animation,
+        motionPath: path,
+        motionPathEditMode: animation.motionPathEditMode ?? "relative",
+        durationMs: animation.durationMs ?? DEFAULT_MOTION_PATH_DURATION_MS
+      } : animation
+    );
+  }
+  return [
+    ...animations,
+    {
+      elementId,
+      motionPath: path,
+      motionPathEditMode: "relative",
+      durationMs: DEFAULT_MOTION_PATH_DURATION_MS,
+      order: animations.length,
+      trigger: DEFAULT_TRIGGER2
+    }
+  ];
+}
+function applyMotionPathPreset(animations, elementId, presetId) {
+  const preset = motionPathPresetById(presetId);
+  if (!preset) {
+    return [...animations];
+  }
+  return setMotionPath(animations, elementId, preset.path);
+}
+function clearMotionPath(animations, elementId) {
+  const index = animations.findIndex((animation) => animation.elementId === elementId);
+  if (index < 0) {
+    return [...animations];
+  }
+  const current = animations[index];
+  const stillHasEffect = Boolean(current.entrance || current.emphasis || current.exit);
+  if (!stillHasEffect) {
+    return animations.filter((animation) => animation.elementId !== elementId).map((animation, i) => ({ ...animation, order: i }));
+  }
+  return animations.map(
+    (animation, i) => i === index ? {
+      ...animation,
+      motionPath: void 0,
+      motionPathEditMode: void 0,
+      motionPtsTypes: void 0
+    } : animation
+  );
+}
+function motionPathNativeAnimations(slide) {
+  const native = slide.nativeAnimations ?? [];
+  const alreadyNative = new Set(
+    native.filter((animation) => animation.motionPath).map((animation) => animation.targetId)
+  );
+  return (slide.animations ?? []).filter((animation) => Boolean(animation.motionPath) && !alreadyNative.has(animation.elementId)).map((animation) => ({
+    targetId: animation.elementId,
+    trigger: animation.trigger ?? DEFAULT_TRIGGER2,
+    triggerShapeId: animation.triggerShapeId,
+    presetClass: "path",
+    durationMs: animation.durationMs ?? DEFAULT_MOTION_PATH_DURATION_MS,
+    delayMs: animation.delayMs ?? 0,
+    motionPath: animation.motionPath,
+    motionPathEditMode: animation.motionPathEditMode ?? "relative"
+  }));
+}
+function buildMotionPathPreview(args) {
+  const keyframeName = `pptx-motion-preview-${args.uid ?? 0}`;
+  const keyframes = buildMotionPathKeyframes({
+    path: args.path,
+    slideWidth: args.slideWidth,
+    slideHeight: args.slideHeight,
+    keyframeName
+  });
+  if (!keyframes) {
+    return void 0;
+  }
+  const durationMs = args.durationMs ?? DEFAULT_MOTION_PATH_DURATION_MS;
+  const delayMs = args.delayMs ?? 0;
+  const easing = timingCurveToCss(args.timingCurve);
+  return {
+    keyframeName,
+    keyframesCss: keyframes.css,
+    cssAnimation: `${keyframeName} ${durationMs}ms ${easing} ${delayMs}ms 1 normal both`,
+    durationMs
+  };
+}
 function buildSegmentCounts(slide, nativeAnims) {
   const segmentCounts = /* @__PURE__ */ new Map();
   for (const anim of nativeAnims) {
@@ -94855,7 +95332,7 @@ var PresentationAnimationController = class _PresentationAnimationController {
    * id list (base element ids + text-build sub-element ids) to track.
    */
   static fromSlide(slide) {
-    const nativeAnims = slide.nativeAnimations ?? [];
+    const nativeAnims = [...slide.nativeAnimations ?? [], ...motionPathNativeAnimations(slide)];
     const segmentCounts = buildSegmentCounts(slide, nativeAnims);
     const expandedAnims = segmentCounts.size > 0 ? expandTextBuildAnimations(nativeAnims, segmentCounts) : nativeAnims;
     const engine = TimelineEngine.fromAnimations(expandedAnims);
@@ -94976,79 +95453,75 @@ var PresentationAnimationController = class _PresentationAnimationController {
     return ids;
   }
 };
-var PRESET_TO_EFFECT = {
-  fadeIn: "fadeIn",
-  flyIn: "flyInBottom",
-  zoomIn: "zoomIn",
-  fadeOut: "fadeOut",
-  flyOut: "flyOutBottom",
-  zoomOut: "zoomOut",
-  spin: "spin",
-  pulse: "pulse",
-  colorWave: "colorWave",
-  bounce: "bounce",
-  flash: "flash"
-};
-var DIRECTION_FLY_MAP = {
-  fromLeft: { flyIn: "flyInLeft", flyOut: "flyOutLeft" },
-  fromRight: { flyIn: "flyInRight", flyOut: "flyOutRight" },
-  fromTop: { flyIn: "flyInTop", flyOut: "flyOutTop" },
-  fromBottom: { flyIn: "flyInBottom", flyOut: "flyOutBottom" },
-  fromTopLeft: { flyIn: "flyInTop", flyOut: "flyOutTop" },
-  fromTopRight: { flyIn: "flyInTop", flyOut: "flyOutTop" },
-  fromBottomLeft: { flyIn: "flyInBottom", flyOut: "flyOutBottom" },
-  fromBottomRight: { flyIn: "flyInBottom", flyOut: "flyOutBottom" }
-};
-function resolvePreviewEffect(preset, direction) {
-  if ((preset === "flyIn" || preset === "flyOut") && direction) {
-    const dirMap = DIRECTION_FLY_MAP[direction];
-    if (dirMap) {
-      return preset === "flyIn" ? dirMap.flyIn : dirMap.flyOut;
-    }
-  }
-  return PRESET_TO_EFFECT[preset];
-}
-function timingCurveToCss(curve, cubicBezierValues) {
-  if (cubicBezierValues) {
-    const parts = cubicBezierValues.split(",").map((s) => s.trim());
-    if (parts.length === 4 && parts.every((p) => !Number.isNaN(Number(p)))) {
-      return `cubic-bezier(${parts.join(", ")})`;
+function applyMediaCommandVerb(el, parsed) {
+  const safePlay = () => {
+    void el.play().catch(() => {
+    });
+  };
+  const safeSeek = (seconds) => {
+    try {
+      el.currentTime = seconds;
+    } catch {
     }
-  }
-  switch (curve) {
-    case "ease":
-      return "ease";
-    case "ease-in":
-      return "ease-in";
-    case "ease-out":
-      return "ease-out";
-    case "linear":
-      return "linear";
+  };
+  switch (parsed.verb) {
+    case "playFrom":
+      safeSeek(parsed.seekSeconds ?? 0);
+      safePlay();
+      return true;
+    case "play":
+      safePlay();
+      return true;
+    case "pause":
+      el.pause();
+      return true;
+    case "stop":
+      el.pause();
+      safeSeek(0);
+      return true;
+    case "togglePlay":
+      if (el.paused) {
+        safePlay();
+      } else {
+        el.pause();
+      }
+      return true;
     default:
-      return "ease";
+      return false;
   }
 }
-function buildPreviewAnimation(preset, options) {
-  if (preset === "none") {
+function findMediaElementByElementId(targetId, root) {
+  if (typeof HTMLMediaElement === "undefined") {
     return void 0;
   }
-  const effectName = resolvePreviewEffect(preset, options?.direction);
-  if (!effectName) {
+  const scope = root ?? (typeof document === "undefined" ? null : document);
+  if (!scope) {
     return void 0;
   }
-  const keyframeName = `pptx-${effectName}`;
-  const keyframesCss = getEffectKeyframes(effectName);
-  if (!keyframesCss) {
-    return void 0;
+  for (const wrapper of scope.querySelectorAll("[data-element-id]")) {
+    if (wrapper.dataset["elementId"] !== targetId) {
+      continue;
+    }
+    if (wrapper instanceof HTMLMediaElement) {
+      return wrapper;
+    }
+    const media = wrapper.querySelector("video, audio");
+    if (media instanceof HTMLMediaElement) {
+      return media;
+    }
   }
-  const duration = options?.durationMs ?? 600;
-  const easing = timingCurveToCss(options?.timingCurve, options?.cubicBezier);
-  return {
-    keyframeName,
-    keyframesCss,
-    cssAnimation: `${keyframeName} ${duration}ms ${easing} 0ms 1 normal both`,
-    durationMs: duration
-  };
+  return void 0;
+}
+function runMediaCommand(command, resolve) {
+  const el = resolve(command.targetId);
+  if (!el) {
+    return false;
+  }
+  const parsed = parseMediaCommand(command.command);
+  if (!parsed) {
+    return false;
+  }
+  return applyMediaCommandVerb(el, parsed);
 }
 var CAMERA_PRESET_MAP = {
   orthographicFront: { rotateX: 0, rotateY: 0, rotateZ: 0 },
@@ -96511,6 +96984,110 @@ function deleteTableColumn(tableData, colIdx) {
   const newWidths = normalizeWidths(tableData.columnWidths.filter((_, i) => i !== colIdx));
   return { ...tableData, rows: newRows, columnWidths: newWidths };
 }
+function setCellText(element, rowIndex, colIndex, text2) {
+  const tableData = element.tableData;
+  if (!tableData) {
+    return element;
+  }
+  const rows = tableData.rows.map((row, ri) => {
+    if (ri !== rowIndex) {
+      return row;
+    }
+    return {
+      ...row,
+      cells: row.cells.map((cell, ci) => ci === colIndex ? { ...cell, text: text2 } : cell)
+    };
+  });
+  return { ...element, tableData: { ...tableData, rows } };
+}
+function buildTableDataGrid(element) {
+  const tableData = element.tableData;
+  const sourceRows = tableData?.rows ?? [];
+  const colCount = tableData?.columnWidths.length ?? 0;
+  const colIndices = Array.from({ length: colCount }, (_unused, index) => index);
+  const rows = sourceRows.map((row, rowIndex) => ({
+    rowIndex,
+    cells: colIndices.map((colIndex) => ({
+      rowIndex,
+      colIndex,
+      text: row.cells[colIndex]?.text ?? ""
+    }))
+  }));
+  return {
+    rowCount: sourceRows.length,
+    colCount,
+    colIndices,
+    rows,
+    canRemoveRow: sourceRows.length > 1,
+    canRemoveColumn: colCount > 1
+  };
+}
+function withTableData(element, transform) {
+  const tableData = element.tableData;
+  if (!tableData) {
+    return element;
+  }
+  const next = transform(tableData);
+  if (next === tableData) {
+    return element;
+  }
+  const updated = { ...element, tableData: next };
+  if (element.rawXml) {
+    const rawXml = rebuildTableStructureInRawXml(element, next);
+    if (rawXml) {
+      updated.rawXml = rawXml;
+    }
+  }
+  return updated;
+}
+function setTableElementCellText(element, rowIndex, colIndex, text2) {
+  const updated = setCellText(element, rowIndex, colIndex, text2);
+  if (updated === element || !element.rawXml) {
+    return updated;
+  }
+  const rawXml = updateCellTextInRawXml(element, rowIndex, colIndex, text2);
+  return rawXml ? { ...updated, rawXml } : updated;
+}
+function insertTableElementRow(element, rowIdx, position2) {
+  return withTableData(element, (data) => insertTableRow(data, rowIdx, position2));
+}
+function removeTableElementRow(element, rowIdx) {
+  return withTableData(element, (data) => deleteTableRow(data, rowIdx));
+}
+function insertTableElementColumn(element, colIdx, position2) {
+  return withTableData(element, (data) => insertTableColumn(data, colIdx, position2));
+}
+function removeTableElementColumn(element, colIdx) {
+  return withTableData(element, (data) => deleteTableColumn(data, colIdx));
+}
+function appendTableElementRow(element) {
+  const rowCount = element.tableData?.rows.length ?? 0;
+  if (rowCount === 0) {
+    return element;
+  }
+  return insertTableElementRow(element, rowCount - 1, "below");
+}
+function removeLastTableElementRow(element) {
+  const rowCount = element.tableData?.rows.length ?? 0;
+  if (rowCount === 0) {
+    return element;
+  }
+  return removeTableElementRow(element, rowCount - 1);
+}
+function appendTableElementColumn(element) {
+  const colCount = element.tableData?.columnWidths.length ?? 0;
+  if (colCount === 0) {
+    return element;
+  }
+  return insertTableElementColumn(element, colCount - 1, "right");
+}
+function removeLastTableElementColumn(element) {
+  const colCount = element.tableData?.columnWidths.length ?? 0;
+  if (colCount === 0) {
+    return element;
+  }
+  return removeTableElementColumn(element, colCount - 1);
+}
 function computeMergeCellRight(td, rowIndex, columnIndex) {
   const row = td.rows[rowIndex];
   if (!row) {
@@ -97984,14 +98561,43 @@ function computeAutoFitTextStyle(input) {
   }
   return result;
 }
+var MAX_GROUP_DEPTH2 = 64;
 function isLinkedTextBox(element) {
   return hasTextProperties(element) && element.linkedTxbxId !== void 0;
 }
+function flattenForChainResolution(elements) {
+  if (!elements.some((el) => el.type === "group")) {
+    return elements;
+  }
+  const flat = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk2 = (list, depth) => {
+    for (const el of list) {
+      if (el.type !== "group") {
+        flat.push(el);
+        continue;
+      }
+      if (seen.has(el)) {
+        continue;
+      }
+      seen.add(el);
+      flat.push(el);
+      if (depth < MAX_GROUP_DEPTH2) {
+        walk2(el.children ?? [], depth + 1);
+      }
+    }
+  };
+  walk2(elements, 0);
+  return flat;
+}
 function getOverflowSegments(element, slideElements) {
   if (!slideElements || slideElements.length === 0) {
     return void 0;
   }
-  return getLinkedTextBoxSegments(element, slideElements);
+  if (!isLinkedTextBox(element)) {
+    return void 0;
+  }
+  return getLinkedTextBoxSegments(element, flattenForChainResolution(slideElements));
 }
 function resolveParagraphRtl(paraSegments, elementRtl) {
   for (const entry2 of paraSegments) {
@@ -98771,21 +99377,6 @@ function buildTextRunFilterChain(style) {
   }
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
-function purifyFn() {
-  const purify = DOMPurify__default.default;
-  return typeof purify.sanitize === "function" ? purify.sanitize : void 0;
-}
-function sanitizeMarkupOrEmpty(markup, config) {
-  const sanitize = purifyFn();
-  return sanitize ? sanitize(markup, config) : "";
-}
-function sanitizeMathMl(markup) {
-  const sanitized = sanitizeMarkupOrEmpty(markup, { USE_PROFILES: { mathMl: true, svg: true } });
-  if (/<math(?:\s|>)/iu.test(markup) && !/<math(?:\s|>)/iu.test(sanitized) && sanitized) {
-    return `<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline">${sanitized}</math>`;
-  }
-  return sanitized;
-}
 function resolveParagraphStrutFontSize(segments, bodyFontSize) {
   let largest;
   for (const segment of segments) {
@@ -106900,6 +107491,488 @@ function mapPresentationKey(input, buffer = createPresentationKeyBuffer()) {
   }
   return { action: "none" };
 }
+var READING_VIEW_ATTR = "data-pptx-reading-view";
+var READING_VIEW_COUNTER_ATTR = "data-pptx-reading-view-counter";
+var READING_VIEW_STAGE_ATTR = "data-pptx-reading-view-stage";
+var CLOSED_READING_VIEW = { open: false, slideIndex: 0 };
+function openReadingView(slideIndex, slideCount) {
+  return { open: true, slideIndex: clampIndex(slideIndex, slideCount) };
+}
+function mapReadingViewKey(input, buffer) {
+  const mapped = mapPresentationKey(input, buffer);
+  switch (mapped.action) {
+    case "next":
+      return { command: "next" };
+    case "previous":
+      return { command: "previous" };
+    case "first":
+      return { command: "first" };
+    case "last":
+      return { command: "last" };
+    case "goto":
+      return { command: "goto", slideIndex: mapped.slideNumber - 1 };
+    case "end":
+      return { command: "exit" };
+    default:
+      return { command: "none" };
+  }
+}
+function handleReadingViewKey(input, buffer) {
+  const command = mapReadingViewKey(input, buffer);
+  if (command.command !== "none") {
+    return { command, swallow: true, preventDefault: true };
+  }
+  const isChord = Boolean(input.ctrlKey || input.metaKey || input.altKey);
+  return { command, swallow: !isChord, preventDefault: false };
+}
+function applyReadingViewCommand(state, command, slideCount) {
+  if (!state.open || slideCount <= 0) {
+    return state.open ? CLOSED_READING_VIEW : state;
+  }
+  const last = slideCount - 1;
+  switch (command.command) {
+    case "next":
+      return state.slideIndex >= last ? CLOSED_READING_VIEW : { open: true, slideIndex: state.slideIndex + 1 };
+    case "previous":
+      return { open: true, slideIndex: Math.max(0, state.slideIndex - 1) };
+    case "first":
+      return { open: true, slideIndex: 0 };
+    case "last":
+      return { open: true, slideIndex: last };
+    case "goto":
+      return { open: true, slideIndex: clampIndex(command.slideIndex, slideCount) };
+    case "exit":
+      return CLOSED_READING_VIEW;
+    default:
+      return state;
+  }
+}
+function canGoPrevious(state) {
+  return state.open && state.slideIndex > 0;
+}
+function canGoNext(state, slideCount) {
+  return state.open && slideCount > 0;
+}
+function readingViewFitScale(canvas, viewport, padding = 0) {
+  const available = {
+    width: viewport.width - padding * 2,
+    height: viewport.height - padding * 2
+  };
+  if (canvas.width <= 0 || canvas.height <= 0 || available.width <= 0 || available.height <= 0) {
+    return 0;
+  }
+  return Math.min(available.width / canvas.width, available.height / canvas.height);
+}
+function clampIndex(index, slideCount) {
+  if (!Number.isFinite(index) || slideCount <= 0) {
+    return 0;
+  }
+  return Math.min(Math.max(Math.trunc(index), 0), slideCount - 1);
+}
+var OUTLINE_VIEW_ATTR = "data-pptx-outline-view";
+var OUTLINE_ROW_ATTR = "data-pptx-outline-row";
+var OUTLINE_SLIDE_ATTR = "data-pptx-outline-slide";
+var OUTLINE_LEVEL_ATTR = "data-pptx-outline-level";
+var MAX_PARAGRAPH_LEVEL = 8;
+var TITLE_PH_TYPES = /* @__PURE__ */ new Set(["title", "ctrtitle"]);
+var CHROME_PH_TYPES = /* @__PURE__ */ new Set(["ftr", "hdr", "dt", "sldnum"]);
+var OUTLINE_TITLE_ELEMENT_NAME = "Title";
+function placeholderType(element) {
+  const ph = element.rawXml?.["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"];
+  if (!ph) {
+    return void 0;
+  }
+  const type = typeof ph["@_type"] === "string" ? ph["@_type"].trim().toLowerCase() : "";
+  return type.length > 0 ? type : "body";
+}
+function isTextBearing(element) {
+  return hasTextProperties(element);
+}
+function elementHasText(element) {
+  if (!hasTextProperties(element)) {
+    return false;
+  }
+  if (typeof element.text === "string" && element.text.trim().length > 0) {
+    return true;
+  }
+  return (element.textSegments ?? []).some((segment) => segment.text.trim().length > 0);
+}
+function resolveSlideOutlineElements(slide) {
+  const elements = (slide.elements ?? []).filter(isTextBearing);
+  const placeholderTitle = elements.find((element) => {
+    const type = placeholderType(element);
+    return type !== void 0 && TITLE_PH_TYPES.has(type);
+  });
+  const placeholderBody = elements.filter((element) => {
+    const type = placeholderType(element);
+    return type !== void 0 && !TITLE_PH_TYPES.has(type) && !CHROME_PH_TYPES.has(type);
+  });
+  if (placeholderTitle || placeholderBody.length > 0) {
+    return { title: placeholderTitle ?? null, body: placeholderBody };
+  }
+  const named = elements.find(
+    (element) => (element.name ?? "").trim().toLowerCase() === OUTLINE_TITLE_ELEMENT_NAME.toLowerCase()
+  );
+  const withText = elements.filter(elementHasText);
+  const title = named ?? withText[0] ?? null;
+  return { title, body: withText.filter((element) => element !== title) };
+}
+function isBulletMarker(segment) {
+  const bullet = segment.bulletInfo;
+  if (!bullet) {
+    return false;
+  }
+  const marker = bullet.char ? `${bullet.char} ` : bullet.imageRelId || bullet.imageDataUrl ? "\u{1F4CE} " : bullet.autoNumType ? void 0 : "\u2022 ";
+  return marker ? segment.text === marker : bullet.paragraphIndex !== void 0;
+}
+function isParagraphSeparator(segment) {
+  return Boolean(segment.isParagraphBreak) || segment.text === "\n" && !segment.isLineBreak;
+}
+function groupElementParagraphs(element) {
+  const withText = hasTextProperties(element) ? element : void 0;
+  const segments = withText?.textSegments;
+  if (!segments || segments.length === 0) {
+    const style = { ...withText?.textStyle ?? {} };
+    return (withText?.text ?? "").split("\n").map((text2) => ({
+      content: [{ text: text2, style: { ...style } }]
+    }));
+  }
+  const groups = [{ content: [] }];
+  for (const segment of segments) {
+    if (isParagraphSeparator(segment)) {
+      groups.push({ content: [] });
+      continue;
+    }
+    const current = groups[groups.length - 1];
+    if (current.content.length === 0 && current.marker === void 0 && isBulletMarker(segment)) {
+      current.marker = segment;
+      continue;
+    }
+    current.content.push(segment);
+  }
+  return groups;
+}
+function paragraphGroupText(group) {
+  return group.content.map((segment) => segment.isLineBreak ? " " : segment.text).join("");
+}
+function paragraphGroupLevel(group) {
+  const first = group.marker ?? group.content[0];
+  const level = first?.paragraphLevel;
+  return typeof level === "number" && level > 0 ? Math.min(level, MAX_PARAGRAPH_LEVEL) : 0;
+}
+function readElementParagraphs(element) {
+  const groups = groupElementParagraphs(element);
+  const paragraphs = groups.map((group) => ({
+    text: paragraphGroupText(group),
+    level: paragraphGroupLevel(group)
+  }));
+  let last = paragraphs.length - 1;
+  while (last >= 0 && paragraphs[last].text.length === 0) {
+    last -= 1;
+  }
+  return paragraphs.slice(0, last + 1);
+}
+function outlineRowKey(slideId, elementId, paragraphIndex) {
+  return `${slideId}|${elementId ?? "\0new-title"}|${paragraphIndex}`;
+}
+function pushElementRows(rows, element, kind, slide, slideIndex) {
+  for (const [paragraphIndex, paragraph] of readElementParagraphs(element).entries()) {
+    rows.push({
+      key: outlineRowKey(slide.id, element.id, paragraphIndex),
+      slideIndex,
+      slideId: slide.id,
+      kind,
+      elementId: element.id,
+      paragraphIndex,
+      // A title always sits in the leftmost column; body text is pushed one
+      // column right of it, so authored level 0 reads as outline level 1.
+      level: kind === "title" ? 0 : paragraph.level + 1,
+      text: paragraph.text
+    });
+  }
+}
+function buildOutline(slides) {
+  const rows = [];
+  for (const [slideIndex, slide] of slides.entries()) {
+    const { title, body } = resolveSlideOutlineElements(slide);
+    const before = rows.length;
+    if (title) {
+      pushElementRows(rows, title, "title", slide, slideIndex);
+    }
+    if (rows.length === before) {
+      rows.push({
+        key: outlineRowKey(slide.id, title?.id ?? null, 0),
+        slideIndex,
+        slideId: slide.id,
+        kind: "title",
+        elementId: title?.id ?? null,
+        paragraphIndex: 0,
+        level: 0,
+        text: ""
+      });
+    }
+    for (const element of body) {
+      pushElementRows(rows, element, "body", slide, slideIndex);
+    }
+  }
+  return rows;
+}
+function findOutlineRow(rows, key) {
+  return rows.find((row) => row.key === key);
+}
+var PASTE_OFFSET_PX = 20;
+function generateElementId() {
+  return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function makeCloneId(intoTemplate, sourceId) {
+  if (!intoTemplate) {
+    return generateElementId();
+  }
+  if (sourceId.startsWith("master-")) {
+    return `master-${generateElementId()}`;
+  }
+  return `layout-${generateElementId()}`;
+}
+function buildElementClipboardPayload(element, isTemplate) {
+  return { element: structuredClone(element), isTemplate };
+}
+function cloneElementForPaste(element, options = {}) {
+  const clone3 = structuredClone(element);
+  clone3.id = makeCloneId(options.intoTemplate ?? false, element.id);
+  clone3.x += options.offsetX ?? PASTE_OFFSET_PX;
+  clone3.y += options.offsetY ?? PASTE_OFFSET_PX;
+  return clone3;
+}
+function mapOutlineKey(input, rowKey) {
+  const none = { edit: null, preventDefault: false };
+  if (input.ctrlKey || input.metaKey) {
+    return none;
+  }
+  if (input.key === "Tab" && !input.altKey) {
+    return {
+      edit: { type: "indent", key: rowKey, delta: input.shiftKey ? -1 : 1 },
+      preventDefault: true
+    };
+  }
+  if (input.altKey && input.shiftKey && (input.key === "ArrowRight" || input.key === "ArrowLeft")) {
+    return {
+      edit: { type: "indent", key: rowKey, delta: input.key === "ArrowRight" ? 1 : -1 },
+      preventDefault: true
+    };
+  }
+  if (input.key === "Enter" && !input.shiftKey && !input.altKey) {
+    return { edit: { type: "insertAfter", key: rowKey }, preventDefault: true };
+  }
+  return none;
+}
+function withLevel(segments, level) {
+  return segments.map((segment, index) => {
+    if (index > 0) {
+      return segment;
+    }
+    const next = { ...segment };
+    if (level > 0) {
+      next.paragraphLevel = Math.min(level, MAX_PARAGRAPH_LEVEL);
+    } else {
+      delete next.paragraphLevel;
+    }
+    return next;
+  });
+}
+function rebuildParagraph(group, donor, text2, elementStyle) {
+  if (group && paragraphGroupText(group) === text2) {
+    return [...group.marker ? [group.marker] : [], ...group.content];
+  }
+  const source = group ?? donor;
+  const marker = source?.marker ? [source.marker] : [];
+  const content = remapTextToSegments(text2, source?.content, elementStyle);
+  return [...marker, ...content];
+}
+function writeElementParagraphs(element, paragraphs) {
+  const groups = groupElementParagraphs(element);
+  const donor = groups[groups.length - 1];
+  const style = hasTextProperties(element) ? element.textStyle : void 0;
+  const segments = [];
+  for (const [index, paragraph] of paragraphs.entries()) {
+    if (index > 0) {
+      const previous = segments[segments.length - 1];
+      segments.push({
+        text: "\n",
+        style: { ...previous?.style ?? style ?? {} },
+        isParagraphBreak: true
+      });
+    }
+    segments.push(
+      ...withLevel(rebuildParagraph(groups[index], donor, paragraph.text, style), paragraph.level)
+    );
+  }
+  return {
+    ...element,
+    text: paragraphs.map((paragraph) => paragraph.text).join("\n"),
+    textSegments: segments
+  };
+}
+var DEFAULT_CANVAS = { width: 960, height: 540 };
+function createTitleElement(text2, options) {
+  const canvas = options.canvas ?? DEFAULT_CANVAS;
+  return {
+    type: "text",
+    id: options.idGenerator ? options.idGenerator() : generateElementId(),
+    name: OUTLINE_TITLE_ELEMENT_NAME,
+    x: Math.round(canvas.width * 0.06),
+    y: Math.round(canvas.height * 0.08),
+    width: Math.round(canvas.width * 0.88),
+    height: Math.round(canvas.height * 0.17),
+    text: text2,
+    textStyle: { fontSize: 36, bold: true },
+    textSegments: [{ text: text2, style: { fontSize: 36, bold: true } }]
+  };
+}
+function renumber(slides) {
+  return slides.map((slide, index) => ({ ...slide, slideNumber: index + 1 }));
+}
+function unchanged(slides, row) {
+  return {
+    slides,
+    changed: false,
+    focusKey: row?.key ?? null,
+    activeSlideIndex: row?.slideIndex ?? 0
+  };
+}
+function replaceElement(slides, slideIndex, elementId, next) {
+  return slides.map(
+    (slide, index) => index === slideIndex ? {
+      ...slide,
+      elements: (slide.elements ?? []).map(
+        (element) => element.id === elementId ? next : element
+      )
+    } : slide
+  );
+}
+function editParagraphs(slides, row, mutate) {
+  const slide = slides[row.slideIndex];
+  const element = (slide?.elements ?? []).find((candidate) => candidate.id === row.elementId);
+  if (!element) {
+    return null;
+  }
+  const paragraphs = readElementParagraphs(element);
+  while (paragraphs.length <= row.paragraphIndex) {
+    paragraphs.push({ text: "", level: 0 });
+  }
+  const next = mutate(paragraphs);
+  if (!next) {
+    return null;
+  }
+  return {
+    slides: replaceElement(
+      slides,
+      row.slideIndex,
+      element.id,
+      writeElementParagraphs(element, next)
+    ),
+    changed: true,
+    focusKey: row.key,
+    activeSlideIndex: row.slideIndex
+  };
+}
+function oneLine(text2) {
+  return text2.replace(/[\r\n]+/g, " ");
+}
+function applySetText(slides, row, raw, options) {
+  const text2 = oneLine(raw);
+  if (row.elementId === null) {
+    if (text2.length === 0) {
+      return unchanged([...slides], row);
+    }
+    const element = createTitleElement(text2, options);
+    const next = slides.map(
+      (slide, index) => index === row.slideIndex ? { ...slide, elements: [element, ...slide.elements ?? []] } : slide
+    );
+    return {
+      slides: next,
+      changed: true,
+      focusKey: outlineRowKey(row.slideId, element.id, 0),
+      activeSlideIndex: row.slideIndex
+    };
+  }
+  const result = editParagraphs(slides, row, (paragraphs) => {
+    if (paragraphs[row.paragraphIndex].text === text2) {
+      return null;
+    }
+    const next = [...paragraphs];
+    next[row.paragraphIndex] = { ...next[row.paragraphIndex], text: text2 };
+    return next;
+  });
+  return result ?? unchanged([...slides], row);
+}
+function applyIndent(slides, row, delta) {
+  if (row.kind !== "body" || row.elementId === null || delta === 0) {
+    return unchanged([...slides], row);
+  }
+  const result = editParagraphs(slides, row, (paragraphs) => {
+    const current = paragraphs[row.paragraphIndex];
+    const level = Math.min(Math.max(current.level + (delta > 0 ? 1 : -1), 0), MAX_PARAGRAPH_LEVEL);
+    if (level === current.level) {
+      return null;
+    }
+    const next = [...paragraphs];
+    next[row.paragraphIndex] = { ...current, level };
+    return next;
+  });
+  return result ?? unchanged([...slides], row);
+}
+function applyInsertAfter(slides, row, options) {
+  if (row.kind === "title") {
+    const slide = {
+      id: makeSlideId(options.idGenerator),
+      rId: "",
+      slideNumber: row.slideIndex + 2,
+      elements: []
+    };
+    const next = renumber([
+      ...slides.slice(0, row.slideIndex + 1),
+      slide,
+      ...slides.slice(row.slideIndex + 1)
+    ]);
+    return {
+      slides: next,
+      changed: true,
+      focusKey: outlineRowKey(slide.id, null, 0),
+      activeSlideIndex: row.slideIndex + 1
+    };
+  }
+  const result = editParagraphs(slides, row, (paragraphs) => {
+    const next = [...paragraphs];
+    next.splice(row.paragraphIndex + 1, 0, {
+      text: "",
+      level: paragraphs[row.paragraphIndex].level
+    });
+    return next;
+  });
+  if (!result) {
+    return unchanged([...slides], row);
+  }
+  return {
+    ...result,
+    focusKey: outlineRowKey(row.slideId, row.elementId, row.paragraphIndex + 1)
+  };
+}
+function applyOutlineEdit(slides, edit, options = {}) {
+  const row = findOutlineRow(buildOutline(slides), edit.key);
+  if (!row) {
+    return unchanged([...slides]);
+  }
+  switch (edit.type) {
+    case "setText":
+      return applySetText(slides, row, edit.text, options);
+    case "indent":
+      return applyIndent(slides, row, edit.delta);
+    case "insertAfter":
+      return applyInsertAfter(slides, row, options);
+    default:
+      return unchanged([...slides], row);
+  }
+}
 var NUDGE_SMALL = 1;
 var NUDGE_LARGE = 10;
 var GUARD_DEFAULTS = {
@@ -108924,29 +109997,6 @@ var COMMON_FONTS = [
   "Tw Cen MT",
   "Verdana"
 ];
-var PASTE_OFFSET_PX = 20;
-function generateElementId() {
-  return `el-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function makeCloneId(intoTemplate, sourceId) {
-  if (!intoTemplate) {
-    return generateElementId();
-  }
-  if (sourceId.startsWith("master-")) {
-    return `master-${generateElementId()}`;
-  }
-  return `layout-${generateElementId()}`;
-}
-function buildElementClipboardPayload(element, isTemplate) {
-  return { element: structuredClone(element), isTemplate };
-}
-function cloneElementForPaste(element, options = {}) {
-  const clone3 = structuredClone(element);
-  clone3.id = makeCloneId(options.intoTemplate ?? false, element.id);
-  clone3.x += options.offsetX ?? PASTE_OFFSET_PX;
-  clone3.y += options.offsetY ?? PASTE_OFFSET_PX;
-  return clone3;
-}
 var DEFAULT_PREVIEW_ELEMENT_CAP = 500;
 function buildPreviewElements(slide, templateElements = [], options) {
   const cap = options?.cap ?? DEFAULT_PREVIEW_ELEMENT_CAP;
@@ -112595,6 +113645,7 @@ exports.DEFAULT_BROADCAST_SERVER_URL = DEFAULT_BROADCAST_SERVER_URL;
 exports.DEFAULT_COLOR_CHANGE_TOLERANCE = DEFAULT_COLOR_CHANGE_TOLERANCE;
 exports.DEFAULT_COLOR_MAP = DEFAULT_COLOR_MAP;
 exports.DEFAULT_INSERT_CHART_TYPE = DEFAULT_INSERT_CHART_TYPE;
+exports.DEFAULT_MOTION_PATH_PRESET_ID = DEFAULT_MOTION_PATH_PRESET_ID;
 exports.DEFAULT_QUICK_ACCESS_COMMAND_IDS = DEFAULT_QUICK_ACCESS_COMMAND_IDS;
 exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT;
 exports.DEFAULT_VIEWER_OPTIONS = DEFAULT_VIEWER_OPTIONS;
@@ -112621,11 +113672,16 @@ exports.MATERIAL_PRESETS = MATERIAL_PRESETS;
 exports.MAX_ZOOM_SCALE = MAX_ZOOM_SCALE;
 exports.MIN_ZOOM_SCALE = MIN_ZOOM_SCALE;
 exports.MOBILE_BREAKPOINT = MOBILE_BREAKPOINT;
+exports.MOTION_PATH_FAMILIES = MOTION_PATH_FAMILIES;
 exports.NOTES_FONT_SIZE_DEFAULT = NOTES_FONT_SIZE_DEFAULT;
 exports.NOTES_FONT_SIZE_MAX = NOTES_FONT_SIZE_MAX;
 exports.NOTES_FONT_SIZE_MIN = NOTES_FONT_SIZE_MIN;
 exports.NOTES_FONT_SIZE_STEP = NOTES_FONT_SIZE_STEP;
 exports.NUM = NUM;
+exports.OUTLINE_LEVEL_ATTR = OUTLINE_LEVEL_ATTR;
+exports.OUTLINE_ROW_ATTR = OUTLINE_ROW_ATTR;
+exports.OUTLINE_SLIDE_ATTR = OUTLINE_SLIDE_ATTR;
+exports.OUTLINE_VIEW_ATTR = OUTLINE_VIEW_ATTR;
 exports.PATTERN_OPTIONS = PATTERN_OPTIONS;
 exports.PRESENTATION_CHANNEL_NAME = PRESENTATION_CHANNEL_NAME;
 exports.PRESENTATION_HASH = PRESENTATION_HASH;
@@ -112637,6 +113693,9 @@ exports.PptxHandler = PptxHandler;
 exports.PptxMarkdownConverter = PptxMarkdownConverter;
 exports.PresentationAnimationController = PresentationAnimationController;
 exports.QUICK_ACCESS_COMMAND_CATALOG = QUICK_ACCESS_COMMAND_CATALOG;
+exports.READING_VIEW_ATTR = READING_VIEW_ATTR;
+exports.READING_VIEW_COUNTER_ATTR = READING_VIEW_COUNTER_ATTR;
+exports.READING_VIEW_STAGE_ATTR = READING_VIEW_STAGE_ATTR;
 exports.RULER_FONT_SIZE = RULER_FONT_SIZE;
 exports.RULER_THICKNESS = RULER_THICKNESS;
 exports.SECTION_HEADING = SECTION_HEADING;
@@ -112681,6 +113740,8 @@ exports.addSmartArtNodeAsChild = addSmartArtNodeAsChild;
 exports.addTagToCollections = addTagToCollections;
 exports.alignElements = alignElements;
 exports.appendPresentationInkPoint = appendPresentationInkPoint;
+exports.appendTableElementColumn = appendTableElementColumn;
+exports.appendTableElementRow = appendTableElementRow;
 exports.apply3dEffects = apply3dEffects;
 exports.applyAcceptAllSlides = applyAcceptAllSlides;
 exports.applyAcceptSlide = applyAcceptSlide;
@@ -112689,7 +113750,10 @@ exports.applyChartBuildReveal = applyChartBuildReveal;
 exports.applyColorChange = applyColorChange;
 exports.applyDuotone = applyDuotone;
 exports.applyFormatToElement = applyFormatToElement;
+exports.applyMotionPathPreset = applyMotionPathPreset;
+exports.applyOutlineEdit = applyOutlineEdit;
 exports.applyPreferenceToOptions = applyPreferenceToOptions;
+exports.applyReadingViewCommand = applyReadingViewCommand;
 exports.applyRehearsalTimings = applyRehearsalTimings;
 exports.applyReroutedConnectors = applyReroutedConnectors;
 exports.applyResize = applyResize;
@@ -112719,9 +113783,11 @@ exports.buildInitialGuides = buildInitialGuides;
 exports.buildInnerShadowCssFromShapeStyle = buildInnerShadowCssFromShapeStyle;
 exports.buildJoinCollaborationConfig = buildJoinCollaborationConfig;
 exports.buildMorphTransitionPlan = buildMorphTransitionPlan;
+exports.buildMotionPathPreview = buildMotionPathPreview;
 exports.buildMultiLayerShadowCss = buildMultiLayerShadowCss;
 exports.buildNotesHtml = buildNotesHtml;
 exports.buildNotesPdfBytes = buildNotesPdfBytes;
+exports.buildOutline = buildOutline;
 exports.buildOutlineHtml = buildOutlineHtml;
 exports.buildPatternFillCss = buildPatternFillCss;
 exports.buildPresentationAudienceUrl = buildPresentationAudienceUrl;
@@ -112739,6 +113805,7 @@ exports.buildSmartArtPresetData = buildSmartArtPresetData;
 exports.buildStrokeOutline = buildStrokeOutline;
 exports.buildSummaryZoomView = buildSummaryZoomView;
 exports.buildSvgGradientDef = buildSvgGradientDef;
+exports.buildTableDataGrid = buildTableDataGrid;
 exports.buildTextBlockStyle = buildTextBlockStyle;
 exports.buildTextBody3DSceneStyle = buildTextBody3DSceneStyle;
 exports.buildTextBuildSpec = buildTextBuildSpec;
@@ -112750,6 +113817,8 @@ exports.buildThemeColorGrid = buildThemeColorGrid;
 exports.buildThemeColorMap = buildThemeColorMap;
 exports.buildUserFontFaceStyles = buildUserFontFaceStyles;
 exports.canCommitActionType = canCommitActionType;
+exports.canGoNext = canGoNext;
+exports.canGoPrevious = canGoPrevious;
 exports.canvasToJpegData = canvasToJpegData;
 exports.cell3DBevelCss = cell3DBevelCss;
 exports.chartDataChangeType = chartDataChangeType;
@@ -112763,6 +113832,7 @@ exports.clampZoomScale = clampZoomScale;
 exports.clearAllLocalViewerData = clearAllLocalViewerData;
 exports.clearAudienceContent = clearAudienceContent;
 exports.clearLocalAwareness = clearLocalAwareness;
+exports.clearMotionPath = clearMotionPath;
 exports.clearStoredViewerPrefs = clearStoredViewerPrefs;
 exports.cloneElementForPaste = cloneElementForPaste;
 exports.cloneHistorySnapshot = cloneHistorySnapshot;
@@ -112773,6 +113843,8 @@ exports.collectMediaElements = collectMediaElements;
 exports.collectUsedFonts = collectUsedFonts;
 exports.colorWithOpacity = colorWithOpacity;
 exports.comparePresentation = comparePresentation;
+exports.compileEquationTemplateMathMl = compileEquationTemplateMathMl;
+exports.compileLatexEquation = compileLatexEquation;
 exports.computeAllNotesPages = computeAllNotesPages;
 exports.computeColumnBoundaries = computeColumnBoundaries;
 exports.computeEntranceAnimationDelay = computeEntranceAnimationDelay;
@@ -112839,6 +113911,7 @@ exports.extractPathPoints = extractPathPoints;
 exports.filterCommands = filterCommands;
 exports.filterRenderedElements = filterRenderedElements;
 exports.findChartPartTarget = findChartPartTarget;
+exports.findMediaElementByElementId = findMediaElementByElementId;
 exports.findSmartArtNodeText = findSmartArtNodeText;
 exports.flattenTagCollections = flattenTagCollections;
 exports.formatAxisValue = formatAxisValue;
@@ -112923,6 +113996,7 @@ exports.groupElements = groupElements;
 exports.groupIntoParagraphs = groupIntoParagraphs;
 exports.groupSlidesBySection = groupSlidesBySection;
 exports.guidePxToEmu = guidePxToEmu;
+exports.handleReadingViewKey = handleReadingViewKey;
 exports.hasCopyableFormat = hasCopyableFormat;
 exports.hasDistinctScriptFonts = hasDistinctScriptFonts;
 exports.hasPressureVariation = hasPressureVariation;
@@ -112935,6 +114009,7 @@ exports.isActionHidden = isActionHidden;
 exports.isBrowserOpenableMime = isBrowserOpenableMime;
 exports.isCalloutShape = isCalloutShape;
 exports.isCellInRect = isCellInRect;
+exports.isEditableMotionPath = isEditableMotionPath;
 exports.isEditableTextElement = isEditableTextElement;
 exports.isEditorTextInputTarget = isEditorTextInputTarget;
 exports.isElementActionable = isElementActionable;
@@ -112960,6 +114035,7 @@ exports.loadAudienceContent = loadAudienceContent;
 exports.makeCloneId = makeCloneId;
 exports.makeSlideId = makeSlideId;
 exports.mapEditorKey = mapEditorKey;
+exports.mapOutlineKey = mapOutlineKey;
 exports.mapPresentationKey = mapPresentationKey;
 exports.mayLeaveSlideShow = mayLeaveSlideShow;
 exports.mergeAdditiveSelection = mergeAdditiveSelection;
@@ -112970,6 +114046,13 @@ exports.mergeSlideTransition = mergeSlideTransition;
 exports.mobileElapsedSince = mobileElapsedSince;
 exports.mobileSlideCounter = mobileSlideCounter;
 exports.morphOptionToMode = morphOptionToMode;
+exports.motionPathEndPixel = motionPathEndPixel;
+exports.motionPathFamilyLabelKey = motionPathFamilyLabelKey;
+exports.motionPathFor = motionPathFor;
+exports.motionPathPresetIdForPath = motionPathPresetIdForPath;
+exports.motionPathPresetLabelKey = motionPathPresetLabelKey;
+exports.motionPathPresetsByFamily = motionPathPresetsByFamily;
+exports.motionPathToSvgD = motionPathToSvgD;
 exports.mountModel3D = mountModel3D;
 exports.mountSurfaceChart3D = mountSurfaceChart3D;
 exports.movePresenterPointer = movePresenterPointer;
@@ -112988,11 +114071,11 @@ exports.ooxmlDashToCssBorderStyle = ooxmlDashToCssBorderStyle;
 exports.ooxmlGradientAngleToCssDegrees = ooxmlGradientAngleToCssDegrees;
 exports.openNativeEyeDropper = openNativeEyeDropper;
 exports.openPptxFile = openPptxFile;
+exports.openReadingView = openReadingView;
 exports.openUrlInNewTab = openUrlInNewTab;
 exports.paletteColor = paletteColor;
 exports.parseDrawingColor = parseDrawingColor;
 exports.parseDrawingColorOpacity = parseDrawingColorOpacity;
-exports.parseMediaCommand = parseMediaCommand;
 exports.parsePpactionUrl = parsePpactionUrl;
 exports.pickSupportedMimeType = pickSupportedMimeType;
 exports.placeAudienceWindow = placeAudienceWindow;
@@ -113014,6 +114097,7 @@ exports.readBackstageRecentFile = readBackstageRecentFile;
 exports.readSlidesFromYDoc = readSlidesFromYDoc;
 exports.readStoredViewerPrefs = readStoredViewerPrefs;
 exports.readViewportMetrics = readViewportMetrics;
+exports.readingViewFitScale = readingViewFitScale;
 exports.rebuildDrawingShapesIfCleared = rebuildDrawingShapesIfCleared;
 exports.rebuildTableStructureInRawXml = rebuildTableStructureInRawXml;
 exports.reconcileSlidesInYDoc = reconcileSlidesInYDoc;
@@ -113023,8 +114107,12 @@ exports.registerCollaborationTeardown = registerCollaborationTeardown;
 exports.remapTextToSegments = remapTextToSegments;
 exports.removeChartCategory = removeChartCategory;
 exports.removeChartSeries = removeChartSeries;
+exports.removeLastTableElementColumn = removeLastTableElementColumn;
+exports.removeLastTableElementRow = removeLastTableElementRow;
 exports.removeQuickAccessCommand = removeQuickAccessCommand;
 exports.removeSmartArtNode = removeSmartArtNode;
+exports.removeTableElementColumn = removeTableElementColumn;
+exports.removeTableElementRow = removeTableElementRow;
 exports.renameSection = renameSection;
 exports.reorderSmartArtNode = reorderSmartArtNode;
 exports.rerouteConnectorsForMovedElements = rerouteConnectorsForMovedElements;
@@ -113057,6 +114145,7 @@ exports.resolveViewerAddinRows = resolveViewerAddinRows;
 exports.restoreSegmentSelection = restoreSegmentSelection;
 exports.revealedSmartArtNodeCount = revealedSmartArtNodeCount;
 exports.rulerDragToGuidePosition = rulerDragToGuidePosition;
+exports.runMediaCommand = runMediaCommand;
 exports.safeOpenUrl = safeOpenUrl;
 exports.sanitizeColor = sanitizeColor;
 exports.sanitizeDownloadFilename = sanitizeDownloadFilename;
@@ -113084,8 +114173,11 @@ exports.setChartDataPointMarker = setChartDataPointMarker;
 exports.setChartSeriesChartType = setChartSeriesChartType;
 exports.setChartSeriesMarker = setChartSeriesMarker;
 exports.setDuotoneCachedResult = setDuotoneCachedResult;
+exports.setMotionPath = setMotionPath;
+exports.setMotionPathEnd = setMotionPathEnd;
 exports.setPendingSelectionRestore = setPendingSelectionRestore;
 exports.setSmartArtNodeStyle = setSmartArtNodeStyle;
+exports.setTableElementCellText = setTableElementCellText;
 exports.shadeColor2 = shadeColor2;
 exports.shouldAutoFollowBroadcaster = shouldAutoFollowBroadcaster;
 exports.shouldCommitSmartArtNodeText = shouldCommitSmartArtNodeText;