@pixerate/editor 0.43.0 → 0.45.0

package/dist/{chunk-DDADOHJW.js → chunk-Q25ZS4F7.js}

@@ -9,6 +9,8 @@ import {
   MAX_TABLE_COLUMNS,
   MAX_TABLE_ROWS,
   TABLE_ACTIONS,
+  applyReplacements,
+  compileFindPattern,
   createTableExtensions,
   getTableActionState,
   getTableState,
@@ -16,8 +18,9 @@ import {
   insertSliceAfterTable,
   outermostTableDepth,
   runTableAction,
+  searchDocument,
   sliceContainsTable
-} from "./chunk-5H2OPMXZ.js";
+} from "./chunk-TK2XZK6Z.js";
 import {
   compareDocuments
 } from "./chunk-QJSOZFCZ.js";
@@ -5513,877 +5516,6 @@ import { Extension as Extension12 } from "@tiptap/core";
 import { Plugin as Plugin14, PluginKey as PluginKey11, TextSelection as TextSelection7 } from "@tiptap/pm/state";
 import { Decoration as Decoration4, DecorationSet as DecorationSet4 } from "@tiptap/pm/view";
 import { closeHistory as closeHistory2 } from "@tiptap/pm/history";
-
-// src/extensions/find-replace/pattern.ts
-var FIND_PARAGRAPH_MARK = "\r";
-var MAX_FIND_PATTERN_LENGTH = 1024;
-var MAX_COUNT = 1e3;
-var MAX_PROGRAM_SIZE = 2e4;
-var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-function createSearchBudget(options = {}) {
-  return {
-    deadline: now() + (options.timeLimitMs ?? 250),
-    steps: options.maxSteps ?? 5e7,
-    exhausted: false
-  };
-}
-var PARA = 13;
-var ANY = (cp) => cp !== PARA;
-var LETTER = /\p{L}/u;
-var PUNCT = /\p{P}/u;
-var WORD = /[\p{L}\p{M}\p{Nd}\p{Pc}]/u;
-var foldCache = /* @__PURE__ */ new Map();
-function foldCodePoint(cp) {
-  if (cp < 128) return cp >= 65 && cp <= 90 ? cp + 32 : cp;
-  const cached = foldCache.get(cp);
-  if (cached !== void 0) return cached;
-  const lower = String.fromCodePoint(cp).toLowerCase();
-  const folded = [...lower].length === 1 ? lower.codePointAt(0) : cp;
-  if (foldCache.size < 4096) foldCache.set(cp, folded);
-  return folded;
-}
-function isWordChar(cp) {
-  if (cp < 0) return false;
-  if (cp < 128) {
-    return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 95;
-  }
-  return WORD.test(String.fromCodePoint(cp));
-}
-var isLetter = (cp) => cp < 128 ? cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 : LETTER.test(String.fromCodePoint(cp));
-function isPunct(cp) {
-  if (cp < 128) {
-    return cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126;
-  }
-  return cp >= 8208 && cp <= 8231 || cp === 161 || cp === 191 || cp === 171 || cp === 187 || PUNCT.test(String.fromCodePoint(cp));
-}
-var isSpace = (cp) => cp === 32 || cp === 9 || cp === 160;
-function cpBefore(hay, pos) {
-  if (pos <= 0) return -1;
-  const low = hay.charCodeAt(pos - 1);
-  if (low >= 56320 && low <= 57343 && pos >= 2) {
-    const high = hay.charCodeAt(pos - 2);
-    if (high >= 55296 && high <= 56319) return hay.codePointAt(pos - 2);
-  }
-  return low;
-}
-var cpAt = (hay, pos) => pos < hay.length ? hay.codePointAt(pos) : -1;
-var PatternError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-  code;
-};
-var charNode = (test) => ({ k: "char", test });
-var exact = (cp) => charNode((c) => c === cp);
-var literalNode = (cp, caseInsensitive) => {
-  if (!caseInsensitive) return exact(cp);
-  const f = foldCodePoint(cp);
-  return charNode((_c, folded) => folded === f);
-};
-var star = (body, lazy) => ({ k: "rep", body, min: 0, max: -1, lazy });
-function findCode(c) {
-  switch (c) {
-    case "p":
-      return exact(PARA);
-    case "t":
-      return exact(9);
-    case "?":
-      return charNode(ANY);
-    case "#":
-      return charNode((cp) => cp >= 48 && cp <= 57);
-    case "$":
-      return charNode((cp) => isLetter(cp));
-    case "^":
-      return exact(94);
-    case "l":
-      return exact(10);
-    case "m":
-      return exact(12);
-    case "n":
-      return exact(14);
-    case "+":
-      return exact(8212);
-    case "=":
-      return exact(8211);
-    case "s":
-      return exact(160);
-    case "~":
-      return exact(8209);
-    case "-":
-      return exact(173);
-    case "w":
-      return { k: "rep", body: charNode((cp) => isSpace(cp)), min: 1, max: -1, lazy: false };
-    case "g":
-      return exact(65532);
-    case "%":
-      return exact(167);
-    case "v":
-      return exact(182);
-    default:
-      return null;
-  }
-}
-function replaceCode(c) {
-  switch (c) {
-    case "p":
-      return FIND_PARAGRAPH_MARK;
-    case "t":
-      return "	";
-    case "^":
-      return "^";
-    case "l":
-      return "\n";
-    case "m":
-      return "\f";
-    case "n":
-      return "";
-    case "+":
-      return "\u2014";
-    case "=":
-      return "\u2013";
-    case "s":
-      return "\xA0";
-    case "~":
-      return "\u2011";
-    case "-":
-      return "\xAD";
-    case "%":
-      return "\xA7";
-    case "v":
-      return "\xB6";
-    default:
-      return null;
-  }
-}
-function codeChar(n) {
-  switch (n) {
-    case 13:
-      return PARA;
-    case 11:
-      return 10;
-    case 12:
-      return 12;
-    case 14:
-      return 14;
-    case 30:
-      return 8209;
-    case 31:
-      return 173;
-  }
-  if (n > 1114111 || n >= 55296 && n <= 57343) return null;
-  if (n < 32 && n !== 9 || n >= 127 && n < 160) return null;
-  return n;
-}
-function numericCode(chars, i) {
-  const unicode = chars[i] === "u";
-  const start2 = unicode ? i + 1 : i;
-  const max = unicode ? 5 : 4;
-  let digits = "";
-  for (let j = start2; j < chars.length && digits.length < max && /[0-9]/.test(chars[j]); j++) digits += chars[j];
-  if (!digits) return null;
-  const cp = codeChar(parseInt(digits, 10));
-  return cp === null ? null : { cp, used: start2 - i + digits.length };
-}
-var toChars = (s) => Array.from(s);
-var cpOf = (ch) => ch.codePointAt(0);
-function parseSpecial(query, o, caseInsensitive) {
-  const chars = toChars(query);
-  const atoms = [];
-  let spans = false;
-  let i = 0;
-  while (i < chars.length) {
-    const c = chars[i++];
-    if (c === "^" && !o.literal && i < chars.length) {
-      const n = chars[i];
-      const code = findCode(n);
-      if (code) {
-        if (n === "p") spans = true;
-        atoms.push(code);
-        i++;
-        continue;
-      }
-      const num = numericCode(chars, i);
-      if (num) {
-        if (num.cp === PARA) spans = true;
-        atoms.push(literalNode(num.cp, caseInsensitive));
-        i += num.used;
-        continue;
-      }
-    }
-    const cp = cpOf(c);
-    if (o.ignorePunctuation && isPunct(cp) || o.ignoreWhitespace && isSpace(cp)) continue;
-    atoms.push(literalNode(cp, caseInsensitive));
-  }
-  const filler = o.ignorePunctuation && o.ignoreWhitespace ? (cp) => isPunct(cp) || isSpace(cp) : o.ignorePunctuation ? (cp) => isPunct(cp) : o.ignoreWhitespace ? (cp) => isSpace(cp) : null;
-  const items = [];
-  atoms.forEach((atom, index) => {
-    if (index > 0 && filler) items.push(star(charNode(filler), false));
-    items.push(atom);
-  });
-  return { node: { k: "cat", items }, spans };
-}
-function parseCount(body) {
-  const bad = () => new PatternError("invalid_pattern", `{${body}} is not a valid count`);
-  const num = (s) => {
-    const t = s.trim();
-    if (!t) return null;
-    if (!/^[0-9]+$/.test(t)) throw bad();
-    const n = parseInt(t, 10);
-    if (n > MAX_COUNT) throw new PatternError("invalid_pattern", `counts go up to ${MAX_COUNT}`);
-    return n;
-  };
-  const sep = body.search(/[,;]/);
-  if (sep < 0) {
-    const n = num(body);
-    if (n === null) throw bad();
-    return { min: n, max: n };
-  }
-  const a = num(body.slice(0, sep)) ?? 0;
-  const b = num(body.slice(sep + 1));
-  if (b !== null && b < a) throw bad();
-  return { min: a, max: b ?? -1 };
-}
-function parseClass(inner) {
-  let negated = false;
-  if (inner[0] === "!") {
-    negated = true;
-    inner = inner.slice(1);
-  }
-  if (inner.length === 0) throw new PatternError("invalid_pattern", "[ ] needs at least one character");
-  const singles = /* @__PURE__ */ new Set();
-  const ranges = [];
-  let i = 0;
-  while (i < inner.length) {
-    let c = inner[i];
-    if (c === "\\" && i + 1 < inner.length) c = inner[++i];
-    i++;
-    if (inner[i] === "-" && i + 1 < inner.length) {
-      const hi = inner[i + 1];
-      if (cpOf(hi) < cpOf(c)) throw new PatternError("invalid_pattern", `[${c}-${hi}] is not in ascending order`);
-      ranges.push([cpOf(c), cpOf(hi)]);
-      i += 2;
-    } else {
-      singles.add(cpOf(c));
-    }
-  }
-  const inSet = (cp) => singles.has(cp) || ranges.some(([lo, hi]) => cp >= lo && cp <= hi);
-  return negated ? (cp) => cp !== PARA && !inSet(cp) : (cp) => inSet(cp);
-}
-function parseWildcards(query) {
-  const chars = toChars(query);
-  const stack = [{ items: [], group: 0 }];
-  let groups = 0;
-  let spans = false;
-  const top = () => stack[stack.length - 1].items;
-  const quantify = (min, max, what) => {
-    const items = top();
-    const last = items[items.length - 1];
-    if (!last || last.k === "assert" || last.k === "rep") {
-      throw new PatternError("invalid_pattern", `${what} needs something to repeat before it`);
-    }
-    items[items.length - 1] = { k: "rep", body: last, min, max, lazy: false };
-  };
-  let i = 0;
-  while (i < chars.length) {
-    const c = chars[i++];
-    switch (c) {
-      case "?":
-        top().push(charNode(ANY));
-        break;
-      case "*":
-        top().push(star(charNode(ANY), true));
-        break;
-      case "@":
-        quantify(1, -1, "@");
-        break;
-      case "<":
-        top().push({ k: "assert", kind: "wordStart" });
-        break;
-      case ">":
-        top().push({ k: "assert", kind: "wordEnd" });
-        break;
-      case "(":
-        stack.push({ items: [], group: ++groups });
-        break;
-      case ")": {
-        if (stack.length === 1) throw new PatternError("invalid_pattern", "a ) has no opening (");
-        const frame = stack.pop();
-        top().push({ k: "group", index: frame.group, body: { k: "cat", items: frame.items } });
-        break;
-      }
-      case "{": {
-        const end = chars.indexOf("}", i);
-        if (end < 0) throw new PatternError("invalid_pattern", "a { needs a closing }");
-        const { min, max } = parseCount(chars.slice(i, end).join(""));
-        quantify(min, max, `{${chars.slice(i, end).join("")}}`);
-        i = end + 1;
-        break;
-      }
-      case "[": {
-        const end = chars.indexOf("]", i);
-        if (end < 0) throw new PatternError("invalid_pattern", "a [ needs a closing ]");
-        top().push(charNode(parseClass(chars.slice(i, end))));
-        i = end + 1;
-        break;
-      }
-      case "\\": {
-        if (i >= chars.length) {
-          top().push(exact(92));
-        } else if (/[0-9]/.test(chars[i])) {
-          throw new PatternError("invalid_pattern", "back-references (\\1) work in Replace with, not in Find what");
-        } else {
-          top().push(exact(cpOf(chars[i++])));
-        }
-        break;
-      }
-      case "^": {
-        if (i >= chars.length) {
-          top().push(exact(94));
-          break;
-        }
-        const n = chars[i];
-        const code = findCode(n);
-        if (code) {
-          if (n === "p") spans = true;
-          top().push(code);
-          i++;
-          break;
-        }
-        const num = numericCode(chars, i);
-        if (num) {
-          if (num.cp === PARA) spans = true;
-          top().push(exact(num.cp));
-          i += num.used;
-        } else {
-          top().push(exact(94));
-        }
-        break;
-      }
-      default:
-        top().push(exact(cpOf(c)));
-    }
-  }
-  if (stack.length > 1) throw new PatternError("invalid_pattern", "a ( needs a closing )");
-  return { node: { k: "cat", items: stack[0].items }, spans, groups };
-}
-function compileProgram(node) {
-  const prog = [];
-  const push = (inst) => {
-    if (prog.length >= MAX_PROGRAM_SIZE) {
-      throw new PatternError("too_complex", "the pattern is too complex (too many repeats)");
-    }
-    prog.push(inst);
-    return prog.length - 1;
-  };
-  const emit = (n) => {
-    switch (n.k) {
-      case "char":
-        push({ op: 0 /* Char */, test: n.test });
-        return;
-      case "cat":
-        n.items.forEach(emit);
-        return;
-      case "group":
-        push({ op: 3 /* Save */, n: 2 * n.index });
-        emit(n.body);
-        push({ op: 3 /* Save */, n: 2 * n.index + 1 });
-        return;
-      case "assert":
-        push({ op: 4 /* Assert */, kind: n.kind });
-        return;
-      case "rep": {
-        for (let k = 0; k < n.min; k++) emit(n.body);
-        if (n.max < 0) {
-          const split = push({ op: 1 /* Split */, x: 0, y: 0 });
-          emit(n.body);
-          push({ op: 2 /* Jmp */, x: split });
-          const exit2 = prog.length;
-          const inst = prog[split];
-          inst.x = n.lazy ? exit2 : split + 1;
-          inst.y = n.lazy ? split + 1 : exit2;
-          return;
-        }
-        const splits = [];
-        for (let k = n.min; k < n.max; k++) {
-          splits.push(push({ op: 1 /* Split */, x: 0, y: 0 }));
-          emit(n.body);
-        }
-        const exit = prog.length;
-        for (const s of splits) {
-          const inst = prog[s];
-          inst.x = n.lazy ? exit : s + 1;
-          inst.y = n.lazy ? s + 1 : exit;
-        }
-        return;
-      }
-    }
-  };
-  push({ op: 3 /* Save */, n: 0 });
-  emit(node);
-  push({ op: 3 /* Save */, n: 1 });
-  push({ op: 5 /* Match */ });
-  return prog;
-}
-function checkAssert(kind, hay, pos) {
-  const before = isWordChar(cpBefore(hay, pos));
-  const after = isWordChar(cpAt(hay, pos));
-  switch (kind) {
-    case "boundary":
-      return before !== after;
-    case "wordStart":
-      return !before && after;
-    case "wordEnd":
-      return before && !after;
-  }
-}
-function pikeExec(prog, groupCount, caseInsensitive, hay, start2, end, budget) {
-  const ncap = 2 * (groupCount + 1);
-  const mark = new Int32Array(prog.length);
-  let gen = 1;
-  let clistPc = [];
-  let clistCaps = [];
-  let nlistPc = [];
-  let nlistCaps = [];
-  const stackPc = [];
-  const stackCaps = [];
-  let matched = null;
-  const initial = new Int32Array(ncap).fill(-1);
-  const add = (listPc, listCaps, pc0, caps0, pos) => {
-    stackPc.push(pc0);
-    stackCaps.push(caps0);
-    while (stackPc.length) {
-      const pc = stackPc.pop();
-      const caps = stackCaps.pop();
-      if (mark[pc] === gen) continue;
-      mark[pc] = gen;
-      const inst = prog[pc];
-      switch (inst.op) {
-        case 2 /* Jmp */:
-          stackPc.push(inst.x);
-          stackCaps.push(caps);
-          break;
-        case 1 /* Split */:
-          stackPc.push(inst.y, inst.x);
-          stackCaps.push(caps, caps);
-          break;
-        case 3 /* Save */: {
-          const next = caps.slice();
-          next[inst.n] = pos;
-          stackPc.push(pc + 1);
-          stackCaps.push(next);
-          break;
-        }
-        case 4 /* Assert */:
-          if (checkAssert(inst.kind, hay, pos)) {
-            stackPc.push(pc + 1);
-            stackCaps.push(caps);
-          }
-          break;
-        default:
-          listPc.push(pc);
-          listCaps.push(caps);
-      }
-    }
-  };
-  let i = start2;
-  if (budget.steps <= 0 || now() > budget.deadline) {
-    budget.exhausted = true;
-    return "budget";
-  }
-  let steps = 0;
-  for (; ; ) {
-    if (!matched) add(clistPc, clistCaps, 0, initial, i);
-    const cp = i < end ? hay.codePointAt(i) : -1;
-    const width = cp > 65535 ? 2 : 1;
-    if (clistPc.length === 0) {
-      if (matched || i >= end) break;
-      gen++;
-      i += width;
-      continue;
-    }
-    const folded = cp >= 0 && caseInsensitive ? foldCodePoint(cp) : cp;
-    gen++;
-    nlistPc = [];
-    nlistCaps = [];
-    for (let t = 0; t < clistPc.length; t++) {
-      if (++steps >= 4096) {
-        budget.steps -= steps;
-        steps = 0;
-        if (budget.steps <= 0 || now() > budget.deadline) {
-          budget.exhausted = true;
-          return "budget";
-        }
-      }
-      const inst = prog[clistPc[t]];
-      if (inst.op === 0 /* Char */) {
-        if (cp >= 0 && inst.test(cp, folded)) add(nlistPc, nlistCaps, clistPc[t] + 1, clistCaps[t], i + width);
-      } else if (inst.op === 5 /* Match */) {
-        matched = clistCaps[t];
-        break;
-      }
-    }
-    clistPc = nlistPc;
-    clistCaps = nlistCaps;
-    if (i >= end) break;
-    i += width;
-  }
-  budget.steps -= steps;
-  if (!matched) return null;
-  const groups = [];
-  for (let g = 0; g <= groupCount; g++) {
-    const a = matched[2 * g];
-    const b = matched[2 * g + 1];
-    groups.push(a >= 0 && b >= 0 ? hay.slice(a, b) : void 0);
-  }
-  return { start: matched[0], end: matched[1], groups };
-}
-var WORD_CLASS = "[\\p{L}\\p{M}\\p{Nd}\\p{Pc}]";
-var REGEX_BOUNDARY = `(?:(?<=${WORD_CLASS})(?!${WORD_CLASS})|(?<!${WORD_CLASS})(?=${WORD_CLASS}))`;
-function hasNestedRepeat(source) {
-  const quantifierAt = (i) => {
-    const c = source[i];
-    if (c === "*" || c === "+") return { repeats: true, many: true };
-    if (c === "{") {
-      const m = /^\{(\d*)(,?)(\d*)\}/.exec(source.slice(i));
-      if (m) {
-        const max = m[2] ? m[3] ? Number(m[3]) : Infinity : Number(m[1]);
-        return { repeats: max > 1, many: max > 1 };
-      }
-    }
-    return { repeats: false, many: false };
-  };
-  const stack = [];
-  let inClass = false;
-  for (let i = 0; i < source.length; i++) {
-    const c = source[i];
-    if (c === "\\") {
-      i++;
-      continue;
-    }
-    if (inClass) {
-      if (c === "]") inClass = false;
-      continue;
-    }
-    if (c === "[") {
-      inClass = true;
-    } else if (c === "(") {
-      stack.push(false);
-    } else if (c === ")") {
-      const inner = stack.pop() ?? false;
-      const q = quantifierAt(i + 1);
-      if (inner && q.many) return true;
-      if (stack.length && (inner || q.repeats)) stack[stack.length - 1] = true;
-    } else if (stack.length && quantifierAt(i).repeats) {
-      stack[stack.length - 1] = true;
-    }
-  }
-  return false;
-}
-function compileRegex(query, o) {
-  if (hasNestedRepeat(query)) {
-    throw new PatternError(
-      "too_complex",
-      "a repeated group containing a repeat, like (a+)+, can take exponential time; rewrite it without nesting"
-    );
-  }
-  let source = query;
-  if (o.wholeWord || o.matchPrefix && o.matchSuffix) source = `${REGEX_BOUNDARY}(?:${query})${REGEX_BOUNDARY}`;
-  else if (o.matchPrefix) source = `${REGEX_BOUNDARY}(?:${query})`;
-  else if (o.matchSuffix) source = `(?:${query})${REGEX_BOUNDARY}`;
-  let re;
-  try {
-    re = new RegExp(source, o.matchCase ? "gu" : "giu");
-  } catch (error) {
-    throw new PatternError("invalid_pattern", `bad pattern: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  let slicedFor = null;
-  return {
-    mode: "regex",
-    spansParagraphs: false,
-    caseInsensitive: !o.matchCase,
-    groupCount: 0,
-    exec(hay, start2, end, budget) {
-      if (now() > budget.deadline) {
-        budget.exhausted = true;
-        return "budget";
-      }
-      let text = hay;
-      if (end < hay.length) {
-        if (!slicedFor || slicedFor.hay !== hay || slicedFor.end !== end) {
-          slicedFor = { hay, end, text: hay.slice(0, end) };
-        }
-        text = slicedFor.text;
-      }
-      re.lastIndex = start2;
-      const m = re.exec(text);
-      if (!m) return null;
-      return { start: m.index, end: m.index + m[0].length, groups: Array.from(m) };
-    }
-  };
-}
-function compileFindPattern(query, options = {}) {
-  try {
-    if (Array.from(query).length > MAX_FIND_PATTERN_LENGTH) {
-      throw new PatternError("too_long", `the Find what text is longer than ${MAX_FIND_PATTERN_LENGTH} characters`);
-    }
-    if (options.regex) return { ok: true, pattern: compileRegex(query, options) };
-    const wildcards = !!options.wildcards && !options.literal;
-    const caseInsensitive = !options.matchCase && !wildcards;
-    let node;
-    let spans;
-    let groups = 0;
-    if (wildcards) {
-      ({ node, spans, groups } = parseWildcards(query));
-    } else {
-      ({ node, spans } = parseSpecial(query, options, caseInsensitive));
-      const before = options.wholeWord || options.matchPrefix;
-      const after = options.wholeWord || options.matchSuffix;
-      if (before || after) {
-        const items = [];
-        if (before) items.push({ k: "assert", kind: "boundary" });
-        items.push(node);
-        if (after) items.push({ k: "assert", kind: "boundary" });
-        node = { k: "cat", items };
-      }
-    }
-    const prog = compileProgram(node);
-    return {
-      ok: true,
-      pattern: {
-        mode: wildcards ? "wildcards" : "special",
-        spansParagraphs: spans,
-        caseInsensitive,
-        groupCount: groups,
-        exec: (hay, start2, end, budget) => pikeExec(prog, groups, caseInsensitive, hay, start2, end, budget)
-      }
-    };
-  } catch (error) {
-    if (error instanceof PatternError) return { ok: false, error: { code: error.code, message: error.message } };
-    return { ok: false, error: { code: "invalid_pattern", message: error instanceof Error ? error.message : String(error) } };
-  }
-}
-function findAllMatches(pattern, hay, options = {}) {
-  const budget = options.budget ?? createSearchBudget();
-  const maxMatches = options.maxMatches ?? 1e4;
-  const cuts = [...options.cuts ?? [], hay.length].sort((a, b) => a - b);
-  const matches = [];
-  let from = 0;
-  for (const cut of cuts) {
-    if (cut <= from) continue;
-    let pos = from;
-    from = cut;
-    for (; ; ) {
-      const m = pattern.exec(hay, pos, cut, budget);
-      if (m === "budget") return { matches, truncated: true };
-      if (!m) break;
-      const empty = m.end === m.start;
-      const next = empty ? m.end + (cpAt(hay, m.end) > 65535 ? 2 : 1) : m.end;
-      if (next > cut) break;
-      pos = next;
-      if (empty) continue;
-      matches.push(m);
-      if (matches.length >= maxMatches) return { matches, truncated: true };
-    }
-  }
-  return { matches, truncated: false };
-}
-function parseReplacement(replacement, options = {}) {
-  if (options.literal || options.regex) return replacement ? [{ type: "text", text: replacement }] : [];
-  const chars = toChars(replacement);
-  const out = [];
-  let cur = "";
-  const flush = () => {
-    if (cur) out.push({ type: "text", text: cur });
-    cur = "";
-  };
-  let i = 0;
-  while (i < chars.length) {
-    const c = chars[i++];
-    if (c === "\\" && options.wildcards && i < chars.length) {
-      const d = chars[i];
-      if (/[1-9]/.test(d)) {
-        flush();
-        out.push({ type: "group", index: Number(d) });
-      } else {
-        cur += d;
-      }
-      i++;
-      continue;
-    }
-    if (c === "^" && i < chars.length) {
-      const n = chars[i];
-      if (n === "&" || n === "c") {
-        flush();
-        out.push(n === "&" ? { type: "found" } : { type: "clipboard" });
-        i++;
-        continue;
-      }
-      const code = replaceCode(n);
-      if (code !== null) {
-        cur += code;
-        i++;
-        continue;
-      }
-      const num = numericCode(chars, i);
-      if (num) {
-        cur += String.fromCodePoint(num.cp);
-        i += num.used;
-        continue;
-      }
-    }
-    cur += c;
-  }
-  flush();
-  return out;
-}
-function expandReplacement(pieces, match, clipboardText = "") {
-  let out = "";
-  for (const piece of pieces) {
-    switch (piece.type) {
-      case "text":
-        out += piece.text;
-        break;
-      case "found":
-        out += match.groups[0] ?? "";
-        break;
-      case "group":
-        out += match.groups[piece.index] ?? "";
-        break;
-      case "clipboard":
-        out += clipboardText.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
-        break;
-    }
-  }
-  return out;
-}
-
-// src/extensions/find-replace/search.ts
-var DELETION_MARK = "deletion";
-var DROPPED_REPLACEMENT_MARKS = /* @__PURE__ */ new Set([DELETION_MARK, "formatChange"]);
-var OBJECT_CHAR = "\uFFFC";
-function searchDocument(doc, query, options = {}, searchOptions = {}) {
-  if (!query) return { matches: [], truncated: false, error: null };
-  const compiled = compileFindPattern(query, options);
-  if (!compiled.ok) return { matches: [], truncated: false, error: compiled.error };
-  const pattern = compiled.pattern;
-  const pieces = parseReplacement(searchOptions.replacement ?? "", options);
-  const budget = createSearchBudget({ timeLimitMs: searchOptions.timeLimitMs });
-  const maxMatches = searchOptions.maxMatches ?? 1e4;
-  const blocks = [];
-  doc.descendants((node, pos, parent, index) => {
-    if (!node.isTextblock) return true;
-    blocks.push({ node, pos, parent, index });
-    return false;
-  });
-  const chunks = [];
-  blocks.forEach((block, i) => {
-    const prev = blocks[i - 1];
-    const joins = pattern.spansParagraphs && prev && prev.parent === block.parent && prev.index + 1 === block.index;
-    if (joins) chunks[chunks.length - 1].push(block);
-    else chunks.push([block]);
-  });
-  const matches = [];
-  let truncated = false;
-  for (const chunk of chunks) {
-    let hay = "";
-    const posOf = [];
-    const endOf = [];
-    const cuts = [];
-    chunk.forEach((block, k) => {
-      const contentStart = block.pos + 1;
-      block.node.forEach((child, offset) => {
-        const at = contentStart + offset;
-        if (child.marks.some((m) => m.type.name === DELETION_MARK)) {
-          if (cuts[cuts.length - 1] !== hay.length) cuts.push(hay.length);
-          return;
-        }
-        if (child.isText) {
-          const text = child.text ?? "";
-          for (let j = 0; j < text.length; j++) {
-            posOf.push(at + j);
-            endOf.push(at + j + 1);
-          }
-          hay += text;
-        } else {
-          posOf.push(at);
-          endOf.push(at + child.nodeSize);
-          hay += child.type.name === "hardBreak" ? "\n" : OBJECT_CHAR;
-        }
-      });
-      const next = chunk[k + 1];
-      if (next) {
-        posOf.push(contentStart + block.node.content.size);
-        endOf.push(next.pos + 1);
-        hay += FIND_PARAGRAPH_MARK;
-      }
-    });
-    if (!hay) continue;
-    const result = findAllMatches(pattern, hay, {
-      cuts,
-      budget,
-      maxMatches: maxMatches - matches.length
-    });
-    for (const m of result.matches) {
-      matches.push({
-        from: posOf[m.start],
-        to: endOf[m.end - 1],
-        text: m.groups[0] ?? hay.slice(m.start, m.end),
-        replacement: expandReplacement(pieces, m, searchOptions.clipboardText ?? "")
-      });
-    }
-    if (result.truncated) {
-      truncated = true;
-      break;
-    }
-  }
-  return { matches, truncated, error: null };
-}
-function replacementMarks(doc, from, to) {
-  const $from = doc.resolve(from);
-  const node = from < to ? $from.nodeAfter : null;
-  const marks = node ? node.marks : $from.marks();
-  return marks.filter((m) => !DROPPED_REPLACEMENT_MARKS.has(m.type.name));
-}
-function inlineContent(schema, text, marks) {
-  const nodes = [];
-  const hardBreak = schema.nodes.hardBreak;
-  const parts = hardBreak ? text.split("\n") : [text];
-  parts.forEach((part, i) => {
-    if (i > 0) nodes.push(hardBreak.create(null, null, marks));
-    if (part) nodes.push(schema.text(part, marks));
-  });
-  return nodes;
-}
-function applyReplacements(tr, matches) {
-  const ends = new Array(matches.length);
-  const schema = tr.doc.type.schema;
-  for (let i = matches.length - 1; i >= 0; i--) {
-    const { from, to, replacement } = matches[i];
-    const marks = replacementMarks(tr.doc, from, to);
-    const parts = replacement.split(/[\r\u2029]/);
-    const stepsBefore = tr.steps.length;
-    const first = inlineContent(schema, parts[0], marks);
-    if (first.length) tr.replaceWith(from, to, first);
-    else if (to > from) tr.delete(from, to);
-    let pos = tr.mapping.slice(stepsBefore).map(to, 1);
-    for (let k = 1; k < parts.length; k++) {
-      tr.split(pos);
-      pos += 2;
-      const content = inlineContent(schema, parts[k], marks);
-      if (content.length) {
-        tr.insert(pos, content);
-        pos += content.reduce((size, node) => size + node.nodeSize, 0);
-      }
-    }
-    const map = tr.mapping.slice(stepsBefore);
-    for (let j = i + 1; j < matches.length; j++) ends[j] = map.map(ends[j], 1);
-    ends[i] = pos;
-  }
-  return ends;
-}
-
-// src/extensions/find-replace/extension.ts
 var EMPTY_OPTIONS = Object.freeze({});
 var EMPTY_FIND_REPLACE_SNAPSHOT = Object.freeze({
   open: false,
@@ -7618,16 +6750,6 @@ export {
   CrossReference,
   documentStructureCommandItems,
   getDocumentStructureCommandItems,
-  FIND_PARAGRAPH_MARK,
-  MAX_FIND_PATTERN_LENGTH,
-  createSearchBudget,
-  foldCodePoint,
-  compileFindPattern,
-  findAllMatches,
-  parseReplacement,
-  expandReplacement,
-  searchDocument,
-  applyReplacements,
   EMPTY_FIND_REPLACE_SNAPSHOT,
   FindReplaceStore,
   findReplacePluginKey,
@@ -7651,4 +6773,4 @@ export {
   validateFindPattern,
   createTableCommands
 };
-//# sourceMappingURL=chunk-DDADOHJW.js.map
+//# sourceMappingURL=chunk-Q25ZS4F7.js.map