ooxml-core 1.8.4 → 1.9.0

package/dist/pptx/editor/render/find-replace.mjs

@@ -1,39 +1,377 @@
-import { hasTextProperties } from 'ooxml-core/pptx';
+import { hasTextProperties, updateCellTextInRawXml, getTblFromRawXml, ensureArray, flattenCellTxBodyText, updateSmartArtNodeText, reconcileSmartArtTextParagraphs } from '../../../chunk-OB277ZGE.mjs';
+import { remapTextToSegments } from '../../../chunk-SVQZXP3F.mjs';
+import '../../../chunk-F4TB6B32.mjs';
+import '../../../chunk-3E6KBUG5.mjs';
+import '../../../chunk-3GAQLUP6.mjs';
+import '../../../chunk-LRKFBOAA.mjs';
+import '../../../chunk-VPHSMBTD.mjs';
+import '../../../chunk-BEGN4NBQ.mjs';
+import '../../../chunk-WWOVZOGU.mjs';
+
+// pptx/editor/render/chart-find-source-guards.ts
+function chartSourceReferenceCounts(slides) {
+  const counts = /* @__PURE__ */ new Map();
+  function visit(elements) {
+    for (const element of elements) {
+      if (element.type === "group") visit(element.children);
+      else if (element.type === "chart" && element.chartData?.chartPartPath) {
+        const part = element.chartData.chartPartPath;
+        counts.set(part, (counts.get(part) ?? 0) + 1);
+      }
+    }
+  }
+  for (const slide of slides) visit(slide.elements);
+  return counts;
+}
+function findMatchChartSource(slides, match) {
+  let element = slides[match.slideIndex]?.elements.find((item) => item.id === match.elementId);
+  for (const index of match.elementPath ?? []) {
+    element = element?.type === "group" ? element.children[index] : void 0;
+  }
+  return element?.type === "chart" ? element.chartData?.chartPartPath : void 0;
+}
+
+// pptx/editor/render/chart-label-editability.ts
+var LITERAL_CATEGORY_TYPES = /* @__PURE__ */ new Set([
+  "bar",
+  "line",
+  "pie",
+  "ofPie",
+  "doughnut",
+  "area",
+  "radar",
+  "bar3D",
+  "line3D",
+  "pie3D",
+  "area3D",
+  "surface"
+]);
+function chartLabelsAreEditable(element) {
+  const data = element.chartData;
+  if (!data) return false;
+  if (data.dataLabelTextEditable !== void 0) {
+    const shape = data.dataLabelSourceShape;
+    return data.dataLabelTextEditable && (!shape || shape.categoryCount === data.categories.length && shape.seriesValueCounts.length === data.series.length && shape.seriesValueCounts.every(
+      (count, index) => count === data.series[index]?.values.length
+    ));
+  }
+  return !element.rawXml && !data.chartPartPath && !data.externalData && !data.categoryLevels && !data.dateCategories && LITERAL_CATEGORY_TYPES.has(data.chartType) && data.categories.length > 0 && data.series.length > 0 && data.series.every(
+    (series) => series.values.length === data.categories.length && series.values.every(Number.isFinite)
+  );
+}
+
+// pptx/editor/render/find-text-targets.ts
+function* smartArtNodes(nodes) {
+  for (const node of nodes) {
+    yield node;
+    if (node.children) yield* smartArtNodes(node.children);
+  }
+}
+function textRuns(cell) {
+  return cell.textRuns?.length ? cell.textRuns : [{ text: cell.text }];
+}
+function* findTextTargets(element, elementId = element.id, path = [], includeChartTitles = true, includeChartData = false) {
+  const location = { elementId, ...path.length ? { elementPath: path } : {} };
+  if (element.type === "group") {
+    for (const [index, child] of element.children.entries())
+      yield* findTextTargets(
+        child,
+        elementId,
+        [...path, index],
+        includeChartTitles,
+        includeChartData
+      );
+  } else if (hasTextProperties(element)) {
+    const runs = element.textSegments?.length ? element.textSegments : element.text ? [{ text: element.text, style: element.textStyle ?? {} }] : [];
+    yield { ...location, runs };
+  } else if (element.type === "table" && element.tableData) {
+    for (const [rowIndex, row] of element.tableData.rows.entries())
+      for (const [colIndex, cell] of row.cells.entries())
+        yield { ...location, tableCell: { rowIndex, colIndex }, runs: textRuns(cell) };
+  } else if (element.type === "smartArt" && element.smartArtData) {
+    for (const node of smartArtNodes(element.smartArtData.nodes))
+      yield { ...location, smartArtNodeId: node.id, runs: [{ text: node.text }] };
+  } else if (element.type === "chart" && element.chartData) {
+    const chart = element.chartData;
+    if (includeChartTitles && chart.style?.hasTitle !== false) {
+      const runs = chart.titleRuns?.length ? chart.titleRuns : chart.title ? [{ text: chart.title }] : [];
+      yield { ...location, chartTitle: true, readOnly: chart.titleTextEditable === false, runs };
+    }
+    if (includeChartData) {
+      const readOnly = !chartLabelsAreEditable(element);
+      for (const [chartSeriesIndex, series] of chart.series.entries())
+        yield { ...location, chartSeriesIndex, readOnly, runs: [{ text: series.name }] };
+      for (const [chartCategoryIndex, text] of chart.categories.entries())
+        yield { ...location, chartCategoryIndex, readOnly, runs: [{ text }] };
+    }
+  }
+}
+function isFindBreak(run) {
+  return Boolean(run.isParagraphBreak || run.isLineBreak || run.text === "\n");
+}
+function replaceFindRuns(runs, startIndex, startOffset, length, replacement) {
+  const first = runs[startIndex];
+  if (!first || isFindBreak(first) || startOffset < 0 || startOffset >= first.text.length || length <= 0)
+    return void 0;
+  const next = [...runs];
+  let remaining = length;
+  for (let index = startIndex; index < runs.length && remaining > 0; index++) {
+    const run = runs[index];
+    if (isFindBreak(run)) return void 0;
+    const offset = index === startIndex ? startOffset : 0;
+    const removed = Math.min(remaining, run.text.length - offset);
+    next[index] = {
+      ...run,
+      text: run.text.slice(0, offset) + (index === startIndex ? replacement : "") + run.text.slice(offset + removed)
+    };
+    remaining -= removed;
+  }
+  return remaining === 0 ? next : void 0;
+}
+function* findSlideTextTargets(slide, includeNotes = false, includeChartTitles = true, includeChartData = false) {
+  for (const element of slide.elements)
+    yield* findTextTargets(element, element.id, [], includeChartTitles, includeChartData);
+  if (includeNotes && slide.notes) {
+    const runs = slide.notesSegments?.length && slide.notesSegments.map((run) => run.text).join("") === slide.notes ? slide.notesSegments : [{ text: slide.notes, style: {} }];
+    yield { elementId: "", notes: true, runs };
+  }
+}
+
+// pptx/editor/render/find-replace-target.ts
+function patchTableXml(element, rowIndex, colIndex, original, runs) {
+  if (!element.rawXml) return void 0;
+  const rawXml = structuredClone(element.rawXml);
+  const table = getTblFromRawXml(rawXml);
+  const row = ensureArray(table?.["a:tr"])[rowIndex];
+  const cell = ensureArray(row?.["a:tc"])[colIndex];
+  const paragraphs = ensureArray(
+    cell?.["a:txBody"]?.["a:p"]
+  );
+  let paragraphIndex = 0, runIndex = 0, fieldIndex = 0;
+  for (let index = 0; index < original.length; index++) {
+    const previous = original[index];
+    if (previous.isParagraphBreak) {
+      paragraphIndex++;
+      runIndex = 0;
+      fieldIndex = 0;
+      continue;
+    }
+    if (previous.isLineBreak) continue;
+    const paragraph = paragraphs[paragraphIndex];
+    const key = previous.isField ? "a:fld" : "a:r";
+    const xmlRun = ensureArray(paragraph?.[key])[previous.isField ? fieldIndex++ : runIndex++];
+    if (!xmlRun) return void 0;
+    if (previous.text !== runs[index].text) xmlRun["a:t"] = runs[index].text;
+  }
+  return rawXml;
+}
+function updateNode(nodes, nodeId, text) {
+  return nodes.map((node) => {
+    if (node.id === nodeId) {
+      const originalParagraphs = node.paragraphs ?? (node.runs?.length ? [{ items: node.runs.map((run) => ({ kind: "run", run })) }] : void 0);
+      const paragraphs = originalParagraphs ? reconcileSmartArtTextParagraphs(originalParagraphs, text) : void 0;
+      return { ...node, text, ...paragraphs ? { paragraphs } : {} };
+    }
+    if (!node.children) return node;
+    const children = updateNode(node.children, nodeId, text);
+    return children.every((child, index) => child === node.children[index]) ? node : { ...node, children };
+  });
+}
+function replaceLeaf(element, match, replacement) {
+  if ((match.chartSeriesIndex !== void 0 || match.chartCategoryIndex !== void 0) && element.type === "chart" && element.chartData) {
+    const data = element.chartData;
+    if (!chartLabelsAreEditable(element))
+      throw new Error("Chart labels require editing in PowerPoint or their source workbook");
+    const text = match.chartSeriesIndex !== void 0 ? data.series[match.chartSeriesIndex]?.name : data.categories[match.chartCategoryIndex];
+    if (text === void 0) return element;
+    const next = replaceFindRuns(
+      [{ text }],
+      match.segmentIndex,
+      match.startOffset,
+      match.length,
+      replacement
+    );
+    if (!next) return element;
+    return {
+      ...element,
+      chartData: {
+        ...data,
+        dataLabelTextOnly: true,
+        ...match.chartSeriesIndex !== void 0 ? {
+          series: data.series.map(
+            (series, index) => index === match.chartSeriesIndex ? { ...series, name: next[0].text } : series
+          )
+        } : {
+          categories: data.categories.map(
+            (category, index) => index === match.chartCategoryIndex ? next[0].text : category
+          )
+        }
+      }
+    };
+  }
+  if (match.chartTitle && element.type === "chart" && element.chartData) {
+    const data = element.chartData;
+    if (data.titleTextEditable === false)
+      throw new Error("This chart title requires editing in PowerPoint or its source workbook");
+    const runs = data.titleRuns?.length ? data.titleRuns : [{ text: data.title ?? "" }];
+    const next = replaceFindRuns(
+      runs,
+      match.segmentIndex,
+      match.startOffset,
+      match.length,
+      replacement
+    );
+    if (!next) return element;
+    return {
+      ...element,
+      chartData: {
+        ...data,
+        title: next[0]?.text ?? "",
+        titleRuns: next,
+        titleTextOnly: true,
+        titleTextOnlyStyles: data.titleTextOnlyStyles ?? runs.map(({ text: _text, ...style }) => style),
+        style: { ...data.style, hasTitle: next.some((run) => run.text.length > 0) }
+      }
+    };
+  }
+  if (match.tableCell && element.type === "table" && element.tableData) {
+    const { rowIndex, colIndex } = match.tableCell;
+    const row = element.tableData.rows[rowIndex], cell = row?.cells[colIndex];
+    if (!cell) return element;
+    const original2 = cell.textRuns?.length ? cell.textRuns : [{ text: cell.text }];
+    const runs = replaceFindRuns(
+      original2,
+      match.segmentIndex,
+      match.startOffset,
+      match.length,
+      replacement
+    );
+    if (!runs) return element;
+    let text = runs.map((run) => run.isParagraphBreak ? "\n" : run.isLineBreak ? "" : run.text).join("");
+    let rawXml = cell.textRuns?.length ? patchTableXml(element, rowIndex, colIndex, original2, runs) : updateCellTextInRawXml(element, rowIndex, colIndex, text);
+    if (rawXml) {
+      const table = getTblFromRawXml(rawXml);
+      const xmlRow = ensureArray(table?.["a:tr"])[rowIndex];
+      const xmlCell = ensureArray(xmlRow?.["a:tc"])[colIndex];
+      text = flattenCellTxBodyText(
+        xmlCell?.["a:txBody"],
+        (value) => ensureArray(value)
+      );
+    }
+    const rows = [...element.tableData.rows], cells = [...row.cells];
+    cells[colIndex] = { ...cell, text, ...cell.textRuns ? { textRuns: runs } : {} };
+    rows[rowIndex] = { ...row, cells };
+    return { ...element, tableData: { ...element.tableData, rows }, ...rawXml ? { rawXml } : {} };
+  }
+  if (match.smartArtNodeId && element.type === "smartArt" && element.smartArtData) {
+    const data = element.smartArtData;
+    const nodes = [...smartArtNodes(data.nodes)], node = nodes.find((candidate) => candidate.id === match.smartArtNodeId);
+    if (!node || match.startOffset < 0 || match.startOffset + match.length > node.text.length)
+      return element;
+    const text = node.text.slice(0, match.startOffset) + replacement + node.text.slice(match.startOffset + match.length);
+    const next = updateSmartArtNodeText({ ...data, nodes }, node.id, text);
+    const drawingShapes = next.drawingShapes?.map((shape, index) => {
+      if (shape === data.drawingShapes?.[index] || !shape.textSegments) return shape;
+      return {
+        ...shape,
+        textSegments: remapTextToSegments(text, shape.textSegments, { fontSize: shape.fontSize })
+      };
+    });
+    return {
+      ...element,
+      smartArtData: { ...next, drawingShapes, nodes: updateNode(data.nodes, node.id, text) }
+    };
+  }
+  if (!hasTextProperties(element)) return element;
+  const original = element.textSegments?.length ? element.textSegments : element.text ? [{ text: element.text, style: element.textStyle ?? {} }] : [];
+  const segments = replaceFindRuns(
+    original,
+    match.segmentIndex,
+    match.startOffset,
+    match.length,
+    replacement
+  );
+  if (!segments) return element;
+  return {
+    ...element,
+    textSegments: segments,
+    text: segments.map((run) => isFindBreak(run) ? "\n" : run.text).join("")
+  };
+}
+function replaceFindTarget(element, match, replacement, path = match.elementPath ?? []) {
+  if (!path.length) return replaceLeaf(element, match, replacement);
+  if (element.type !== "group") return element;
+  const index = path[0], child = element.children[index];
+  if (!child) return element;
+  const next = replaceFindTarget(child, match, replacement, path.slice(1));
+  if (next === child) return element;
+  const children = [...element.children];
+  children[index] = next;
+  return { ...element, children };
+}
 
 // pptx/editor/render/find-replace.ts
