@harbour-enterprises/superdoc 1.4.0 → 1.4.1-next.2

package/dist/chunks/{index-BKXWekME.cjs → index-DS7Ttafb.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-C4XfNZf6.cjs");
+const superEditor_converter = require("./SuperConverter-Bukam51x.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -12638,11 +12638,15 @@ const resolveCommentMeta = ({ converter, importedId }) => {
   const matchingImportedComment = comments.find((c2) => c2.importedId == importedId);
   const resolvedCommentId = matchingImportedComment?.commentId ?? (importedId ? String(importedId) : uuid.v4());
   const internal = matchingImportedComment?.internal ?? matchingImportedComment?.isInternal ?? false;
+  const parentCommentId = matchingImportedComment?.parentCommentId;
+  const trackedChangeIds = converter?.trackedChangeIdMap ? new Set(Array.from(converter.trackedChangeIdMap.values()).map((id) => String(id))) : null;
+  const isTrackedChangeParent = parentCommentId && trackedChangeIds ? trackedChangeIds.has(String(parentCommentId)) : false;
   return {
     resolvedCommentId,
     importedId,
     internal,
-    matchingImportedComment
+    matchingImportedComment,
+    trackedChange: matchingImportedComment?.trackedChange === true || isTrackedChangeParent
   };
 };
 const ensureFallbackComment = ({ converter, matchingImportedComment, commentId, importedId }) => {
@@ -12660,6 +12664,7 @@ const ensureFallbackComment = ({ converter, matchingImportedComment, commentId,
     isDone: false
   });
 };
+const TRACK_CHANGE_MARKS$1 = [superEditor_converter.TrackInsertMarkName, superEditor_converter.TrackDeleteMarkName, superEditor_converter.TrackFormatMarkName];
 const removeCommentsById = ({ commentId, state, tr, dispatch }) => {
   const positions = getCommentPositionsById(commentId, state.doc);
   positions.forEach(({ from: from3, to }) => {
@@ -12803,6 +12808,35 @@ const prepareCommentsForExport = (doc2, tr, schema, comments = []) => {
         });
       });
     });
