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

package/dist/superdoc.umd.js

@@ -38097,7 +38097,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.6.0-next.1") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.6.0-next.2") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -47391,6 +47391,158 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return Object.fromEntries(markEntries);
     }
   };
+  const positionTrackerKey = new PluginKey("positionTracker");
+  function createPositionTrackerPlugin() {
+    return new Plugin({
+      key: positionTrackerKey,
+      state: {
+        init() {
+          return {
+            decorations: DecorationSet.empty,
+            generation: 0
+          };
+        },
+        apply(tr, state) {
+          let { decorations, generation } = state;
+          const meta2 = tr.getMeta(positionTrackerKey);
+          if (meta2?.action === "add") {
+            decorations = decorations.add(tr.doc, meta2.decorations);
+          } else if (meta2?.action === "remove") {
+            const toRemove = decorations.find().filter((decoration) => meta2.ids.includes(decoration.spec.id));
+            decorations = decorations.remove(toRemove);
+          } else if (meta2?.action === "removeByType") {
+            const toRemove = decorations.find().filter((decoration) => decoration.spec.type === meta2.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(from2, to, spec) {
+      const id = v4();
+      if (!this.#editor?.state) return id;
+      const fullSpec = { kind: "range", ...spec, id };
+      const deco = Decoration.inline(from2, 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(() => v4());
+      }
+      const ids = [];
+      const decorations = [];
+      for (const { from: from2, to, spec } of ranges) {
+        const id = v4();
+        ids.push(id);
+        const fullSpec = { kind: "range", ...spec, id };
+        decorations.push(Decoration.inline(from2, 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 found2 = state.decorations.find().find((decoration) => decoration.spec.id === id);
+      if (!found2) return null;
+      const spec = found2.spec;
+      return {
+        id: spec.id,
+        from: found2.from,
+        to: found2.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$2 {
     constructor(config2) {
       super(config2);
@@ -49751,6 +49903,34 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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;
+    }
+  });
   let EventEmitter$1 = class EventEmitter {
     #events = /* @__PURE__ */ new Map();
     /**
@@ -64003,7 +64183,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.6.0-next.1";
+  const summaryVersion = "1.6.0-next.2";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -65497,7 +65677,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      */
     #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;
@@ -66671,7 +66851,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * 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.2");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -123801,14 +123981,317 @@ ${o}
     let search2 = searchKey.getState(state);
     return search2 ? search2.deco : DecorationSet.empty;
   }
-  function setSearchState(tr, query, range2 = 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(node2, contentStart, offset2, addSegment) {
+      let currentOffset = offset2;
+      let isFirstChild = true;
+      node2.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(node2, docPos, offset2, addSegment) {
+      if (node2.isText) {
+        const text2 = node2.text || "";
+        if (text2.length > 0) {
+          addSegment({
+            offsetStart: offset2,
+            offsetEnd: offset2 + text2.length,
+            docFrom: docPos,
+            docTo: docPos + text2.length,
+            kind: "text"
+          });
+          return offset2 + text2.length;
+        }
+        return offset2;
+      }
+      if (node2.isLeaf) {
+        if (node2.type.name === "hard_break") {
+          addSegment({
+            offsetStart: offset2,
+            offsetEnd: offset2 + 1,
+            docFrom: docPos,
+            docTo: docPos + node2.nodeSize,
+            kind: "hardBreak"
+          });
+          return offset2 + 1;
+        }
+        addSegment({
+          offsetStart: offset2,
+          offsetEnd: offset2 + 1,
+          docFrom: docPos,
+          docTo: docPos + node2.nodeSize,
+          kind: "atom"
+        });
+        return offset2 + 1;
+      }
+      return this.#walkNodeContent(node2, 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 matches2 = [];
+      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 matches2;
+        const flexiblePattern = SearchIndex.toFlexiblePattern(pattern);
+        if (flexiblePattern.length === 0) return matches2;
+        const flags = caseSensitive ? "g" : "gi";
+        regex = new RegExp(flexiblePattern, flags);
+      } else {
+        return matches2;
+      }
+      let match;
+      while ((match = regex.exec(this.text)) !== null && matches2.length < maxMatches) {
+        matches2.push({
+          start: match.index,
+          end: match.index + match[0].length,
+          text: match[0]
+        });
+        if (match[0].length === 0) {
+          regex.lastIndex++;
+        }
+      }
+      return matches2;
     }
-    const highlight = typeof options?.highlight === "boolean" ? options.highlight : true;
-    return tr.setMeta(searchKey, { query, range: range2, highlight });
   }
+  const customSearchHighlightsKey = new PluginKey("customSearchHighlights");
   const isRegExp = (value) => Object.prototype.toString.call(value) === "[object RegExp]";
+  const resolveInlineTextPosition = (doc2, position2, direction) => {
+    const docSize = doc2.content.size;
+    if (!Number.isFinite(position2) || position2 < 0 || position2 > docSize) {
+      return position2;
+    }
+    const step = direction === "forward" ? 1 : -1;
+    let current = position2;
+    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 next2 = current + step;
+      if (next2 < 0 || next2 > docSize) break;
+      current = next2;
+      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: from2, to, expectedText, highlights }) => {
+    const docSize = doc2.content.size;
+    let resolvedFrom = Math.max(0, Math.min(from2, 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() {
@@ -123817,29 +124300,58 @@ ${o}
          * @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 Plugin({
+        key: new 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 Plugin({
-        key: new PluginKey("customSearchHighlights"),
+        key: customSearchHighlightsKey,
         props: {
           decorations(state) {
             if (!editor) return null;
             const matches2 = storage?.searchResults;
             if (!matches2?.length) return null;
-            const decorations = matches2.map(
-              (match) => Decoration.inline(match.from, match.to, {
-                id: `search-match-${match.id}`
-              })
-            );
+            const highlightEnabled = storage?.highlightEnabled !== false;
+            const decorations = [];
+            for (const match of matches2) {
+              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 range2 of match.ranges) {
+                  decorations.push(Decoration.inline(range2.from, range2.to, attrs));
+                }
+              } else {
+                decorations.push(Decoration.inline(match.from, match.to, attrs));
+              }
+            }
             return DecorationSet.create(state.doc, decorations);
           }
         }
       });
-      return [search$1(), searchHighlightWithIdPlugin];
+      return [search$1(), searchIndexInvalidatorPlugin, searchHighlightWithIdPlugin];
     },
     addCommands() {
       return {
@@ -123853,21 +124365,51 @@ ${o}
         goToFirstMatch: () => (
           /** @returns {boolean} */
           ({ state, editor, dispatch }) => {
+            const searchResults = this.storage?.searchResults;
+            if (Array.isArray(searchResults) && searchResults.length > 0) {
+              const firstMatch = searchResults[0];
+              const from2 = firstMatch.ranges?.[0]?.from ?? firstMatch.from;
+              const to = firstMatch.ranges?.[0]?.to ?? firstMatch.to;
+              if (typeof from2 !== "number" || typeof to !== "number") {
+                return false;
+              }
+              editor.view.focus();
+              const tr2 = state.tr.setSelection(TextSelection$1.create(state.doc, from2, to)).scrollIntoView();
+              if (dispatch) dispatch(tr2);
+              const presentationEditor2 = editor.presentationEditor;
+              if (presentationEditor2 && typeof presentationEditor2.scrollToPosition === "function") {
+                const didScroll = presentationEditor2.scrollToPosition(from2, { block: "center" });
+                if (didScroll) return true;
+              }
+              try {
+                const domPos = editor.view.domAtPos(from2);
+                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(TextSelection$1.create(state.doc, firstMatch.from, firstMatch.to)).scrollIntoView();
+            const tr = state.tr.setSelection(TextSelection$1.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;
           }
         ),
@@ -123885,53 +124427,57 @@ ${o}
          *
          * // 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 matches2 = decoSet ? decoSet.find() : [];
-            const resultMatches = matches2.map((d2) => ({
-              from: d2.from,
-              to: d2.to,
-              text: newState.doc.textBetween(d2.from, d2.to),
-              id: 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: v4(),
+                ranges,
+                trackerIds: []
+              };
+              resultMatches.push(match);
+            }
             this.storage.searchResults = resultMatches;
+            this.storage.highlightEnabled = highlight;
             return resultMatches;
           }
         ),
@@ -123942,12 +124488,48 @@ ${o}
          * @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: from2, to } = match;
+            const positionTracker = getPositionTracker(editor);
+            const doc2 = state.doc;
+            const highlights = getMatchHighlights(state);
+            let from2, 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) {
+                  from2 = resolved.from;
+                  to = resolved.to;
+                }
+              }
+              if (from2 === void 0) {
+                from2 = match.ranges[0].from;
+                to = match.ranges[0].to;
+              }
+            } else {
+              from2 = match.from;
+              to = match.to;
+              if (positionTracker?.resolve && match?.id) {
+                const resolved = positionTracker.resolve(match.id);
+                if (resolved) {
+                  from2 = resolved.from;
+                  to = resolved.to;
+                }
+              }
+            }
+            const normalized = resolveSearchRange({
+              doc: doc2,
+              from: from2,
+              to,
+              expectedText: match?.text ?? null,
+              highlights
+            });
+            from2 = normalized.from;
+            to = normalized.to;
             editor.view.focus();
             const tr = state.tr.setSelection(TextSelection$1.create(state.doc, from2, to)).scrollIntoView();
             if (dispatch) dispatch(tr);
@@ -149687,7 +150269,7 @@ ${reason}`);
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.6.0-next.1";
+      this.version = "1.6.0-next.2";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;