@harbour-enterprises/superdoc 1.6.0-next.1 → 1.6.0-next.3

package/dist/chunks/{index-Cto-XsBE.cjs → index-vSyQ2hF9.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-DpKjVrPl.cjs");
+const superEditor_converter = require("./SuperConverter-UL6mfKlt.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -9387,6 +9387,158 @@ class Schema {
     return Object.fromEntries(markEntries);
   }
 }
+const positionTrackerKey = new superEditor_converter.PluginKey("positionTracker");
+function createPositionTrackerPlugin() {
+  return new superEditor_converter.Plugin({
+    key: positionTrackerKey,
+    state: {
+      init() {
+        return {
+          decorations: DecorationSet.empty,
+          generation: 0
+        };
+      },
+      apply(tr, state) {
+        let { decorations, generation } = state;
+        const meta = tr.getMeta(positionTrackerKey);
+        if (meta?.action === "add") {
+          decorations = decorations.add(tr.doc, meta.decorations);
+        } else if (meta?.action === "remove") {
+          const toRemove = decorations.find().filter((decoration) => meta.ids.includes(decoration.spec.id));
+          decorations = decorations.remove(toRemove);
+        } else if (meta?.action === "removeByType") {
+          const toRemove = decorations.find().filter((decoration) => decoration.spec.type === meta.type);
+          decorations = decorations.remove(toRemove);
+        }
+        if (tr.docChanged) {
+          decorations = decorations.map(tr.mapping, tr.doc);
+          generation += 1;
+        }
+        return { decorations, generation };
+      }
+    },
+    props: {
+      decorations() {
+        return DecorationSet.empty;
+      }
+    }
+  });
+}
+class PositionTracker {
+  #editor;
+  constructor(editor) {
+    this.#editor = editor;
+  }
+  #getState() {
+    if (!this.#editor?.state) return null;
+    return positionTrackerKey.getState(this.#editor.state) ?? null;
+  }
+  track(from3, to, spec) {
+    const id = uuid.v4();
+    if (!this.#editor?.state) return id;
+    const fullSpec = { kind: "range", ...spec, id };
+    const deco = Decoration.inline(from3, to, {}, fullSpec);
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "add",
+      decorations: [deco]
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+    return id;
+  }
+  trackMany(ranges) {
+    if (!this.#editor?.state) {
+      return ranges.map(() => uuid.v4());
+    }
+    const ids = [];
+    const decorations = [];
+    for (const { from: from3, to, spec } of ranges) {
+      const id = uuid.v4();
+      ids.push(id);
+      const fullSpec = { kind: "range", ...spec, id };
+      decorations.push(Decoration.inline(from3, to, {}, fullSpec));
+    }
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "add",
+      decorations
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+    return ids;
+  }
+  untrack(id) {
+    if (!this.#editor?.state) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "remove",
+      ids: [id]
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  untrackMany(ids) {
+    if (!this.#editor?.state || ids.length === 0) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "remove",
+      ids
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  untrackByType(type) {
+    if (!this.#editor?.state) return;
+    const tr = this.#editor.state.tr.setMeta(positionTrackerKey, {
+      action: "removeByType",
+      type
+    }).setMeta("addToHistory", false);
+    this.#editor.dispatch(tr);
+  }
+  resolve(id) {
+    const state = this.#getState();
+    if (!state) return null;
+    const found = state.decorations.find().find((decoration) => decoration.spec.id === id);
+    if (!found) return null;
+    const spec = found.spec;
+    return {
+      id: spec.id,
+      from: found.from,
+      to: found.to,
+      spec
+    };
+  }
+  resolveMany(ids) {
+    const result = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      result.set(id, null);
+    }
+    const state = this.#getState();
+    if (!state || ids.length === 0) return result;
+    const idSet = new Set(ids);
+    for (const decoration of state.decorations.find()) {
+      const spec = decoration.spec;
+      if (idSet.has(spec.id)) {
+        result.set(spec.id, {
+          id: spec.id,
+          from: decoration.from,
+          to: decoration.to,
+          spec
+        });
+      }
+    }
+    return result;
+  }
+  findByType(type) {
+    const state = this.#getState();
+    if (!state) return [];
+    return state.decorations.find().filter((decoration) => decoration.spec.type === type).map((decoration) => {
+      const spec = decoration.spec;
+      return {
+        id: spec.id,
+        from: decoration.from,
+        to: decoration.to,
+        spec
+      };
+    });
+  }
+  get generation() {
+    return this.#getState()?.generation ?? 0;
+  }
+}
 class OxmlNode extends Node$1 {
   constructor(config) {
     super(config);
@@ -11747,6 +11899,34 @@ const EditorFocus = Extension.create({
     return [editorFocusPlugin];
   }
 });
+const PositionTrackerExtension = Extension.create({
+  name: "positionTracker",
+  addStorage() {
+    return {
+      tracker: null
+    };
+  },
+  addPmPlugins() {
+    return [createPositionTrackerPlugin()];
+  },
+  onCreate() {
+    const existing = this.editor?.positionTracker ?? this.storage.tracker;
+    if (existing) {
+      this.storage.tracker = existing;
+      this.editor.positionTracker = existing;
+      return;
+    }
+    const tracker = new PositionTracker(this.editor);
+    this.storage.tracker = tracker;
+    this.editor.positionTracker = tracker;
+  },
+  onDestroy() {
+    if (this.editor?.positionTracker === this.storage.tracker) {
+      this.editor.positionTracker = null;
+    }
+    this.storage.tracker = null;
+  }
+});
 class EventEmitter {
   #events = /* @__PURE__ */ new Map();
   /**
@@ -13081,6 +13261,90 @@ const CommentsPlugin = Extension.create({
   name: "comments",
   addCommands() {
     return {
+      /**
+       * Add a comment to the current selection
+       * @category Command
+       * @param {string|Object} contentOrOptions - Comment content as a string, or an options object
+       * @param {string} [contentOrOptions.content] - The comment content (text or HTML)
+       * @param {string} [contentOrOptions.author] - Author name (defaults to user from editor config)
+       * @param {string} [contentOrOptions.authorEmail] - Author email (defaults to user from editor config)
+       * @param {string} [contentOrOptions.authorImage] - Author image URL (defaults to user from editor config)
+       * @param {boolean} [contentOrOptions.isInternal=false] - Whether the comment is internal/private
+       * @returns {boolean} True if the comment was added successfully, false otherwise
+       * @example
+       * // Simple usage with just content
+       * editor.commands.addComment('This needs review')
+       *
+       * // With options
+       * editor.commands.addComment({
+       *   content: 'Please clarify this section',
+       *   author: 'Jane Doe',
+       *   isInternal: true
+       * })
+       *
+       * // To get the comment ID, listen to the commentsUpdate event
+       * editor.on('commentsUpdate', (event) => {
+       *   if (event.type === 'add') {
+       *     console.log('New comment ID:', event.activeCommentId)
+       *   }
+       * })
+       */
+      addComment: (contentOrOptions) => ({ tr, dispatch, editor }) => {
+        const { selection } = tr;
+        const { $from, $to } = selection;
+        if ($from.pos === $to.pos) {
+          console.warn("addComment requires a text selection. Please select text before adding a comment.");
+          return false;
+        }
+        let content, author, authorEmail, authorImage, isInternal;
+        if (typeof contentOrOptions === "string") {
+          content = contentOrOptions;
+        } else if (contentOrOptions && typeof contentOrOptions === "object") {
+          content = contentOrOptions.content;
+          author = contentOrOptions.author;
+          authorEmail = contentOrOptions.authorEmail;
+          authorImage = contentOrOptions.authorImage;
+          isInternal = contentOrOptions.isInternal;
+        }
+        const commentId = uuid.v4();
+        const resolvedInternal = isInternal ?? false;
+        const configUser = editor.options?.user || {};
+        tr.setMeta(CommentsPluginKey, { event: "add" });
+        tr.addMark(
+          $from.pos,
+          $to.pos,
+          editor.schema.marks[CommentMarkName$1].create({
+            commentId,
+            internal: resolvedInternal
+          })
+        );
+        if (dispatch) dispatch(tr);
+        const commentPayload = normalizeCommentEventPayload({
+          conversation: {
+            commentId,
+            isInternal: resolvedInternal,
+            commentText: content,
+            creatorName: author ?? configUser.name,
+            creatorEmail: authorEmail ?? configUser.email,
+            creatorImage: authorImage ?? configUser.image,
+            createdTime: Date.now()
+          },
+          editorOptions: editor.options,
+          fallbackCommentId: commentId,
+          fallbackInternal: resolvedInternal
+        });
+        editor.emit("commentsUpdate", {
+          type: comments_module_events.ADD,
+          comment: commentPayload,
+          activeCommentId: commentId
+        });
+        return true;
+      },
+      /**
+       * @private
+       * Internal command to insert a comment mark at the current selection.
+       * Use `addComment` for the public API.
+       */
       insertComment: (conversation = {}) => ({ tr, dispatch }) => {
         const { selection } = tr;
         const { $from, $to } = selection;
@@ -15524,7 +15788,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.6.0-next.1";
+const summaryVersion = "1.6.0-next.3";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -17017,7 +17281,7 @@ class Editor extends EventEmitter {
    */
   #createExtensionService() {
     const allowedExtensions = ["extension", "node", "mark"];
-    const coreExtensions = [Editable, Commands, EditorFocus, Keymap];
+    const coreExtensions = [Editable, Commands, EditorFocus, Keymap, PositionTrackerExtension];
     const externalExtensions = this.options.externalExtensions || [];
     const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension) => {
       const extensionType = typeof extension?.type === "string" ? extension.type : void 0;
@@ -18191,7 +18455,7 @@ class Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.6.0-next.1");
+    console.debug("[checkVersionMigrations] Current editor version", "1.6.0-next.3");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -75544,14 +75808,317 @@ function getMatchHighlights(state) {
   let search2 = searchKey.getState(state);
   return search2 ? search2.deco : DecorationSet.empty;
 }
-function setSearchState(tr, query, range = null, options = {}) {
-  if (options != null && (typeof options !== "object" || Array.isArray(options))) {
-    throw new TypeError("setSearchState options must be an object");
+const BLOCK_SEPARATOR = "\n";
+const ATOM_PLACEHOLDER = "";
+class SearchIndex {
+  /** @type {string} */
+  text = "";
+  /** @type {Segment[]} */
+  segments = [];
+  /** @type {boolean} */
+  valid = false;
+  /** @type {number} */
+  docSize = 0;
+  /**
+   * Build the search index from a ProseMirror document.
+   * Uses doc.textBetween for the flattened string and walks
+   * the document to build the segment offset map.
+   *
+   * @param {import('prosemirror-model').Node} doc - The ProseMirror document
+   */
+  build(doc2) {
+    this.text = doc2.textBetween(0, doc2.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
+    this.segments = [];
+    this.docSize = doc2.content.size;
+    let offset2 = 0;
+    this.#walkNodeContent(doc2, 0, offset2, (segment) => {
+      this.segments.push(segment);
+      offset2 = segment.offsetEnd;
+    });
+    this.valid = true;
+  }
+  /**
+   * Walk the content of a node to build segments.
+   * This method processes the children of a node, given the position
+   * where the node's content starts.
+   *
+   * @param {import('prosemirror-model').Node} node - Current node
+   * @param {number} contentStart - Document position where this node's content starts
+   * @param {number} offset - Current offset in flattened string
+   * @param {(segment: Segment) => void} addSegment - Callback to add a segment
+   * @returns {number} The new offset after processing this node's content
+   */
+  #walkNodeContent(node, contentStart, offset2, addSegment) {
+    let currentOffset = offset2;
+    let isFirstChild = true;
+    node.forEach((child, childContentOffset) => {
+      const childDocPos = contentStart + childContentOffset;
+      if (child.isBlock && !isFirstChild) {
+        addSegment({
+          offsetStart: currentOffset,
+          offsetEnd: currentOffset + 1,
+          docFrom: childDocPos,
+          docTo: childDocPos,
+          kind: "blockSep"
+        });
+        currentOffset += 1;
+      }
+      currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment);
+      isFirstChild = false;
+    });
+    return currentOffset;
+  }
+  /**
+   * Recursively walk a node and its descendants to build segments.
+   *
+   * @param {import('prosemirror-model').Node} node - Current node
+   * @param {number} docPos - Document position at start of this node
+   * @param {number} offset - Current offset in flattened string
+   * @param {(segment: Segment) => void} addSegment - Callback to add a segment
+   * @returns {number} The new offset after processing this node
+   */
+  #walkNode(node, docPos, offset2, addSegment) {
+    if (node.isText) {
+      const text = node.text || "";
+      if (text.length > 0) {
+        addSegment({
+          offsetStart: offset2,
+          offsetEnd: offset2 + text.length,
+          docFrom: docPos,
+          docTo: docPos + text.length,
+          kind: "text"
+        });
+        return offset2 + text.length;
+      }
+      return offset2;
+    }
+    if (node.isLeaf) {
+      if (node.type.name === "hard_break") {
+        addSegment({
+          offsetStart: offset2,
+          offsetEnd: offset2 + 1,
+          docFrom: docPos,
+          docTo: docPos + node.nodeSize,
+          kind: "hardBreak"
+        });
+        return offset2 + 1;
+      }
+      addSegment({
+        offsetStart: offset2,
+        offsetEnd: offset2 + 1,
+        docFrom: docPos,
+        docTo: docPos + node.nodeSize,
+        kind: "atom"
+      });
+      return offset2 + 1;
+    }
+    return this.#walkNodeContent(node, docPos + 1, offset2, addSegment);
+  }
+  /**
+   * Mark the index as stale. It will be rebuilt on next search.
+   */
+  invalidate() {
+    this.valid = false;
+  }
+  /**
+   * Check if the index needs rebuilding for the given document.
+   *
+   * @param {import('prosemirror-model').Node} doc - The document to check against
+   * @returns {boolean} True if index is stale and needs rebuilding
+   */
+  isStale(doc2) {
+    return !this.valid || doc2.content.size !== this.docSize;
+  }
+  /**
+   * Ensure the index is valid for the given document.
+   * Rebuilds if stale.
+   *
+   * @param {import('prosemirror-model').Node} doc - The document
+   */
+  ensureValid(doc2) {
+    if (this.isStale(doc2)) {
+      this.build(doc2);
+    }
+  }
+  /**
+   * Convert an offset range in the flattened string to document ranges.
+   * Skips separator/atom segments and returns only text ranges.
+   *
+   * @param {number} start - Start offset in flattened string
+   * @param {number} end - End offset in flattened string
+   * @returns {DocRange[]} Array of document ranges (text segments only)
+   */
+  offsetRangeToDocRanges(start2, end2) {
+    const ranges = [];
+    for (const segment of this.segments) {
+      if (segment.offsetEnd <= start2) continue;
+      if (segment.offsetStart >= end2) break;
+      if (segment.kind !== "text") continue;
+      const overlapStart = Math.max(start2, segment.offsetStart);
+      const overlapEnd = Math.min(end2, segment.offsetEnd);
+      if (overlapStart < overlapEnd) {
+        const startInSegment = overlapStart - segment.offsetStart;
+        const endInSegment = overlapEnd - segment.offsetStart;
+        ranges.push({
+          from: segment.docFrom + startInSegment,
+          to: segment.docFrom + endInSegment
+        });
+      }
+    }
+    return ranges;
+  }
+  /**
+   * Find the document position for a given offset in the flattened string.
+   *
+   * @param {number} offset - Offset in flattened string
+   * @returns {number|null} Document position, or null if not found
+   */
+  offsetToDocPos(offset2) {
+    for (const segment of this.segments) {
+      if (offset2 >= segment.offsetStart && offset2 < segment.offsetEnd) {
+        if (segment.kind === "text") {
+          return segment.docFrom + (offset2 - segment.offsetStart);
+        }
+        return segment.docFrom;
+      }
+    }
+    if (this.segments.length > 0 && offset2 === this.segments[this.segments.length - 1].offsetEnd) {
+      const lastSeg = this.segments[this.segments.length - 1];
+      return lastSeg.docTo;
+    }
+    return null;
+  }
+  /**
+   * Escape special regex characters in a string.
+   *
+   * @param {string} str - String to escape
+   * @returns {string} Escaped string safe for use in RegExp
+   */
+  static escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Convert a plain search string to a whitespace-flexible regex pattern.
+   * This allows matching across paragraph boundaries.
+   *
+   * @param {string} searchString - The search string
+   * @returns {string} Regex pattern string
+   */
+  static toFlexiblePattern(searchString) {
+    const parts = searchString.split(/\s+/).filter((part) => part.length > 0);
+    if (parts.length === 0) return "";
+    return parts.map((part) => SearchIndex.escapeRegex(part)).join("\\s+");
+  }
+  /**
+   * Search the index for matches.
+   *
+   * @param {string | RegExp} pattern - Search pattern (string or regex)
+   * @param {Object} options - Search options
+   * @param {boolean} [options.caseSensitive=false] - Case sensitive search
+   * @param {number} [options.maxMatches=1000] - Maximum number of matches to return
+   * @returns {Array<{start: number, end: number, text: string}>} Array of matches with offsets
+   */
+  search(pattern, options = {}) {
+    const { caseSensitive = false, maxMatches = 1e3 } = options;
+    const matches = [];
+    let regex;
+    if (pattern instanceof RegExp) {
+      const flags = pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g";
+      regex = new RegExp(pattern.source, flags);
+    } else if (typeof pattern === "string") {
+      if (pattern.length === 0) return matches;
+      const flexiblePattern = SearchIndex.toFlexiblePattern(pattern);
+      if (flexiblePattern.length === 0) return matches;
+      const flags = caseSensitive ? "g" : "gi";
+      regex = new RegExp(flexiblePattern, flags);
+    } else {
+      return matches;
+    }
+    let match;
+    while ((match = regex.exec(this.text)) !== null && matches.length < maxMatches) {
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        text: match[0]
+      });
+      if (match[0].length === 0) {
+        regex.lastIndex++;
+      }
+    }
+    return matches;
   }
-  const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
-  return tr.setMeta(searchKey, { query, range, highlight });
 }
+const customSearchHighlightsKey = new superEditor_converter.PluginKey("customSearchHighlights");
 const isRegExp = (value) => Object.prototype.toString.call(value) === "[object RegExp]";
+const resolveInlineTextPosition = (doc2, position, direction) => {
+  const docSize = doc2.content.size;
+  if (!Number.isFinite(position) || position < 0 || position > docSize) {
+    return position;
+  }
+  const step = direction === "forward" ? 1 : -1;
+  let current = position;
+  let iterations = 0;
+  while (iterations < 8) {
+    iterations += 1;
+    const resolved = doc2.resolve(current);
+    const boundaryNode = direction === "forward" ? resolved.nodeAfter : resolved.nodeBefore;
+    if (!boundaryNode) break;
+    if (boundaryNode.isText) break;
+    if (!boundaryNode.isInline || boundaryNode.isAtom || boundaryNode.content.size === 0) break;
+    const next = current + step;
+    if (next < 0 || next > docSize) break;
+    current = next;
+    const adjacent = doc2.resolve(current);
+    const checkNode = direction === "forward" ? adjacent.nodeAfter : adjacent.nodeBefore;
+    if (checkNode && checkNode.isText) break;
+  }
+  return current;
+};
+const resolveSearchRange = ({ doc: doc2, from: from3, to, expectedText, highlights }) => {
+  const docSize = doc2.content.size;
+  let resolvedFrom = Math.max(0, Math.min(from3, docSize));
+  let resolvedTo = Math.max(0, Math.min(to, docSize));
+  if (highlights) {
+    const windowStart = Math.max(0, resolvedFrom - 4);
+    const windowEnd = Math.min(docSize, resolvedTo + 4);
+    const candidates = highlights.find(windowStart, windowEnd);
+    if (candidates.length > 0) {
+      let chosen = candidates[0];
+      if (expectedText) {
+        const matching = candidates.filter(
+          (decoration) => doc2.textBetween(decoration.from, decoration.to) === expectedText
+        );
+        if (matching.length > 0) {
+          chosen = matching[0];
+        }
+      }
+      resolvedFrom = chosen.from;
+      resolvedTo = chosen.to;
+    }
+  }
+  const normalizedFrom = resolveInlineTextPosition(doc2, resolvedFrom, "forward");
+  const normalizedTo = resolveInlineTextPosition(doc2, resolvedTo, "backward");
+  if (Number.isFinite(normalizedFrom) && Number.isFinite(normalizedTo) && normalizedFrom <= normalizedTo) {
+    resolvedFrom = normalizedFrom;
+    resolvedTo = normalizedTo;
+  }
+  return { from: resolvedFrom, to: resolvedTo };
+};
+const getPositionTracker = (editor) => {
+  if (!editor) return null;
+  if (editor.positionTracker) return editor.positionTracker;
+  const storageTracker = editor.storage?.positionTracker?.tracker;
+  if (storageTracker) {
+    editor.positionTracker = storageTracker;
+    return storageTracker;
+  }
+  const tracker = new PositionTracker(editor);
+  if (editor.storage?.positionTracker) {
+    editor.storage.positionTracker.tracker = tracker;
+  }
+  editor.positionTracker = tracker;
+  return tracker;
+};
 const Search = Extension.create({
   // @ts-expect-error - Storage type mismatch will be fixed in TS migration
   addStorage() {
@@ -75560,29 +76127,58 @@ const Search = Extension.create({
        * @private
        * @type {SearchMatch[]|null}
        */
-      searchResults: []
+      searchResults: [],
+      /**
+       * @private
+       * @type {boolean}
+       * Whether to apply CSS highlight classes to matches
+       */
+      highlightEnabled: true,
+      /**
+       * @private
+       * @type {SearchIndex}
+       * Lazily-built search index for cross-paragraph matching
+       */
+      searchIndex: new SearchIndex()
     };
   },
   addPmPlugins() {
     const editor = this.editor;
     const storage = this.storage;
+    const searchIndexInvalidatorPlugin = new superEditor_converter.Plugin({
+      key: new superEditor_converter.PluginKey("searchIndexInvalidator"),
+      appendTransaction(transactions, oldState, newState) {
+        const docChanged = transactions.some((tr) => tr.docChanged);
+        if (docChanged && storage?.searchIndex) {
+          storage.searchIndex.invalidate();
+        }
+        return null;
+      }
+    });
     const searchHighlightWithIdPlugin = new superEditor_converter.Plugin({
-      key: new superEditor_converter.PluginKey("customSearchHighlights"),
+      key: customSearchHighlightsKey,
       props: {
         decorations(state) {
           if (!editor) return null;
           const matches = storage?.searchResults;
           if (!matches?.length) return null;
-          const decorations = matches.map(
-            (match) => Decoration.inline(match.from, match.to, {
-              id: `search-match-${match.id}`
-            })
-          );
+          const highlightEnabled = storage?.highlightEnabled !== false;
+          const decorations = [];
+          for (const match of matches) {
+            const attrs = highlightEnabled ? { id: `search-match-${match.id}`, class: "ProseMirror-search-match" } : { id: `search-match-${match.id}` };
+            if (match.ranges && match.ranges.length > 0) {
+              for (const range of match.ranges) {
+                decorations.push(Decoration.inline(range.from, range.to, attrs));
+              }
+            } else {
+              decorations.push(Decoration.inline(match.from, match.to, attrs));
+            }
+          }
           return DecorationSet.create(state.doc, decorations);
         }
       }
     });
-    return [search(), searchHighlightWithIdPlugin];
+    return [search(), searchIndexInvalidatorPlugin, searchHighlightWithIdPlugin];
   },
   addCommands() {
     return {
@@ -75596,21 +76192,51 @@ const Search = Extension.create({
       goToFirstMatch: () => (
         /** @returns {boolean} */
         ({ state, editor, dispatch }) => {
+          const searchResults = this.storage?.searchResults;
+          if (Array.isArray(searchResults) && searchResults.length > 0) {
+            const firstMatch = searchResults[0];
+            const from3 = firstMatch.ranges?.[0]?.from ?? firstMatch.from;
+            const to = firstMatch.ranges?.[0]?.to ?? firstMatch.to;
+            if (typeof from3 !== "number" || typeof to !== "number") {
+              return false;
+            }
+            editor.view.focus();
+            const tr2 = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, from3, to)).scrollIntoView();
+            if (dispatch) dispatch(tr2);
+            const presentationEditor2 = editor.presentationEditor;
+            if (presentationEditor2 && typeof presentationEditor2.scrollToPosition === "function") {
+              const didScroll = presentationEditor2.scrollToPosition(from3, { block: "center" });
+              if (didScroll) return true;
+            }
+            try {
+              const domPos = editor.view.domAtPos(from3);
+              if (domPos?.node?.scrollIntoView) {
+                domPos.node.scrollIntoView(true);
+              }
+            } catch {
+            }
+            return true;
+          }
           const highlights = getMatchHighlights(state);
           if (!highlights) return false;
           const decorations = highlights.find();
           if (!decorations?.length) return false;
-          const firstMatch = decorations[0];
+          const firstDeco = decorations[0];
           editor.view.focus();
-          const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, firstMatch.from, firstMatch.to)).scrollIntoView();
+          const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, firstDeco.from, firstDeco.to)).scrollIntoView();
           if (dispatch) dispatch(tr);
           const presentationEditor = editor.presentationEditor;
           if (presentationEditor && typeof presentationEditor.scrollToPosition === "function") {
-            const didScroll = presentationEditor.scrollToPosition(firstMatch.from, { block: "center" });
+            const didScroll = presentationEditor.scrollToPosition(firstDeco.from, { block: "center" });
             if (didScroll) return true;
           }
-          const domPos = editor.view.domAtPos(firstMatch.from);
-          domPos?.node?.scrollIntoView(true);
+          try {
+            const domPos = editor.view.domAtPos(firstDeco.from);
+            if (domPos?.node?.scrollIntoView) {
+              domPos.node.scrollIntoView(true);
+            }
+          } catch {
+          }
           return true;
         }
       ),
@@ -75628,53 +76254,57 @@ const Search = Extension.create({
        *
        * // Search without visual highlighting
        * const silentMatches = editor.commands.search('test', { highlight: false })
-       * @note Returns array of SearchMatch objects with positions and IDs
+       *
+       * // Cross-paragraph search (works by default for plain strings)
+       * const crossParagraphMatches = editor.commands.search('end of paragraph start of next')
+       * @note Returns array of SearchMatch objects with positions and IDs.
+       *       Plain string searches are whitespace-flexible and match across paragraphs.
+       *       Regex searches match exactly as specified.
        */
       search: (patternInput, options = {}) => (
         /** @returns {SearchMatch[]} */
-        ({ state, dispatch }) => {
+        ({ state, dispatch, editor }) => {
           if (options != null && (typeof options !== "object" || Array.isArray(options))) {
             throw new TypeError("Search options must be an object");
           }
           const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
-          let pattern;
+          const maxMatches = typeof options?.maxMatches === "number" ? options.maxMatches : 1e3;
           let caseSensitive = false;
-          let regexp = false;
-          const wholeWord = false;
+          let searchPattern = patternInput;
           if (isRegExp(patternInput)) {
-            const regexPattern = (
-              /** @type {RegExp} */
-              patternInput
-            );
-            regexp = true;
-            pattern = regexPattern.source;
-            caseSensitive = !regexPattern.flags.includes("i");
+            caseSensitive = !patternInput.flags.includes("i");
+            searchPattern = patternInput;
           } else if (typeof patternInput === "string" && /^\/(.+)\/([gimsuy]*)$/.test(patternInput)) {
             const [, body, flags] = patternInput.match(/^\/(.+)\/([gimsuy]*)$/);
-            regexp = true;
-            pattern = body;
             caseSensitive = !flags.includes("i");
+            searchPattern = new RegExp(body, flags.includes("g") ? flags : flags + "g");
           } else {
-            pattern = String(patternInput);
+            searchPattern = String(patternInput);
           }
-          const query = new SearchQuery({
-            search: pattern,
+          const searchIndex = this.storage.searchIndex;
+          searchIndex.ensureValid(state.doc);
+          const indexMatches = searchIndex.search(searchPattern, {
             caseSensitive,
-            regexp,
-            wholeWord
+            maxMatches
           });
-          const tr = setSearchState(state.tr, query, null, { highlight });
-          dispatch(tr);
-          const newState = state.apply(tr);
-          const decoSet = getMatchHighlights(newState);
-          const matches = decoSet ? decoSet.find() : [];
-          const resultMatches = matches.map((d) => ({
-            from: d.from,
-            to: d.to,
-            text: newState.doc.textBetween(d.from, d.to),
-            id: uuid.v4()
-          }));
+          const resultMatches = [];
+          for (const indexMatch of indexMatches) {
+            const ranges = searchIndex.offsetRangeToDocRanges(indexMatch.start, indexMatch.end);
+            if (ranges.length === 0) continue;
+            const matchTexts = ranges.map((r2) => state.doc.textBetween(r2.from, r2.to));
+            const combinedText = matchTexts.join("");
+            const match = {
+              from: ranges[0].from,
+              to: ranges[ranges.length - 1].to,
+              text: combinedText,
+              id: uuid.v4(),
+              ranges,
+              trackerIds: []
+            };
+            resultMatches.push(match);
+          }
           this.storage.searchResults = resultMatches;
+          this.storage.highlightEnabled = highlight;
           return resultMatches;
         }
       ),
@@ -75685,12 +76315,48 @@ const Search = Extension.create({
        * @example
        * const searchResults = editor.commands.search('test string')
        * editor.commands.goToSearchResult(searchResults[3])
-       * @note Scrolls to match and selects it
+       * @note Scrolls to match and selects it. For multi-range matches (cross-paragraph),
+       *       selects the first range and scrolls to it.
        */
       goToSearchResult: (match) => (
         /** @returns {boolean} */
         ({ state, dispatch, editor }) => {
-          const { from: from3, to } = match;
+          const positionTracker = getPositionTracker(editor);
+          const doc2 = state.doc;
+          const highlights = getMatchHighlights(state);
+          let from3, to;
+          if (match?.ranges && match.ranges.length > 0 && match?.trackerIds && match.trackerIds.length > 0) {
+            if (positionTracker?.resolve && match.trackerIds[0]) {
+              const resolved = positionTracker.resolve(match.trackerIds[0]);
+              if (resolved) {
+                from3 = resolved.from;
+                to = resolved.to;
+              }
+            }
+            if (from3 === void 0) {
+              from3 = match.ranges[0].from;
+              to = match.ranges[0].to;
+            }
+          } else {
+            from3 = match.from;
+            to = match.to;
+            if (positionTracker?.resolve && match?.id) {
+              const resolved = positionTracker.resolve(match.id);
+              if (resolved) {
+                from3 = resolved.from;
+                to = resolved.to;
+              }
+            }
+          }
+          const normalized = resolveSearchRange({
+            doc: doc2,
+            from: from3,
+            to,
+            expectedText: match?.text ?? null,
+            highlights
+          });
+          from3 = normalized.from;
+          to = normalized.to;
           editor.view.focus();
           const tr = state.tr.setSelection(superEditor_converter.TextSelection.create(state.doc, from3, to)).scrollIntoView();
           if (dispatch) dispatch(tr);