ooxml-core 1.8.4 → 1.9.0

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

@@ -1,41 +1,379 @@
 'use strict';
 
-var pptx = require('ooxml-core/pptx');
+var chunkAT66SA5M_cjs = require('../../../chunk-AT66SA5M.cjs');
+var chunkCPKNMQLX_cjs = require('../../../chunk-CPKNMQLX.cjs');
+require('../../../chunk-7IUNOWFJ.cjs');
+require('../../../chunk-Y6665UXH.cjs');
+require('../../../chunk-RGLJ6BCK.cjs');
+require('../../../chunk-R6Z5C4DA.cjs');
+require('../../../chunk-AT2NLO2F.cjs');
+require('../../../chunk-57KYGHFF.cjs');
+require('../../../chunk-V33BRBWQ.cjs');
+
+// 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 (chunkAT66SA5M_cjs.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 = chunkAT66SA5M_cjs.getTblFromRawXml(rawXml);
+  const row = chunkAT66SA5M_cjs.ensureArray(table?.["a:tr"])[rowIndex];
+  const cell = chunkAT66SA5M_cjs.ensureArray(row?.["a:tc"])[colIndex];
+  const paragraphs = chunkAT66SA5M_cjs.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 = chunkAT66SA5M_cjs.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 ? chunkAT66SA5M_cjs.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) : chunkAT66SA5M_cjs.updateCellTextInRawXml(element, rowIndex, colIndex, text);
+    if (rawXml) {
+      const table = chunkAT66SA5M_cjs.getTblFromRawXml(rawXml);
+      const xmlRow = chunkAT66SA5M_cjs.ensureArray(table?.["a:tr"])[rowIndex];
+      const xmlCell = chunkAT66SA5M_cjs.ensureArray(xmlRow?.["a:tc"])[colIndex];
+      text = chunkAT66SA5M_cjs.flattenCellTxBodyText(
+        xmlCell?.["a:txBody"],
+        (value) => chunkAT66SA5M_cjs.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 = chunkAT66SA5M_cjs.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: chunkCPKNMQLX_cjs.remapTextToSegments(text, shape.textSegments, { fontSize: shape.fontSize })
+      };
+    });
+    return {
+      ...element,
+      smartArtData: { ...next, drawingShapes, nodes: updateNode(data.nodes, node.id, text) }
+    };
+  }
+  if (!chunkAT66SA5M_cjs.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 (!pptx.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;
@@ -44,9 +382,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 = [];
@@ -57,37 +419,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 (!pptx.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++;
     }
@@ -108,5 +478,6 @@ function replaceInSlides(slides, query, replacement, opts = {}) {
 
 exports.applyFindReplacements = applyFindReplacements;
 exports.findInSlides = findInSlides;
+exports.findReplacementAvailability = findReplacementAvailability;
 exports.replaceInSlides = replaceInSlides;
 exports.replaceMatch = replaceMatch;

package/dist/pptx/editor/render/find-replace.d.ts

@@ -1,4 +1,5 @@
-import { PptxSlide } from "ooxml-core/pptx";
+import { C as PptxSlide } from "../../chunks/text-operations-BLodkuXE.js";
+import "../../chunks/index-B4cnSPNz.js";
 //#region pptx/editor/render/find-replace.d.ts
 /** Identifies a single match of the find query at segment-level precision. */
 export interface FindResult {
@@ -12,11 +13,36 @@ export interface FindResult {
   startOffset: number;
   /** Number of characters matched (equals `query.length`). */
   length: number;
+  /** Child indexes inside the selected top-level group, when the match is nested. */
+  elementPath?: number[];
+  /** Table-cell coordinates, when the match belongs to a table. */
+  tableCell?: {
+    rowIndex: number;
+    colIndex: number;
+  };
+  /** Data-model node id, when the match belongs to SmartArt. */
+  smartArtNodeId?: string;
+  /** Offset within this object's run stream, used to resolve overlapping replacements. */
+  textOffset?: number;
+  /** Speaker-note body match, rather than a canvas element. */
+  notes?: boolean;
+  /** Match in the chart title rather than the shape's own text. */
+  chartTitle?: boolean;
+  chartSeriesIndex?: number;
+  chartCategoryIndex?: number;
+  /** Linked or complex chart text is searchable but requires source editing. */
+  readOnly?: boolean;
 }
 /** Options passed to search and replace helpers. */
 export interface FindOptions {
   /** When `true`, the search is case-sensitive. Defaults to `false`. */
   matchCase?: boolean;
+  /** Search speaker notes as well as editable slide text. */
+  includeNotes?: boolean;
+  /** Include chart titles. Enabled by default; disable to replace only ordinary slide text. */
+  includeChartTitles?: boolean;
+  /** Opt-in search of series names and category labels, with transactional source editing. */
+  includeChartData?: boolean;
 }
 /** Result returned by {@link replaceInSlides} and {@link replaceMatch}. */
 export interface ReplaceResult {
@@ -25,12 +51,17 @@ export interface ReplaceResult {
   /** Number of text replacements actually applied. */
   replacements: number;
 }
+/** Shared replacement gating for searchable text whose source is not safely editable. */
+export declare function findReplacementAvailability(matches: readonly Pick<FindResult, 'readOnly'>[], index: number): {
+  current: boolean;
+  all: boolean;
+  hasReadOnly: boolean;
+};
 /**
  * Search all slides for occurrences of `query` at segment-level precision.
  *
- * - Only elements that pass `hasTextProperties` (text / shape / connector) are
- *   searched; tables, smartArt, and groups are skipped (they have no
- *   `textSegments`).
+ * - Searches shape text, table cells and SmartArt nodes, including nested groups.
+ * - Formatting boundaries do not split a match; explicit paragraph/line markers do.
  * - Overlapping matches are counted (search advances by 1 character after each
  *   hit, not by `query.length`).
  * - Returns an empty array when `query` is empty.

package/dist/pptx/editor/render/find-replace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-replace.d.ts","names":[],"sources":["../../../../pptx/editor/render/find-replace.ts"],"mappings":";;;iBAeiB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;;iBAIgB;;EAEhB;;;iBAIgB;;EAEhB,iBAAiB;;EAEjB;;;;;;;;;;;;wBAiBe,aACf,iBAAiB,aACjB,eACA,OAAM,cACJ;;;;;;;;;;wBAmDa,sBACf,iBAAiB,aACjB,oBAAoB,cACpB,sBACE;;;;;;;;;wBAiFa,aACf,iBAAiB,aACjB,qBAAqB,cACrB,oBACA,sBACE;;;;;;;wBAca,gBACf,iBAAiB,aACjB,eACA,qBACA,OAAM,cACJ"}
+{"version":3,"file":"find-replace.d.ts","names":[],"sources":["../../../../pptx/editor/render/find-replace.ts"],"mappings":";;;;iBAiBiB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;IAAc;IAAkB;;;EAEhC;;EAEA;;EAEA;;EAEA;EACA;EACA;;EAEA;;;iBAIgB;;EAEhB;;EAEA;;EAEA;;EAEA;;;iBAIgB;;EAEhB,iBAAiB;;EAEjB;;;wBAIe,4BACf,kBAAkB,KAAK,2BACvB;;;;;;;;;;;;;;wBAuBe,aACf,iBAAiB,aACjB,eACA,OAAM,cACJ;;;;;;;;;;wBA4Ea,sBACf,iBAAiB,aACjB,oBAAoB,cACpB,sBACE;;;;;;;;;wBAuHa,aACf,iBAAiB,aACjB,qBAAqB,cACrB,oBACA,sBACE;;;;;;;wBAca,gBACf,iBAAiB,aACjB,eACA,qBACA,OAAM,cACJ"}