@harbour-enterprises/superdoc 0.28.1 → 0.28.3

package/dist/super-editor/chunks/{editor-D3TKfdXs.js → editor-C3KgN3zx.js}

@@ -12,9 +12,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _events, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _editor, _stateValidators, _xmlValidators, _requiredNodeTypes, _requiredMarkTypes, _SuperValidator_instances, initializeValidators_fn, collectValidatorRequirements_fn, analyzeDocument_fn, _commandService, _Editor_instances, initContainerElement_fn, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, registerCopyHandler_fn, insertNewFileData_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, initFonts_fn, checkFonts_fn, determineUnsupportedFonts_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, handleNodeSelection_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, validateDocumentInit_fn, validateDocumentExport_fn, initDevTools_fn, _DocumentSectionView_instances, init_fn2, addToolTip_fn, _ListItemNodeView_instances, init_fn3, applyIndentStyling_fn, _FieldAnnotationView_instances, createAnnotation_fn, _AutoPageNumberNodeView_instances, renderDom_fn, scheduleUpdateNodeStyle_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement, encodeStateAsUpdate } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as updateDOMAttributes, ah as findChildren$5, ai as htmlHandler, aj as generateRandomSigned32BitIntStrId, ak as InputRule, al as kebabCase, am as findParentNodeClosestToPos, an as getListItemStyleDefinitions, ao as docxNumberingHelpers, ap as parseIndentElement, aq as combineIndents, ar as twipsToPixels, as as PIXELS_PER_INCH, at as SelectionRange, au as Transform, av as isInTable$1, aw as generateDocxRandomId, ax as insertNewRelationship, ay as inchesToPixels } from "./converter-D6Z6OmA3.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, B as Buffer2, f as callOrGet, g as getExtensionConfigField, h as getMarkType, i as getMarksFromSelection, j as getNodeType, k as getSchemaTypeNameByName, l as Schema$1, m as cleanSchemaItem, n as canSplit, o as defaultBlockAt$1, q as liftTarget, r as canJoin, s as joinPoint, t as replaceStep$1, R as ReplaceAroundStep$1, u as isTextSelection, v as getMarkRange, w as isMarkActive, x as isNodeActive, y as deleteProps, z as processContent, C as ReplaceStep, E as NodeRange, G as findWrapping, L as ListHelpers, H as findParentNode, I as isMacOS, J as isIOS, K as getSchemaTypeByName, O as inputRulesPlugin, Q as TrackDeleteMarkName, U as TrackInsertMarkName, V as v4, W as TrackFormatMarkName, X as comments_module_events, Y as findMark, Z as objectIncludes, _ as AddMarkStep, $ as RemoveMarkStep, a0 as twipsToLines, a1 as pixelsToTwips, a2 as helpers, a3 as posToDOMRect, a4 as CommandService, a5 as SuperConverter, a6 as createDocument, a7 as createDocFromMarkdown, a8 as createDocFromHTML, a9 as EditorState, aa as hasSomeParentWithClass, ab as isActive, ac as unflattenListsInHtml, ad as parseSizeUnit, ae as minMax, af as getLineHeightValueString, ag as updateDOMAttributes, ah as findChildren$5, ai as htmlHandler, aj as generateRandomSigned32BitIntStrId, ak as InputRule, al as kebabCase, am as findParentNodeClosestToPos, an as getListItemStyleDefinitions, ao as docxNumberingHelpers, ap as parseIndentElement, aq as combineIndents, ar as twipsToPixels, as as PIXELS_PER_INCH, at as SelectionRange, au as Transform, av as isInTable$1, aw as generateDocxRandomId, ax as insertNewRelationship, ay as inchesToPixels } from "./converter-CMtyH2w0.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
-import { D as DocxZipper } from "./docx-zipper-Dni97kMT.js";
+import { D as DocxZipper } from "./docx-zipper-Pgf9i5kI.js";
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence2() {
 };
@@ -11302,17 +11302,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,
@@ -11323,7 +11313,7 @@ const TrackChangesBasePlugin = () => {
             )
           };
         }
