pptx-react-viewer 2.16.5 → 2.16.7

package/dist/{chunk-6QGTRYSC.js → chunk-USAJMMF2.js}

@@ -30542,6 +30542,52 @@ function getPresetShapeClipPath(presetName) {
   }
   return PRESET_SHAPE_CLIP_PATHS[presetName.toLowerCase()];
 }
+function getShapeType(shapeType) {
+  if (!shapeType) {
+    return "rect";
+  }
+  const normalized = shapeType.toLowerCase();
+  if (normalized === "rect") {
+    return "rect";
+  }
+  if (normalized === "roundrect") {
+    return "roundRect";
+  }
+  if (normalized === "ellipse" || normalized === "oval") {
+    return "ellipse";
+  }
+  if (normalized === "cylinder" || normalized === "can") {
+    return "cylinder";
+  }
+  if (normalized === "triangle") {
+    return "triangle";
+  }
+  if (normalized === "diamond") {
+    return "diamond";
+  }
+  if (normalized === "line" || normalized === "lineinv") {
+    return "line";
+  }
+  if (normalized === "rtarrow" || normalized === "rightarrow") {
+    return "rtArrow";
+  }
+  if (normalized === "leftarrow") {
+    return "leftArrow";
+  }
+  if (normalized === "uparrow") {
+    return "upArrow";
+  }
+  if (normalized === "downarrow") {
+    return "downArrow";
+  }
+  if (normalized.includes("connector")) {
+    return "connector";
+  }
+  if (PRESET_SHAPE_CLIP_PATHS[normalized] !== void 0) {
+    return "rect";
+  }
+  return "rect";
+}
 function getShapeClipPath(shapeType) {
   return getPresetShapeClipPath(shapeType);
 }
@@ -100715,6 +100761,29 @@ function apply3dEffects(base, scene3d, shape3d, fillColorFallback) {
     base.backgroundImage = base.backgroundImage ? `${lightRig.backgroundImage}, ${base.backgroundImage}` : lightRig.backgroundImage;
   }
 }
+function edgesFromSection(borders, regionTop, regionBottom, regionLeft, regionRight) {
+  if (!borders) {
+    return void 0;
+  }
+  return {
+    top: regionTop ? borders.top ?? borders.insideH : borders.insideH,
+    bottom: regionBottom ? borders.bottom ?? borders.insideH : borders.insideH,
+    left: regionLeft ? borders.left ?? borders.insideV : borders.insideV,
+    right: regionRight ? borders.right ?? borders.insideV : borders.insideV
+  };
+}
+function borderToCss(border, resolve2) {
+  if (!border) {
+    return void 0;
+  }
+  if (border.noFill) {
+    return "none";
+  }
+  const width = border.width ?? 1;
+  const dash = ooxmlDashToCssBorderStyle(border.dash);
+  const color2 = border.color ?? resolve2(border.fill) ?? "#000000";
+  return `${width}px ${dash} ${color2}`;
+}
 function collectSections(entry2, tableData, pos2) {
   const { rowIndex, cellIndex, rowCount, columnCount } = pos2;
   const isTop = rowIndex === 0;
@@ -100766,6 +100835,51 @@ function collectSections(entry2, tableData, pos2) {
   }
   return sections2;
 }
