@harbour-enterprises/superdoc 0.28.0-next.13 → 0.28.0-next.14

package/dist/chunks/{super-editor.es-C0LbO3l0.es.js → super-editor.es-CSyQAFrJ.es.js}

@@ -49979,17 +49979,7 @@ const TrackChangesBasePlugin = () => {
       },
       apply(tr, oldState, prevEditorState, newEditorState) {
         const meta = tr.getMeta(TrackChangesBasePluginKey);
-        if (!meta) {
-          return {
-            ...oldState,
-            decorations: getTrackChangesDecorations(
-              newEditorState,
-              oldState.onlyOriginalShown,
-              oldState.onlyModifiedShown
-            )
-          };
-        }
-        if (meta.type === "TRACK_CHANGES_ENABLE") {
+        if (meta && meta.type === "TRACK_CHANGES_ENABLE") {
           return {
             ...oldState,
             isTrackChangesActive: meta.value === true,
@@ -50000,7 +49990,7 @@ const TrackChangesBasePlugin = () => {
             )
           };
         }
-        if (meta.type === "SHOW_ONLY_ORIGINAL") {
+        if (meta && meta.type === "SHOW_ONLY_ORIGINAL") {
           return {
             ...oldState,
             onlyOriginalShown: meta.value === true,
@@ -50008,7 +49998,7 @@ const TrackChangesBasePlugin = () => {
             decorations: getTrackChangesDecorations(newEditorState, meta.value === true, false)
           };
         }
-        if (meta.type === "SHOW_ONLY_MODIFIED") {
+        if (meta && meta.type === "SHOW_ONLY_MODIFIED") {
           return {
             ...oldState,
             onlyOriginalShown: false,
@@ -50016,6 +50006,31 @@ const TrackChangesBasePlugin = () => {
             decorations: getTrackChangesDecorations(newEditorState, false, meta.value === true)
           };
         }
+        if (!tr.docChanged) {
+          return oldState;
+        }
+        if (!meta) {
+          let mightAffectTrackChanges = false;
+          tr.steps.forEach((step) => {
+            if (step.slice || step.from !== step.to) {
+              mightAffectTrackChanges = true;
+            }
+          });
+          if (mightAffectTrackChanges) {
+            return {
+              ...oldState,
+              decorations: getTrackChangesDecorations(
+                newEditorState,
+                oldState.onlyOriginalShown,
+                oldState.onlyModifiedShown
+              )
+            };
+          }
+          return {
+            ...oldState,
+            decorations: oldState.decorations.map(tr.mapping, tr.doc)
+          };
+        }
         return {
           ...oldState,
           decorations: getTrackChangesDecorations(
@@ -50770,6 +50785,7 @@ const CommentsPlugin = Extension.create({
       view() {
         let prevDoc;
         let prevActiveThreadId;
+        let prevAllCommentPositions = {};
         return {
           update(view) {
             const { state: state2 } = view;
@@ -50780,16 +50796,19 @@ const CommentsPlugin = Extension.create({
             if (meta?.type === "setActiveComment" || meta?.forceUpdate) {
               shouldUpdate = true;
             }
-            if (prevDoc && !prevDoc.eq(doc2)) shouldUpdate = true;
-            if (prevActiveThreadId !== currentActiveThreadId) {
+            const docChanged = prevDoc && !prevDoc.eq(doc2);
+            if (docChanged) shouldUpdate = true;
+            const activeThreadChanged = prevActiveThreadId !== currentActiveThreadId;
+            if (activeThreadChanged) {
               shouldUpdate = true;
               prevActiveThreadId = currentActiveThreadId;
             }
+            const onlyActiveThreadChanged = !docChanged && activeThreadChanged;
             if (!shouldUpdate) return;
             prevDoc = doc2;
             shouldUpdate = false;
             const decorations = [];
-            const allCommentPositions = {};
+            const allCommentPositions = onlyActiveThreadChanged ? prevAllCommentPositions : {};
             doc2.descendants((node, pos) => {
               const { marks = [] } = node;
               const commentMarks = marks.filter((mark) => mark.type.name === CommentMarkName);
@@ -50797,14 +50816,16 @@ const CommentsPlugin = Extension.create({
               commentMarks.forEach((commentMark) => {
                 const { attrs } = commentMark;
                 const threadId = attrs.commentId || attrs.importedId;
-                const currentBounds = view.coordsAtPos(pos);
-                updatePosition({
-                  allCommentPositions,
-                  threadId,
-                  pos,
-                  currentBounds,
-                  node
-                });
+                if (!onlyActiveThreadChanged) {
+                  const currentBounds = view.coordsAtPos(pos);
+                  updatePosition({
+                    allCommentPositions,
+                    threadId,
+                    pos,
+                    currentBounds,
+                    node
+                  });
+                }
                 const isInternal = attrs.internal;
                 if (!hasActive) hasActive = currentActiveThreadId === threadId;
                 let color = getHighlightColor({
@@ -50827,20 +50848,22 @@ const CommentsPlugin = Extension.create({
                 to: pos + node.nodeSize
               });
               if (trackedChangeMark) {
-                const currentBounds = view.coordsAtPos(pos);
-                const { id } = trackedChangeMark.mark.attrs;
-                updatePosition({
-                  allCommentPositions,
-                  threadId: id,
-                  pos,
-                  currentBounds,
-                  node
-                });
-                const isActiveTrackedChange = currentActiveThreadId === id;
+                if (!onlyActiveThreadChanged) {
+                  const currentBounds = view.coordsAtPos(pos);
+                  const { id } = trackedChangeMark.mark.attrs;
+                  updatePosition({
+                    allCommentPositions,
+                    threadId: id,
+                    pos,
+                    currentBounds,
+                    node
+                  });
+                }
+                const isActiveTrackedChange = currentActiveThreadId === trackedChangeMark.mark.attrs.id;
                 if (isActiveTrackedChange) {
                   const trackedChangeDeco = Decoration.inline(pos, pos + node.nodeSize, {
                     style: `border-width: 2px;`,
-                    "data-thread-id": id,
+                    "data-thread-id": trackedChangeMark.mark.attrs.id,
                     class: "sd-editor-tracked-change-highlight"
                   });
                   decorations.push(trackedChangeDeco);
@@ -50858,7 +50881,13 @@ const CommentsPlugin = Extension.create({
               });
               view.dispatch(tr2);
             }
-            editor.emit("comment-positions", { allCommentPositions });
+            if (!onlyActiveThreadChanged) {
+              const positionsChanged = hasPositionsChanged(prevAllCommentPositions, allCommentPositions);
+              if (positionsChanged) {
+                prevAllCommentPositions = allCommentPositions;
+                editor.emit("comment-positions", { allCommentPositions });
+              }
+            }
           }
         };
       }
@@ -50866,6 +50895,19 @@ const CommentsPlugin = Extension.create({
     return [commentsPlugin];
   }
 });
+const hasPositionsChanged = (prevPositions, currPositions) => {
+  const prevKeys = Object.keys(prevPositions);
+  const currKeys = Object.keys(currPositions);
+  if (prevKeys.length !== currKeys.length) return true;
+  for (const key2 of currKeys) {
+    const prev = prevPositions[key2];
+    const curr = currPositions[key2];
+    if (!prev || prev.top !== curr.top || prev.left !== curr.left) {
+      return true;
+    }
+  }
+  return false;
+};
 const getActiveCommentId = (doc2, selection) => {
   if (!selection) return;
   const { $from, $to } = selection;
@@ -53632,7 +53674,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-BNr0wgOU-j0xGZdr7.es.js"),
+      import("./index-BNr0wgOU-Bj1k6CCB.es.js"),
       import("./index-DRCvimau-Cw339678.es.js"),
       import("./index-C_x_N6Uh-DJn8hIEt.es.js"),
       import("./index-D_sWOSiG-DE96TaT5.es.js"),
@@ -58070,8 +58112,36 @@ const createLinkedStylesPlugin = (editor) => {
         if (!editor.converter || editor.options.mode !== "docx") return { ...prev };
         let decorations = prev.decorations || DecorationSet.empty;
         if (tr.docChanged) {
-          const styles = LinkedStylesPluginKey.getState(editor.state).styles;
-          decorations = generateDecorations(newEditorState, styles);
+          let mightAffectStyles = false;
+          const styleRelatedMarks = /* @__PURE__ */ new Set(["textStyle", "bold", "italic", "underline", "strike"]);
+          tr.steps.forEach((step) => {
+            if (step.slice) {
+              step.slice.content.descendants((node) => {
+                if (node.attrs?.styleId) {
+                  mightAffectStyles = true;
+                  return false;
+                }
+                if (node.marks.length > 0) {
+                  const hasStyleMarks = node.marks.some((mark) => styleRelatedMarks.has(mark.type.name));
+                  if (hasStyleMarks) {
+                    mightAffectStyles = true;
+                    return false;
+                  }
+                }
+              });
+            }
+            if (step.jsonID === "addMark" || step.jsonID === "removeMark") {
+              if (step.mark && styleRelatedMarks.has(step.mark.type.name)) {
+                mightAffectStyles = true;
+              }
+            }
+          });
+          if (mightAffectStyles) {
+            const styles = LinkedStylesPluginKey.getState(editor.state).styles;
+            decorations = generateDecorations(newEditorState, styles);
+          } else {
+            decorations = decorations.map(tr.mapping, tr.doc);
+          }
         }
         return { ...prev, decorations };
       }
@@ -58384,6 +58454,12 @@ function parseFontFamilyFromRunProperties(listRunProperties) {
   const eastAsia = listRunProperties?.["w:eastAsia"];
   return ascii || hAnsi || eastAsia || null;
 }
+const computedStylesCache = /* @__PURE__ */ new WeakMap();
+function clearComputedStyleCache(domNode) {
+  if (domNode) {
+    computedStylesCache.delete(domNode);
+  }
+}
 function readNodeViewStyles(view) {
   const fallback = { fontSize: null, fontFamily: null, lineHeight: null };
   if (!view?.dom) return fallback;
@@ -58393,13 +58469,27 @@ function readNodeViewStyles(view) {
     lineHeight: view.dom.style?.lineHeight || null
   };
   if (inline.fontSize && inline.fontFamily && inline.lineHeight) return inline;
+  if (computedStylesCache.has(view.dom)) {
+    const cached = computedStylesCache.get(view.dom);
+    return {
+      fontSize: inline.fontSize || cached.fontSize,
+      fontFamily: inline.fontFamily || cached.fontFamily,
+      lineHeight: inline.lineHeight || cached.lineHeight
+    };
+  }
   const globalWindow = typeof window !== "undefined" ? window : void 0;
   if (globalWindow?.getComputedStyle) {
     const computed2 = globalWindow.getComputedStyle(view.dom);
+    const computedStyles = {
+      fontSize: computed2.fontSize,
+      fontFamily: computed2.fontFamily,
+      lineHeight: computed2.lineHeight
+    };
+    computedStylesCache.set(view.dom, computedStyles);
     return {
-      fontSize: inline.fontSize || computed2.fontSize,
-      fontFamily: inline.fontFamily || computed2.fontFamily,
-      lineHeight: inline.lineHeight || computed2.lineHeight
+      fontSize: inline.fontSize || computedStyles.fontSize,
+      fontFamily: inline.fontFamily || computedStyles.fontFamily,
+      lineHeight: inline.lineHeight || computedStyles.lineHeight
     };
   }
   return inline;
@@ -58613,9 +58703,14 @@ class ListItemNodeView {
     });
   }
   update(node, decorations) {
+    const prevNode = this.node;
     this.node = node;
     this.decorations = decorations;
     this.invalidateResolvedPos();
+    const stylingAttrsChanged = !prevNode || prevNode.attrs.styleId !== node.attrs.styleId || prevNode.attrs.numId !== node.attrs.numId || prevNode.attrs.level !== node.attrs.level;
+    if (stylingAttrsChanged) {
+      clearComputedStyleCache(this.dom);
+    }
     const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = resolveListItemTypography({
       node,
       pos: this.getResolvedPos(),
@@ -58626,11 +58721,15 @@ class ListItemNodeView {
     this.dom.style.fontSize = fontSize2;
     this.dom.style.fontFamily = fontFamily2 || "inherit";
     this.dom.style.lineHeight = lineHeight2 || "";
-    this.refreshIndentStyling();
+    const attrsChanged = stylingAttrsChanged || prevNode?.attrs.indent !== node.attrs.indent;
+    if (attrsChanged) {
+      this.refreshIndentStyling();
+    }
   }
   destroy() {
     activeListItemNodeViews.delete(this);
     this.numberingDOM.removeEventListener("click", this.handleNumberingClick);
+    clearComputedStyleCache(this.dom);
     const caf = typeof globalThis !== "undefined" ? globalThis.cancelAnimationFrame : void 0;
     if (this._pendingIndentRefresh != null && typeof caf === "function") {
       caf(this._pendingIndentRefresh);
@@ -58749,8 +58848,11 @@ function calculateMarkerWidth(dom, numberingDOM, editor, { withPadding = true }
   if (!markerText.trim()) return 0;
   try {
     if (editor?.options?.isHeadless) return 0;
+    if (typeof globalThis.CanvasRenderingContext2D === "undefined") return 0;
     const canvas = document.createElement("canvas");
+    if (typeof canvas.getContext !== "function") return 0;
     const context = canvas.getContext("2d");
+    if (!context) return 0;
     const fontSizePx = fontSize2.includes("pt") ? Number.parseFloat(fontSize2) * POINT_TO_PIXEL_CONVERSION_FACTOR : Number.parseFloat(fontSize2);
     context.font = `${fontSizePx}px ${fontFamily2}`;
     const textWidth = context.measureText(markerText).width;
@@ -58769,7 +58871,9 @@ function orderedListSync(editor) {
     appendTransaction(transactions, oldState, newState) {
       if (transactions.every((tr2) => tr2.getMeta("y-sync$"))) return null;
       const updateNodeViews = transactions.some((tr2) => tr2.getMeta("updatedListItemNodeViews"));
-      if (updateNodeViews || !hasInitialized) refreshAllListItemNodeViews();
+      if (updateNodeViews || !hasInitialized) {
+        refreshAllListItemNodeViews();
+      }
       const isFromPlugin = transactions.some((tr2) => tr2.getMeta("orderedListSync"));
       const docChanged = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
       if (isFromPlugin || !docChanged) {
@@ -58781,10 +58885,24 @@ function orderedListSync(editor) {
       const listMap = /* @__PURE__ */ new Map();
       const listInitialized = /* @__PURE__ */ new Map();
       const shouldProcess = transactions.some((tr2) => {
+        if (tr2.getMeta("updateListSync")) return true;
         return tr2.steps.some((step) => {
           const stepJSON = step.toJSON();
-          const hasUpdateMeta = tr2.getMeta("updateListSync");
-          return hasUpdateMeta || stepJSON && stepJSON.slice && JSON.stringify(stepJSON).includes('"listItem"');
+          if (step.slice?.content) {
+            let hasListItem = false;
+            step.slice.content.descendants((node) => {
+              if (node.type.name === "listItem") {
+                hasListItem = true;
+                return false;
+              }
+            });
+            if (hasListItem) return true;
+          }
+          if (stepJSON && stepJSON.slice) {
+            const jsonStr = JSON.stringify(stepJSON);
+            if (jsonStr.includes('"listItem"')) return true;
+          }
+          return false;
         });
       });
       if (!shouldProcess) return null;
@@ -59254,17 +59372,68 @@ const Paragraph = OxmlNode.create({
   },
   addPmPlugins() {
     const { view } = this.editor;
+    const dropcapWidthCache = /* @__PURE__ */ new Map();
+    const hasDropcapParagraph = (node) => node.type.name === "paragraph" && node.attrs.dropcap?.type === "margin";
+    const invalidateCacheForRange = (from2, to) => {
+      for (const [pos] of dropcapWidthCache) {
+        if (pos >= from2 && pos <= to) {
+          dropcapWidthCache.delete(pos);
+        }
+      }
+    };
     const dropcapPlugin = new Plugin({
       name: "dropcapPlugin",
       key: new PluginKey("dropcapPlugin"),
       state: {
         init(_2, state2) {
-          let decorations = getDropcapDecorations(state2, view);
+          const decorations = getDropcapDecorations(state2, view, dropcapWidthCache);
           return DecorationSet.create(state2.doc, decorations);
         },
         apply(tr, oldDecorationSet, oldState, newState) {
           if (!tr.docChanged) return oldDecorationSet;
-          const decorations = getDropcapDecorations(newState, view);
+          let hasDropcaps = false;
+          newState.doc.descendants((node) => {
+            if (hasDropcapParagraph(node)) {
+              hasDropcaps = true;
+              return false;
+            }
+          });
+          if (!hasDropcaps) {
+            dropcapWidthCache.clear();
+            return DecorationSet.empty;
+          }
+          let affectsDropcaps = false;
+          tr.steps.forEach((step) => {
+            if (step.slice?.content) {
+              step.slice.content.descendants((node) => {
+                if (hasDropcapParagraph(node)) {
+                  affectsDropcaps = true;
+                  return false;
+                }
+              });
+            }
+            if (step.jsonID === "replace" && step.from !== void 0 && step.to !== void 0) {
+              try {
+                oldState.doc.nodesBetween(step.from, step.to, (node) => {
+                  if (hasDropcapParagraph(node)) {
+                    affectsDropcaps = true;
+                    return false;
+                  }
+                });
+              } catch {
+                affectsDropcaps = true;
+              }
+            }
+          });
+          if (!affectsDropcaps) {
+            return oldDecorationSet.map(tr.mapping, tr.doc);
+          }
+          tr.steps.forEach((step) => {
+            if (step.from !== void 0 && step.to !== void 0) {
+              invalidateCacheForRange(step.from, step.to);
+            }
+          });
+          const decorations = getDropcapDecorations(newState, view, dropcapWidthCache);
           return DecorationSet.create(newState.doc, decorations);
         }
       },
@@ -59277,12 +59446,12 @@ const Paragraph = OxmlNode.create({
     return [dropcapPlugin];
   }
 });
-const getDropcapDecorations = (state2, view) => {
-  let decorations = [];
+const getDropcapDecorations = (state2, view, widthCache) => {
+  const decorations = [];
   state2.doc.descendants((node, pos) => {
     if (node.type.name === "paragraph") {
       if (node.attrs.dropcap?.type === "margin") {
-        const width = getDropcapWidth(view, pos);
+        const width = getDropcapWidth(view, pos, widthCache);
         decorations.push(Decoration.inline(pos, pos + node.nodeSize, { style: `margin-left: -${width}px;` }));
       }
       return false;
@@ -59290,12 +59459,17 @@ const getDropcapDecorations = (state2, view) => {
   });
   return decorations;
 };
-function getDropcapWidth(view, pos) {
+function getDropcapWidth(view, pos, widthCache) {
+  if (widthCache.has(pos)) {
+    return widthCache.get(pos);
+  }
   const domNode = view.nodeDOM(pos);
   if (domNode) {
     const range2 = document.createRange();
     range2.selectNodeContents(domNode);
-    return range2.getBoundingClientRect().width;
+    const width = range2.getBoundingClientRect().width;
+    widthCache.set(pos, width);
+    return width;
   }
   return 0;
 }
@@ -59757,7 +59931,7 @@ const TabNode = Node$1.create({
   },
   addPmPlugins() {
     const { view, helpers: helpers2 } = this.editor;
-    const mergeRanges = (ranges) => {
+    const mergeRanges2 = (ranges) => {
       if (ranges.length === 0) return [];
       const sorted = ranges.slice().sort((a, b2) => a[0] - b2[0]);
       const merged = [sorted[0]];
@@ -59830,7 +60004,7 @@ const TabNode = Node$1.create({
           if (rangesToRecalculate.length === 0) {
             return { decorations };
           }
-          const mergedRanges = mergeRanges(rangesToRecalculate);
+          const mergedRanges = mergeRanges2(rangesToRecalculate);
           mergedRanges.forEach(([start2, end2]) => {
             const oldDecorations = decorations.find(start2, end2);
             decorations = decorations.remove(oldDecorations);
@@ -63733,6 +63907,29 @@ createAnnotation_fn = function({ displayLabel } = {}) {
     content
   };
 };
+const mergeRanges = (ranges) => {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b2) => a[0] - b2[0]).map((range2) => [...range2]);
+  const merged = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const current = sorted[i];
+    const lastMerged = merged[merged.length - 1];
+    if (current[0] <= lastMerged[1]) {
+      lastMerged[1] = Math.max(lastMerged[1], current[1]);
+    } else {
+      merged.push(current);
+    }
+  }
+  return merged;
+};
+const clampRange = (start2, end2, docSize) => {
+  const safeStart = Math.max(0, Math.min(start2, docSize));
+  const safeEnd = Math.max(0, Math.min(end2, docSize));
+  if (safeStart >= safeEnd) {
+    return null;
+  }
+  return [safeStart, safeEnd];
+};
 const FieldAnnotationPlugin = (options = {}) => {
   let { editor, annotationClass: annotationClass2 } = options;
   return new Plugin({
@@ -63807,24 +64004,104 @@ const FieldAnnotationPlugin = (options = {}) => {
     },
     /// For y-prosemirror support.
     appendTransaction: (transactions, oldState, newState) => {
-      let docChanges = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
+      const docChanges = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
       if (!docChanges) {
         return;
       }
-      let { tr } = newState;
-      let changed = false;
-      let annotations = getAllFieldAnnotations(newState);
-      if (!annotations.length) {
-        return;
+      const affectedRanges = [];
+      let hasFieldAnnotationsInSlice = false;
+      let hasSteps = false;
+      transactions.forEach((transaction) => {
+        if (!transaction.steps) return;
+        hasSteps = true;
+        transaction.steps.forEach((step) => {
+          if (step.slice?.content) {
+            step.slice.content.descendants((node) => {
+              if (node.type.name === "fieldAnnotation") {
+                hasFieldAnnotationsInSlice = true;
+                return false;
+              }
+            });
+          }
+          if (typeof step.from === "number" && typeof step.to === "number") {
+            const from2 = step.from;
+            const to = step.from === step.to && step.slice?.size ? step.from + step.slice.size : step.to;
+            affectedRanges.push([from2, to]);
+          }
+        });
+      });
+      if (hasSteps && !hasFieldAnnotationsInSlice && affectedRanges.length > 0) {
+        const mergedRanges = mergeRanges(affectedRanges);
+        let hasExistingAnnotations = false;
+        for (const [start2, end2] of mergedRanges) {
+          const clampedRange = clampRange(start2, end2, newState.doc.content.size);
+          if (!clampedRange) continue;
+          const [validStart, validEnd] = clampedRange;
+          try {
+            newState.doc.nodesBetween(validStart, validEnd, (node) => {
+              if (node.type.name === "fieldAnnotation") {
+                hasExistingAnnotations = true;
+                return false;
+              }
+            });
+          } catch (error) {
+            console.warn("FieldAnnotationPlugin: range check failed, assuming annotations exist", error);
+            hasExistingAnnotations = true;
+            break;
+          }
+          if (hasExistingAnnotations) break;
+        }
+        if (!hasExistingAnnotations) {
+          return;
+        }
       }
-      annotations.forEach(({ node, pos }) => {
-        let { marks } = node;
-        let currentNode = tr.doc.nodeAt(pos);
+      const { tr } = newState;
+      let changed = false;
+      const removeMarksFromAnnotation = (node, pos) => {
+        const { marks } = node;
+        const currentNode = tr.doc.nodeAt(pos);
         if (marks.length > 0 && node.eq(currentNode)) {
           tr.removeMark(pos, pos + node.nodeSize, null);
           changed = true;
         }
-      });
+      };
+      if (affectedRanges.length > 0) {
+        const mergedRanges = mergeRanges(affectedRanges);
+        let shouldFallbackToFullScan = false;
+        for (const [start2, end2] of mergedRanges) {
+          const clampedRange = clampRange(start2, end2, newState.doc.content.size);
+          if (!clampedRange) continue;
+          const [validStart, validEnd] = clampedRange;
+          try {
+            newState.doc.nodesBetween(validStart, validEnd, (node, pos) => {
+              if (node.type.name === "fieldAnnotation") {
+                removeMarksFromAnnotation(node, pos);
+              }
+            });
+          } catch (error) {
+            console.warn("FieldAnnotationPlugin: nodesBetween failed, falling back to full scan", error);
+            shouldFallbackToFullScan = true;
+            break;
+          }
+        }
+        if (shouldFallbackToFullScan) {
+          const annotations = getAllFieldAnnotations(newState);
+          if (!annotations.length) {
+            return changed ? tr : null;
+          }
+          annotations.forEach(({ node, pos }) => {
+            removeMarksFromAnnotation(node, pos);
+          });
+        }
+      } else {
+        const annotations = getAllFieldAnnotations(newState);
+        if (!annotations.length) {
+          return;
+        }
+        annotations.forEach(({ node, pos }) => {
+          removeMarksFromAnnotation(node, pos);
+        });
+      }
       return changed ? tr : null;
     }
     ///
@@ -65634,7 +65911,9 @@ const registerImages = async (foundImages, editor, view) => {
     }
   });
 };
+const stepHasSlice = (step) => "slice" in step && Boolean(step.slice);
 const ImagePositionPluginKey = new PluginKey("ImagePosition");
+const pageBreakPositionCache = /* @__PURE__ */ new WeakMap();
 const ImagePositionPlugin = ({ editor }) => {
   const { view } = editor;
   let shouldUpdate = false;
@@ -65647,6 +65926,20 @@ const ImagePositionPlugin = ({ editor }) => {
       },
       apply(tr, oldDecorationSet, oldState, newState) {
         if (!tr.docChanged && !shouldUpdate) return oldDecorationSet;
+        let affectsImages = false;
+        tr.steps.forEach((step) => {
+          if (stepHasSlice(step)) {
+            step.slice.content.descendants((node) => {
+              if (node.type.name === "image" || node.attrs?.anchorData) {
+                affectsImages = true;
+                return false;
+              }
+            });
+          }
+        });
+        if (!affectsImages && !shouldUpdate) {
+          return oldDecorationSet.map(tr.mapping, tr.doc);
+        }
         const decorations = getImagePositionDecorations(newState, view);
         shouldUpdate = false;
         return DecorationSet.create(newState.doc, decorations);
@@ -65676,6 +65969,16 @@ const ImagePositionPlugin = ({ editor }) => {
 };
 const getImagePositionDecorations = (state2, view) => {
   let decorations = [];
+  let hasAnchoredImages = false;
+  state2.doc.descendants((node) => {
+    if (node.attrs?.anchorData) {
+      hasAnchoredImages = true;
+      return false;
+    }
+  });
+  if (!hasAnchoredImages) {
+    return decorations;
+  }
   state2.doc.descendants((node, pos) => {
     if (node.attrs.anchorData) {
       let style2 = "";
@@ -65684,7 +65987,15 @@ const getImagePositionDecorations = (state2, view) => {
       const { size: size2, padding } = node.attrs;
       const pageBreak = findPreviousDomNodeWithClass(view, pos, "pagination-break-wrapper");
       if (pageBreak && vRelativeFrom === "margin" && alignH) {
-        const topPos = pageBreak?.offsetTop + pageBreak?.offsetHeight;
+        let pageBreakPos = pageBreakPositionCache.get(pageBreak);
+        if (!pageBreakPos) {
+          pageBreakPos = {
+            top: pageBreak.offsetTop,
+            height: pageBreak.offsetHeight
+          };
+          pageBreakPositionCache.set(pageBreak, pageBreakPos);
+        }
+        const topPos = pageBreakPos.top + pageBreakPos.height;
         let horizontalAlignment = `${alignH}: 0;`;
         if (alignH === "center") horizontalAlignment = "left: 50%; transform: translateX(-50%);";
         style2 += vRelativeFrom === "margin" ? `position: absolute; top: ${topPos}px; ${horizontalAlignment}` : "";
@@ -67176,11 +67487,22 @@ const BlockNode = Extension.create({
   },
   addPmPlugins() {
     let hasInitialized = false;
+    const assignBlockId = (tr, node, pos) => {
+      tr.setNodeMarkup(
+        pos,
+        void 0,
+        {
+          ...node.attrs,
+          sdBlockId: v4()
+        },
+        node.marks
+      );
+    };
     return [
       new Plugin({
         key: BlockNodePluginKey,
         appendTransaction: (transactions, oldState, newState) => {
-          let docChanges = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
+          const docChanges = transactions.some((tr2) => tr2.docChanged) && !oldState.doc.eq(newState.doc);
           if (hasInitialized && !docChanges) {
             return;
           }
@@ -67189,21 +67511,87 @@ const BlockNode = Extension.create({
           }
           const { tr } = newState;
           let changed = false;
-          newState.doc.descendants((node, pos) => {
-            if (!nodeAllowsSdBlockIdAttr(node) || !nodeNeedsSdBlockId(node)) {
-              return;
+          if (!hasInitialized) {
+            newState.doc.descendants((node, pos) => {
+              if (nodeAllowsSdBlockIdAttr(node) && nodeNeedsSdBlockId(node)) {
+                assignBlockId(tr, node, pos);
+                changed = true;
+              }
+            });
+          } else {
+            const rangesToCheck = [];
+            let shouldFallbackToFullTraversal = false;
+            transactions.forEach((transaction, txIndex) => {
+              transaction.steps.forEach((step, stepIndex) => {
+                if (!(step instanceof ReplaceStep)) return;
+                const hasNewBlockNodes = step.slice?.content?.content?.some((node) => nodeAllowsSdBlockIdAttr(node));
+                if (!hasNewBlockNodes) return;
+                const stepMap = step.getMap();
+                stepMap.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+                  if (newEnd <= newStart) {
+                    if (process$1$1.env.NODE_ENV === "development") {
+                      console.debug("Block node: invalid range in step map, falling back to full traversal");
+                    }
+                    shouldFallbackToFullTraversal = true;
+                    return;
+                  }
+                  let rangeStart = newStart;
+                  let rangeEnd = newEnd;
+                  for (let i = stepIndex + 1; i < transaction.steps.length; i++) {
+                    const laterStepMap = transaction.steps[i].getMap();
+                    rangeStart = laterStepMap.map(rangeStart, -1);
+                    rangeEnd = laterStepMap.map(rangeEnd, 1);
+                  }
+                  for (let i = txIndex + 1; i < transactions.length; i++) {
+                    const laterTx = transactions[i];
+                    rangeStart = laterTx.mapping.map(rangeStart, -1);
+                    rangeEnd = laterTx.mapping.map(rangeEnd, 1);
+                  }
+                  if (rangeEnd <= rangeStart) {
+                    if (process$1$1.env.NODE_ENV === "development") {
+                      console.debug("Block node: invalid range after mapping, falling back to full traversal");
+                    }
+                    shouldFallbackToFullTraversal = true;
+                    return;
+                  }
+                  rangesToCheck.push([rangeStart, rangeEnd]);
+                });
+              });
+            });
+            const mergedRanges = mergeRanges(rangesToCheck);
+            for (const [start2, end2] of mergedRanges) {
+              const docSize = newState.doc.content.size;
+              const clampedRange = clampRange(start2, end2, docSize);
+              if (!clampedRange) {
+                if (process$1$1.env.NODE_ENV === "development") {
+                  console.debug("Block node: invalid range after clamping, falling back to full traversal");
+                }
+                shouldFallbackToFullTraversal = true;
+                break;
+              }
+              const [safeStart, safeEnd] = clampedRange;
+              try {
+                newState.doc.nodesBetween(safeStart, safeEnd, (node, pos) => {
+                  if (nodeAllowsSdBlockIdAttr(node) && nodeNeedsSdBlockId(node)) {
+                    assignBlockId(tr, node, pos);
+                    changed = true;
+                  }
+                });
+              } catch (error) {
+                console.warn("Block node plugin: nodesBetween failed, falling back to full traversal", error);
+                shouldFallbackToFullTraversal = true;
+                break;
+              }
             }
-            tr.setNodeMarkup(
-              pos,
-              void 0,
-              {
-                ...node.attrs,
-                sdBlockId: v4()
-              },
-              node.marks
-            );
-            changed = true;
-          });
+            if (shouldFallbackToFullTraversal) {
+              newState.doc.descendants((node, pos) => {
+                if (nodeAllowsSdBlockIdAttr(node) && nodeNeedsSdBlockId(node)) {
+                  assignBlockId(tr, node, pos);
+                  changed = true;
+                }
+              });
+            }
+          }
           if (changed && !hasInitialized) {
             hasInitialized = true;
             tr.setMeta("blockNodeInitialUpdate", true);
@@ -73679,8 +74067,8 @@ const PopoverPlugin = Extension.create({
           return {};
         },
         apply: (tr, value) => {
-          let newValue = { ...value };
-          if (tr.docChanged) {
+          const newValue = { ...value };
+          if (tr.docChanged || tr.selectionSet) {
             newValue.shouldUpdate = true;
           } else {
             newValue.shouldUpdate = false;
@@ -74935,6 +75323,8 @@ const Pagination = Extension.create({
     let shouldUpdate = false;
     let hasInitialized = false;
     let shouldInitialize = false;
+    let paginationTimeout = null;
+    const PAGINATION_DEBOUNCE_MS = 150;
     const paginationPlugin = new Plugin({
       key: PaginationPluginKey,
       state: {
@@ -74962,6 +75352,9 @@ const Pagination = Extension.create({
             shouldUpdate = true;
             shouldInitialize = meta.isReadyToInit;
           }
+          if (meta && meta.skipPagination) {
+            return { ...oldState };
+          }
           const syncMeta = tr.getMeta("y-sync$");
           const listSyncMeta = tr.getMeta("orderedListSync");
           if (syncMeta && syncMeta.isChangeOrigin || listSyncMeta) {
@@ -74993,11 +75386,23 @@ const Pagination = Extension.create({
             shouldUpdate = false;
             return { ...oldState };
           }
+          if (!isForceUpdate && hasInitialized && tr.docChanged) {
+            let isMarkOnlyChange = true;
+            tr.steps.forEach((step) => {
+              if (step.jsonID !== "addMark" && step.jsonID !== "removeMark") {
+                isMarkOnlyChange = false;
+              }
+            });
+            if (isMarkOnlyChange) {
+              shouldUpdate = false;
+              return { ...oldState };
+            }
+          }
           shouldUpdate = true;
           if (isForceUpdate) shouldUpdate = true;
           return {
             ...oldState,
-            decorations: meta?.decorations?.map(tr.mapping, tr.doc) || DecorationSet.empty,
+            decorations: meta?.decorations?.map(tr.mapping, tr.doc) || oldState.decorations.map(tr.mapping, tr.doc),
             isReadyToInit: shouldInitialize
           };
         }
@@ -75009,11 +75414,22 @@ const Pagination = Extension.create({
           update: (view) => {
             if (!PaginationPluginKey.getState(view.state)?.isEnabled) return;
             if (!shouldUpdate || isUpdating) return;
-            isUpdating = true;
-            hasInitialized = true;
-            performUpdate(editor, view, previousDecorations);
-            isUpdating = false;
-            shouldUpdate = false;
+            const performPaginationUpdate = () => {
+              if (!shouldUpdate) return;
+              isUpdating = true;
+              hasInitialized = true;
+              performUpdate(editor, view, previousDecorations);
+              isUpdating = false;
+              shouldUpdate = false;
+            };
+            if (!hasInitialized) {
+              performPaginationUpdate();
+              return;
+            }
+            if (paginationTimeout) {
+              clearTimeout(paginationTimeout);
+            }
+            paginationTimeout = setTimeout(performPaginationUpdate, PAGINATION_DEBOUNCE_MS);
           }
         };
       },