-        if (meta.type === "SHOW_ONLY_ORIGINAL") {
+        if (meta && meta.type === "SHOW_ONLY_ORIGINAL") {
           return {
             ...oldState,
             onlyOriginalShown: meta.value === true,
@@ -11331,7 +11321,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,
@@ -11339,6 +11329,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(
@@ -12091,8 +12106,10 @@ const CommentsPlugin = Extension.create({
         }
       },
       view() {
-        let prevDoc;
-        let prevActiveThreadId;
+        let prevDoc = null;
+        let prevActiveThreadId = null;
+        let prevAllCommentPositions = {};
+        let hasEverEmitted = false;
         return {
           update(view) {
             const { state } = view;
@@ -12103,16 +12120,20 @@ 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 isInitialLoad = prevDoc === null;
+            const onlyActiveThreadChanged = !isInitialLoad && !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);
@@ -12120,14 +12141,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({
@@ -12150,20 +12173,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);
@@ -12181,7 +12206,16 @@ const CommentsPlugin = Extension.create({
               });
               view.dispatch(tr2);
             }
-            editor.emit("comment-positions", { allCommentPositions });
+            if (!onlyActiveThreadChanged) {
+              const positionsChanged = hasPositionsChanged(prevAllCommentPositions, allCommentPositions);
+              const hasComments = Object.keys(allCommentPositions).length > 0;
+              const shouldEmitPositions = positionsChanged || !hasEverEmitted && hasComments;
+              if (shouldEmitPositions) {
+                prevAllCommentPositions = allCommentPositions;
+                hasEverEmitted = true;
+                editor.emit("comment-positions", { allCommentPositions });
+              }
+            }
           }
         };
       }
@@ -12189,6 +12223,22 @@ 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.bounds || !curr.bounds) {
+      return true;
+    }
+    if (prev.bounds.top !== curr.bounds.top || prev.bounds.left !== curr.bounds.left) {
+      return true;
+    }
+  }
+  return false;
+};
 const getActiveCommentId = (doc2, selection) => {
   if (!selection) return;
   const { $from, $to } = selection;
@@ -15002,7 +15052,7 @@ const _Editor = class _Editor extends EventEmitter {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-njnq8umX.js"),
+      import("./index-B3rVM2bJ.js"),
       import("./index-DRCvimau.js"),
       import("./index-C_x_N6Uh.js"),
       import("./index-D_sWOSiG.js"),
@@ -15220,7 +15270,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Object | void} Migration results
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.28.0");
+    console.debug("[checkVersionMigrations] Current editor version", "0.28.2");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -19561,8 +19611,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 };
       }
@@ -19875,6 +19953,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;
@@ -19884,13 +19968,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;
@@ -20104,9 +20202,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, fontFamily, lineHeight } = resolveListItemTypography({
       node,
       pos: this.getResolvedPos(),
@@ -20117,11 +20220,15 @@ class ListItemNodeView {
     this.dom.style.fontSize = fontSize;
     this.dom.style.fontFamily = fontFamily || "inherit";
     this.dom.style.lineHeight = lineHeight || "";
-    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);
@@ -20240,8 +20347,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 = fontSize.includes("pt") ? Number.parseFloat(fontSize) * POINT_TO_PIXEL_CONVERSION_FACTOR : Number.parseFloat(fontSize);
     context.font = `${fontSizePx}px ${fontFamily}`;
     const textWidth = context.measureText(markerText).width;
@@ -20260,7 +20370,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) {
@@ -20272,10 +20384,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;
@@ -20745,17 +20871,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(_, state) {
-          let decorations = getDropcapDecorations(state, view);
+          const decorations = getDropcapDecorations(state, view, dropcapWidthCache);
           return DecorationSet.create(state.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);
         }
       },
@@ -20768,12 +20945,12 @@ const Paragraph = OxmlNode.create({
     return [dropcapPlugin];
   }
 });
