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

package/dist/superdoc.umd.js

@@ -57694,17 +57694,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         },
         apply(tr, oldState, prevEditorState, newEditorState) {
           const meta2 = tr.getMeta(TrackChangesBasePluginKey);
-          if (!meta2) {
-            return {
-              ...oldState,
-              decorations: getTrackChangesDecorations(
-                newEditorState,
-                oldState.onlyOriginalShown,
-                oldState.onlyModifiedShown
-              )
-            };
-          }
-          if (meta2.type === "TRACK_CHANGES_ENABLE") {
+          if (meta2 && meta2.type === "TRACK_CHANGES_ENABLE") {
             return {
               ...oldState,
               isTrackChangesActive: meta2.value === true,
@@ -57715,7 +57705,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               )
             };
           }
-          if (meta2.type === "SHOW_ONLY_ORIGINAL") {
+          if (meta2 && meta2.type === "SHOW_ONLY_ORIGINAL") {
             return {
               ...oldState,
               onlyOriginalShown: meta2.value === true,
@@ -57723,7 +57713,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               decorations: getTrackChangesDecorations(newEditorState, meta2.value === true, false)
             };
           }
-          if (meta2.type === "SHOW_ONLY_MODIFIED") {
+          if (meta2 && meta2.type === "SHOW_ONLY_MODIFIED") {
             return {
               ...oldState,
               onlyOriginalShown: false,
@@ -57731,6 +57721,31 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               decorations: getTrackChangesDecorations(newEditorState, false, meta2.value === true)
             };
           }
+          if (!tr.docChanged) {
+            return oldState;
+          }
+          if (!meta2) {
+            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(
@@ -58485,6 +58500,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         view() {
           let prevDoc;
           let prevActiveThreadId;
+          let prevAllCommentPositions = {};
           return {
             update(view) {
               const { state: state2 } = view;
@@ -58495,16 +58511,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
               if (meta2?.type === "setActiveComment" || meta2?.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((node2, pos) => {
                 const { marks = [] } = node2;
                 const commentMarks = marks.filter((mark2) => mark2.type.name === CommentMarkName);
@@ -58512,14 +58531,16 @@ Please report this to https://github.com/markedjs/marked.`, e) {
                 commentMarks.forEach((commentMark) => {
                   const { attrs } = commentMark;
                   const threadId = attrs.commentId || attrs.importedId;
-                  const currentBounds = view.coordsAtPos(pos);
-                  updatePosition({
-                    allCommentPositions,
-                    threadId,
-                    pos,
-                    currentBounds,
-                    node: node2
-                  });
+                  if (!onlyActiveThreadChanged) {
+                    const currentBounds = view.coordsAtPos(pos);
+                    updatePosition({
+                      allCommentPositions,
+                      threadId,
+                      pos,
+                      currentBounds,
+                      node: node2
+                    });
+                  }
                   const isInternal = attrs.internal;
                   if (!hasActive) hasActive = currentActiveThreadId === threadId;
                   let color2 = getHighlightColor({
@@ -58542,20 +58563,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
                   to: pos + node2.nodeSize
                 });
                 if (trackedChangeMark) {
-                  const currentBounds = view.coordsAtPos(pos);
-                  const { id } = trackedChangeMark.mark.attrs;
-                  updatePosition({
-                    allCommentPositions,
-                    threadId: id,
-                    pos,
-                    currentBounds,
-                    node: node2
-                  });
-                  const isActiveTrackedChange = currentActiveThreadId === id;
+                  if (!onlyActiveThreadChanged) {
+                    const currentBounds = view.coordsAtPos(pos);
+                    const { id } = trackedChangeMark.mark.attrs;
+                    updatePosition({
+                      allCommentPositions,
+                      threadId: id,
+                      pos,
+                      currentBounds,
+                      node: node2
+                    });
+                  }
+                  const isActiveTrackedChange = currentActiveThreadId === trackedChangeMark.mark.attrs.id;
                   if (isActiveTrackedChange) {
                     const trackedChangeDeco = Decoration.inline(pos, pos + node2.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);
@@ -58573,7 +58596,13 @@ Please report this to https://github.com/markedjs/marked.`, e) {
                 });
                 view.dispatch(tr2);
               }
-              editor.emit("comment-positions", { allCommentPositions });
+              if (!onlyActiveThreadChanged) {
+                const positionsChanged = hasPositionsChanged(prevAllCommentPositions, allCommentPositions);
+                if (positionsChanged) {
+                  prevAllCommentPositions = allCommentPositions;
+                  editor.emit("comment-positions", { allCommentPositions });
+                }
+              }
             }
           };
         }
@@ -58581,6 +58610,19 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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;
@@ -65785,8 +65827,36 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           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((node2) => {
+                  if (node2.attrs?.styleId) {
+                    mightAffectStyles = true;
+                    return false;
+                  }
+                  if (node2.marks.length > 0) {
+                    const hasStyleMarks = node2.marks.some((mark2) => styleRelatedMarks.has(mark2.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 };
         }
@@ -66099,6 +66169,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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;
@@ -66108,13 +66184,27 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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;
@@ -66328,9 +66418,14 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       });
     }
     update(node2, decorations) {
+      const prevNode = this.node;
       this.node = node2;
       this.decorations = decorations;
       this.invalidateResolvedPos();
+      const stylingAttrsChanged = !prevNode || prevNode.attrs.styleId !== node2.attrs.styleId || prevNode.attrs.numId !== node2.attrs.numId || prevNode.attrs.level !== node2.attrs.level;
+      if (stylingAttrsChanged) {
+        clearComputedStyleCache(this.dom);
+      }
       const { fontSize: fontSize2, fontFamily: fontFamily2, lineHeight: lineHeight2 } = resolveListItemTypography({
         node: node2,
         pos: this.getResolvedPos(),
@@ -66341,11 +66436,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       this.dom.style.fontSize = fontSize2;
       this.dom.style.fontFamily = fontFamily2 || "inherit";
       this.dom.style.lineHeight = lineHeight2 || "";
-      this.refreshIndentStyling();
+      const attrsChanged = stylingAttrsChanged || prevNode?.attrs.indent !== node2.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);
@@ -66464,8 +66563,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     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;
@@ -66484,7 +66586,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       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) {
@@ -66496,10 +66600,24 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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((node2) => {
+                if (node2.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;
@@ -66969,17 +67087,68 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     },
     addPmPlugins() {
       const { view } = this.editor;
+      const dropcapWidthCache = /* @__PURE__ */ new Map();
+      const hasDropcapParagraph = (node2) => node2.type.name === "paragraph" && node2.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((node2) => {
+              if (hasDropcapParagraph(node2)) {
+                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((node2) => {
+                  if (hasDropcapParagraph(node2)) {
+                    affectsDropcaps = true;
+                    return false;
+                  }
+                });
+              }
+              if (step.jsonID === "replace" && step.from !== void 0 && step.to !== void 0) {
+                try {
+                  oldState.doc.nodesBetween(step.from, step.to, (node2) => {
+                    if (hasDropcapParagraph(node2)) {
+                      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);
           }
         },
@@ -66992,12 +67161,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return [dropcapPlugin];
     }
   });
-  const getDropcapDecorations = (state2, view) => {
-    let decorations = [];
+  const getDropcapDecorations = (state2, view, widthCache) => {
+    const decorations = [];
     state2.doc.descendants((node2, pos) => {
       if (node2.type.name === "paragraph") {
         if (node2.attrs.dropcap?.type === "margin") {
-          const width = getDropcapWidth(view, pos);
+          const width = getDropcapWidth(view, pos, widthCache);
           decorations.push(Decoration.inline(pos, pos + node2.nodeSize, { style: `margin-left: -${width}px;` }));
         }
         return false;
@@ -67005,12 +67174,17 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     });
     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;
   }
@@ -67472,7 +67646,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     },
     addPmPlugins() {
       const { view, helpers: helpers2 } = this.editor;
-      const mergeRanges = (ranges) => {
+      const mergeRanges2 = (ranges) => {
         if (ranges.length === 0) return [];
         const sorted = ranges.slice().sort((a2, b2) => a2[0] - b2[0]);
         const merged = [sorted[0]];
@@ -67545,7 +67719,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
             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);
@@ -71448,6 +71622,29 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       content: content2
     };
   };
+  const mergeRanges = (ranges) => {
+    if (ranges.length === 0) return [];
+    const sorted = [...ranges].sort((a2, b2) => a2[0] - b2[0]).map((range2) => [...range2]);
+    const merged = [sorted[0]];
+    for (let i2 = 1; i2 < sorted.length; i2++) {
+      const current = sorted[i2];
+      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({
@@ -71522,24 +71719,104 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       },
       /// 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((node2) => {
+                if (node2.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, (node2) => {
+                if (node2.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: node2, pos }) => {
-          let { marks } = node2;
-          let currentNode = tr.doc.nodeAt(pos);
+        const { tr } = newState;
+        let changed = false;
+        const removeMarksFromAnnotation = (node2, pos) => {
+          const { marks } = node2;
+          const currentNode = tr.doc.nodeAt(pos);
           if (marks.length > 0 && node2.eq(currentNode)) {
             tr.removeMark(pos, pos + node2.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, (node2, pos) => {
+                if (node2.type.name === "fieldAnnotation") {
+                  removeMarksFromAnnotation(node2, 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: node2, pos }) => {
+              removeMarksFromAnnotation(node2, pos);
+            });
+          }
+        } else {
+          const annotations = getAllFieldAnnotations(newState);
+          if (!annotations.length) {
+            return;
+          }
+          annotations.forEach(({ node: node2, pos }) => {
+            removeMarksFromAnnotation(node2, pos);
+          });
+        }
         return changed ? tr : null;
       }
       ///
@@ -73349,7 +73626,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       }
     });
   };
+  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;
@@ -73362,6 +73641,20 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         },
         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((node2) => {
+                if (node2.type.name === "image" || node2.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);
@@ -73391,6 +73684,16 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   };
   const getImagePositionDecorations = (state2, view) => {
     let decorations = [];
+    let hasAnchoredImages = false;
+    state2.doc.descendants((node2) => {
+      if (node2.attrs?.anchorData) {
+        hasAnchoredImages = true;
+        return false;
+      }
+    });
+    if (!hasAnchoredImages) {
+      return decorations;
+    }
     state2.doc.descendants((node2, pos) => {
       if (node2.attrs.anchorData) {
         let style2 = "";
@@ -73399,7 +73702,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         const { size: size2, padding } = node2.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}` : "";
@@ -74891,11 +75202,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     },
     addPmPlugins() {
       let hasInitialized = false;
+      const assignBlockId = (tr, node2, pos) => {
+        tr.setNodeMarkup(
+          pos,
+          void 0,
+          {
+            ...node2.attrs,
+            sdBlockId: v4$1()
+          },
+          node2.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;
             }
@@ -74904,21 +75226,87 @@ Please report this to https://github.com/markedjs/marked.`, e) {
             }
             const { tr } = newState;
             let changed = false;
-            newState.doc.descendants((node2, pos) => {
-              if (!nodeAllowsSdBlockIdAttr(node2) || !nodeNeedsSdBlockId(node2)) {
-                return;
+            if (!hasInitialized) {
+              newState.doc.descendants((node2, pos) => {
+                if (nodeAllowsSdBlockIdAttr(node2) && nodeNeedsSdBlockId(node2)) {
+                  assignBlockId(tr, node2, 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((node2) => nodeAllowsSdBlockIdAttr(node2));
+                  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 i2 = stepIndex + 1; i2 < transaction.steps.length; i2++) {
+                      const laterStepMap = transaction.steps[i2].getMap();
+                      rangeStart = laterStepMap.map(rangeStart, -1);
+                      rangeEnd = laterStepMap.map(rangeEnd, 1);
+                    }
+                    for (let i2 = txIndex + 1; i2 < transactions.length; i2++) {
+                      const laterTx = transactions[i2];
+                      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, (node2, pos) => {
+                    if (nodeAllowsSdBlockIdAttr(node2) && nodeNeedsSdBlockId(node2)) {
+                      assignBlockId(tr, node2, 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,
-                {
-                  ...node2.attrs,
-                  sdBlockId: v4$1()
-                },
-                node2.marks
-              );
-              changed = true;
-            });
+              if (shouldFallbackToFullTraversal) {
+                newState.doc.descendants((node2, pos) => {
+                  if (nodeAllowsSdBlockIdAttr(node2) && nodeNeedsSdBlockId(node2)) {
+                    assignBlockId(tr, node2, pos);
+                    changed = true;
+                  }
+                });
+              }
+            }
             if (changed && !hasInitialized) {
               hasInitialized = true;
               tr.setMeta("blockNodeInitialUpdate", true);
@@ -81394,8 +81782,8 @@ ${l}
             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;
@@ -82650,6 +83038,8 @@ ${l}
       let shouldUpdate = false;
       let hasInitialized = false;
       let shouldInitialize = false;
+      let paginationTimeout = null;
+      const PAGINATION_DEBOUNCE_MS = 150;
       const paginationPlugin = new Plugin({
         key: PaginationPluginKey,
         state: {
@@ -82677,6 +83067,9 @@ ${l}
               shouldUpdate = true;
               shouldInitialize = meta2.isReadyToInit;
             }
+            if (meta2 && meta2.skipPagination) {
+              return { ...oldState };
+            }
             const syncMeta = tr.getMeta("y-sync$");
             const listSyncMeta = tr.getMeta("orderedListSync");
             if (syncMeta && syncMeta.isChangeOrigin || listSyncMeta) {
@@ -82708,11 +83101,23 @@ ${l}
               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: meta2?.decorations?.map(tr.mapping, tr.doc) || DecorationSet.empty,
+              decorations: meta2?.decorations?.map(tr.mapping, tr.doc) || oldState.decorations.map(tr.mapping, tr.doc),
               isReadyToInit: shouldInitialize
             };
           }
@@ -82724,11 +83129,22 @@ ${l}
             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);
             }
           };
         },