+function collectLayers(entry2, tableData, pos2) {
+  const layers = [];
+  for (const section of collectSections(entry2, tableData, pos2)) {
+    layers.push(
+      edgesFromSection(
+        section.borders,
+        section.regionTop,
+        section.regionBottom,
+        section.regionLeft,
+        section.regionRight
+      )
+    );
+  }
+  return layers.filter((layer) => layer !== void 0);
+}
+function resolveCellBorderCss(entry2, tableData, pos2, resolve2) {
+  if (!entry2) {
+    return void 0;
+  }
+  const layers = collectLayers(entry2, tableData, pos2);
+  if (layers.length === 0) {
+    return void 0;
+  }
+  const pick = (edge) => {
+    let winner;
+    for (const layer of layers) {
+      if (layer[edge]) {
+        winner = layer[edge];
+      }
+    }
+    return winner;
+  };
+  const css = {};
+  let applied = false;
+  const edges = ["top", "bottom", "left", "right"];
+  for (const edge of edges) {
+    const value = borderToCss(pick(edge), resolve2);
+    if (value) {
+      const key = `border${edge[0].toUpperCase()}${edge.slice(1)}`;
+      css[key] = value;
+      applied = true;
+    }
+  }
+  return applied ? css : void 0;
+}
 function resolveStyleDiagonalBorders(entry2, tableData, pos2, resolve2) {
   if (!entry2) {
     return void 0;
@@ -100848,6 +100962,66 @@ function resolveStyleFillColor(fill, colorScheme) {
   }
   return applyTintShade(base, fill);
 }
+function clearBackground(css) {
+  delete css.background;
+  delete css.backgroundColor;
+  delete css.backgroundImage;
+}
+function gradientCssFromFill(fill, colorScheme) {
+  const gradient = fill.gradient;
+  if (!gradient || gradient.stops.length === 0) {
+    return void 0;
+  }
+  const shapeLike = {
+    fillMode: "gradient",
+    fillGradientType: gradient.type,
+    fillGradientAngle: gradient.angle ?? 90,
+    fillGradientStops: gradient.stops.map((stop) => ({
+      color: resolveStyleFillColor(stop.fill, colorScheme) ?? stop.fill.color ?? "#000000",
+      position: stop.position
+    }))
+  };
+  return buildGradientCss(shapeLike);
+}
+function applyStyleFill(fill, colorScheme, css, fallback) {
+  if (fill?.noFill) {
+    clearBackground(css);
+    css.backgroundColor = "transparent";
+    return true;
+  }
+  if (fill?.gradient) {
+    const gradientCss = gradientCssFromFill(fill, colorScheme);
+    if (gradientCss) {
+      clearBackground(css);
+      css.background = gradientCss;
+      return true;
+    }
+  }
+  if (fill?.pattern) {
+    const fg = normalizeHexColor(
+      resolveStyleFillColor(fill.pattern.foreground, colorScheme),
+      "#000000"
+    );
+    const bg = normalizeHexColor(
+      resolveStyleFillColor(fill.pattern.background, colorScheme),
+      "#ffffff"
+    );
+    const svg = getPatternSvg(fill.pattern.preset, fg, bg);
+    clearBackground(css);
+    if (svg) {
+      css.backgroundImage = `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
+    }
+    css.backgroundColor = bg;
+    return true;
+  }
+  const color2 = resolveStyleFillColor(fill, colorScheme) ?? fallback;
+  if (color2) {
+    clearBackground(css);
+    css.backgroundColor = color2;
+    return true;
+  }
+  return false;
+}
 function resolveFontRefIdx(idx, fontScheme) {
   if (!idx || !fontScheme) {
     return void 0;
@@ -100860,6 +101034,52 @@ function resolveFontRefIdx(idx, fontScheme) {
   }
   return void 0;
 }
+function applyStyleText(text2, colorScheme, css, fontScheme) {
+  if (!text2) {
+    return false;
+  }
+  let applied = false;
+  if (text2.bold) {
+    css.fontWeight = 700;
+    applied = true;
+  }
+  if (text2.italic) {
+    css.fontStyle = "italic";
+    applied = true;
+  }
+  if (text2.underline) {
+    css.textDecorationLine = "underline";
+    applied = true;
+  }
+  if (text2.fontFace) {
+    css.fontFamily = text2.fontFace;
+    applied = true;
+  } else {
+    const refFont = resolveFontRefIdx(text2.fontRefIdx, fontScheme);
+    if (refFont) {
+      css.fontFamily = refFont;
+      applied = true;
+    }
+  }
+  if (text2.fontSchemeColor && colorScheme) {
+    const base = colorScheme[text2.fontSchemeColor];
+    if (base) {
+      let color2 = base;
+      if (text2.fontTint !== void 0 && text2.fontTint > 0) {
+        color2 = tintColor(color2, text2.fontTint / 1e5);
+      }
+      if (text2.fontShade !== void 0 && text2.fontShade > 0) {
+        color2 = shadeColor(color2, 1 - text2.fontShade / 1e5);
+      }
+      css.color = color2;
+      applied = true;
+    }
+  } else if (text2.fontColor) {
+    css.color = text2.fontColor;
+    applied = true;
+  }
+  return applied;
+}
 var BEVEL_LIGHT_OFFSETS = {
   tl: { x: 1, y: 1 },
   t: { x: 0, y: 1 },
@@ -100878,6 +101098,23 @@ function cell3DBevelCss(cell3D) {
   const shadow = `inset ${-off.x * size}px ${-off.y * size}px ${size}px rgba(0,0,0,0.4)`;
   return { boxShadow: `${highlight}, ${shadow}` };
 }
+function cellPatternFillCss(style) {
+  if (style.fillMode !== "pattern" || !style.patternFillPreset) {
+    return null;
+  }
+  const fg = normalizeHexColor(style.patternFillForeground, "#000000");
+  const bg = normalizeHexColor(style.patternFillBackground, "#ffffff");
+  const svgMarkup = getPatternSvg(style.patternFillPreset, fg, bg);
+  if (svgMarkup) {
+    const encoded = encodeURIComponent(svgMarkup);
+    return {
+      backgroundImage: `url("data:image/svg+xml,${encoded}")`,
+      backgroundColor: bg
+    };
+  }
+  const fallback = style.patternFillBackground ?? style.backgroundColor;
+  return fallback ? { backgroundColor: fallback } : null;
+}
 function resolveTableStyleEntry(tableStyleId, tableStyleMap) {
   if (!tableStyleId || !tableStyleMap) {
     return void 0;
@@ -100911,6 +101148,146 @@ function ooxmlDashToCssBorderStyle(dashVal) {
       return "solid";
   }
 }
+function cellStyleToCss(style) {
+  if (!style) {
+    return {};
+  }
+  const css = {};
+  if (style.fontSize) {
+    css.fontSize = `${style.fontSize}px`;
+  }
+  if (style.bold) {
+    css.fontWeight = "bold";
+  }
+  if (style.italic) {
+    css.fontStyle = "italic";
+  }
+  if (style.underline) {
+    css.textDecorationLine = "underline";
+  }
+  if (style.color) {
+    css.color = style.color;
+  }
+  if (style.gradientFillCss) {
+    css.background = style.gradientFillCss;
+  } else if (style.fillMode === "pattern") {
+    const patternResult = cellPatternFillCss(style);
+    if (patternResult) {
+      if (patternResult.backgroundImage) {
+        css.backgroundImage = patternResult.backgroundImage;
+      }
+      if (patternResult.backgroundColor) {
+        css.backgroundColor = patternResult.backgroundColor;
+      }
+    } else {
+      const fallback = style.patternFillBackground ?? style.backgroundColor;
+      if (fallback) {
+        css.backgroundColor = fallback;
+      }
+    }
+  } else if (style.backgroundColor) {
+    css.backgroundColor = style.backgroundColor;
+  }
+  if (style.align) {
+    css.textAlign = style.align;
+  } else if (style.anchorCtr) {
+    css.textAlign = "center";
+  }
+  if (style.vAlign) {
+    css.verticalAlign = style.vAlign;
+  }
+  if (style.horzOverflow === "clip") {
+    css.overflowX = "hidden";
+  } else if (style.horzOverflow === "overflow") {
+    css.overflowX = "visible";
+  }
+  if (style.textDirection) {
+    switch (style.textDirection) {
+      case "vert":
+      case "eaVert":
+      case "wordArtVert":
+      case "wordArtVertRtl":
+        css.writingMode = "vertical-rl";
+        break;
+      case "vert270":
+      case "mongolianVert":
+        css.writingMode = "vertical-lr";
+        break;
+    }
+    if (style.textDirection === "wordArtVert") {
+      css.textOrientation = "upright";
+    } else if (css.writingMode) {
+      css.textOrientation = "mixed";
+    }
+    if (style.textDirection === "wordArtVertRtl") {
+      css.direction = "rtl";
+    }
+  }
+  const borderEdges = [
+    {
+      prefix: "borderTop",
+      width: style.borderTopWidth,
+      color: style.borderTopColor,
+      dash: style.borderTopDash
+    },
+    {
+      prefix: "borderBottom",
+      width: style.borderBottomWidth,
+      color: style.borderBottomColor,
+      dash: style.borderBottomDash
+    },
+    {
+      prefix: "borderLeft",
+      width: style.borderLeftWidth,
+      color: style.borderLeftColor,
+      dash: style.borderLeftDash
+    },
+    {
+      prefix: "borderRight",
+      width: style.borderRightWidth,
+      color: style.borderRightColor,
+      dash: style.borderRightDash
+    }
+  ];
+  for (const edge of borderEdges) {
+    if (edge.width || edge.color) {
+      const w = edge.width ?? 1;
+      const c = edge.color ?? style.borderColor ?? "#000000";
+      const s = ooxmlDashToCssBorderStyle(edge.dash);
+      css[edge.prefix] = `${w}px ${s} ${c}`;
+    }
+  }
+  if (style.marginLeft) {
+    css.paddingLeft = `${style.marginLeft}px`;
+  }
+  if (style.marginRight) {
+    css.paddingRight = `${style.marginRight}px`;
+  }
+  if (style.marginTop) {
+    css.paddingTop = `${style.marginTop}px`;
+  }
+  if (style.marginBottom) {
+    css.paddingBottom = `${style.marginBottom}px`;
+  }
+  const textShadowParts = [];
+  if (style.textShadowColor) {
+    const offX = style.textShadowOffsetX ?? 1;
+    const offY = style.textShadowOffsetY ?? 1;
+    const blur = style.textShadowBlur ?? 0;
+    textShadowParts.push(`${offX}px ${offY}px ${blur}px ${style.textShadowColor}`);
+  }
+  if (style.textGlowColor) {
+    const radius = style.textGlowRadius ?? 2;
+    textShadowParts.push(`0px 0px ${radius}px ${style.textGlowColor}`);
+  }
+  if (textShadowParts.length > 0) {
+    css.textShadow = textShadowParts.join(", ");
+  }
+  if (style.cell3D) {
+    Object.assign(css, cell3DBevelCss(style.cell3D));
+  }
+  return css;
+}
 function getDiagonalBorders(style, styleDiagonals) {
   const cellHasDown = Boolean(style?.borderDiagDownColor && style?.borderDiagDownWidth);
   const cellHasUp = Boolean(style?.borderDiagUpColor && style?.borderDiagUpWidth);
@@ -100949,6 +101326,138 @@ function getCellDiagonalBorders(style, tableData, pos2, styleCtx) {
   }
   return getDiagonalBorders(style, styleDiagonals);
 }
+function getTableCellBandStyle(tableData, rowIndex, cellIndex, rowCount, columnCount, styleCtx) {
+  if (!tableData) {
+    return void 0;
+  }
+  const styleEntry = resolveTableStyleEntry(tableData.tableStyleId, styleCtx?.tableStyleMap);
+  const colorScheme = styleCtx?.colorScheme;
+  const fontScheme = styleCtx?.fontScheme;
+  const resolveFill = (fill, fallback) => resolveStyleFillColor(fill, colorScheme) ?? fallback;
+  const style = {};
+  let applied = false;
+  if (styleEntry?.wholeTblFill) {
+    if (applyStyleFill(styleEntry.wholeTblFill, colorScheme, style, "")) {
+      applied = true;
+    }
+  }
+  if (applyStyleText(styleEntry?.wholeTblText, colorScheme, style, fontScheme)) {
+    applied = true;
+  }
+  const bandStartRow = tableData.firstRowHeader ? 1 : 0;
+  const bandEndRow = tableData.lastRow ? rowCount - 1 : rowCount;
+  if (tableData.bandedRows && rowIndex >= bandStartRow && rowIndex < bandEndRow) {
+    const bandIndex = rowIndex - bandStartRow;
+    const rowCycle = Math.max(tableData.bandRowCycle ?? 1, 1);
+    const bandGroup = Math.floor(bandIndex / rowCycle) % 2;
+    if (bandGroup === 0) {
+      applyStyleFill(styleEntry?.band1HFill, colorScheme, style, "rgba(217, 226, 243, 0.5)");
+      applyStyleText(styleEntry?.band1HText, colorScheme, style, fontScheme);
+      applied = true;
+    } else if (styleEntry?.band2HFill) {
+      if (applyStyleFill(styleEntry.band2HFill, colorScheme, style, "")) {
+        applyStyleText(styleEntry.band2HText, colorScheme, style, fontScheme);
+        applied = true;
+      }
+    }
+  }
+  if (tableData.bandedColumns) {
+    const isFirstCol = tableData.firstCol;
+    const isLastCol = tableData.lastCol;
+    const colBandIndex = isFirstCol && cellIndex > 0 ? cellIndex - 1 : cellIndex;
+    const skipCol = isFirstCol && cellIndex === 0 || isLastCol && cellIndex === columnCount - 1;
+    if (!skipCol) {
+      const colCycle = Math.max(tableData.bandColCycle ?? 1, 1);
+      const colBandGroup = Math.floor(colBandIndex / colCycle) % 2;
+      const canOverride = !style.backgroundColor || !tableData.bandedRows;
+      if (colBandGroup === 0) {
+        if (canOverride) {
+          applyStyleFill(styleEntry?.band1VFill, colorScheme, style, "rgba(217, 226, 243, 0.35)");
+          applyStyleText(styleEntry?.band1VText, colorScheme, style, fontScheme);
+          applied = true;
+        }
+      } else if (styleEntry?.band2VFill && canOverride) {
+        if (applyStyleFill(styleEntry.band2VFill, colorScheme, style, "")) {
+          applyStyleText(styleEntry.band2VText, colorScheme, style, fontScheme);
+          applied = true;
+        }
+      }
+    }
+  }
+  if (tableData.firstRowHeader && rowIndex === 0) {
+    style.fontWeight = 700;
+    applyStyleFill(styleEntry?.firstRowFill, colorScheme, style, "rgba(68, 114, 196, 0.85)");
+    if (!styleEntry?.firstRowFill?.noFill) {
+      style.color = "#ffffff";
+    }
+    applyStyleText(styleEntry?.firstRowText, colorScheme, style, fontScheme);
+    applied = true;
+  }
+  if (tableData.lastRow && rowIndex === rowCount - 1) {
+    style.fontWeight = 700;
+    if (styleEntry?.lastRowFill) {
+      applyStyleFill(styleEntry.lastRowFill, colorScheme, style, "");
+    }
+    const borderColor = resolveFill(styleEntry?.firstRowFill, "rgba(68, 114, 196, 0.7)");
+    style.borderTop = `2px solid ${borderColor}`;
+    applyStyleText(styleEntry?.lastRowText, colorScheme, style, fontScheme);
+    applied = true;
+  }
+  if (tableData.firstCol && cellIndex === 0) {
+    style.fontWeight = 700;
+    if (styleEntry?.firstColFill) {
+      applyStyleFill(styleEntry.firstColFill, colorScheme, style, "");
+    }
+    applyStyleText(styleEntry?.firstColText, colorScheme, style, fontScheme);
+    applied = true;
+  }
+  if (tableData.lastCol && cellIndex === columnCount - 1) {
+    style.fontWeight = 700;
+    if (styleEntry?.lastColFill) {
+      applyStyleFill(styleEntry.lastColFill, colorScheme, style, "");
+    }
+    applyStyleText(styleEntry?.lastColText, colorScheme, style, fontScheme);
+    applied = true;
+  }
+  if (styleEntry) {
+    const atTop = Boolean(tableData.firstRowHeader) && rowIndex === 0;
+    const atBottom = Boolean(tableData.lastRow) && rowIndex === rowCount - 1;
+    const atLeft = Boolean(tableData.firstCol) && cellIndex === 0;
+    const atRight = Boolean(tableData.lastCol) && cellIndex === columnCount - 1;
+    let cornerFill;
+    let cornerText = void 0;
+    if (atTop && atLeft) {
+      cornerFill = styleEntry.nwCellFill;
+      cornerText = styleEntry.nwCellText;
+    } else if (atTop && atRight) {
+      cornerFill = styleEntry.neCellFill;
+      cornerText = styleEntry.neCellText;
+    } else if (atBottom && atLeft) {
+      cornerFill = styleEntry.swCellFill;
+      cornerText = styleEntry.swCellText;
+    } else if (atBottom && atRight) {
+      cornerFill = styleEntry.seCellFill;
+      cornerText = styleEntry.seCellText;
+    }
+    if (cornerFill && applyStyleFill(cornerFill, colorScheme, style, "")) {
+      applied = true;
+    }
+    if (applyStyleText(cornerText, colorScheme, style, fontScheme)) {
+      applied = true;
+    }
+  }
+  const borderCss = resolveCellBorderCss(
+    styleEntry,
+    tableData,
+    { rowIndex, cellIndex, rowCount, columnCount },
+    (fill) => resolveStyleFillColor(fill, colorScheme)
+  );
+  if (borderCss) {
+    Object.assign(style, borderCss);
+    applied = true;
+  }
+  return applied ? style : void 0;
+}
 function computeBoundingRect(cells) {
   if (cells.length === 0) {
     return void 0;
@@ -106933,6 +107442,167 @@ function resolvePictureBullet(info, baseFontSize) {
     ...info.imageRelId ? { imageRelId: info.imageRelId } : {}
   };
 }
+var DEBOUNCE_MS = 600;
+var EXPANDED_MAX_HEIGHT = 200;
+var PX_TO_PT = 0.75;
+var MAX_INDENT_LEVEL = 4;
+var INDENT_PX = 24;
+function escapeHtml2(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&#39;");
+}
+function createPlainNotesSegments(text2) {
+  const lines = text2.split("\n");
+  const segments = [];
+  lines.forEach((line22, index) => {
+    segments.push({ text: line22, style: {} });
+    if (index < lines.length - 1) {
+      segments.push({ text: "", style: {}, isParagraphBreak: true });
+    }
+  });
+  if (segments.length === 0) {
+    segments.push({ text: "", style: {} });
+  }
+  return segments;
+}
+function segmentsToPlainText(segments) {
+  return segments.map((segment) => segment.isParagraphBreak ? "\n" : segment.text).join("");
+}
+function normalizeSegments(segments) {
+  const cleaned = segments.filter((segment) => segment.isParagraphBreak || segment.text.length > 0);
+  while (cleaned.length > 0 && cleaned[cleaned.length - 1].isParagraphBreak) {
+    cleaned.pop();
+  }
+  return cleaned.length > 0 ? cleaned : [{ text: "", style: {} }];
+}
+function parsePt(value) {
+  if (!value) {
+    return void 0;
+  }
+  const numeric = Number.parseFloat(value);
+  if (Number.isNaN(numeric) || !Number.isFinite(numeric)) {
+    return void 0;
+  }
+  if (value.endsWith("px")) {
+    return numeric * PX_TO_PT;
+  }
+  return numeric;
+}
+function buildParagraph(segments) {
+  const first = segments[0];
+  let bulletType = "none";
+  let indentLevel = 0;
+  if (first?.bulletInfo) {
+    if (first.bulletInfo.char) {
+      bulletType = "bullet";
+    } else if (first.bulletInfo.autoNumType) {
+      bulletType = "numbered";
+    }
+  }
+  if (first?.style.paragraphMarginLeft) {
+    indentLevel = Math.min(
+      MAX_INDENT_LEVEL,
+      Math.max(0, Math.round(first.style.paragraphMarginLeft / INDENT_PX))
+    );
+  }
+  return {
+    segments: segments.length > 0 ? segments : [{ text: "", style: {} }],
+    bulletType,
+    indentLevel
+  };
+}
+function segmentsToParagraphs(segments) {
+  const normalized = normalizeSegments(segments);
+  const paragraphs = [];
+  let current = [];
+  for (const seg of normalized) {
+    if (seg.isParagraphBreak) {
+      paragraphs.push(buildParagraph(current));
+      current = [];
+    } else {
+      current.push(seg);
+    }
+  }
+  if (current.length > 0) {
+    paragraphs.push(buildParagraph(current));
+  }
+  if (paragraphs.length === 0) {
+    paragraphs.push({
+      segments: [{ text: "", style: {} }],
+      bulletType: "none",
+      indentLevel: 0
+    });
+  }
+  return paragraphs;
+}
+function paragraphsToSegments(paragraphs) {
+  const result = [];
+  let numberedCounter = 0;
+  paragraphs.forEach((para, pIdx) => {
+    if (para.bulletType === "numbered") {
+      numberedCounter++;
+    } else {
+      numberedCounter = 0;
+    }
+    para.segments.forEach((seg, sIdx) => {
+      const updated = { ...seg, style: { ...seg.style } };
+      if (para.indentLevel > 0) {
+        updated.style.paragraphMarginLeft = para.indentLevel * INDENT_PX;
+      } else {
+        delete updated.style.paragraphMarginLeft;
+      }
+      if (sIdx === 0) {
+        if (para.bulletType === "bullet") {
+          updated.bulletInfo = { char: "\u2022" };
+        } else if (para.bulletType === "numbered") {
+          updated.bulletInfo = {
+            autoNumType: "arabicPeriod",
+            paragraphIndex: numberedCounter - 1
+          };
+        } else {
+          delete updated.bulletInfo;
+        }
+      }
+      result.push(updated);
+    });
+    if (pIdx < paragraphs.length - 1) {
+      result.push({ text: "", style: {}, isParagraphBreak: true });
+    }
+  });
+  return result;
+}
+function getCurrentParagraphIndex(editorEl, segments) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) {
+    return 0;
+  }
+  const range = sel.getRangeAt(0);
+  let charOffset = 0;
+  const walker = document.createTreeWalker(editorEl, NodeFilter.SHOW_TEXT);
+  let node = walker.nextNode();
+  while (node) {
+    if (range.startContainer === node) {
+      charOffset += range.startOffset;
+      break;
+    }
+    charOffset += (node.textContent ?? "").length;
+    node = walker.nextNode();
+  }
+  let paraIdx = 0;
+  let pos2 = 0;
+  for (const seg of segments) {
+    if (seg.isParagraphBreak) {
+      paraIdx++;
+      pos2++;
+      continue;
+    }
+    const segLen = seg.text.length;
+    if (pos2 + segLen > charOffset) {
+      return paraIdx;
+    }
+    pos2 += segLen;
+  }
+  return paraIdx;
+}
 var BLOCKED_PROTOCOLS = /* @__PURE__ */ new Set([
   `${"javascript"}:`,
   "data:",
@@ -106999,6 +107669,186 @@ function parsePpactionUrl(url) {
   }
   return { action: url, targetSlideIndex };
 }
+var CSS_VALUE_SAFE = /^[a-zA-Z0-9 _,.\-+#'%/]{1,100}$/u;
+function isCssValueSafe(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  const str = String(value);
+  return str.length > 0 && CSS_VALUE_SAFE.test(str);
+}
+function deriveStyleFromElement(element, inheritedStyle) {
+  const style = { ...inheritedStyle };
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "b" || tagName === "strong") {
+    style.bold = true;
+  }
+  if (tagName === "i" || tagName === "em") {
+    style.italic = true;
+  }
+  if (tagName === "u") {
+    style.underline = true;
+  }
+  if (tagName === "s" || tagName === "strike") {
+    style.strikethrough = true;
+  }
+  if (tagName === "a") {
+    const href = element.getAttribute("href");
+    if (href) {
+      style.hyperlink = href;
+    }
+    style.underline = true;
+    style.color = "#4a9eff";
+  }
+  const inlineStyle = element.style;
+  if (inlineStyle.fontWeight === "bold" || Number(inlineStyle.fontWeight) >= 600) {
+    style.bold = true;
+  }
+  if (inlineStyle.fontStyle === "italic") {
+    style.italic = true;
+  }
+  if (inlineStyle.textDecoration.includes("underline") || inlineStyle.textDecorationLine.includes("underline")) {
+    style.underline = true;
+  }
+  if (inlineStyle.textDecoration.includes("line-through") || inlineStyle.textDecorationLine.includes("line-through")) {
+    style.strikethrough = true;
+  }
+  if (inlineStyle.color) {
+    style.color = inlineStyle.color;
+  }
+  const fontSizePt = parsePt(inlineStyle.fontSize);
+  if (fontSizePt !== void 0) {
+    style.fontSize = fontSizePt;
+  }
+  if (inlineStyle.fontFamily) {
+    style.fontFamily = inlineStyle.fontFamily;
+  }
+  return style;
+}
+function parseSegmentsFromRichEditor(root) {
+  const segments = [];
+  const walk2 = (node, inheritedStyle) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const value = node.textContent ?? "";
+      if (value.length > 0) {
+        segments.push({ text: value, style: { ...inheritedStyle } });
+      }
+      return;
+    }
+    if (!(node instanceof HTMLElement)) {
+      return;
+    }
+    if (node.tagName.toLowerCase() === "br") {
+      segments.push({ text: "", style: {}, isParagraphBreak: true });
+      return;
+    }
+    const nextStyle = deriveStyleFromElement(node, inheritedStyle);
+    const tag = node.tagName.toLowerCase();
+    const isBlock = ["div", "p", "li"].includes(tag);
+    let bulletInfo;
+    let paraIndent = 0;
+    if (isBlock && node.dataset.bulletType) {
+      const bt = node.dataset.bulletType;
+      if (bt === "bullet") {
+        bulletInfo = { char: "\u2022" };
+      } else if (bt === "numbered") {
+        bulletInfo = { autoNumType: "arabicPeriod" };
+      }
+    }
+    if (isBlock && node.dataset.indentLevel) {
+      paraIndent = Number.parseInt(node.dataset.indentLevel, 10) || 0;
+    }
+    const segStartIdx = segments.length;
+    node.childNodes.forEach((child22) => walk2(child22, nextStyle));
+    if (isBlock && (bulletInfo || paraIndent > 0)) {
+      for (let i = segStartIdx; i < segments.length; i++) {
+        if (!segments[i].isParagraphBreak) {
+          if (bulletInfo) {
+            segments[i].bulletInfo = bulletInfo;
+          }
+          if (paraIndent > 0) {
+            segments[i].style = {
+              ...segments[i].style,
+              paragraphMarginLeft: paraIndent * INDENT_PX
+            };
+          }
+          break;
+        }
+      }
+    }
+    if (isBlock) {
+      segments.push({ text: "", style: {}, isParagraphBreak: true });
+    }
+  };
+  root.childNodes.forEach((child22) => walk2(child22, {}));
+  return normalizeSegments(segments);
+}
+function segmentsToEditorHtml(segments) {
+  const paragraphs = segmentsToParagraphs(segments);
+  let numberedCounter = 0;
+  return paragraphs.map((para) => {
+    if (para.bulletType === "numbered") {
+      numberedCounter++;
+    } else {
+      numberedCounter = 0;
+    }
+    const runsHtml = para.segments.map((segment) => {
+      if (segment.isParagraphBreak) {
+        return "";
+      }
+      const inlineStyles = [];
+      if (segment.style.bold) {
+        inlineStyles.push("font-weight:700");
+      }
+      if (segment.style.italic) {
+        inlineStyles.push("font-style:italic");
+      }
+      if (segment.style.underline) {
+        inlineStyles.push("text-decoration:underline");
+      }
+      if (segment.style.strikethrough) {
+        inlineStyles.push("text-decoration:line-through");
+      }
+      if (segment.style.color && isCssValueSafe(segment.style.color)) {
+        inlineStyles.push(`color:${segment.style.color}`);
+      }
+      if (segment.style.fontSize && Number.isFinite(Number(segment.style.fontSize))) {
+        inlineStyles.push(`font-size:${Number(segment.style.fontSize)}pt`);
+      }
+      if (segment.style.fontFamily && isCssValueSafe(segment.style.fontFamily)) {
+        inlineStyles.push(`font-family:${segment.style.fontFamily}`);
+      }
+      const text2 = escapeHtml2(segment.text);
+      if (segment.style.hyperlink && isUrlSafe(segment.style.hyperlink)) {
+        const href = escapeHtml2(segment.style.hyperlink);
+        return `<a href="${href}" style="color:#4a9eff;text-decoration:underline;cursor:pointer" data-hyperlink="${href}">${text2}</a>`;
+      }
+      const styleAttr = inlineStyles.length > 0 ? ` style="${inlineStyles.join(";")}"` : "";
+      return `<span${styleAttr}>${text2}</span>`;
+    }).join("");
+    const attrs3 = [];
+    if (para.bulletType !== "none") {
+      attrs3.push(`data-bullet-type="${para.bulletType}"`);
+    }
+    if (para.indentLevel > 0) {
+      attrs3.push(`data-indent-level="${para.indentLevel}"`);
+    }
+    const indent = para.indentLevel * INDENT_PX;
+    const divStyles = [];
+    if (indent > 0) {
+      divStyles.push(`padding-left:${indent}px`);
+    }
+    let prefix = "";
+    if (para.bulletType === "bullet") {
+      prefix = `<span style="margin-right:6px;color:#9ca3af" contenteditable="false">\u2022</span>`;
+    } else if (para.bulletType === "numbered") {
+      prefix = `<span style="margin-right:6px;color:#9ca3af" contenteditable="false">${numberedCounter}.</span>`;
+    }
+    const styleStr = divStyles.length > 0 ? ` style="${divStyles.join(";")}"` : "";
+    const attrStr = attrs3.length > 0 ? ` ${attrs3.join(" ")}` : "";
+    return `<div${attrStr}${styleStr}>${prefix}${runsHtml || "<br />"}</div>`;
+  }).join("");
+}
 var MOBILE_BREAKPOINT = 768;
 var TABLET_BREAKPOINT = 1024;
 var MOBILE_LANDSCAPE_MAX_HEIGHT = 500;
@@ -108057,6 +108907,29 @@ function resolveParagraphStrutFontSize(segments, bodyFontSize) {
   }
   return largest;
 }
+var PT_TO_PX = 96 / 72;
+function resolveParagraphSpacing(input) {
+  const { paraProps, bodyStyle, isFirst = false, isLast = false, spaceFirstLast = true } = input;
+  const out = {};
+  const before = paraProps?.paragraphSpacingBefore ?? bodyStyle?.paragraphSpacingBefore;
+  if (typeof before === "number" && before > 0 && (!isFirst || spaceFirstLast)) {
+    out.spaceBeforePx = before;
+  }
+  const after = paraProps?.paragraphSpacingAfter ?? bodyStyle?.paragraphSpacingAfter;
+  if (typeof after === "number" && after > 0 && (!isLast || spaceFirstLast)) {
+    out.spaceAfterPx = after;
+  }
+  const hasOwnLineSpacing = paraProps?.lineSpacing !== void 0 || paraProps?.lineSpacingExactPt !== void 0;
+  const lineSource = hasOwnLineSpacing ? paraProps : bodyStyle;
+  const exactPt = lineSource?.lineSpacingExactPt;
+  const multiplier = lineSource?.lineSpacing;
+  if (typeof exactPt === "number" && exactPt > 0) {
+    out.lineHeight = `${exactPt * PT_TO_PX}px`;
+  } else if (typeof multiplier === "number" && multiplier > 0) {
+    out.lineHeight = proportionalLineHeight(multiplier);
+  }
+  return out;
+}
 function parseHexColor(hex10) {
   if (!hex10 || typeof hex10 !== "string") {
     return null;
@@ -113287,6 +114160,17 @@ function fitFontSize(text2, maxWidth, maxHeight, baseSize) {
   const maxByHeight = maxHeight * 0.5;
   return Math.max(6, Math.min(baseSize, maxByWidth, maxByHeight));
 }
+function chevronPoints(x, y, w, h) {
+  const depth = Math.min(w * 0.2, h * 0.4);
+  return [
+    `${x},${y}`,
+    `${x + w - depth},${y}`,
+    `${x + w},${y + h / 2}`,
+    `${x + w - depth},${y + h}`,
+    `${x},${y + h}`,
+    `${x + depth},${y + h / 2}`
+  ].join(" ");
+}
 function strokeFor(sw) {
   return sw > 0 ? "rgba(255,255,255,0.3)" : "none";
 }
@@ -114928,6 +115812,21 @@ function computeSmartArtLayout2(nodes, box, palette, style, elementId, resolvedL
       return computeTargetLayout(flat, box, pal, style, elementId);
   }
 }
+function parseHex(hex10) {
+  let h = hex10.trim().replace(/^#/u, "");
+  if (h.length === 3) {
+    h = h.split("").map((c) => c + c).join("");
+  }
+  if (h.length !== 6 || /[^0-9a-fA-F]/u.test(h)) {
+    return [128, 128, 128];
+  }
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function contrastTextColor(fill) {
+  const [r, g, b] = parseHex(fill);
+  const lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return lum > 0.6 ? "#1a1a1a" : "#ffffff";
+}
 function parseViewBox(viewBox) {
   const parts = viewBox.trim().split(/\s+/u).map(Number);
   const width = parts[2];
@@ -115077,21 +115976,6 @@ function boundsOf(points3) {
     height: maxY - minY
   };
 }
-function parseHex(hex10) {
-  let h = hex10.trim().replace(/^#/u, "");
-  if (h.length === 3) {
-    h = h.split("").map((c) => c + c).join("");
-  }
-  if (h.length !== 6 || /[^0-9a-fA-F]/u.test(h)) {
-    return [128, 128, 128];
-  }
-  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
-}
-function contrastTextColor(fill) {
-  const [r, g, b] = parseHex(fill);
-  const lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
-  return lum > 0.6 ? "#1a1a1a" : "#ffffff";
-}
 function ringPoint(x, y) {
   const radius = Math.hypot(x, y);
   const angle = Math.atan2(x, y);
@@ -115749,6 +116633,205 @@ async function mountSurfaceChart3D(container, options) {
     }
   };
 }
+var AVERAGE_ADVANCE_RATIO = 0.5;
+function wrapTextByEstimatedWidth(text2, maxWidth, fontSize, options = {}) {
+  if (!text2 || text2.trim().length === 0) {
+    return [];
+  }
+  const charactersPerLine = Math.floor(maxWidth / Math.max(fontSize * AVERAGE_ADVANCE_RATIO, 1));
+  if (charactersPerLine <= 0) {
+    return [];
+  }
+  const lines = [];
+  for (const paragraph of text2.split(/\r?\n/u)) {
+    if (paragraph.trim().length === 0) {
+      if (options.keepBlankLines) {
+        lines.push("");
+      }
+      continue;
+    }
+    let current = "";
+    for (const word of paragraph.split(/\s+/u)) {
+      if (current.length === 0) {
+        current = word;
+      } else if (current.length + 1 + word.length <= charactersPerLine) {
+        current += ` ${word}`;
+      } else {
+        lines.push(current);
+        current = word;
+      }
+    }
+    if (current.length > 0) {
+      lines.push(current);
+    }
+  }
+  return lines;
+}
+var LINE_HEIGHT_RATIO = 1.2;
+function centeredSvgTextLines(text2, fontSize, options = {}) {
+  const lines = options.maxWidth !== void 0 ? wrapTextByEstimatedWidth(text2, options.maxWidth, fontSize) : text2.split("\n").filter((line22) => line22.length > 0);
+  const centerY = options.centerY ?? 0;
+  if (lines.length === 0) {
+    return [{ text: "", y: centerY }];
+  }
+  const lineHeight = fontSize * LINE_HEIGHT_RATIO;
+  const blockTop = centerY - lines.length * lineHeight / 2;
+  return lines.map((line22, index) => ({
+    text: line22,
+    y: blockTop + lineHeight / 2 + index * lineHeight
+  }));
+}
+var PALETTES = {
+  colorful1: ["#3b82f6", "#22c55e", "#f97316", "#eab308", "#a855f7", "#ec4899"],
+  colorful2: ["#6366f1", "#14b8a6", "#f59e0b", "#ef4444", "#8b5cf6", "#06b6d4"],
+  colorful3: ["#0ea5e9", "#84cc16", "#f43e5e", "#a855f7", "#f97316", "#10b981"],
+  monochromatic1: ["#3b82f6", "#60a5fa", "#93c5fd", "#bfdbfe", "#2563eb", "#1d4ed8"],
+  monochromatic2: ["#6366f1", "#818cf8", "#a5b4fc", "#c7d2fe", "#4f46e5", "#4338ca"]
+};
+var DEFAULT_PALETTE2 = PALETTES.colorful1;
+function paletteColour(index, palette) {
+  return palette[index % palette.length];
+}
+function resolvePalette(data) {
+  if (!data) {
+    return DEFAULT_PALETTE2;
+  }
+  const ctFills = data.colorTransform?.fillColors;
+  if (ctFills && ctFills.length > 0) {
+    return ctFills;
+  }
+  return PALETTES[data.colorScheme ?? "colorful1"] ?? DEFAULT_PALETTE2;
+}
+var TEXT_WIDTH_FRACTION = 0.82;
+function underlyingFill(shape, shapes, index) {
+  const centerX = shape.x + shape.width / 2;
+  const centerY = shape.y + shape.height / 2;
+  for (let below = index - 1; below >= 0; below--) {
+    const candidate = shapes[below];
+    if (!candidate || candidate.fillNone || !candidate.fillColor) {
+      continue;
+    }
+    if (centerX >= candidate.x && centerX <= candidate.x + candidate.width && centerY >= candidate.y && centerY <= candidate.y + candidate.height) {
+      return candidate.fillColor;
+    }
+  }
+  return void 0;
+}
+function drawingShapeLabelColor(shape, shapes, index, resolvedFill) {
+  const basis = resolvedFill === "none" || resolvedFill.startsWith("url(") ? underlyingFill(shape, shapes, index) : resolvedFill;
+  return basis ? contrastTextColor(basis) : "#1a1a1a";
+}
+function computeDrawingViewBox(shapes) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const s of shapes) {
+    if (s.x < minX) {
+      minX = s.x;
+    }
+    if (s.y < minY) {
+      minY = s.y;
+    }
+    if (s.x + s.width > maxX) {
+      maxX = s.x + s.width;
+    }
+    if (s.y + s.height > maxY) {
+      maxY = s.y + s.height;
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, width: 1, height: 1 };
+  }
+  return {
+    minX,
+    minY,
+    width: maxX - minX || 1,
+    height: maxY - minY || 1
+  };
+}
+function resolveGradient(shape, id) {
+  const stops = shape.fillGradientStops;
+  if (!stops || stops.length === 0) {
+    return void 0;
+  }
+  const mapped = stops.map((stop) => ({
+    offset: `${Math.max(0, Math.min(100, stop.position))}%`,
+    color: stop.color,
+    ...stop.opacity !== void 0 ? { opacity: stop.opacity } : {}
+  }));
+  if (shape.fillGradientType === "radial") {
+    return { id, kind: "radial", cx: "50%", cy: "50%", r: "50%", stops: mapped };
+  }
+  const radians = (shape.fillGradientAngle ?? 0) * Math.PI / 180;
+  const dx = Math.cos(radians) / 2;
+  const dy = Math.sin(radians) / 2;
+  return {
+    id,
+    kind: "linear",
+    x1: `${(0.5 - dx) * 100}%`,
+    y1: `${(0.5 - dy) * 100}%`,
+    x2: `${(0.5 + dx) * 100}%`,
+    y2: `${(0.5 + dy) * 100}%`,
+    stops: mapped
+  };
+}
+function resolveShapeKind(shape, hasImage) {
+  if (hasImage) {
+    return "image";
+  }
+  const normalized = (shape.shapeType ?? "").trim().toLowerCase();
+  if (normalized === "chevron" || normalized === "homeplate") {
+    return "polygon";
+  }
+  return getShapeType(shape.shapeType) === "ellipse" ? "ellipse" : "rect";
+}
+function projectDrawingShapes(elementId, shapes, viewBox, palette, style) {
+  const { minX, minY } = viewBox;
+  const sw = styleStroke(style);
+  return shapes.map((shape, i) => {
+    const gradient = shape.fillNone ? void 0 : resolveGradient(shape, `${elementId}-dspgrad-${shape.id}-${i}`);
+    const fill = shape.fillNone ? "none" : gradient ? `url(#${gradient.id})` : shape.fillPatternForegroundColor ?? shape.fillColor ?? paletteColour(i, palette);
+    const relX = shape.x - minX;
+    const relY = shape.y - minY;
+    const kind = resolveShapeKind(shape, Boolean(shape.fillImageUrl));
+    const rx = getShapeType(shape.shapeType) === "roundRect" ? Math.min(shape.width, shape.height) * 0.1 : 0;
+    const cx = relX + shape.width / 2;
+    const cy = relY + shape.height / 2;
+    const stroke = shape.strokeColor ?? (sw > 0 ? "rgba(255,255,255,0.3)" : "none");
+    const transform = shape.rotation !== void 0 ? `rotate(${shape.rotation} ${cx} ${cy})` : void 0;
+    const fontSize = shape.fontSize ?? Math.max(8, Math.min(14, shape.height * 0.2));
+    return {
+      key: `${elementId}-dsp-${shape.id}-${i}`,
+      kind,
+      ...kind === "polygon" ? { points: chevronPoints(relX, relY, shape.width, shape.height) } : {},
+      ...gradient ? { gradient } : {},
+      x: relX,
+      y: relY,
+      width: shape.width,
+      height: shape.height,
+      rx,
+      cx,
+      cy,
+      fill,
+      stroke,
+      strokeWidth: shape.strokeWidth ?? sw,
+      transform,
+      imageUrl: shape.fillImageUrl,
+      textLines: shape.text ? centeredSvgTextLines(shape.text, fontSize, {
+        maxWidth: shape.width * TEXT_WIDTH_FRACTION,
+        centerY: cy
+      }) : [],
+      textX: cx,
+      textY: cy,
+      fontColor: shape.fontColor ?? drawingShapeLabelColor(shape, shapes, i, fill),
+      fontSize
+    };
+  });
+}
+function styleShadowFilter(style) {
+  return styleShadow(style);
+}
 var FONT_NAME_UNSAFE_CHARS = /["\\\n\r;}<>]/u;
 var FONT_FORMAT_ALLOWED = /* @__PURE__ */ new Set(["truetype", "opentype", "woff", "woff2"]);
 var FONT_DATA_URL_PATTERN = /^data:font\/[a-z0-9+.-]+(?:;charset=[a-z0-9-]+)?;base64,[a-z0-9+/=]+$/iu;
@@ -118731,6 +119814,97 @@ var DUOTONE_PRESETS = [
     highlight: "#F5DEB3"
   }
 ];
+function findInSlides(slides, query, opts = {}) {
+  if (!query) {
+    return [];
+  }
+  const matchCase = opts.matchCase ?? false;
+  const normalised = matchCase ? query : query.toLowerCase();
+  const results = [];
+  for (let slideIndex = 0; slideIndex < slides.length; slideIndex++) {
+    const slide = slides[slideIndex];
+    for (const element of slide.elements) {
+      if (!hasTextProperties(element)) {
+        continue;
+      }
+      const segments = element.textSegments ?? [];
+      for (let segIndex = 0; segIndex < segments.length; segIndex++) {
+        const raw = segments[segIndex].text ?? "";
+        const haystack = matchCase ? raw : raw.toLowerCase();
+        let offset = 0;
+        while (offset < haystack.length) {
+          const pos2 = haystack.indexOf(normalised, offset);
+          if (pos2 === -1) {
+            break;
+          }
+          results.push({
+            slideIndex,
+            elementId: element.id,
+            segmentIndex: segIndex,
+            startOffset: pos2,
+            length: query.length
+          });
+          offset = pos2 + 1;
+        }
+      }
+    }
+  }
+  return results;
+}
+function applyFindReplacements(slides, toReplace, replacement) {
+  if (toReplace.length === 0) {
+    return { slides, replacements: 0 };
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const match of toReplace) {
+    const key = `${match.slideIndex}::${match.elementId}::${match.segmentIndex}`;
+    let bucket = grouped.get(key);
+    if (!bucket) {
+      bucket = [];
+      grouped.set(key, bucket);
+    }
+    bucket.push(match);
+  }
+  const nextSlides = slides.slice();
+  let totalReplacements = 0;
+  for (const [, matches] of grouped) {
+    const sorted = matches.slice().sort((a, b) => b.startOffset - a.startOffset);
+    for (const match of sorted) {
+      const slide = nextSlides[match.slideIndex];
+      if (!slide) {
+        continue;
+      }
+      const elIdx = slide.elements.findIndex((e) => e.id === match.elementId);
+      if (elIdx === -1) {
+        continue;
+      }
+      const element = slide.elements[elIdx];
+      if (!hasTextProperties(element)) {
+        continue;
+      }
+      const segments = element.textSegments ?? [];
+      const seg = segments[match.segmentIndex];
+      if (!seg) {
+        continue;
+      }
+      const before = seg.text.slice(0, match.startOffset);
+      const after = seg.text.slice(match.startOffset + match.length);
+      const newSegText = before + replacement + after;
+      const nextSegments = segments.slice();
+      nextSegments[match.segmentIndex] = { ...seg, text: newSegText };
+      const nextText = nextSegments.map((s) => s.text).join("");
+      const nextElements = slide.elements.slice();
+      nextElements[elIdx] = {
+        ...element,
+        text: nextText,
+        textSegments: nextSegments
+      };
+      nextSlides[match.slideIndex] = { ...slide, elements: nextElements };
+      totalReplacements++;
+    }
+  }
+  return { slides: nextSlides, replacements: totalReplacements };
+}
 function isElementHidden(element) {
   return element?.hidden === true;
 }
@@ -120422,6 +121596,24 @@ var COMMON_FONTS = [
   "Tw Cen MT",
   "Verdana"
 ];
+function partitionTemplateElements(slides) {
+  const templateElementsBySlideId = {};
+  const nextSlides = slides.map((slide) => {
+    const template = slide.elements.filter(isTemplateElement);
+    if (template.length === 0) {
+      return slide;
+    }
+    templateElementsBySlideId[slide.id] = template;
+    return { ...slide, elements: slide.elements.filter((element) => !isTemplateElement(element)) };
+  });
+  return { slides: nextSlides, templateElementsBySlideId };
+}
+function buildSaveSlides(slides, templateElementsBySlideId) {
+  return slides.map((slide) => {
+    const template = templateElementsBySlideId[slide.id];
+    return template?.length ? { ...slide, elements: [...template, ...slide.elements] } : slide;
+  });
+}
 var DEFAULT_PREVIEW_ELEMENT_CAP = 500;
 function buildPreviewElements(slide, templateElements = [], options) {
   const cap = options?.cap ?? DEFAULT_PREVIEW_ELEMENT_CAP;
@@ -122816,38 +124008,7 @@ function calculateNotesPageLayout(slideWidth, slideHeight) {
   };
 }
 function wrapNotesText(text2, maxWidth, fontSize) {
-  if (!text2 || text2.trim().length === 0) {
-    return [];
-  }
-  const avgCharWidth = fontSize * 0.5;
-  const maxCharsPerLine = Math.floor(maxWidth / avgCharWidth);
-  if (maxCharsPerLine <= 0) {
-    return [];
-  }
-  const lines = [];
-  const paragraphs = text2.split(/\r?\n/u);
-  for (const paragraph of paragraphs) {
-    if (paragraph.trim().length === 0) {
-      lines.push("");
-      continue;
-    }
-    const words = paragraph.split(/\s+/u);
-    let currentLine = "";
-    for (const word of words) {
-      if (currentLine.length === 0) {
-        currentLine = word;
-      } else if (currentLine.length + 1 + word.length <= maxCharsPerLine) {
-        currentLine += ` ${word}`;
-      } else {
-        lines.push(currentLine);
-        currentLine = word;
-      }
-    }
-    if (currentLine.length > 0) {
-      lines.push(currentLine);
-    }
-  }
-  return lines;
+  return wrapTextByEstimatedWidth(text2, maxWidth, fontSize, { keepBlankLines: true });
 }
 function calculateContinuationPageMaxLines() {
   const contentHeight = NOTES_PAGE_H - 2 * NOTES_MARGIN;
@@ -123736,14 +124897,14 @@ ${xrefPos}
 }
 var NOTE_LINE_COUNT = 8;
 var TRANSPARENT_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNgAAIAAAUAAen63NgAAAAASUVORK5CYII=";
-function escapeHtml2(value) {
+function escapeHtml22(value) {
   return value.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;").split("'").join("&#39;");
 }
 function safeDataImageSrc(src) {
   if (typeof src !== "string" || !src.startsWith("data:image/")) {
     return TRANSPARENT_PNG;
   }
-  return escapeHtml2(src);
+  return escapeHtml22(src);
 }
 function slideTitle(slide, index) {
   const fallback = `Slide ${index + 1}`;
@@ -123769,7 +124930,7 @@ function buildOutlineHtml(slideIndices, slides) {
     }
     const titleText = slideTitle(slide, idx);
     const notes = (slide.notes ?? "").trim();
-    return `<h2>${escapeHtml2(titleText)}</h2>${notes ? `<p>${escapeHtml2(notes)}</p>` : ""}`;
+    return `<h2>${escapeHtml22(titleText)}</h2>${notes ? `<p>${escapeHtml22(notes)}</p>` : ""}`;
   }).join("");
 }
 function buildSlidesHtml(slideImages, slideIndices) {
@@ -123783,7 +124944,7 @@ function buildNotesHtml(slideImages, slideIndices, slides) {
     const notes = (slides[idx]?.notes ?? "").trim();
     return `<section class="page notes-page">
   <img class="notes-slide" src="${safeDataImageSrc(img)}" alt="Slide ${idx + 1}" />
-  <div class="notes-text">${escapeHtml2(notes)}</div>
+  <div class="notes-text">${escapeHtml22(notes)}</div>
 </section>`;
   }).join("");
 }