+    const trackedChangeMark = node.marks?.find((mark) => TRACK_CHANGE_MARKS$1.includes(mark.type.name));
+    if (trackedChangeMark) {
+      const trackedChangeId = trackedChangeMark.attrs?.id;
+      if (trackedChangeId) {
+        const childComments = comments.filter((c2) => c2.parentCommentId === trackedChangeId && !c2.trackedChange).sort((a, b) => a.createdTime - b.createdTime);
+        childComments.forEach((c2) => {
+          if (seen.has(c2.commentId)) return;
+          seen.add(c2.commentId);
+          const childMark = getPreparedComment({
+            commentId: c2.commentId,
+            internal: c2.isInternal
+          });
+          const childStartNode = schema.nodes.commentRangeStart.create(childMark);
+          startNodes.push({
+            pos,
+            node: childStartNode,
+            commentId: c2.commentId,
+            parentCommentId: c2.parentCommentId
+          });
+          const childEndNode = schema.nodes.commentRangeEnd.create(childMark);
+          endNodes.push({
+            pos: pos + node.nodeSize,
+            node: childEndNode,
+            commentId: c2.commentId,
+            parentCommentId: c2.parentCommentId
+          });
+        });
+      }
+    }
   });
   startNodes.sort((a, b) => {
     if (a.pos !== b.pos) return a.pos - b.pos;
@@ -12857,17 +12891,18 @@ const prepareCommentsForImport = (doc2, tr, schema, converter) => {
     const { type } = node;
     const commentNodes = ["commentRangeStart", "commentRangeEnd", "commentReference"];
     if (!commentNodes.includes(type.name)) return;
-    const { resolvedCommentId, importedId, internal, matchingImportedComment } = resolveCommentMeta({
+    const { resolvedCommentId, importedId, internal, matchingImportedComment, trackedChange } = resolveCommentMeta({
       converter,
       importedId: node.attrs["w:id"]
     });
     const isDone = !!matchingImportedComment?.isDone;
     if (type.name === "commentRangeStart") {
-      if (!isDone) {
+      if (!matchingImportedComment || !matchingImportedComment.isDone) {
         toMark.push({
           commentId: resolvedCommentId,
           importedId,
           internal,
+          trackedChange,
           start: pos
         });
       }
@@ -12906,7 +12941,8 @@ const prepareCommentsForImport = (doc2, tr, schema, converter) => {
       const markAttrs = {
         commentId: itemToMark.commentId,
         importedId,
-        internal: itemToMark.internal
+        internal: itemToMark.internal,
+        trackedChange: itemToMark.trackedChange
       };
       tr.addMark(start2, pos + 1, schema.marks[CommentMarkName$1].create(markAttrs));
       toDelete.push({ start: pos, end: pos + 1 });
@@ -13468,26 +13504,30 @@ const handleTrackedChangeTransaction = (trackedChangeMeta, trackedChanges, newEd
   if (emitParams) editor.emit("commentsUpdate", emitParams);
   return newTrackedChanges;
 };
-const getTrackedChangeText = ({ nodes, mark, trackedChangeType, isDeletionInsertion }) => {
+const getTrackedChangeText = ({ nodes, mark, trackedChangeType, isDeletionInsertion, marks }) => {
   let trackedChangeText = "";
   let deletionText = "";
-  if (trackedChangeType === superEditor_converter.TrackInsertMarkName) {
+  if (trackedChangeType === superEditor_converter.TrackDeleteMarkName || isDeletionInsertion) {
+    deletionText = nodes.reduce((acc, node) => {
+      const hasDeleteMark = node.marks.find((nodeMark) => nodeMark.type.name === superEditor_converter.TrackDeleteMarkName);
+      if (!hasDeleteMark) return acc;
+      const nodeText = node?.text || node?.textContent || "";
+      acc += nodeText;
+      return acc;
+    }, "");
+  }
+  if (trackedChangeType === superEditor_converter.TrackInsertMarkName || isDeletionInsertion) {
     trackedChangeText = nodes.reduce((acc, node) => {
-      if (!node.marks.find((nodeMark) => nodeMark.type.name === mark.type.name)) return acc;
-      acc += node?.text || node?.textContent || "";
+      const hasInsertMark = node.marks.find((nodeMark) => nodeMark.type.name === superEditor_converter.TrackInsertMarkName);
+      if (!hasInsertMark) return acc;
+      const nodeText = node?.text || node?.textContent || "";
+      acc += nodeText;
       return acc;
     }, "");
   }
   if (trackedChangeType === superEditor_converter.TrackFormatMarkName) {
     trackedChangeText = translateFormatChangesToEnglish(mark.attrs);
   }
-  if (trackedChangeType === superEditor_converter.TrackDeleteMarkName || isDeletionInsertion) {
-    deletionText = nodes.reduce((acc, node) => {
-      if (!node.marks.find((nodeMark) => nodeMark.type.name === superEditor_converter.TrackDeleteMarkName)) return acc;
-      acc += node?.text || node?.textContent || "";
-      return acc;
-    }, "");
-  }
   return {
     deletionText,
     trackedChangeText
@@ -13500,22 +13540,41 @@ const createOrUpdateTrackedChangeComment = ({ event, marks, deletionNodes, nodes
   const { author, authorEmail, authorImage, date, importedAuthor } = attrs;
   const id = attrs.id;
   const node = nodes[0];
-  const isDeletionInsertion = !!(marks.insertedMark && marks.deletionMark);
+  const trackedChangesWithId = getTrackChanges(newEditorState, id);
+  let isDeletionInsertion = !!(marks.insertedMark && marks.deletionMark);
+  if (!isDeletionInsertion) {
+    const hasInsertMark = trackedChangesWithId.some(({ mark }) => mark.type.name === superEditor_converter.TrackInsertMarkName);
+    const hasDeleteMark = trackedChangesWithId.some(({ mark }) => mark.type.name === superEditor_converter.TrackDeleteMarkName);
+    isDeletionInsertion = hasInsertMark && hasDeleteMark;
+  }
   let nodesWithMark = [];
-  newEditorState.doc.descendants((node2) => {
-    const { marks: marks2 = [] } = node2;
-    const changeMarks = marks2.filter((mark) => TRACK_CHANGE_MARKS.includes(mark.type.name));
-    if (!changeMarks.length) return;
-    const hasMatchingId = changeMarks.find((mark) => mark.attrs.id === id);
-    if (hasMatchingId) nodesWithMark.push(node2);
+  trackedChangesWithId.forEach(({ from: from3, to, mark }) => {
+    newEditorState.doc.nodesBetween(from3, to, (node2, pos) => {
+      if (node2.isText) {
+        const hasMatchingMark = node2.marks?.some((m) => TRACK_CHANGE_MARKS.includes(m.type.name) && m.attrs.id === id);
+        if (hasMatchingMark) {
+          const alreadyAdded = nodesWithMark.some((n) => n === node2);
+          if (!alreadyAdded) {
+            nodesWithMark.push(node2);
+          }
+        }
+      }
+    });
   });
-  const nodesToProcess = nodesWithMark.length ? nodesWithMark : node ? [node] : [];
-  if (!nodesToProcess.length) {
+  let nodesToUse;
+  if (isDeletionInsertion) {
+    const allNodes = [...nodesWithMark, ...nodes, ...deletionNodes || []];
+    nodesToUse = Array.from(new Set(allNodes));
+  } else {
+    nodesToUse = nodesWithMark.length ? nodesWithMark : node ? [node] : [];
+  }
+  if (!nodesToUse.length) {
     return;
   }
   const { deletionText, trackedChangeText } = getTrackedChangeText({
-    nodes: nodesToProcess,
+    nodes: nodesToUse,
     mark: trackedMark,
+    marks,
     trackedChangeType,
     isDeletionInsertion
   });
@@ -15457,7 +15516,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.4.0";
+const summaryVersion = "1.4.1-next.2";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -18089,7 +18148,7 @@ class Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.4.0");
+    console.debug("[checkVersionMigrations] Current editor version", "1.4.1-next.2");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -23272,7 +23331,6 @@ const SDT_CONTAINER_STYLES = `
 const FIELD_ANNOTATION_STYLES = `
 /* Field annotation draggable styles */
 .superdoc-layout .annotation[data-draggable="true"] {
-  cursor: grab;
   user-select: none;
   -webkit-user-select: none;
 }
@@ -27197,12 +27255,15 @@ class DomPainter {
       }
     }
     applyRunStyles(elem, run, isActiveLink);
-    const commentColor = getCommentHighlight(run);
-    if (commentColor && !run.highlight) {
+    const textRun = run;
+    const commentAnnotations = textRun.comments;
+    const hasAnyComment = !!commentAnnotations?.length;
+    const hasHighlightableComment = !!commentAnnotations?.some((c2) => !c2.trackedChange);
+    const commentColor = getCommentHighlight(textRun);
+    if (commentColor && !textRun.highlight && hasHighlightableComment) {
       elem.style.backgroundColor = commentColor;
     }
-    const commentAnnotations = run.comments;
-    if (commentAnnotations?.length) {
+    if (hasAnyComment) {
       elem.dataset.commentIds = commentAnnotations.map((c2) => c2.commentId).join(",");
       if (commentAnnotations.some((c2) => c2.internal)) {
         elem.dataset.commentInternal = "true";
@@ -41182,6 +41243,7 @@ const pushCommentAnnotation = (run, attrs) => {
   const commentId = typeof attrs?.commentId === "string" ? attrs.commentId : void 0;
   const importedId = typeof attrs?.importedId === "string" ? attrs.importedId : void 0;
   const internal = attrs?.internal === true;
+  const trackedChange = attrs?.trackedChange === true;
   if (!commentId && !importedId) return;
   const annotations = run.comments ? [...run.comments] : [];
   const key2 = `${commentId ?? ""}::${importedId ?? ""}`;
@@ -41190,7 +41252,8 @@ const pushCommentAnnotation = (run, attrs) => {
     annotations.push({
       commentId: commentId ?? importedId,
       importedId,
-      internal
+      internal,
+      trackedChange
     });
   }
   run.comments = annotations;
@@ -52469,6 +52532,40 @@ class PresentationEditor extends EventEmitter {
       this.#editor.view?.focus();
     }
   }
+  #resolveFieldAnnotationSelectionFromElement(annotationEl) {
+    const pmStartRaw = annotationEl.dataset?.pmStart;
+    if (pmStartRaw == null) {
+      return null;
+    }
+    const pmStart = Number(pmStartRaw);
+    if (!Number.isFinite(pmStart)) {
+      return null;
+    }
+    const doc2 = this.#editor.state?.doc;
+    if (!doc2) {
+      return null;
+    }
+    const layoutEpochRaw = annotationEl.dataset?.layoutEpoch;
+    const layoutEpoch = layoutEpochRaw != null ? Number(layoutEpochRaw) : NaN;
+    const effectiveEpoch = Number.isFinite(layoutEpoch) ? layoutEpoch : this.#epochMapper.getCurrentEpoch();
+    const mapped = this.#epochMapper.mapPosFromLayoutToCurrentDetailed(pmStart, effectiveEpoch, 1);
+    if (!mapped.ok) {
+      const fallbackPos = Math.max(0, Math.min(pmStart, doc2.content.size));
+      const fallbackNode = doc2.nodeAt(fallbackPos);
+      if (fallbackNode?.type?.name === "fieldAnnotation") {
+        return { node: fallbackNode, pos: fallbackPos };
+      }
+      this.#pendingDocChange = true;
+      this.#scheduleRerender();
+      return null;
+    }
+    const clampedPos = Math.max(0, Math.min(mapped.pos, doc2.content.size));
+    const node = doc2.nodeAt(clampedPos);
+    if (!node || node.type.name !== "fieldAnnotation") {
+      return null;
+    }
+    return { node, pos: clampedPos };
+  }
   #setupInputBridge() {
     this.#inputBridge?.destroy();
     const win = this.#visibleHost.ownerDocument?.defaultView ?? window;
@@ -52559,8 +52656,30 @@ class PresentationEditor extends EventEmitter {
       linkEl.dispatchEvent(linkClickEvent);
       return;
     }
+    const annotationEl = target?.closest?.(".annotation[data-pm-start]");
     const isDraggableAnnotation = target?.closest?.('[data-draggable="true"]') != null;
     this.#suppressFocusInFromDraggable = isDraggableAnnotation;
+    if (annotationEl) {
+      if (!this.#editor.isEditable) {
+        return;
+      }
+      const resolved = this.#resolveFieldAnnotationSelectionFromElement(annotationEl);
+      if (resolved) {
+        try {
+          const tr = this.#editor.state.tr.setSelection(superEditor_converter.NodeSelection.create(this.#editor.state.doc, resolved.pos));
+          this.#editor.view?.dispatch(tr);
+        } catch {
+        }
+        this.#editor.emit("fieldAnnotationClicked", {
+          editor: this.#editor,
+          node: resolved.node,
+          nodePos: resolved.pos,
+          event,
+          currentTarget: annotationEl
+        });
+      }
+      return;
+    }
     if (!this.#layoutState.layout) {
       if (!isDraggableAnnotation) {
         event.preventDefault();
@@ -60175,6 +60294,10 @@ const CommentsMark = Mark.create({
       internal: {
         default: true,
         rendered: false
+      },
+      trackedChange: {
+        default: false,
+        rendered: false
       }
     };
   },

package/dist/chunks/{index-DbSiW7hc.es.js → index-QUPzhiU8.es.js}

@@ -1,5 +1,5 @@
-import { B as BIT8, M as MAX_SAFE_INTEGER, c as create, a as BITS7, u as utf8TextDecoder, b as create$1, s as setIfUndefined, d as create$2, f as from, e as floor$1, g as equalityDeep, w as writeVarUint, h as writeVarString, t as toUint8Array, i as createEncoder, j as createInjectionKey, k as toString, l as throwError, m as useSsrAdapter, n as configProviderInjectionKey, o as cssrAnchorMetaName, p as globalStyle, q as cB, r as c, v as isMounted, x as commonVariables$2, y as cM, z as cNotM, A as cE, C as derived, D as changeColor, E as insideModal, F as insidePopover, G as resolveWrappedSlot, H as on, I as warnOnce, J as useConfig, K as useMergedState, L as useMemo, N as useTheme, O as useRtl, P as createKey, Q as useThemeClass, R as createId, S as call, T as render, U as messageProviderInjectionKey, V as messageApiInjectionKey, W as fromBase64, X as onChange, Y as varStorage, Z as toBase64, _ as createUint8ArrayFromArrayBuffer, $ as offChange, a0 as writeVarUint8Array, a1 as map, a2 as length, a3 as isNode, a4 as min, a5 as pow, a6 as comments_module_events, a7 as getFileObject, a8 as getTrackChanges, a9 as CommentsPluginKey, aa as TrackChangesBasePluginKey, ab as Editor, ac as getRichTextExtensions, ad as ellipsisVerticalSvg, ae as xmarkIconSvg, af as checkIconSvg, ag as caretDownIconSvg, ah as commentIconSvg, ai as _export_sfc, aj as NDropdown, ak as SuperInput, al as vClickOutside, am as PresentationEditor, an as SuperEditor, ao as AIWriter, ap as NConfigProvider, aq as SuperToolbar } from "./index-B6VX2S0H.es.js";
-import "./SuperConverter-DAO7c_d4.es.js";
+import { B as BIT8, M as MAX_SAFE_INTEGER, c as create, a as BITS7, u as utf8TextDecoder, b as create$1, s as setIfUndefined, d as create$2, f as from, e as floor$1, g as equalityDeep, w as writeVarUint, h as writeVarString, t as toUint8Array, i as createEncoder, j as createInjectionKey, k as toString, l as throwError, m as useSsrAdapter, n as configProviderInjectionKey, o as cssrAnchorMetaName, p as globalStyle, q as cB, r as c, v as isMounted, x as commonVariables$2, y as cM, z as cNotM, A as cE, C as derived, D as changeColor, E as insideModal, F as insidePopover, G as resolveWrappedSlot, H as on, I as warnOnce, J as useConfig, K as useMergedState, L as useMemo, N as useTheme, O as useRtl, P as createKey, Q as useThemeClass, R as createId, S as call, T as render, U as messageProviderInjectionKey, V as messageApiInjectionKey, W as fromBase64, X as onChange, Y as varStorage, Z as toBase64, _ as createUint8ArrayFromArrayBuffer, $ as offChange, a0 as writeVarUint8Array, a1 as map, a2 as length, a3 as isNode, a4 as min, a5 as pow, a6 as comments_module_events, a7 as getFileObject, a8 as getTrackChanges, a9 as CommentsPluginKey, aa as TrackChangesBasePluginKey, ab as Editor, ac as getRichTextExtensions, ad as ellipsisVerticalSvg, ae as xmarkIconSvg, af as checkIconSvg, ag as caretDownIconSvg, ah as commentIconSvg, ai as _export_sfc, aj as NDropdown, ak as SuperInput, al as vClickOutside, am as PresentationEditor, an as SuperEditor, ao as AIWriter, ap as NConfigProvider, aq as SuperToolbar } from "./index-BQPLVzyQ.es.js";
+import "./SuperConverter-BJi_tRyc.es.js";
 import { B as BlankDOCX } from "./blank-docx-ABm6XYAA.es.js";
 import { E as EventEmitter } from "./eventemitter3-CwrdEv8r.es.js";
 import { HocuspocusProvider, HocuspocusProviderWebsocket } from "@hocuspocus/provider";
@@ -5113,11 +5113,14 @@ const groupChanges = (changes) => {
     trackFormat: "formatMark"
   };
   const grouped = [];
+  const processed = /* @__PURE__ */ new Set();
   for (let i = 0; i < changes.length; i++) {
+    if (processed.has(i)) continue;
     const c1 = changes[i];
-    const c2 = changes[i + 1];
     const c1Key = markMetaKeys[c1.mark.type.name];
-    if (c1 && c2 && c1.to === c2.from && c1.mark.attrs.id === c2.mark.attrs.id) {
+    const c1Id = c1.mark.attrs.id;
+    const c2 = changes[i + 1];
+    if (c2 && c1.to === c2.from && c1Id === c2.mark.attrs.id) {
       const c2Key = markMetaKeys[c2.mark.type.name];
       grouped.push({
         from: c1.from,
@@ -5125,13 +5128,35 @@ const groupChanges = (changes) => {
         [c1Key]: c1,
         [c2Key]: c2
       });
-      i++;
-    } else {
+      processed.add(i);
+      processed.add(i + 1);
+      continue;
+    }
+    let foundMatch = false;
+    for (let j = i + 1; j < changes.length; j++) {
+      if (processed.has(j)) continue;
+      const c22 = changes[j];
+      if (c1Id === c22.mark.attrs.id && c1.mark.type.name !== c22.mark.type.name) {
+        const c2Key = markMetaKeys[c22.mark.type.name];
+        grouped.push({
+          from: Math.min(c1.from, c22.from),
+          to: Math.max(c1.to, c22.to),
+          [c1Key]: c1,
+          [c2Key]: c22
+        });
+        processed.add(i);
+        processed.add(j);
+        foundMatch = true;
+        break;
+      }
+    }
+    if (!foundMatch) {
       grouped.push({
         from: c1.from,
         to: c1.to,
         [c1Key]: c1
       });
+      processed.add(i);
     }
   }
   return grouped;
@@ -5433,7 +5458,12 @@ const useCommentsStore = /* @__PURE__ */ defineStore("comments", () => {
         trackedChange: comment.trackedChange || false,
         trackedChangeText: comment.trackedChangeText,
         trackedChangeType: comment.trackedChangeType,
-        deletedText: comment.trackedDeletedText
+        deletedText: comment.trackedDeletedText,
+        // Preserve origin metadata for export
+        origin: comment.origin || "word",
+        // Default to 'word' for backward compatibility
+        threadingMethod: comment.threadingMethod,
+        originalXmlStructure: comment.originalXmlStructure
       });
       addComment({ superdoc, comment: newComment });
     });
@@ -6213,7 +6243,11 @@ const _sfc_main$c = {
         const isThreadedComment = c2.parentCommentId === parentComment.commentId;
         const isThisComment = c2.commentId === props.comment.commentId;
         return isThreadedComment || isThisComment;
-      }).sort((a, b) => a.commentId === props.comment.commentId && a.createdTime - b.createdTime);
+      }).sort((a, b) => {
+        if (a.commentId === props.comment.commentId) return -1;
+        if (b.commentId === props.comment.commentId) return 1;
+        return a.createdTime - b.createdTime;
+      });
     });
     const isInternalDropdownDisabled = computed(() => {
       if (props.comment.resolvedTime) return true;
@@ -6472,7 +6506,7 @@ const _sfc_main$c = {
     };
   }
 };
-const CommentDialog = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__scopeId", "data-v-d50fd675"]]);
+const CommentDialog = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__scopeId", "data-v-f9956635"]]);
 const _hoisted_1$a = { class: "comments-list" };
 const _hoisted_2$5 = { key: 0 };
 const _hoisted_3$3 = { class: "comment-item" };
@@ -7479,7 +7513,7 @@ const _sfc_main = {
   __name: "SuperDoc",
   emits: ["selection-update"],
   setup(__props, { emit: __emit }) {
-    const PdfViewer = defineAsyncComponent(() => import("./PdfViewer-CihMmpz1.es.js"));
+    const PdfViewer = defineAsyncComponent(() => import("./PdfViewer-JG6s_6rr.es.js"));
     const superdocStore = useSuperdocStore();
     const commentsStore = useCommentsStore();
     const {
@@ -8433,7 +8467,7 @@ class SuperDoc extends EventEmitter {
     this.config.colors = shuffleArray(this.config.colors);
     this.userColorMap = /* @__PURE__ */ new Map();
     this.colorIndex = 0;
-    this.version = "1.4.0";
+    this.version = "1.4.1-next.2";
     this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
     this.superdocId = config.superdocId || v4();
     this.colors = this.config.colors;

package/dist/style.css

@@ -2299,32 +2299,32 @@ span[data-v-53e13009] {
   display: inline-block;
 }
 
-.change-type[data-v-d50fd675] {
+.change-type[data-v-f9956635] {
   font-style: italic;
   font-weight: 600;
   font-size: 10px;
   color: #555;
 }
-.tracked-change[data-v-d50fd675] {
+.tracked-change[data-v-f9956635] {
   font-size: 12px;
 }
-.tracked-change-text[data-v-d50fd675] {
+.tracked-change-text[data-v-f9956635] {
   color: #111;
 }
-.comment-separator[data-v-d50fd675] {
+.comment-separator[data-v-f9956635] {
   background-color: #dbdbdb;
   height: 1px;
   width: 100%;
   margin: 10px 0;
   font-weight: 400;
 }
-.existing-internal-input[data-v-d50fd675] {
+.existing-internal-input[data-v-f9956635] {
   margin-bottom: 10px;
 }
-.initial-internal-dropdown[data-v-d50fd675] {
+.initial-internal-dropdown[data-v-f9956635] {
   margin-top: 10px;
 }
-.comments-dialog[data-v-d50fd675] {
+.comments-dialog[data-v-f9956635] {
   display: flex;
   flex-direction: column;
   padding: 10px 15px;
@@ -2340,39 +2340,39 @@ span[data-v-53e13009] {
   min-width: 200px;
   width: 100%;
 }
-.is-active[data-v-d50fd675] {
+.is-active[data-v-f9956635] {
   z-index: 10;
 }
-.input-section[data-v-d50fd675] {
+.input-section[data-v-f9956635] {
   margin-top: 10px;
 }
-.sd-button[data-v-d50fd675] {
+.sd-button[data-v-f9956635] {
   font-size: 12px;
   margin-left: 5px;
 }
-.comment[data-v-d50fd675] {
+.comment[data-v-f9956635] {
   font-size: 13px;
   margin: 10px 0;
 }
-.is-resolved[data-v-d50fd675] {
+.is-resolved[data-v-f9956635] {
   background-color: #f0f0f0;
 }
-.comment-footer[data-v-d50fd675] {
+.comment-footer[data-v-f9956635] {
   margin: 5px 0 5px;
   display: flex;
   justify-content: flex-end;
   width: 100%;
 }
-.internal-dropdown[data-v-d50fd675] {
+.internal-dropdown[data-v-f9956635] {
   display: inline-block;
 }
-.comment-editing[data-v-d50fd675] {
+.comment-editing[data-v-f9956635] {
   padding-bottom: 10px;
 }
-.comment-editing button[data-v-d50fd675] {
+.comment-editing button[data-v-f9956635] {
   margin-left: 5px;
 }
-.tracked-change[data-v-d50fd675] {
+.tracked-change[data-v-f9956635] {
   margin: 0;
 }
 

package/dist/super-editor/converter.cjs

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../chunks/jszip-C8_CqJxM.cjs");
 require("../chunks/helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("../chunks/SuperConverter-C4XfNZf6.cjs");
+const superEditor_converter = require("../chunks/SuperConverter-Bukam51x.cjs");
 require("../chunks/uuid-R7L08bOx.cjs");
 exports.SuperConverter = superEditor_converter.SuperConverter;

package/dist/super-editor/converter.es.js

@@ -1,6 +1,6 @@
 import "../chunks/jszip-B1fkPkPJ.es.js";
 import "../chunks/helpers-C8e9wR5l.es.js";
-import { S } from "../chunks/SuperConverter-DAO7c_d4.es.js";
+import { S } from "../chunks/SuperConverter-BJi_tRyc.es.js";
 import "../chunks/uuid-CjlX8hrF.es.js";
 export {
   S as SuperConverter

package/dist/super-editor.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./chunks/index-BKXWekME.cjs");
+const index = require("./chunks/index-DS7Ttafb.cjs");
 const superEditor_docxZipper = require("./super-editor/docx-zipper.cjs");
 const superEditor_fileZipper = require("./super-editor/file-zipper.cjs");
 const vue = require("./chunks/vue-De9wkgLl.cjs");
-const superEditor_converter = require("./chunks/SuperConverter-C4XfNZf6.cjs");
+const superEditor_converter = require("./chunks/SuperConverter-Bukam51x.cjs");
 function isNodeType(node, name) {
   return node.type.name === name;
 }

package/dist/super-editor.es.js

@@ -1,9 +1,9 @@
-import { ax as Node, ay as Mark } from "./chunks/index-B6VX2S0H.es.js";
-import { ao, au, a9, ab, aw, am, av, aA, an, ak, aq, az, aa, as, aC, aE, aB, ac, aD, ar, at } from "./chunks/index-B6VX2S0H.es.js";
+import { ax as Node, ay as Mark } from "./chunks/index-BQPLVzyQ.es.js";
+import { ao, au, a9, ab, aw, am, av, aA, an, ak, aq, az, aa, as, aC, aE, aB, ac, aD, ar, at } from "./chunks/index-BQPLVzyQ.es.js";
 import { default as default2 } from "./super-editor/docx-zipper.es.js";
 import { createZip } from "./super-editor/file-zipper.es.js";
 import { d as defineComponent, E as createElementBlock, G as openBlock, K as createBaseVNode } from "./chunks/vue-BnBKJwCW.es.js";
-import { S, r } from "./chunks/SuperConverter-DAO7c_d4.es.js";
+import { S, r } from "./chunks/SuperConverter-BJi_tRyc.es.js";
 function isNodeType(node, name) {
   return node.type.name === name;
 }

package/dist/superdoc/src/components/CommentsLayer/use-comment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-comment.d.ts","sourceRoot":"","sources":["../../../../../src/components/CommentsLayer/use-comment.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,2CAHW,MAAM,GACJ,MAAM,CA0RlB"}
+{"version":3,"file":"use-comment.d.ts","sourceRoot":"","sources":["../../../../../src/components/CommentsLayer/use-comment.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,2CAHW,MAAM,GACJ,MAAM,CAuRlB"}

package/dist/superdoc/src/helpers/group-changes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group-changes.d.ts","sourceRoot":"","sources":["../../../../src/helpers/group-changes.js"],"names":[],"mappings":"AAQO,oDA+BN"}
+{"version":3,"file":"group-changes.d.ts","sourceRoot":"","sources":["../../../../src/helpers/group-changes.js"],"names":[],"mappings":"AAQO,oDA+DN"}

package/dist/superdoc/src/stores/comments-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comments-store.d.ts","sourceRoot":"","sources":["../../../../src/stores/comments-store.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiDa,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA0HJ,IAAI;;sDAlbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBArEN,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA0HJ,IAAI;;sDAlbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBArEN,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA0HJ,IAAI;;sDAlbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;iYA+kBhB"}
+{"version":3,"file":"comments-store.d.ts","sourceRoot":"","sources":["../../../../src/stores/comments-store.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiDa,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA8HJ,IAAI;;sDAtbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBArEN,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA8HJ,IAAI;;sDAtbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBArEN,MAAM,KACJ,IAAI;;qBAiBN,MAAM,KACJ,MAAM;0CAuBR,MAAM,GAAG,SAAS,GAAG,IAAI,KACvB,IAAI;;;;;;gFA+Ld;QAAuB,SAAS,EAAxB,MAAM;QACS,UAAU;QACV,eAAe;KACtC,KAAU,MAAM;;0DAqDhB;QAAuB,QAAQ,EAAvB,MAAM;KACd,KAAU,IAAI;sCAyEJ,IAAI;;;;;6CAzFJ,IAAI;4EAsGd;QAAsB,QAAQ;QACP,UAAU;KACjC,KAAU,IAAI;;+DA8HJ,IAAI;;sDAtbd;QAAuB,QAAQ,EAAvB,MAAM;QACS,MAAM,EAArB,MAAM;KACd,KAAU,IAAI;iYAmlBhB"}

package/dist/superdoc.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./chunks/index-BKXWekME.cjs");
-const superdoc = require("./chunks/index-CZ5yJPHg.cjs");
-const superEditor_converter = require("./chunks/SuperConverter-C4XfNZf6.cjs");
+const index = require("./chunks/index-DS7Ttafb.cjs");
+const superdoc = require("./chunks/index-CZMyxx0v.cjs");
+const superEditor_converter = require("./chunks/SuperConverter-Bukam51x.cjs");
 const blankDocx = require("./chunks/blank-docx-DfW3Eeh2.cjs");
 require("./chunks/jszip-C8_CqJxM.cjs");
 require("./chunks/helpers-nOdwpmwb.cjs");

package/dist/superdoc.es.js

@@ -1,6 +1,6 @@
-import { au, ab, aw, av, as, a7, ac, ar, at } from "./chunks/index-B6VX2S0H.es.js";
-import { D, H, P, S, c } from "./chunks/index-DbSiW7hc.es.js";
-import { S as S2, r } from "./chunks/SuperConverter-DAO7c_d4.es.js";
+import { au, ab, aw, av, as, a7, ac, ar, at } from "./chunks/index-BQPLVzyQ.es.js";
+import { D, H, P, S, c } from "./chunks/index-QUPzhiU8.es.js";
+import { S as S2, r } from "./chunks/SuperConverter-BJi_tRyc.es.js";
 import { B } from "./chunks/blank-docx-ABm6XYAA.es.js";
 import "./chunks/jszip-B1fkPkPJ.es.js";
 import "./chunks/helpers-C8e9wR5l.es.js";