@tiptap/extension-find-and-replace 3.29.0

package/dist/index.cjs

@@ -0,0 +1,950 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FindAndReplace: () => FindAndReplace,
+  FindAndReplacePlugin: () => FindAndReplacePlugin,
+  FindAndReplacePluginKey: () => FindAndReplacePluginKey,
+  createSearchRegex: () => createSearchRegex,
+  currentResultClass: () => currentResultClass,
+  default: () => index_default,
+  findNextIndex: () => findNextIndex,
+  resultClass: () => resultClass,
+  searchDocument: () => searchDocument,
+  searchTextblocks: () => searchTextblocks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/find-and-replace.ts
+var import_core = require("@tiptap/core");
+var import_state2 = require("@tiptap/pm/state");
+
+// src/state/debounced-search-state.ts
+var debouncedSearchState = /* @__PURE__ */ new WeakMap();
+function getDebouncedSearchState(editor) {
+  const existingState = debouncedSearchState.get(editor);
+  if (existingState) {
+    return existingState;
+  }
+  const nextState = {
+    timeout: null,
+    pendingTerm: null
+  };
+  debouncedSearchState.set(editor, nextState);
+  return nextState;
+}
+function clearDebouncedSearchState(editor) {
+  const state = debouncedSearchState.get(editor);
+  if (!state) {
+    return;
+  }
+  if (state.timeout !== null) {
+    clearTimeout(state.timeout);
+  }
+  debouncedSearchState.delete(editor);
+}
+
+// src/plugin/plugin.ts
+var import_state = require("@tiptap/pm/state");
+
+// src/constants/constants.ts
+var resultClass = "find-and-replace-result";
+var currentResultClass = "find-and-replace-result-current";
+
+// src/style/create-style-tag.ts
+var createStyleTag = (style2, nonce) => {
+  const existing = document.querySelector(
+    "style[data-tiptap-extension-find-and-replace-style]"
+  );
+  if (existing !== null) {
+    return existing;
+  }
+  const styleNode = document.createElement("style");
+  if (nonce) {
+    styleNode.setAttribute("nonce", nonce);
+  }
+  styleNode.setAttribute("data-tiptap-extension-find-and-replace-style", "");
+  styleNode.textContent = style2;
+  document.getElementsByTagName("head")[0].appendChild(styleNode);
+  return styleNode;
+};
+
+// src/style/style.ts
+var style = `.find-and-replace-result {
+  background-color: rgb(255 225 0 / 0.4);
+}
+
+.find-and-replace-result-current {
+  background-color: rgb(255 165 0 / 0.55);
+}
+`;
+
+// src/search/regex.ts
+var import_re2js = require("re2js");
+var escapeRegExp = (value) => {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+var unicodeWordCharacter = "[\\p{L}\\p{M}\\p{N}\\p{Pc}]";
+function compileNativeRegex(source, caseSensitive) {
+  try {
+    return new RegExp(source, caseSensitive ? "gu" : "giu");
+  } catch {
+    return null;
+  }
+}
+function compileSafeRegex(source, caseSensitive) {
+  try {
+    const flags = caseSensitive ? 0 : import_re2js.RE2JS.CASE_INSENSITIVE;
+    return import_re2js.RE2JS.compile(source, flags);
+  } catch {
+    return null;
+  }
+}
+function compileRegex(source, options) {
+  return options.useRegex ? compileSafeRegex(source, options.caseSensitive) : compileNativeRegex(source, options.caseSensitive);
+}
+function createSearchRegex(term, options) {
+  if (!term) {
+    return null;
+  }
+  let source;
+  if (options.useRegex) {
+    source = term;
+  } else {
+    const escaped = escapeRegExp(term);
+    source = options.wholeWord ? `(?<!${unicodeWordCharacter})${escaped}(?!${unicodeWordCharacter})` : escaped;
+  }
+  return compileRegex(source, options);
+}
+
+// src/search/matches.ts
+function* findNativeMatches(regex, text) {
+  for (const match of text.matchAll(regex)) {
+    yield { index: match.index, value: match[0] };
+  }
+}
+function* findSafeMatches(regex, text) {
+  var _a;
+  const matcher = regex.matcher(text);
+  while (matcher.find()) {
+    yield { index: matcher.start(), value: (_a = matcher.group()) != null ? _a : "" };
+  }
+}
+function findMatches(regex, text) {
+  return regex instanceof RegExp ? findNativeMatches(regex, text) : findSafeMatches(regex, text);
+}
+
+// src/search/text-segments.ts
+function getTextSegments(textblock, pos) {
+  const segments = [];
+  let textOffset = 0;
+  textblock.forEach((child, offset) => {
+    var _a;
+    const text = child.isText ? (_a = child.text) != null ? _a : "" : "\n";
+    segments.push({
+      isText: child.isText,
+      pos: pos + 1 + offset,
+      length: child.nodeSize,
+      text,
+      textOffset
+    });
+    textOffset += text.length;
+  });
+  return segments;
+}
+function findOffsetSegment(segments, offset) {
+  var _a;
+  let low = 0;
+  let high = segments.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    const segment = segments[middle];
+    const segmentEnd = segment.textOffset + segment.text.length;
+    if (offset < segmentEnd) {
+      high = middle;
+    } else {
+      low = middle + 1;
+    }
+  }
+  return (_a = segments[low]) != null ? _a : segments.at(-1);
+}
+function offsetToPos(segments, offset) {
+  const segment = findOffsetSegment(segments, offset);
+  return segment ? segment.pos + Math.min(offset - segment.textOffset, segment.length) : 0;
+}
+function overlapsNonTextSegment(segments, from, to) {
+  return segments.some(
+    (segment) => !segment.isText && from < segment.textOffset + segment.text.length && to > segment.textOffset
+  );
+}
+
+// src/search/textblock-search.ts
+function searchTextblock(regex, textblock, pos) {
+  const segments = getTextSegments(textblock, pos);
+  const text = segments.map((segment) => segment.text).join("");
+  const results = [];
+  for (const match of findMatches(regex, text)) {
+    if (match.value.length === 0) {
+      continue;
+    }
+    const matchEnd = match.index + match.value.length;
+    if (overlapsNonTextSegment(segments, match.index, matchEnd)) {
+      continue;
+    }
+    results.push({
+      from: offsetToPos(segments, match.index),
+      to: offsetToPos(segments, matchEnd)
+    });
+  }
+  return results;
+}
+
+// src/search/search.ts
+function searchTextblocks(textblocks, term, options) {
+  const regex = createSearchRegex(term, options);
+  if (!regex) {
+    return [];
+  }
+  return textblocks.flatMap(({ node, pos }) => searchTextblock(regex, node, pos));
+}
+function searchDocument(doc, term, options) {
+  const textblocks = [];
+  doc.descendants((node, pos) => {
+    if (!node.isTextblock) {
+      return true;
+    }
+    textblocks.push({ node, pos });
+    return false;
+  });
+  return searchTextblocks(textblocks, term, options);
+}
+function findNextIndex(results, from) {
+  if (results.length === 0) {
+    return null;
+  }
+  const index = results.findIndex((result) => result.from >= from);
+  return index === -1 ? 0 : index;
+}
+
+// src/utils/createDecorations.ts
+var import_view2 = require("@tiptap/pm/view");
+
+// src/utils/createDecoration.ts
+var import_view = require("@tiptap/pm/view");
+function createDecoration(result, currentIndex, index) {
+  const className = index === currentIndex ? `${resultClass} ${currentResultClass}` : resultClass;
+  return import_view.Decoration.inline(result.from, result.to, { class: className });
+}
+
+// src/utils/createDecorations.ts
+function createDecorations(doc, results, currentIndex) {
+  const decorations = results.map((result, index) => createDecoration(result, currentIndex, index));
+  return import_view2.DecorationSet.create(doc, decorations);
+}
+
+// src/utils/createState.ts
+function createState(doc, options) {
+  const results = searchDocument(doc, options.searchTerm, options);
+  const currentIndex = results.length > 0 ? 0 : null;
+  return {
+    searchTerm: options.searchTerm,
+    replaceTerm: options.replaceTerm,
+    caseSensitive: options.caseSensitive,
+    useRegex: options.useRegex,
+    wholeWord: options.wholeWord,
+    results,
+    currentIndex,
+    decorations: createDecorations(doc, results, currentIndex)
+  };
+}
+
+// src/utils/hasCurrentIndex.ts
+function hasCurrentIndex(meta) {
+  return !!meta && "currentIndex" in meta;
+}
+
+// src/utils/findDecorations.ts
+function findDecorations(decorations, results, textblocks) {
+  const found = /* @__PURE__ */ new Set();
+  textblocks.forEach((textblock) => {
+    decorations.find(textblock.from, textblock.to).forEach((decoration) => found.add(decoration));
+  });
+  results.forEach((result) => {
+    decorations.find(result.from, result.to, (decoration) => {
+      return decoration.from === result.from && decoration.to === result.to;
+    }).forEach((decoration) => found.add(decoration));
+  });
+  return [...found];
+}
+
+// src/utils/sameResult.ts
+function sameResult(first, second) {
+  return first.from === second.from && first.to === second.to;
+}
+
+// src/utils/isCurrentResult.ts
+function isCurrentResult(result, current) {
+  return current !== null && sameResult(result, current);
+}
+
+// src/utils/resultInTextblocks.ts
+function resultInTextblocks(result, textblocks) {
+  let start = 0;
+  let end = textblocks.length - 1;
+  while (start <= end) {
+    const index = Math.floor((start + end) / 2);
+    const textblock = textblocks[index];
+    if (result.from < textblock.from) {
+      end = index - 1;
+      continue;
+    }
+    if (result.to > textblock.to) {
+      start = index + 1;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/utils/shouldRefreshResult.ts
+function shouldRefreshResult(result, textblocks, previousCurrent, current) {
+  return resultInTextblocks(result, textblocks) || isCurrentResult(result, previousCurrent) || isCurrentResult(result, current);
+}
+
+// src/utils/getResultsToRefresh.ts
+function getResultsToRefresh(results, textblocks, previousCurrent, currentIndex) {
+  var _a;
+  const current = currentIndex === null ? null : (_a = results[currentIndex]) != null ? _a : null;
+  const refreshedResults = [];
+  results.forEach((result, index) => {
+    if (shouldRefreshResult(result, textblocks, previousCurrent, current)) {
+      refreshedResults.push({ result, index });
+    }
+  });
+  return refreshedResults;
+}
+
+// src/utils/refreshDecorations.ts
+function refreshDecorations(decorations, doc, results, currentIndex, textblocks, previousCurrent) {
+  const resultsToRefresh = getResultsToRefresh(results, textblocks, previousCurrent, currentIndex);
+  const refreshedResults = resultsToRefresh.map(({ result }) => result);
+  const staleResults = previousCurrent ? [...refreshedResults, previousCurrent] : refreshedResults;
+  const decorationsToRemove = findDecorations(decorations, staleResults, textblocks);
+  const decorationsToAdd = resultsToRefresh.map(({ result, index }) => {
+    return createDecoration(result, currentIndex, index);
+  });
+  return decorations.remove(decorationsToRemove).add(doc, decorationsToAdd);
+}
+
+// src/utils/normalizeCurrentIndex.ts
+function normalizeCurrentIndex(currentIndex, length) {
+  if (currentIndex === void 0 || currentIndex === null || length === 0) {
+    return null;
+  }
+  return Math.max(0, Math.min(currentIndex, length - 1));
+}
+
+// src/utils/getMetaCurrentIndex.ts
+function getMetaCurrentIndex(meta, length) {
+  if (!meta) {
+    return void 0;
+  }
+  if (!hasCurrentIndex(meta)) {
+    return void 0;
+  }
+  return normalizeCurrentIndex(meta.currentIndex, length);
+}
+
+// src/utils/getFallbackCurrentIndex.ts
+function getFallbackCurrentIndex(previousState, length) {
+  return previousState.currentIndex === null ? 0 : Math.min(previousState.currentIndex, length - 1);
+}
+
+// src/utils/getPreviousCurrentResult.ts
+function getPreviousCurrentResult(previousState) {
+  return previousState.currentIndex === null ? void 0 : previousState.results[previousState.currentIndex];
+}
+
+// src/utils/getMappedCurrentIndex.ts
+function getMappedCurrentIndex(previousState, results, docChanged, mapping) {
+  if (!docChanged) {
+    return void 0;
+  }
+  if (!mapping) {
+    return void 0;
+  }
+  const previousResult = getPreviousCurrentResult(previousState);
+  if (!previousResult) {
+    return void 0;
+  }
+  const mappedFrom = mapping.map(previousResult.from, 1);
+  return findNextIndex(results, mappedFrom);
+}
+
+// src/utils/isNewSearch.ts
+function isNewSearch(meta) {
+  return !!meta && "searchTerm" in meta;
+}
+
+// src/utils/getSearchCurrentIndex.ts
+function getSearchCurrentIndex(previousState, results, meta, docChanged, mapping) {
+  if (isNewSearch(meta)) {
+    return 0;
+  }
+  const mappedIndex = getMappedCurrentIndex(previousState, results, docChanged, mapping);
+  return mappedIndex != null ? mappedIndex : getFallbackCurrentIndex(previousState, results.length);
+}
+
+// src/utils/resolveCurrentIndex.ts
+function resolveCurrentIndex(previousState, results, meta, docChanged, mapping) {
+  if (results.length === 0) {
+    return null;
+  }
+  const metaIndex = getMetaCurrentIndex(meta, results.length);
+  if (metaIndex !== void 0) {
+    return metaIndex;
+  }
+  return getSearchCurrentIndex(previousState, results, meta, docChanged, mapping);
+}
+
+// src/utils/refreshCurrentIndexState.ts
+function refreshCurrentIndexState(previousState, state, doc, meta) {
+  const currentIndex = resolveCurrentIndex(previousState, state.results, meta, false, void 0);
+  const previousCurrent = previousState.currentIndex === null ? null : previousState.results[previousState.currentIndex];
+  return {
+    ...state,
+    currentIndex,
+    decorations: refreshDecorations(
+      previousState.decorations,
+      doc,
+      state.results,
+      currentIndex,
+      [],
+      previousCurrent
+    )
+  };
+}
+
+// src/utils/getChangedTextblocks.ts
+function getChangedTextblocks(doc, mapping) {
+  const textblocks = /* @__PURE__ */ new Map();
+  mapping.maps.forEach((stepMap, index) => {
+    const remaining = mapping.slice(index + 1);
+    stepMap.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+      const from = Math.max(0, remaining.map(newStart, -1) - 1);
+      const to = Math.min(doc.content.size, remaining.map(newEnd, 1) + 1);
+      doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isTextblock) {
+          return true;
+        }
+        textblocks.set(pos, { node, pos, from: pos, to: pos + node.nodeSize });
+        return false;
+      });
+    });
+  });
+  return [...textblocks.values()].sort((first, second) => first.pos - second.pos);
+}
+
+// src/utils/mapResult.ts
+function mapResult(result, mapping) {
+  const from = mapping.map(result.from, 1);
+  const to = mapping.map(result.to, -1);
+  return from < to ? { from, to } : null;
+}
+
+// src/utils/mapResults.ts
+function mapResults(results, mapping) {
+  const mappedResults = [];
+  results.forEach((result) => {
+    const mapped = mapResult(result, mapping);
+    if (mapped) {
+      mappedResults.push(mapped);
+    }
+  });
+  return mappedResults;
+}
+
+// src/utils/mergeResults.ts
+function mergeResults(first, second) {
+  const results = [];
+  let firstIndex = 0;
+  let secondIndex = 0;
+  while (firstIndex < first.length && secondIndex < second.length) {
+    if (first[firstIndex].from < second[secondIndex].from) {
+      results.push(first[firstIndex++]);
+      continue;
+    }
+    results.push(second[secondIndex++]);
+  }
+  return results.concat(first.slice(firstIndex), second.slice(secondIndex));
+}
+
+// src/utils/refreshDocumentState.ts
+function refreshDocumentState(previousState, state, doc, meta, mapping) {
+  const textblocks = getChangedTextblocks(doc, mapping);
+  const mappedResults = mapResults(previousState.results, mapping);
+  const unaffectedResults = mappedResults.filter((result) => !resultInTextblocks(result, textblocks));
+  const changedResults = searchTextblocks(textblocks, state.searchTerm, state);
+  const results = mergeResults(unaffectedResults, changedResults);
+  const currentIndex = resolveCurrentIndex(previousState, results, meta, true, mapping);
+  const previousCurrent = previousState.currentIndex === null ? null : mapResult(previousState.results[previousState.currentIndex], mapping);
+  const decorations = previousState.decorations.map(mapping, doc);
+  return {
+    ...state,
+    results,
+    currentIndex,
+    decorations: refreshDecorations(
+      decorations,
+      doc,
+      results,
+      currentIndex,
+      textblocks,
+      previousCurrent
+    )
+  };
+}
+
+// src/utils/refreshState.ts
+function refreshState(previousState, state, doc, meta, docChanged, mapping) {
+  const results = searchDocument(doc, state.searchTerm, state);
+  const currentIndex = resolveCurrentIndex(previousState, results, meta, docChanged, mapping);
+  return {
+    ...state,
+    results,
+    currentIndex,
+    decorations: createDecorations(doc, results, currentIndex)
+  };
+}
+
+// src/utils/touchesSearch.ts
+var searchKeys = ["searchTerm", "caseSensitive", "useRegex", "wholeWord"];
+function touchesSearch(meta) {
+  return !!meta && searchKeys.some((key) => key in meta);
+}
+
+// src/utils/updateState.ts
+function updateState(previousState, state, doc, meta, docChanged, mapping) {
+  if (touchesSearch(meta)) {
+    return refreshState(previousState, state, doc, meta, docChanged, mapping);
+  }
+  if (docChanged) {
+    return refreshDocumentState(previousState, state, doc, meta, mapping);
+  }
+  if (hasCurrentIndex(meta)) {
+    return refreshCurrentIndexState(previousState, state, doc, meta);
+  }
+  return state;
+}
+
+// src/plugin/plugin.ts
+var FindAndReplacePluginKey = new import_state.PluginKey("findAndReplace");
+var FindAndReplacePlugin = (options, onCreate) => {
+  return new import_state.Plugin({
+    key: FindAndReplacePluginKey,
+    state: {
+      init: (_config, state) => {
+        if (options.injectCSS && typeof document !== "undefined") {
+          createStyleTag(style, options.injectNonce);
+        }
+        const pluginState = createState(state.doc, options);
+        onCreate(pluginState);
+        return pluginState;
+      },
+      apply: (tr, state, _oldState, newState) => {
+        const meta = tr.getMeta(FindAndReplacePluginKey);
+        if (!meta && !tr.docChanged) {
+          return state;
+        }
+        return updateState(
+          state,
+          { ...state, ...meta },
+          newState.doc,
+          meta,
+          tr.docChanged,
+          tr.mapping
+        );
+      }
+    },
+    props: {
+      decorations(state) {
+        var _a;
+        return (_a = FindAndReplacePluginKey.getState(state)) == null ? void 0 : _a.decorations;
+      }
+    }
+  });
+};
+
+// src/utils/getTextNodeResult.ts
+function getTextNodeResult(state, result) {
+  const $from = state.doc.resolve(result.from);
+  const node = $from.parent.child($from.index());
+  if (!node.isText || !node.text) {
+    return null;
+  }
+  const from = result.from - $from.textOffset;
+  return result.to <= from + node.nodeSize ? { from, text: node.text } : null;
+}
+
+// src/utils/groupResults.ts
+function shouldMergeResult(group, textNode) {
+  if (!group || !textNode) {
+    return false;
+  }
+  return group.from === textNode.from && group.text !== null;
+}
+function createTextResultGroup(result, textNode) {
+  return {
+    from: textNode.from,
+    text: textNode.text,
+    results: [result]
+  };
+}
+function createResultGroup(result) {
+  return {
+    from: result.from,
+    text: null,
+    results: [result]
+  };
+}
+function appendResult(groups, result, textNode) {
+  const group = groups.at(-1);
+  if (shouldMergeResult(group, textNode)) {
+    group.results.push(result);
+    return;
+  }
+  if (textNode) {
+    groups.push(createTextResultGroup(result, textNode));
+    return;
+  }
+  groups.push(createResultGroup(result));
+}
+function groupResults(state, results) {
+  const groups = [];
+  for (const result of results) {
+    appendResult(groups, result, getTextNodeResult(state, result));
+  }
+  return groups;
+}
+
+// src/utils/replaceGroup.ts
+function replaceSeparateResults(tr, results, replaceTerm) {
+  for (const result of [...results].reverse()) {
+    tr.insertText(replaceTerm, result.from, result.to);
+  }
+}
+function createReplacement(group, text, firstResult, replaceTerm) {
+  let offset = firstResult.from - group.from;
+  const replacement = [];
+  for (const result of group.results) {
+    const from = result.from - group.from;
+    const to = result.to - group.from;
+    replacement.push(text.slice(offset, from), replaceTerm);
+    offset = to;
+  }
+  return replacement.join("");
+}
+function replaceGroup(tr, group, replaceTerm) {
+  const firstResult = group.results[0];
+  const lastResult = group.results.at(-1);
+  if (!lastResult) {
+    return;
+  }
+  if (group.text === null) {
+    replaceSeparateResults(tr, group.results, replaceTerm);
+    return;
+  }
+  tr.insertText(
+    createReplacement(group, group.text, firstResult, replaceTerm),
+    firstResult.from,
+    lastResult.to
+  );
+}
+
+// src/utils/replaceAllResults.ts
+function replaceAllResults(tr, state, results, replaceTerm) {
+  const groups = groupResults(state, results);
+  for (const group of groups.reverse()) {
+    replaceGroup(tr, group, replaceTerm);
+  }
+}
+
+// src/find-and-replace.ts
+function mergePluginMeta(tr, meta) {
+  const currentMeta = tr.getMeta(FindAndReplacePluginKey);
+  tr.setMeta(FindAndReplacePluginKey, { ...currentMeta, ...meta });
+}
+function setPluginMeta(meta) {
+  return ({ tr, dispatch }) => {
+    if (dispatch) {
+      mergePluginMeta(tr, meta);
+    }
+    return true;
+  };
+}
+function applySearchTerm(editor, term) {
+  const tr = editor.state.tr;
+  mergePluginMeta(tr, { searchTerm: term });
+  editor.view.dispatch(tr);
+}
+function consumePendingSearch(editor) {
+  const state = getDebouncedSearchState(editor);
+  if (state.pendingTerm === null) {
+    return null;
+  }
+  const pendingTerm = state.pendingTerm;
+  state.pendingTerm = null;
+  if (state.timeout !== null) {
+    clearTimeout(state.timeout);
+    state.timeout = null;
+  }
+  return pendingTerm;
+}
+function getPendingAwarePluginState(state, pendingTerm) {
+  const pluginState = FindAndReplacePluginKey.getState(state);
+  if (!pluginState) {
+    return null;
+  }
+  if (pendingTerm === null) {
+    return pluginState.results.length === 0 ? null : pluginState;
+  }
+  const results = searchDocument(state.doc, pendingTerm, {
+    caseSensitive: pluginState.caseSensitive,
+    useRegex: pluginState.useRegex,
+    wholeWord: pluginState.wholeWord
+  });
+  if (results.length === 0) {
+    return null;
+  }
+  return {
+    ...pluginState,
+    searchTerm: pendingTerm,
+    results,
+    currentIndex: 0
+  };
+}
+function currentResult(pluginState) {
+  var _a;
+  return pluginState.results[(_a = pluginState.currentIndex) != null ? _a : 0];
+}
+function shiftIndex(currentIndex, length, direction) {
+  if (currentIndex === null) {
+    return direction === 1 ? 0 : length - 1;
+  }
+  return (currentIndex + direction + length) % length;
+}
+function selectResult(tr, result, index) {
+  tr.setSelection(import_state2.TextSelection.create(tr.doc, result.from, result.to));
+  mergePluginMeta(tr, { currentIndex: index });
+  tr.scrollIntoView();
+}
+function replaceResult(tr, pluginState, result) {
+  const { searchTerm, replaceTerm, caseSensitive, useRegex, wholeWord } = pluginState;
+  tr.insertText(replaceTerm, result.from, result.to);
+  const results = searchDocument(tr.doc, searchTerm, { caseSensitive, useRegex, wholeWord });
+  const nextIndex = findNextIndex(results, result.from + replaceTerm.length);
+  if (nextIndex === null) {
+    mergePluginMeta(tr, { currentIndex: null });
+    return;
+  }
+  selectResult(tr, results[nextIndex], nextIndex);
+}
+var FindAndReplace = import_core.Extension.create({
+  name: "findAndReplace",
+  addOptions() {
+    return {
+      searchTerm: "",
+      replaceTerm: "",
+      caseSensitive: false,
+      useRegex: false,
+      wholeWord: false,
+      searchDebounceMs: 250,
+      injectCSS: true,
+      injectNonce: void 0
+    };
+  },
+  addStorage() {
+    return {
+      searchTerm: this.options.searchTerm,
+      replaceTerm: this.options.replaceTerm,
+      caseSensitive: this.options.caseSensitive,
+      useRegex: this.options.useRegex,
+      wholeWord: this.options.wholeWord,
+      results: [],
+      currentIndex: null
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      FindAndReplacePlugin(this.options, (pluginState) => {
+        this.storage.results = pluginState.results;
+        this.storage.currentIndex = pluginState.currentIndex;
+      })
+    ];
+  },
+  onTransaction() {
+    const pluginState = FindAndReplacePluginKey.getState(this.editor.state);
+    if (!pluginState) {
+      return;
+    }
+    this.storage.searchTerm = pluginState.searchTerm;
+    this.storage.replaceTerm = pluginState.replaceTerm;
+    this.storage.caseSensitive = pluginState.caseSensitive;
+    this.storage.useRegex = pluginState.useRegex;
+    this.storage.wholeWord = pluginState.wholeWord;
+    this.storage.results = pluginState.results;
+    this.storage.currentIndex = pluginState.currentIndex;
+  },
+  addCommands() {
+    const scheduleSearchTerm = (term) => {
+      const state = getDebouncedSearchState(this.editor);
+      if (this.options.searchDebounceMs <= 0) {
+        if (state.timeout !== null) {
+          clearTimeout(state.timeout);
+          state.timeout = null;
+        }
+        state.pendingTerm = null;
+        applySearchTerm(this.editor, term);
+        return true;
+      }
+      if (state.timeout !== null) {
+        clearTimeout(state.timeout);
+      }
+      state.pendingTerm = term;
+      state.timeout = setTimeout(() => {
+        const debouncedState = getDebouncedSearchState(this.editor);
+        debouncedState.timeout = null;
+        if (debouncedState.pendingTerm === null) {
+          return;
+        }
+        const pendingTerm = debouncedState.pendingTerm;
+        debouncedState.pendingTerm = null;
+        applySearchTerm(this.editor, pendingTerm);
+      }, this.options.searchDebounceMs);
+      return true;
+    };
+    return {
+      setSearchTerm: (term) => ({ dispatch }) => {
+        if (!dispatch) {
+          return true;
+        }
+        return scheduleSearchTerm(term);
+      },
+      setReplaceTerm: (term) => setPluginMeta({ replaceTerm: term }),
+      setCaseSensitive: (caseSensitive) => setPluginMeta({ caseSensitive }),
+      setUseRegex: (useRegex) => setPluginMeta({ useRegex }),
+      setWholeWord: (wholeWord) => setPluginMeta({ wholeWord }),
+      clearSearch: () => ({ tr, dispatch }) => {
+        const state = getDebouncedSearchState(this.editor);
+        if (state.timeout !== null) {
+          clearTimeout(state.timeout);
+          state.timeout = null;
+        }
+        state.pendingTerm = null;
+        if (dispatch) {
+          mergePluginMeta(tr, { searchTerm: "" });
+        }
+        return true;
+      },
+      replace: () => ({ tr, state, dispatch }) => {
+        const pendingTerm = dispatch ? consumePendingSearch(this.editor) : null;
+        if (dispatch && pendingTerm !== null) {
+          mergePluginMeta(tr, { searchTerm: pendingTerm });
+        }
+        const pluginState = getPendingAwarePluginState(state, pendingTerm);
+        if (!pluginState) {
+          return false;
+        }
+        const result = currentResult(pluginState);
+        if (!result) {
+          return false;
+        }
+        if (dispatch) {
+          replaceResult(tr, pluginState, result);
+        }
+        return true;
+      },
+      replaceAll: () => ({ tr, state, dispatch }) => {
+        const pendingTerm = dispatch ? consumePendingSearch(this.editor) : null;
+        if (dispatch && pendingTerm !== null) {
+          mergePluginMeta(tr, { searchTerm: pendingTerm });
+        }
+        const pluginState = getPendingAwarePluginState(state, pendingTerm);
+        if (!pluginState) {
+          return false;
+        }
+        if (dispatch) {
+          replaceAllResults(tr, state, pluginState.results, pluginState.replaceTerm);
+        }
+        return true;
+      },
+      goToNextResult: () => ({ tr, state, dispatch }) => {
+        const pendingTerm = dispatch ? consumePendingSearch(this.editor) : null;
+        if (dispatch && pendingTerm !== null) {
+          mergePluginMeta(tr, { searchTerm: pendingTerm });
+        }
+        const pluginState = getPendingAwarePluginState(state, pendingTerm);
+        if (!pluginState) {
+          return false;
+        }
+        const nextIndex = shiftIndex(pluginState.currentIndex, pluginState.results.length, 1);
+        if (dispatch) {
+          selectResult(tr, pluginState.results[nextIndex], nextIndex);
+        }
+        return true;
+      },
+      goToPreviousResult: () => ({ tr, state, dispatch }) => {
+        const pendingTerm = dispatch ? consumePendingSearch(this.editor) : null;
+        if (dispatch && pendingTerm !== null) {
+          mergePluginMeta(tr, { searchTerm: pendingTerm });
+        }
+        const pluginState = getPendingAwarePluginState(state, pendingTerm);
+        if (!pluginState) {
+          return false;
+        }
+        const previousIndex = shiftIndex(pluginState.currentIndex, pluginState.results.length, -1);
+        if (dispatch) {
+          selectResult(tr, pluginState.results[previousIndex], previousIndex);
+        }
+        return true;
+      }
+    };
+  },
+  onDestroy() {
+    clearDebouncedSearchState(this.editor);
+  }
+});
+
+// src/index.ts
+var index_default = FindAndReplace;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FindAndReplace,
+  FindAndReplacePlugin,
+  FindAndReplacePluginKey,
+  createSearchRegex,
+  currentResultClass,
+  findNextIndex,
+  resultClass,
+  searchDocument,
+  searchTextblocks
+});
+//# sourceMappingURL=index.cjs.map