-const getDropcapDecorations = (state, view) => {
-  let decorations = [];
+const getDropcapDecorations = (state, view, widthCache) => {
+  const decorations = [];
   state.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;
@@ -20781,12 +20958,17 @@ const getDropcapDecorations = (state, 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 range = document.createRange();
     range.selectNodeContents(domNode);
-    return range.getBoundingClientRect().width;
+    const width = range.getBoundingClientRect().width;
+    widthCache.set(pos, width);
+    return width;
   }
   return 0;
 }
@@ -20972,10 +21154,16 @@ const getTabDecorations = (doc2, view, helpers2, from2 = 0, to = null) => {
     const paragraphContext = getParagraphContext($pos, paragraphCache, helpers2);
     if (!paragraphContext) return;
     try {
-      const { tabStops, flattened, startPos } = paragraphContext;
-      const entryIndex = flattened.findIndex((entry) => entry.pos === pos);
-      if (entryIndex === -1) return;
-      const indentWidth = getIndentWidth(view, startPos, paragraphContext.indent, coordCache, domPosCache);
+      const { tabStops, flattened, positionMap, startPos } = paragraphContext;
+      const entryIndex = positionMap.get(pos);
+      if (entryIndex === void 0) return;
+      if (paragraphContext.indentWidth === void 0) {
+        paragraphContext.indentWidth = getIndentWidth(view, startPos, paragraphContext.indent, coordCache, domPosCache);
+      }
+      if (paragraphContext.tabHeight === void 0) {
+        paragraphContext.tabHeight = calcTabHeight($pos);
+      }
+      const indentWidth = paragraphContext.indentWidth;
       const accumulatedTabWidth = paragraphContext.accumulatedTabWidth || 0;
       const currentWidth = indentWidth + measureRangeWidth(view, startPos + 1, pos, coordCache, domPosCache) + accumulatedTabWidth;
       let tabWidth;
@@ -21017,7 +21205,7 @@ const getTabDecorations = (doc2, view, helpers2, from2 = 0, to = null) => {
         tabWidth = defaultTabDistance - currentWidth % defaultLineLength % defaultTabDistance;
         if (tabWidth === 0) tabWidth = defaultTabDistance;
       }
-      const tabHeight = calcTabHeight($pos);
+      const tabHeight = paragraphContext.tabHeight;
       decorations.push(
         Decoration.node(pos, pos + node.nodeSize, {
           style: `width: ${tabWidth}px; height: ${tabHeight};${extraStyles}`
@@ -21045,13 +21233,16 @@ function getParagraphContext($pos, cache, helpers2) {
             tabStops = style.definition.styles.tabStops;
           }
         }
+        const { entries, positionMap } = flattenParagraph(node, startPos);
         cache.set(startPos, {
           paragraph: node,
           paragraphDepth: depth,
           startPos,
           indent: node.attrs?.indent || {},
           tabStops,
-          flattened: flattenParagraph(node, startPos),
+          flattened: entries,
+          positionMap,
+          // Store position map for O(1) lookups
           accumulatedTabWidth: 0
         });
       }
@@ -21062,6 +21253,7 @@ function getParagraphContext($pos, cache, helpers2) {
 }
 function flattenParagraph(paragraph, paragraphStartPos) {
   const entries = [];
+  const positionMap = /* @__PURE__ */ new Map();
   const walk = (node, basePos) => {
     if (!node) return;
     if (node.type?.name === "run") {
@@ -21071,13 +21263,16 @@ function flattenParagraph(paragraph, paragraphStartPos) {
       });
       return;
     }
-    entries.push({ node, pos: basePos - 1 });
+    const pos = basePos - 1;
+    const index2 = entries.length;
+    entries.push({ node, pos });
+    positionMap.set(pos, index2);
   };
   paragraph.forEach((child, offset2) => {
     const childPos = paragraphStartPos + offset2 + 1;
     walk(child, childPos);
   });
-  return entries;
+  return { entries, positionMap };
 }
 function findNextTabIndex(flattened, fromIndex) {
   for (let i = fromIndex; i < flattened.length; i++) {
@@ -21235,6 +21430,21 @@ const TabNode = Node$1.create({
   },
   addPmPlugins() {
     const { view, helpers: helpers2 } = this.editor;
+    const mergeRanges2 = (ranges) => {
+      if (ranges.length === 0) return [];
+      const sorted = ranges.slice().sort((a, b) => a[0] - b[0]);
+      const merged = [sorted[0]];
+      for (let i = 1; i < sorted.length; i++) {
+        const [start2, end2] = sorted[i];
+        const last = merged[merged.length - 1];
+        if (start2 <= last[1]) {
+          last[1] = Math.max(last[1], end2);
+        } else {
+          merged.push([start2, end2]);
+        }
+      }
+      return merged;
+    };
     const tabPlugin = new Plugin({
       name: "tabPlugin",
       key: new PluginKey("tabPlugin"),
@@ -21245,43 +21455,56 @@ const TabNode = Node$1.create({
         apply(tr, { decorations }, _oldState, newState) {
           if (!decorations) {
             decorations = DecorationSet.create(newState.doc, getTabDecorations(newState.doc, view, helpers2));
+            return { decorations };
           }
-          if (!tr.docChanged || tr.getMeta("blockNodeInitialUpdate") === true) {
+          if (!tr.docChanged || tr.getMeta("blockNodeInitialUpdate")) {
             return { decorations };
           }
           decorations = decorations.map(tr.mapping, tr.doc);
-          let rangesToRecalculate = [];
+          const rangesToRecalculate = [];
+          const containsTab = (node) => node.type.name === "tab";
           tr.steps.forEach((step, index2) => {
-            const stepMap = step.getMap();
-            if (step instanceof ReplaceStep || step instanceof ReplaceAroundStep$1) {
-              const $from = tr.docs[index2].resolve(step.from);
-              const $to = tr.docs[index2].resolve(step.to);
-              const start2 = $from.start(Math.min($from.depth, 1));
-              const end2 = $to.end(Math.min($to.depth, 1));
-              let addRange = false;
-              tr.docs[index2].nodesBetween(start2, end2, (node) => {
-                if (node.type.name === "tab") {
-                  addRange = true;
+            if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep$1)) {
+              return;
+            }
+            let hasTabInRange = false;
+            if (step.slice?.content) {
+              step.slice.content.descendants((node) => {
+                if (containsTab(node)) {
+                  hasTabInRange = true;
+                  return false;
                 }
               });
-              if (!addRange && step.slice?.content) {
-                step.slice.content.descendants((node) => {
-                  if (node.type.name === "tab") {
-                    addRange = true;
-                  }
-                });
-              }
-              if (addRange) {
-                rangesToRecalculate.push([start2, end2]);
-              }
             }
-            rangesToRecalculate = rangesToRecalculate.map(([from2, to]) => {
-              const mappedFrom = stepMap.map(from2, -1);
-              const mappedTo = stepMap.map(to, 1);
-              return [mappedFrom, mappedTo];
-            });
+            if (!hasTabInRange) {
+              tr.docs[index2].nodesBetween(step.from, step.to, (node) => {
+                if (containsTab(node)) {
+                  hasTabInRange = true;
+                  return false;
+                }
+              });
+            }
+            if (!hasTabInRange) {
+              return;
+            }
+            let fromPos = step.from;
+            let toPos = step.to;
+            for (let i = index2; i < tr.steps.length; i++) {
+              const stepMap = tr.steps[i].getMap();
+              fromPos = stepMap.map(fromPos, -1);
+              toPos = stepMap.map(toPos, 1);
+            }
+            const $from = newState.doc.resolve(fromPos);
+            const $to = newState.doc.resolve(toPos);
+            const start2 = $from.start(Math.min($from.depth, 1));
+            const end2 = $to.end(Math.min($to.depth, 1));
+            rangesToRecalculate.push([start2, end2]);
           });
-          rangesToRecalculate.forEach(([start2, end2]) => {
+          if (rangesToRecalculate.length === 0) {
+            return { decorations };
+          }
+          const mergedRanges = mergeRanges2(rangesToRecalculate);
+          mergedRanges.forEach(([start2, end2]) => {
             const oldDecorations = decorations.find(start2, end2);
             decorations = decorations.remove(oldDecorations);
             const newDecorations = getTabDecorations(newState.doc, view, helpers2, start2, end2);
@@ -25183,6 +25406,29 @@ createAnnotation_fn = function({ displayLabel } = {}) {
     content
   };
 };
+const mergeRanges = (ranges) => {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]).map((range) => [...range]);
+  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({
@@ -25257,24 +25503,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;
     }
     ///
@@ -27084,7 +27410,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;
@@ -27097,6 +27425,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);
@@ -27126,6 +27468,16 @@ const ImagePositionPlugin = ({ editor }) => {
 };
 const getImagePositionDecorations = (state, view) => {
   let decorations = [];
+  let hasAnchoredImages = false;
+  state.doc.descendants((node) => {
+    if (node.attrs?.anchorData) {
+      hasAnchoredImages = true;
+      return false;
+    }
+  });
+  if (!hasAnchoredImages) {
+    return decorations;
+  }
   state.doc.descendants((node, pos) => {
     if (node.attrs.anchorData) {
       let style = "";
@@ -27134,7 +27486,15 @@ const getImagePositionDecorations = (state, view) => {
       const { size, 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%);";
         style += vRelativeFrom === "margin" ? `position: absolute; top: ${topPos}px; ${horizontalAlignment}` : "";
@@ -27445,15 +27805,15 @@ const Image = Node$1.create({
             style += "float: right;";
             floatRight = true;
           } else if (["largest", "bothSides"].includes(attrs.wrapText)) {
-            const pageStylesData2 = getDataFromPageStyles({
+            const pageStylesData = getDataFromPageStyles({
               editor: this.editor,
               marginOffset,
               size,
               attrs
             });
-            style += pageStylesData2.style;
-            floatRight = pageStylesData2.floatRight;
-            baseHorizontal = pageStylesData2.baseHorizontal;
+            style += pageStylesData.style;
+            floatRight = pageStylesData.floatRight;
+            baseHorizontal = pageStylesData.baseHorizontal;
           }
           if (attrs.distTop) margin.top += attrs.distTop;
           if (attrs.distBottom) margin.bottom += attrs.distBottom;
@@ -27461,7 +27821,7 @@ const Image = Node$1.create({
           if (attrs.distRight) margin.right += attrs.distRight;
           break;
         case "Through":
-        case "Tight":
+        case "Tight": {
           style += "clear: both;";
           const pageStylesData = getDataFromPageStyles({
             editor: this.editor,
@@ -27498,11 +27858,14 @@ const Image = Node$1.create({
             style += `shape-outside: polygon(${points});`;
           }
           break;
+        }
         case "TopAndBottom":
           style += "display: block; clear: both;";
+          if (!anchorData) {
+            centered = true;
+          }
           if (attrs.distTop) margin.top += attrs.distTop;
           if (attrs.distBottom) margin.bottom += attrs.distBottom;
-          centered = true;
           break;
       }
     }
@@ -27522,6 +27885,20 @@ const Image = Node$1.create({
             style += `position: absolute; ${anchorData.alignH}: 0;`;
           }
           break;
+        case "column":
+          if (anchorData.alignH === "center") {
+            centered = true;
+          } else if (anchorData.alignH === "right") {
+            floatRight = true;
+            if (!style.includes("float: right;")) {
+              style += "float: right;";
+            }
+          } else if (anchorData.alignH === "left") {
+            if (!style.includes("float: left;")) {
+              style += "float: left;";
+            }
+          }
+          break;
       }
     }
     if (hasAnchorData || hasMarginOffsets) {
@@ -28609,11 +28986,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;
           }
@@ -28622,21 +29010,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.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.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.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);
@@ -35112,8 +35566,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;
@@ -36368,6 +36822,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: {
@@ -36395,6 +36851,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) {
@@ -36426,11 +36885,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
           };
         }
@@ -36442,11 +36913,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);
           }
         };
       },