+function findReplacementAvailability(matches, index) {
+  const hasReadOnly = matches.some((match) => match.readOnly);
+  return {
+    current: Boolean(matches[index] && !matches[index].readOnly),
+    all: matches.length > 0 && !hasReadOnly,
+    hasReadOnly
+  };
+}
 function findInSlides(slides, query, opts = {}) {
   if (!query) {
     return [];
   }
-  const matchCase = opts.matchCase ?? false;
-  const normalised = matchCase ? query : query.toLowerCase();
+  const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(?=(${escaped}))`, opts.matchCase ? "gu" : "giu");
   const results = [];
+  const chartSources = chartSourceReferenceCounts(slides);
   for (let slideIndex = 0; slideIndex < slides.length; slideIndex++) {
     const slide = slides[slideIndex];
-    for (const element of slide.elements) {
-      if (!hasTextProperties(element)) {
-        continue;
+    for (const { runs, ...target } of findSlideTextTargets(
+      slide,
+      opts.includeNotes,
+      opts.includeChartTitles,
+      opts.includeChartData
+    )) {
+      if (target.chartTitle || target.chartSeriesIndex !== void 0 || target.chartCategoryIndex !== void 0) {
+        const source = findMatchChartSource(slides, { ...target, slideIndex });
+        if (source && (chartSources.get(source) ?? 0) > 1) target.readOnly = true;
       }
-      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 pos = haystack.indexOf(normalised, offset);
-          if (pos === -1) {
-            break;
-          }
-          results.push({
-            slideIndex,
-            elementId: element.id,
-            segmentIndex: segIndex,
-            startOffset: pos,
-            length: query.length
-          });
-          offset = pos + 1;
+      let text = "", totalOffset = 0, regionOffset = 0;
+      let positions = [];
+      const flush = () => {
+        for (const match of text.matchAll(pattern)) {
+          const pos = match.index;
+          const run = positions.find(
+            (position) => pos >= position.offset && pos < position.offset + position.length
+          );
+          if (run)
+            results.push({
+              ...target,
+              slideIndex,
+              segmentIndex: run.index,
+              startOffset: pos - run.offset,
+              length: match[1].length,
+              textOffset: regionOffset + pos
+            });
         }
+        text = "";
+        positions = [];
+      };
+      for (const [index, run] of runs.entries()) {
+        if (isFindBreak(run)) {
+          flush();
+          totalOffset++;
+          regionOffset = totalOffset;
+          continue;
+        }
+        positions.push({ index, offset: text.length, length: run.text.length });
+        text += run.text;
+        totalOffset += run.text.length;
       }
+      flush();
     }
   }
   return results;
@@ -42,9 +380,33 @@ function applyFindReplacements(slides, toReplace, replacement) {
   if (toReplace.length === 0) {
     return { slides, replacements: 0 };
   }
+  if (toReplace.some((match) => match.readOnly))
+    throw new Error(
+      "Linked or complex chart text must be edited in PowerPoint or their source workbook"
+    );
+  const chartSources = chartSourceReferenceCounts(slides);
+  if (toReplace.some((match) => {
+    if (!match.chartTitle && match.chartSeriesIndex === void 0 && match.chartCategoryIndex === void 0)
+      return false;
+    const source = findMatchChartSource(slides, match);
+    return source && (chartSources.get(source) ?? 0) > 1;
+  }))
+    throw new Error(
+      "Text in a shared chart part requires editing in PowerPoint or its source workbook"
+    );
   const grouped = /* @__PURE__ */ new Map();
   for (const match of toReplace) {
-    const key = `${match.slideIndex}::${match.elementId}::${match.segmentIndex}`;
+    const key = JSON.stringify([
+      match.slideIndex,
+      match.elementId,
+      match.elementPath,
+      match.tableCell,
+      match.smartArtNodeId,
+      match.notes,
+      match.chartTitle,
+      match.chartSeriesIndex,
+      match.chartCategoryIndex
+    ]);
     let bucket = grouped.get(key);
     if (!bucket) {
       bucket = [];
@@ -55,37 +417,45 @@ function applyFindReplacements(slides, toReplace, replacement) {
   const nextSlides = slides.slice();
   let totalReplacements = 0;
   for (const [, matches] of grouped) {
-    const sorted = matches.slice().sort((a, b) => b.startOffset - a.startOffset);
+    const sorted = matches.slice().sort((a, b) => b.segmentIndex - a.segmentIndex || b.startOffset - a.startOffset);
+    let lastOffset = Infinity;
     for (const match of sorted) {
       const slide = nextSlides[match.slideIndex];
       if (!slide) {
         continue;
       }
+      if (match.notes) {
+        if (match.textOffset !== void 0 && match.textOffset + match.length > lastOffset)
+          continue;
+        const runs = slide.notesSegments?.length && slide.notesSegments.map((run) => run.text).join("") === slide.notes ? slide.notesSegments : [{ text: slide.notes ?? "", style: {} }];
+        const updated2 = replaceFindRuns(
+          runs,
+          match.segmentIndex,
+          match.startOffset,
+          match.length,
+          replacement
+        );
+        if (!updated2) continue;
+        nextSlides[match.slideIndex] = {
+          ...slide,
+          notes: updated2.map((run) => run.text).join(""),
+          notesSegments: updated2
+        };
+        if (match.textOffset !== void 0) lastOffset = match.textOffset;
+        totalReplacements++;
+        continue;
+      }
       const elIdx = slide.elements.findIndex((e) => e.id === match.elementId);
       if (elIdx === -1) {
         continue;
       }
+      if (match.textOffset !== void 0 && match.textOffset + match.length > lastOffset) 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 updated = replaceFindTarget(element, match, replacement);
+      if (updated === element) continue;
+      if (match.textOffset !== void 0) lastOffset = match.textOffset;
       const nextElements = slide.elements.slice();
-      nextElements[elIdx] = {
-        ...element,
-        text: nextText,
-        textSegments: nextSegments
-      };
+      nextElements[elIdx] = updated;
       nextSlides[match.slideIndex] = { ...slide, elements: nextElements };
       totalReplacements++;
     }
@@ -104,4 +474,4 @@ function replaceInSlides(slides, query, replacement, opts = {}) {
   return applyFindReplacements(slides, results, replacement);
 }
 
-export { applyFindReplacements, findInSlides, replaceInSlides, replaceMatch };
+export { applyFindReplacements, findInSlides, findReplacementAvailability, replaceInSlides, replaceMatch };

package/dist/pptx/editor/render/slide-operations.cjs

@@ -1,6 +1,88 @@
 'use strict';
 
+require('../../../chunk-SWF7KVL5.cjs');
+var chunkAT66SA5M_cjs = require('../../../chunk-AT66SA5M.cjs');
+
+// pptx/core/builders/sdk/slide-operations.ts
+var cloneIdCounter = 0;
+function generateCloneId(prefix) {
+  cloneIdCounter += 1;
+  return `${prefix}_clone_${Date.now().toString(36)}_${cloneIdCounter}`;
+}
+function reassignElementId(element) {
+  const prefix = element.type === "text" ? "txt" : element.type === "shape" ? "shp" : element.type === "connector" ? "cxn" : element.type === "image" || element.type === "picture" ? "img" : element.type === "table" ? "tbl" : element.type === "chart" ? "cht" : element.type === "media" ? "med" : element.type === "group" ? "grp" : element.type;
+  const newElement = { ...element, id: generateCloneId(prefix) };
+  if (newElement.type === "group" && "children" in newElement) {
+    newElement.children = newElement.children.map((child) => reassignElementId(child));
+  }
+  return newElement;
+}
+function duplicateSlide(slide, newSlideNumber) {
+  const cloned = chunkAT66SA5M_cjs.cloneSlide(slide);
+  cloned.sourceSlideId = slide.id.startsWith("ppt/slides/") ? slide.id : slide.sourceSlideId ?? slide.id;
+  cloned.id = `slide${newSlideNumber}`;
+  cloned.rId = `rId${newSlideNumber + 1}`;
+  cloned.slideNumber = newSlideNumber;
+  cloned.elements = cloned.elements.map(reassignElementId);
+  if (cloned.animations && cloned.animations.length > 0) {
+    const idMap = /* @__PURE__ */ new Map();
+    const mapElements = (originals, copies) => {
+      originals.forEach((original, index) => {
+        const copy = copies[index];
+        if (!copy) return;
+        idMap.set(original.id, copy.id);
+        if (original.type === "group" && copy.type === "group")
+          mapElements(original.children, copy.children);
+      });
+    };
+    mapElements(slide.elements, cloned.elements);
+    cloned.animations = cloned.animations.map((anim) => ({
+      ...anim,
+      elementId: idMap.get(anim.elementId) ?? anim.elementId
+    }));
+  }
+  return cloned;
+}
+
 // pptx/editor/render/slide-operations.ts
+function captureSlideClipboard(slides, ids) {
+  return ids.flatMap((id) => {
+    const slide = slides.find((candidate) => candidate.id === id);
+    return slide ? [chunkAT66SA5M_cjs.cloneSlide(slide)] : [];
+  });
+}
+function createSlidePaste(clipboard, insertAt, templates = {}) {
+  return {
+    copies: clipboard.map((slide, index) => ({
+      ...duplicateSlide(slide, insertAt + index + 1),
+      id: makeSlideId()
+    })),
+    sourceIds: clipboard.map((slide) => slide.id),
+    insertAt,
+    templateElements: clipboard.map((slide) => (templates[slide.id] ?? []).map(chunkAT66SA5M_cjs.cloneElement))
+  };
+}
+function insertSlidePaste(slides, request) {
+  const index = Math.max(0, Math.min(slides.length, request.insertAt));
+  const next = [
+    ...slides.slice(0, index),
+    ...request.copies.map(chunkAT66SA5M_cjs.cloneSlide),
+    ...slides.slice(index)
+  ];
+  return next.map(
+    (slide, position) => slide.slideNumber === position + 1 ? slide : { ...slide, slideNumber: position + 1 }
+  );
+}
+function applySlidePasteTemplates(mapping, request) {
+  const next = { ...mapping };
+  request.copies.forEach((copy, index) => {
+    next[copy.id] = (request.templateElements[index] ?? []).map(chunkAT66SA5M_cjs.cloneElement);
+  });
+  return next;
+}
+function captureSlideClipboardTemplates(mapping, ids) {
+  return Object.fromEntries(ids.map((id) => [id, (mapping[id] ?? []).map(chunkAT66SA5M_cjs.cloneElement)]));
+}
 function makeSlideId(idGenerator) {
   if (idGenerator) {
     return idGenerator();
@@ -16,5 +98,10 @@ function createBlankSlide(slideNumber, idGenerator) {
   };
 }
 
+exports.applySlidePasteTemplates = applySlidePasteTemplates;
+exports.captureSlideClipboard = captureSlideClipboard;
+exports.captureSlideClipboardTemplates = captureSlideClipboardTemplates;
 exports.createBlankSlide = createBlankSlide;
+exports.createSlidePaste = createSlidePaste;
+exports.insertSlidePaste = insertSlidePaste;
 exports.makeSlideId = makeSlideId;

package/dist/pptx/editor/render/slide-operations.d.ts

@@ -1,5 +1,21 @@
-import { PptxSlide } from "ooxml-core/pptx";
+import { PptxElement, PptxSlide } from "ooxml-core/pptx";
 //#region pptx/editor/render/slide-operations.d.ts
+export interface SlidePasteRequest {
+  /** Independent slide copies with their new identities already assigned. */
+  readonly copies: PptxSlide[];
+  /** Original clipboard identities, for the host's separate template-view cache. */
+  readonly sourceIds: string[];
+  /** Zero-based insertion position, immediately after the destination selection. */
+  readonly insertAt: number;
+  /** Template-view content captured with the clipboard, never read from a later live cache. */
+  readonly templateElements: PptxElement[][];
+}
+export declare function captureSlideClipboard(slides: readonly PptxSlide[], ids: readonly string[]): PptxSlide[];
+export declare function createSlidePaste(clipboard: readonly PptxSlide[], insertAt: number, templates?: Record<string, PptxElement[]>): SlidePasteRequest;
+/** Apply one paste atomically; copied content and source package hints remain independent. */
+export declare function insertSlidePaste(slides: readonly PptxSlide[], request: SlidePasteRequest): PptxSlide[];
+export declare function applySlidePasteTemplates(mapping: Record<string, PptxElement[]>, request: SlidePasteRequest): Record<string, PptxElement[]>;
+export declare function captureSlideClipboardTemplates(mapping: Record<string, PptxElement[]>, ids: readonly string[]): Record<string, PptxElement[]>;
 /**
  * Generate a collision-resistant slide id of the form
  * `slide-<timestamp>-<base36 suffix>`.

package/dist/pptx/editor/render/slide-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slide-operations.d.ts","names":[],"sources":["../../../../pptx/editor/render/slide-operations.ts"],"mappings":";;;;;;;;;wBAsBgB,YAAY;;;;;;;;;wBAeZ,iBAAiB,qBAAqB,6BAA6B"}
+{"version":3,"file":"slide-operations.d.ts","names":[],"sources":["../../../../pptx/editor/render/slide-operations.ts"],"mappings":";;iBAgBiB;;WAEP,QAAQ;;WAER;;WAEA;;WAEA,kBAAkB;;wBAGZ,sBACf,iBAAiB,aACjB,yBACE;wBAOa,iBACf,oBAAoB,aACpB,kBACA,YAAW,eAAe,iBACxB;;wBAaa,iBACf,iBAAiB,aACjB,SAAS,oBACP;wBAYa,yBACf,SAAS,eAAe,gBACxB,SAAS,oBACP,eAAe;wBAQF,+BACf,SAAS,eAAe,gBACxB,yBACE,eAAe;;;;;;;;wBAWF,YAAY;;;;;;;;;wBAeZ,iBAAiB,qBAAqB,6BAA6B"}