@@ -123851,7 +125012,7 @@ function buildPrintHtmlDocument(options) {
 <html>
   <head>
     <meta charset="utf-8" />
-    <title>${escapeHtml2(title)}</title>
+    <title>${escapeHtml22(title)}</title>
     <style>
       :root { color-scheme: light; }
       * { box-sizing: border-box; }
@@ -123960,12 +125121,14 @@ exports.CHARACTER_SPACING_OPTIONS = CHARACTER_SPACING_OPTIONS;
 exports.COLOR_MAP_ALIAS_KEYS = COLOR_MAP_ALIAS_KEYS;
 exports.COMMON_FONTS = COMMON_FONTS;
 exports.CONNECTION_TIMEOUT_MS = CONNECTION_TIMEOUT_MS;
+exports.DEBOUNCE_MS = DEBOUNCE_MS;
 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_FONT_FAMILY = DEFAULT_FONT_FAMILY;
 exports.DEFAULT_INSERT_CHART_KIND = DEFAULT_INSERT_CHART_KIND;
 exports.DEFAULT_MOTION_PATH_PRESET_ID = DEFAULT_MOTION_PATH_PRESET_ID;
+exports.DEFAULT_PALETTE2 = DEFAULT_PALETTE2;
 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;
@@ -123978,6 +125141,7 @@ exports.EMPHASIS_PRESET_VALUES = EMPHASIS_PRESET_VALUES;
 exports.ENTRANCE_PRESET_VALUES = ENTRANCE_PRESET_VALUES;
 exports.EQUATION_TEMPLATES = EQUATION_TEMPLATES;
 exports.EXIT_PRESET_VALUES = EXIT_PRESET_VALUES;
+exports.EXPANDED_MAX_HEIGHT = EXPANDED_MAX_HEIGHT;
 exports.EXPORT_ASSEMBLING_PERCENT = EXPORT_ASSEMBLING_PERCENT;
 exports.EXPORT_DONE_PERCENT = EXPORT_DONE_PERCENT;
 exports.EncryptedFileError = EncryptedFileError;
@@ -123988,6 +125152,7 @@ exports.HANDOUT_OPTIONS = HANDOUT_OPTIONS;
 exports.HIDDEN_SLIDE_LABEL_KEY = HIDDEN_SLIDE_LABEL_KEY;
 exports.HIDDEN_SLIDE_SLASH_GRADIENT = HIDDEN_SLIDE_SLASH_GRADIENT;
 exports.HIGHLIGHTER_COLORS = HIGHLIGHTER_COLORS;
+exports.INDENT_PX = INDENT_PX;
 exports.INK_REPLAY_KEYFRAMES = INK_REPLAY_KEYFRAMES;
 exports.INSERT_CHART_TYPES = INSERT_CHART_TYPES;
 exports.LBL = LBL;
@@ -123998,6 +125163,7 @@ exports.LINK_TOOLTIP_LABEL_CLASS = LINK_TOOLTIP_LABEL_CLASS;
 exports.LINK_TOOLTIP_PANEL_CLASS = LINK_TOOLTIP_PANEL_CLASS;
 exports.LOCAL_SYNC_ORIGIN = LOCAL_SYNC_ORIGIN;
 exports.MATERIAL_PRESETS = MATERIAL_PRESETS;
+exports.MAX_INDENT_LEVEL = MAX_INDENT_LEVEL;
 exports.MAX_ZOOM_SCALE = MAX_ZOOM_SCALE;
 exports.MEDIA_CHROME_ATTRIBUTE = MEDIA_CHROME_ATTRIBUTE;
 exports.MIN_ZOOM_SCALE = MIN_ZOOM_SCALE;
@@ -124091,6 +125257,7 @@ exports.applyCaseTransformToSegments = applyCaseTransformToSegments;
 exports.applyChartBuildReveal = applyChartBuildReveal;
 exports.applyColorChange = applyColorChange;
 exports.applyDuotone = applyDuotone;
+exports.applyFindReplacements = applyFindReplacements;
 exports.applyFormatToElement = applyFormatToElement;
 exports.applyMotionPathPreset = applyMotionPathPreset;
 exports.applyOutlineEdit = applyOutlineEdit;
@@ -124141,6 +125308,7 @@ exports.buildPreviewElements = buildPreviewElements;
 exports.buildPrintDocument = buildPrintDocument;
 exports.buildPrintHtmlDocument = buildPrintHtmlDocument;
 exports.buildReflectionCss = buildReflectionCss;
+exports.buildSaveSlides = buildSaveSlides;
 exports.buildShadowCssFromShapeStyle = buildShadowCssFromShapeStyle;
 exports.buildSlideTemplateContent = buildSlideTemplateContent;
 exports.buildSlideTemplateSlide = buildSlideTemplateSlide;
@@ -124162,12 +125330,14 @@ exports.buildTextRunFilterChain = buildTextRunFilterChain;
 exports.buildTextShadowCss = buildTextShadowCss;
 exports.buildThemeColorGrid = buildThemeColorGrid;
 exports.buildThemeColorMap = buildThemeColorMap;
+exports.buildTree = buildTree;
 exports.buildUserFontFaceStyles = buildUserFontFaceStyles;
 exports.canCommitActionType = canCommitActionType;
 exports.canGoNext = canGoNext;
 exports.canGoPrevious = canGoPrevious;
 exports.canvasToJpegData = canvasToJpegData;
-exports.cell3DBevelCss = cell3DBevelCss;
+exports.cellStyleToCss = cellStyleToCss;
+exports.centeredSvgTextLines = centeredSvgTextLines;
 exports.chartAreaFill = chartAreaFill;
 exports.chartDataChangeType = chartDataChangeType;
 exports.chartPartToAttrs = chartPartToAttrs;
@@ -124195,6 +125365,7 @@ exports.compileEquationTemplateMathMl = compileEquationTemplateMathMl;
 exports.compileLatexEquation = compileLatexEquation;
 exports.computeAllNotesPages = computeAllNotesPages;
 exports.computeColumnBoundaries = computeColumnBoundaries;
+exports.computeDrawingViewBox = computeDrawingViewBox;
 exports.computeEntranceAnimationDelay = computeEntranceAnimationDelay;
 exports.computeHandoutLayout = computeHandoutLayout;
 exports.computeInlineEditorRect = computeInlineEditorRect;
@@ -124224,6 +125395,7 @@ exports.createCollaborationLivePatcher = createCollaborationLivePatcher;
 exports.createDefaultChartElement = createDefaultChartElement;
 exports.createDepartureChannel = createDepartureChannel;
 exports.createInitialPresentationSnapshot = createInitialPresentationSnapshot;
+exports.createPlainNotesSegments = createPlainNotesSegments;
 exports.createPresenceProjector = createPresenceProjector;
 exports.createPresentationKeyBuffer = createPresentationKeyBuffer;
 exports.createPresentationSessionId = createPresentationSessionId;
@@ -124257,15 +125429,18 @@ exports.encodeGif = encodeGif;
 exports.endAudienceDisplay = endAudienceDisplay;
 exports.ensureActionAffordanceStyles = ensureActionAffordanceStyles;
 exports.erasePresentationInkAt = erasePresentationInkAt;
+exports.escapeHtml2 = escapeHtml22;
 exports.exportDeckJson = exportDeckJson;
 exports.extraQuickAccessCommands = extraQuickAccessCommands;
 exports.extractPathPoints = extractPathPoints;
 exports.filterCommands = filterCommands;
 exports.filterRenderedElements = filterRenderedElements;
 exports.findChartPartTarget = findChartPartTarget;
+exports.findInSlides = findInSlides;
 exports.findMediaElementByElementId = findMediaElementByElementId;
 exports.findSmartArtNodeText = findSmartArtNodeText;
 exports.firstShowSlideIndex = firstShowSlideIndex;
+exports.fitFontSize = fitFontSize;
 exports.flattenTagCollections = flattenTagCollections;
 exports.forgetSessionDeck = forgetSessionDeck;
 exports.formatAxisValue = formatAxisValue;
@@ -124306,6 +125481,7 @@ exports.getComputedEffectStyle = getComputedEffectStyle;
 exports.getConnectionSites = getConnectionSites;
 exports.getContentPartReplayStyles = getContentPartReplayStyles;
 exports.getCssBorderDashStyle = getCssBorderDashStyle;
+exports.getCurrentParagraphIndex = getCurrentParagraphIndex;
 exports.getDisplayUnitLabel = getDisplayUnitLabel;
 exports.getDuotoneCachedResult = getDuotoneCachedResult;
 exports.getEffectDagFilter = getEffectDagFilter;
@@ -124345,6 +125521,7 @@ exports.getSoftEdgeFilterId = getSoftEdgeFilterId;
 exports.getSoftEdgeSvgFilter = getSoftEdgeSvgFilter;
 exports.getSubstituteFontFamily = getSubstituteFontFamily;
 exports.getSvgStrokeDasharray = getSvgStrokeDasharray;
+exports.getTableCellBandStyle = getTableCellBandStyle;
 exports.getTextAlphaOpacity = getTextAlphaOpacity;
 exports.getTextCompensationTransform = getTextCompensationTransform;
 exports.getWarpPath = getWarpPath;
@@ -124386,7 +125563,6 @@ exports.isPpactionUrl = isPpactionUrl;
 exports.isPresentationAdvanceClick = isPresentationAdvanceClick;
 exports.isPresentationSessionMessage = isPresentationSessionMessage;
 exports.isStrokeOnlyPresetElement = isStrokeOnlyPresetElement;
-exports.isTemplateElement = isTemplateElement;
 exports.isTemplateElementId = isTemplateElementId2;
 exports.isUrlSafe = isUrlSafe;
 exports.lastShowSlideIndex = lastShowSlideIndex;
@@ -124432,13 +125608,14 @@ exports.moveSlidesToSection = moveSlidesToSection;
 exports.newTableElement = newTableElement;
 exports.nextPresentedSlide = nextPresentedSlide;
 exports.nextShowSlideIndex = nextShowSlideIndex;
+exports.nodeOpacity = nodeOpacity;
 exports.normalizeColorsForCapture = normalizeColorsForCapture;
 exports.normalizeHexColor = normalizeHexColor;
+exports.normalizeSegments = normalizeSegments;
 exports.normalizeStrokeDashType = normalizeStrokeDashType;
 exports.normalizeValue = normalizeValue;
 exports.notesSegmentsToSpans = notesSegmentsToSpans;
 exports.observeYDocSlides = observeYDocSlides;
-exports.ooxmlDashToCssBorderStyle = ooxmlDashToCssBorderStyle;
 exports.ooxmlGradientAngleToCssDegrees = ooxmlGradientAngleToCssDegrees;
 exports.openNativeEyeDropper = openNativeEyeDropper;
 exports.openPptxFile = openPptxFile;
@@ -124446,10 +125623,14 @@ exports.openReadingView = openReadingView;
 exports.openUrlInNewTab = openUrlInNewTab;
 exports.paintedStrokeWidth = paintedStrokeWidth;
 exports.paletteColor = paletteColor;
+exports.paletteColour = paletteColour;
+exports.paragraphsToSegments = paragraphsToSegments;
 exports.parseDrawingColor = parseDrawingColor;
 exports.parseDrawingColorOpacity = parseDrawingColorOpacity;
 exports.parsePanoseString = parsePanoseString;
 exports.parsePpactionUrl = parsePpactionUrl;
+exports.parseSegmentsFromRichEditor = parseSegmentsFromRichEditor;
+exports.partitionTemplateElements = partitionTemplateElements;
 exports.pickSupportedMimeType = pickSupportedMimeType;
 exports.pieceLetterSpacing = pieceLetterSpacing;
 exports.placeAudienceWindow = placeAudienceWindow;
@@ -124467,8 +125648,8 @@ exports.pressuresToWidths = pressuresToWidths;
 exports.previousShowSlideIndex = previousShowSlideIndex;
 exports.printPropertiesFrameSlides = printPropertiesFrameSlides;
 exports.printPropertiesSlidesPerPage = printPropertiesSlidesPerPage;
+exports.projectDrawingShapes = projectDrawingShapes;
 exports.promoteSmartArtNode = promoteSmartArtNode;
-exports.proportionalLineHeight = proportionalLineHeight;
 exports.publishLiveGeometry = publishLiveGeometry;
 exports.publishLiveInlineText = publishLiveInlineText;
 exports.quickStyleSwatchCss = quickStyleSwatchCss;
@@ -124507,15 +125688,16 @@ exports.resolveCssTextAlign = resolveCssTextAlign;
 exports.resolveDrawingShapeNodeId = resolveDrawingShapeNodeId;
 exports.resolveElementActionAffordance = resolveElementActionAffordance;
 exports.resolveFontForScript = resolveFontForScript;
-exports.resolveFontRefIdx = resolveFontRefIdx;
 exports.resolveGroupChildFill = resolveGroupChildFill;
 exports.resolveInkColor = resolveInkColor;
 exports.resolveInkOpacity = resolveInkOpacity;
 exports.resolveInkWidth = resolveInkWidth;
 exports.resolveMetricTrackingPx = resolveMetricTrackingPx;
 exports.resolveOleType = resolveOleType;
+exports.resolvePalette = resolvePalette;
 exports.resolveParagraphAlign = resolveParagraphAlign;
 exports.resolveParagraphRtl = resolveParagraphRtl;
+exports.resolveParagraphSpacing = resolveParagraphSpacing;
 exports.resolveParagraphStrutFontSize = resolveParagraphStrutFontSize;
 exports.resolvePictureBullet = resolvePictureBullet;
 exports.resolveProfileInitial = resolveProfileInitial;
@@ -124544,6 +125726,9 @@ exports.scanAvailableFontFamilies = scanAvailableFontFamilies;
 exports.schemaLabel = schemaLabel;
 exports.segmentByScript = segmentByScript;
 exports.segmentFrameCount = segmentFrameCount;
+exports.segmentsToEditorHtml = segmentsToEditorHtml;
+exports.segmentsToParagraphs = segmentsToParagraphs;
+exports.segmentsToPlainText = segmentsToPlainText;
 exports.sendBackward = sendBackward;
 exports.sendToBack = sendToBack;
 exports.sequentialColorScale = sequentialColorScale;
@@ -124566,7 +125751,6 @@ exports.setMotionPathEnd = setMotionPathEnd;
 exports.setPendingSelectionRestore = setPendingSelectionRestore;
 exports.setSmartArtNodeStyle = setSmartArtNodeStyle;
 exports.setTableElementCellText = setTableElementCellText;
-exports.shadeColor2 = shadeColor2;
 exports.shouldAutoFollowBroadcaster = shouldAutoFollowBroadcaster;
 exports.shouldCommitSmartArtNodeText = shouldCommitSmartArtNodeText;
 exports.shouldConfirmExternalHyperlink = shouldConfirmExternalHyperlink;
@@ -124582,6 +125766,9 @@ exports.stepPresenterZoom = stepPresenterZoom;
 exports.stopAllPersistentAudio = stopAllPersistentAudio;
 exports.storeAudienceContent = storeAudienceContent;
 exports.strokeOutlineViewBox = strokeOutlineViewBox;
+exports.styleShadow = styleShadow;
+exports.styleShadowFilter = styleShadowFilter;
+exports.styleStroke = styleStroke;
 exports.substituteFieldText = substituteFieldText;
 exports.suppressesCssBorder = suppressesCssBorder;
 exports.svgGradientFillRef = svgGradientFillRef;
@@ -124596,7 +125783,6 @@ exports.textBuildSpanStyle = textBuildSpanStyle;
 exports.themeColorLabel = themeColorLabel;
 exports.themeColorSchemesEqual = themeColorSchemesEqual;
 exports.themeToCssVars = themeToCssVars;
-exports.tintColor2 = tintColor2;
 exports.toCssTextOrientation = toCssTextOrientation;
 exports.toCssVerticalDirection = toCssVerticalDirection;
 exports.toCssWritingMode = toCssWritingMode;
@@ -124605,6 +125791,9 @@ exports.toggleBlackboard = toggleBlackboard;
 exports.togglePresenterTimer = togglePresenterTimer;
 exports.toggleText3dExtrusion = toggleText3dExtrusion;
 exports.transformTextCase = transformTextCase;
+exports.treeDepth = treeDepth2;
+exports.treeWidth = treeWidth2;
+exports.truncate = truncate;
 exports.updateCellTextInRawXml = updateCellTextInRawXml;
 exports.updateCellTextStyleInRawXml = updateCellTextStyleInRawXml;
 exports.updateMergeAttrsInRawXml = updateMergeAttrsInRawXml;