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

package/dist/superdoc.umd.js

@@ -11946,8 +11946,11 @@
     createAttributeHandler("w:authorEmail", "authorEmail")
   ];
   const encode$L = (params2, encodedAttrs = {}) => {
-    const { nodeListHandler, extraParams = {} } = params2;
+    const { nodeListHandler, extraParams = {}, converter } = params2;
     const { node: node2 } = extraParams;
+    if (encodedAttrs.id && converter?.trackedChangeIdMap?.has(encodedAttrs.id)) {
+      encodedAttrs.id = converter.trackedChangeIdMap.get(encodedAttrs.id);
+    }
     const subs = nodeListHandler.handler({
       ...params2,
       insideTrackChange: true,
@@ -11955,6 +11958,9 @@
       path: [...params2.path || [], node2]
     });
     encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+    if (converter?.documentOrigin) {
+      encodedAttrs.origin = converter.documentOrigin;
+    }
     subs.forEach((subElement) => {
       subElement.marks = [];
       if (subElement?.content?.[0]) {
@@ -32897,8 +32903,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     createAttributeHandler("w:authorEmail", "authorEmail")
   ];
   const encode$3 = (params2, encodedAttrs = {}) => {
-    const { nodeListHandler, extraParams = {} } = params2;
+    const { nodeListHandler, extraParams = {}, converter } = params2;
     const { node: node2 } = extraParams;
+    if (encodedAttrs.id && converter?.trackedChangeIdMap?.has(encodedAttrs.id)) {
+      encodedAttrs.id = converter.trackedChangeIdMap.get(encodedAttrs.id);
+    }
     const subs = nodeListHandler.handler({
       ...params2,
       insideTrackChange: true,
@@ -32906,6 +32915,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       path: [...params2.path || [], node2]
     });
     encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+    if (converter?.documentOrigin) {
+      encodedAttrs.origin = converter.documentOrigin;
+    }
     subs.forEach((subElement) => {
       subElement.marks = [];
       if (subElement?.content?.[0]) {
@@ -33625,6 +33637,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       });
       const lastElement = parsedElements[parsedElements.length - 1];
       const paraId = lastElement?.attrs?.["w14:paraId"];
+      const commentsExtended = docx["word/commentsExtended.xml"];
+      const threadingMethod = commentsExtended ? "commentsExtended" : "range-based";
       return {
         commentId: internalId || v4(),
         importedId,
@@ -33639,19 +33653,31 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         trackedChangeText,
         trackedChangeType,
         trackedDeletedText,
-        isDone: false
+        isDone: false,
+        origin: converter?.documentOrigin || "word",
+        threadingMethod,
+        originalXmlStructure: {
+          hasCommentsExtended: !!commentsExtended,
+          hasCommentsExtensible: !!docx["word/commentsExtensible.xml"],
+          hasCommentsIds: !!docx["word/commentsIds.xml"]
+        }
       };
     });
-    const extendedComments = generateCommentsWithExtendedData({ docx, comments: extractedComments });
+    const extendedComments = generateCommentsWithExtendedData({ docx, comments: extractedComments, converter });
     return extendedComments;
   }
-  const generateCommentsWithExtendedData = ({ docx, comments }) => {
+  const generateCommentsWithExtendedData = ({ docx, comments, converter }) => {
     if (!comments?.length) return [];
+    const rangeData = extractCommentRangesFromDocument(docx, converter);
+    const { commentsInTrackedChanges } = rangeData;
+    const trackedChangeParentMap = detectThreadingFromTrackedChanges(comments, commentsInTrackedChanges);
     const commentsExtended = docx["word/commentsExtended.xml"];
     if (!commentsExtended) {
-      const commentRanges = extractCommentRangesFromDocument(docx);
-      const commentsWithThreading = detectThreadingFromRanges(comments, commentRanges);
-      return commentsWithThreading.map((comment2) => ({ ...comment2, isDone: comment2.isDone ?? false }));
+      const commentsWithThreading = detectThreadingFromRanges(comments, rangeData);
+      return commentsWithThreading.map((comment2) => ({
+        ...comment2,
+        isDone: comment2.isDone ?? false
+      }));
     }
     const { elements: initialElements = [] } = commentsExtended;
     if (!initialElements?.length) return comments.map((comment2) => ({ ...comment2, isDone: comment2.isDone ?? false }));
@@ -33659,25 +33685,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const commentEx = elements.filter((el) => el.name === "w15:commentEx");
     return comments.map((comment2) => {
       const extendedDef = commentEx.find((ce2) => {
-        const isIncludedInCommentElements = comment2.elements?.some(
-          (el) => el.attrs?.["w14:paraId"] === ce2.attributes["w15:paraId"]
-        );
-        return isIncludedInCommentElements;
-      });
-      if (!extendedDef) return { ...comment2, isDone: comment2.isDone ?? false };
-      const { isDone, paraIdParent } = getExtendedDetails(extendedDef);
-      let parentComment;
-      if (paraIdParent) {
-        parentComment = comments.find(
-          (c2) => c2.paraId === paraIdParent || c2.elements?.some((el) => el.attrs?.["w14:paraId"] === paraIdParent)
-        );
+        return comment2.elements?.some((el) => el.attrs?.["w14:paraId"] === ce2.attributes["w15:paraId"]);
+      });
+      let isDone = comment2.isDone ?? false;
+      let parentCommentId = void 0;
+      const trackedChangeParent = trackedChangeParentMap.get(comment2.importedId);
+      const isInsideTrackedChange = trackedChangeParent?.isTrackedChangeParent;
+      if (extendedDef) {
+        const details = getExtendedDetails(extendedDef);
+        isDone = details.isDone ?? false;
+        if (!isInsideTrackedChange && details.paraIdParent) {
+          const parentComment = comments.find(
+            (c2) => c2.paraId === details.paraIdParent || c2.elements?.some((el) => el.attrs?.["w14:paraId"] === details.paraIdParent)
+          );
+          parentCommentId = parentComment?.commentId;
+        }
+      }
+      if (isInsideTrackedChange) {
+        parentCommentId = trackedChangeParent.trackedChangeId;
       }
-      const newComment = {
+      return {
         ...comment2,
-        isDone: isDone ?? false,
-        parentCommentId: parentComment?.commentId
+        isDone,
+        parentCommentId
       };
-      return newComment;
     });
   };
   const getExtendedDetails = (commentEx) => {
@@ -33687,34 +33718,117 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const paraIdParent = attributes["w15:paraIdParent"];
     return { paraId, isDone, paraIdParent };
   };
-  const extractCommentRangesFromDocument = (docx) => {
+  const extractCommentRangesFromDocument = (docx, converter) => {
     const documentXml = docx["word/document.xml"];
     if (!documentXml) {
-      return [];
-    }
-    const pendingComments = [];
-    const walkElements = (elements) => {
+      return { rangeEvents: [], rangePositions: /* @__PURE__ */ new Map(), commentsInTrackedChanges: /* @__PURE__ */ new Map() };
+    }
+    const rangeEvents = [];
+    const rangePositions = /* @__PURE__ */ new Map();
+    const commentsInTrackedChanges = /* @__PURE__ */ new Map();
+    let positionIndex = 0;
+    let lastElementWasCommentMarker = false;
+    const recentlyClosedComments = /* @__PURE__ */ new Set();
+    let lastTrackedChange = null;
+    const walkElements = (elements, currentTrackedChangeId = null) => {
       if (!elements || !Array.isArray(elements)) return;
       elements.forEach((element2) => {
-        if (element2.name === "w:commentRangeStart") {
+        const isCommentStart = element2.name === "w:commentRangeStart";
+        const isCommentEnd = element2.name === "w:commentRangeEnd";
+        const isTrackedChange = element2.name === "w:ins" || element2.name === "w:del";
+        if (isCommentStart) {
           const commentId = element2.attributes?.["w:id"];
           if (commentId !== void 0) {
-            pendingComments.push({
+            const id = String(commentId);
+            rangeEvents.push({
               type: "start",
-              commentId: String(commentId)
+              commentId: id
             });
+            if (!rangePositions.has(id)) {
+              rangePositions.set(id, { startIndex: positionIndex, endIndex: -1 });
+            } else {
+              rangePositions.get(id).startIndex = positionIndex;
+            }
+            if (currentTrackedChangeId !== null) {
+              commentsInTrackedChanges.set(id, currentTrackedChangeId);
+            }
           }
-        } else if (element2.name === "w:commentRangeEnd") {
+          lastElementWasCommentMarker = true;
+          recentlyClosedComments.clear();
+        } else if (isCommentEnd) {
           const commentId = element2.attributes?.["w:id"];
           if (commentId !== void 0) {
-            pendingComments.push({
+            const id = String(commentId);
+            rangeEvents.push({
               type: "end",
-              commentId: String(commentId)
+              commentId: id
             });
+            if (!rangePositions.has(id)) {
+              rangePositions.set(id, { startIndex: -1, endIndex: positionIndex });
+            } else {
+              rangePositions.get(id).endIndex = positionIndex;
+            }
+            recentlyClosedComments.add(id);
+          }
+          lastElementWasCommentMarker = true;
+        } else if (isTrackedChange) {
+          const trackedChangeId = element2.attributes?.["w:id"];
+          const author = element2.attributes?.["w:author"];
+          const date = element2.attributes?.["w:date"];
+          const elementType = element2.name;
+          let mappedId = trackedChangeId;
+          let isReplacement = false;
+          if (trackedChangeId !== void 0 && converter) {
+            if (!converter.trackedChangeIdMap) {
+              converter.trackedChangeIdMap = /* @__PURE__ */ new Map();
+            }
+            if (lastTrackedChange && lastTrackedChange.type !== elementType && lastTrackedChange.author === author && lastTrackedChange.date === date) {
+              mappedId = lastTrackedChange.mappedId;
+              converter.trackedChangeIdMap.set(String(trackedChangeId), mappedId);
+              isReplacement = true;
+            } else {
+              if (!converter.trackedChangeIdMap.has(String(trackedChangeId))) {
+                converter.trackedChangeIdMap.set(String(trackedChangeId), v4());
+              }
+              mappedId = converter.trackedChangeIdMap.get(String(trackedChangeId));
+            }
+          }
+          if (currentTrackedChangeId === null) {
+            if (isReplacement) {
+              lastTrackedChange = null;
+            } else {
+              lastTrackedChange = {
+                type: elementType,
+                author,
+                date,
+                mappedId,
+                wordId: String(trackedChangeId)
+              };
+            }
+          }
+          if (mappedId && recentlyClosedComments.size > 0) {
+            recentlyClosedComments.forEach((commentId) => {
+              if (!commentsInTrackedChanges.has(commentId)) {
+                commentsInTrackedChanges.set(commentId, String(mappedId));
+              }
+            });
+          }
+          recentlyClosedComments.clear();
+          if (element2.elements && Array.isArray(element2.elements)) {
+            walkElements(element2.elements, mappedId !== void 0 ? String(mappedId) : currentTrackedChangeId);
+          }
+        } else {
+          if (lastElementWasCommentMarker) {
+            positionIndex++;
+            lastElementWasCommentMarker = false;
+          }
+          if (element2.name === "w:p") {
+            recentlyClosedComments.clear();
+            lastTrackedChange = null;
+          }
+          if (element2.elements && Array.isArray(element2.elements)) {
+            walkElements(element2.elements, currentTrackedChangeId);
           }
-        }
-        if (element2.elements && Array.isArray(element2.elements)) {
-          walkElements(element2.elements);
         }
       });
     };
@@ -33724,19 +33838,20 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         walkElements(body.elements);
       }
     }
-    return pendingComments;
+    return { rangeEvents, rangePositions, commentsInTrackedChanges };
   };
-  const detectThreadingFromRanges = (comments, rangeEvents) => {
-    if (!rangeEvents || rangeEvents.length === 0) {
-      return comments;
-    }
+  const detectThreadingFromNestedRanges = (comments, rangeEvents, skipComments = /* @__PURE__ */ new Set()) => {
     const openRanges = [];
     const parentMap = /* @__PURE__ */ new Map();
     rangeEvents.forEach((event) => {
       if (event.type === "start") {
-        if (openRanges.length > 0) {
-          const parentCommentId = openRanges[openRanges.length - 1];
-          parentMap.set(event.commentId, parentCommentId);
+        if (!skipComments.has(event.commentId) && openRanges.length > 0) {
+          for (let i2 = openRanges.length - 1; i2 >= 0; i2--) {
+            if (!skipComments.has(openRanges[i2])) {
+              parentMap.set(event.commentId, openRanges[i2]);
+              break;
+            }
+          }
         }
         openRanges.push(event.commentId);
       } else if (event.type === "end") {
@@ -33746,10 +33861,113 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         }
       }
     });
+    return parentMap;
+  };
+  const detectThreadingFromSharedPosition = (comments, rangePositions) => {
+    const parentMap = /* @__PURE__ */ new Map();
+    const commentsByStartPosition = /* @__PURE__ */ new Map();
+    comments.forEach((comment2) => {
+      const position2 = rangePositions.get(comment2.importedId);
+      if (position2 && position2.startIndex >= 0) {
+        const startKey = position2.startIndex;
+        if (!commentsByStartPosition.has(startKey)) {
+          commentsByStartPosition.set(startKey, []);
+        }
+        commentsByStartPosition.get(startKey).push(comment2);
+      }
+    });
+    commentsByStartPosition.forEach((commentsAtPosition) => {
+      if (commentsAtPosition.length <= 1) return;
+      const sorted = [...commentsAtPosition].sort((a2, b2) => a2.createdTime - b2.createdTime);
+      const parentComment = sorted[0];
+      for (let i2 = 1; i2 < sorted.length; i2++) {
+        parentMap.set(sorted[i2].importedId, parentComment.importedId);
+      }
+    });
+    return parentMap;
+  };
+  const detectThreadingFromMissingRanges = (comments, rangePositions) => {
+    const parentMap = /* @__PURE__ */ new Map();
+    const commentsWithRanges = [];
+    const commentsWithoutRanges = [];
+    comments.forEach((comment2) => {
+      const position2 = rangePositions.get(comment2.importedId);
+      if (position2 && position2.startIndex >= 0) {
+        commentsWithRanges.push(comment2);
+      } else {
+        commentsWithoutRanges.push(comment2);
+      }
+    });
+    commentsWithoutRanges.forEach((comment2) => {
+      const potentialParents = commentsWithRanges.filter((c2) => c2.createdTime < comment2.createdTime).sort((a2, b2) => b2.createdTime - a2.createdTime);
+      if (potentialParents.length > 0) {
+        parentMap.set(comment2.importedId, potentialParents[0].importedId);
+      }
+    });
+    return parentMap;
+  };
+  const detectThreadingFromTrackedChanges = (comments, commentsInTrackedChanges) => {
+    const parentMap = /* @__PURE__ */ new Map();
+    if (!commentsInTrackedChanges || commentsInTrackedChanges.size === 0) {
+      return parentMap;
+    }
+    comments.forEach((comment2) => {
+      const trackedChangeId = commentsInTrackedChanges.get(comment2.importedId);
+      if (trackedChangeId !== void 0) {
+        parentMap.set(comment2.importedId, { trackedChangeId, isTrackedChangeParent: true });
+      }
+    });
+    return parentMap;
+  };
+  const detectThreadingFromRanges = (comments, rangeData) => {
+    const { rangeEvents, rangePositions, commentsInTrackedChanges } = Array.isArray(rangeData) ? { rangeEvents: rangeData, rangePositions: /* @__PURE__ */ new Map(), commentsInTrackedChanges: /* @__PURE__ */ new Map() } : rangeData;
+    if (!rangeEvents || rangeEvents.length === 0) {
+      if (comments.length > 1) {
+        const parentMap = detectThreadingFromMissingRanges(comments, rangePositions);
+        return applyParentRelationships(comments, parentMap);
+      }
+      return comments;
+    }
+    const commentsWithSharedPosition = findCommentsWithSharedStartPosition(comments, rangePositions);
+    const nestedParentMap = detectThreadingFromNestedRanges(comments, rangeEvents, commentsWithSharedPosition);
+    const sharedPositionParentMap = detectThreadingFromSharedPosition(comments, rangePositions);
+    const missingRangeParentMap = detectThreadingFromMissingRanges(comments, rangePositions);
+    const trackedChangeParentMap = detectThreadingFromTrackedChanges(comments, commentsInTrackedChanges);
+    const mergedParentMap = new Map([...missingRangeParentMap, ...nestedParentMap, ...sharedPositionParentMap]);
+    return applyParentRelationships(comments, mergedParentMap, trackedChangeParentMap);
+  };
+  const findCommentsWithSharedStartPosition = (comments, rangePositions) => {
+    const sharedPositionComments = /* @__PURE__ */ new Set();
+    const commentsByStartPosition = /* @__PURE__ */ new Map();
+    comments.forEach((comment2) => {
+      const position2 = rangePositions.get(comment2.importedId);
+      if (position2 && position2.startIndex >= 0) {
+        const startKey = position2.startIndex;
+        if (!commentsByStartPosition.has(startKey)) {
+          commentsByStartPosition.set(startKey, []);
+        }
+        commentsByStartPosition.get(startKey).push(comment2.importedId);
+      }
+    });
+    commentsByStartPosition.forEach((commentIds) => {
+      if (commentIds.length > 1) {
+        commentIds.forEach((id) => sharedPositionComments.add(id));
+      }
+    });
+    return sharedPositionComments;
+  };
+  const applyParentRelationships = (comments, parentMap, trackedChangeParentMap = /* @__PURE__ */ new Map()) => {
     return comments.map((comment2) => {
-      const parentCommentId = parentMap.get(comment2.importedId);
-      if (parentCommentId) {
-        const parentComment = comments.find((c2) => c2.importedId === parentCommentId);
+      const trackedChangeParent = trackedChangeParentMap.get(comment2.importedId);
+      if (trackedChangeParent && trackedChangeParent.isTrackedChangeParent) {
+        return {
+          ...comment2,
+          parentCommentId: trackedChangeParent.trackedChangeId
+        };
+      }
+      const parentImportedId = parentMap.get(comment2.importedId);
+      if (parentImportedId) {
+        const parentComment = comments.find((c2) => c2.importedId === parentImportedId);
         if (parentComment) {
           return {
             ...comment2,
@@ -34480,9 +34698,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   );
   const permStartHandlerEntity = generateV2HandlerEntity("permStartHandler", translator$8);
   const permEndHandlerEntity = generateV2HandlerEntity("permEndHandler", translator$7);
+  const detectDocumentOrigin = (docx) => {
+    const commentsExtended = docx["word/commentsExtended.xml"];
+    if (commentsExtended) {
+      const { elements: initialElements = [] } = commentsExtended;
+      if (initialElements?.length > 0) {
+        const { elements = [] } = initialElements[0] ?? {};
+        const commentEx = elements.filter((el) => el.name === "w15:commentEx");
+        if (commentEx.length > 0) {
+          return "word";
+        }
+      }
+    }
+    const comments = docx["word/comments.xml"];
+    if (comments && !commentsExtended) {
+      return "google-docs";
+    }
+    return "unknown";
+  };
   const createDocumentJson = (docx, converter, editor) => {
     const json = carbonCopy(getInitialJSON(docx));
     if (!json) return null;
+    if (converter) {
+      converter.documentOrigin = detectDocumentOrigin(docx);
+    }
     if (converter?.telemetry) {
       const files = Object.keys(docx).map((filePath) => {
         const parts = filePath.split("/");
@@ -36054,7 +36293,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     };
     if (comment2?.parentCommentId) {
       const parentComment = allComments.find((c2) => c2.commentId === comment2.parentCommentId);
-      attributes["w15:paraIdParent"] = parentComment.commentParaId;
+      if (parentComment && !parentComment.trackedChange) {
+        attributes["w15:paraIdParent"] = parentComment.commentParaId;
+      }
     }
     return {
       type: "element",
@@ -36099,7 +36340,22 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     newCommentsXml.elements[0].elements = commentDefs;
     return newCommentsXml;
   };
-  const updateCommentsExtendedXml = (comments = [], commentsExtendedXml) => {
+  const determineExportStrategy = (comments) => {
+    if (!comments || comments.length === 0) {
+      return "word";
+    }
+    const origins = new Set(comments.map((c2) => c2.origin || "word"));
+    if (origins.size === 1) {
+      const origin = origins.values().next().value;
+      return origin === "google-docs" ? "google-docs" : "word";
+    }
+    return "word";
+  };
+  const updateCommentsExtendedXml = (comments = [], commentsExtendedXml, exportStrategy = "word") => {
+    const shouldGenerateCommentsExtended = exportStrategy === "word" || comments.some((c2) => c2.originalXmlStructure?.hasCommentsExtended);
+    if (!shouldGenerateCommentsExtended && exportStrategy === "google-docs") {
+      return null;
+    }
     const xmlCopy = carbonCopy(commentsExtendedXml);
     const commentsEx = comments.map((comment2) => {
       const isResolved = comment2.resolvedTime || comment2.isDone;
@@ -36108,9 +36364,11 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         "w15:done": isResolved ? "1" : "0"
       };
       const parentId = comment2.parentCommentId;
-      if (parentId) {
+      if (parentId && (exportStrategy === "word" || comment2.originalXmlStructure?.hasCommentsExtended)) {
         const parentComment = comments.find((c2) => c2.commentId === parentId);
-        attributes["w15:paraIdParent"] = parentComment.commentParaId;
+        if (parentComment && !parentComment.trackedChange) {
+          attributes["w15:paraIdParent"] = parentComment.commentParaId;
+        }
       }
       return {
         type: "element",
@@ -36180,14 +36438,21 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       const documentXml = removeCommentsFilesFromConvertedXml(convertedXml);
       return { documentXml, relationships };
     }
+    const exportStrategy = determineExportStrategy(commentsWithParaIds);
     const updatedXml = generateConvertedXmlWithCommentFiles(convertedXml);
     updatedXml["word/comments.xml"] = updateCommentsXml(defs, updatedXml["word/comments.xml"]);
     relationships.push(generateRelationship("comments.xml"));
-    updatedXml["word/commentsExtended.xml"] = updateCommentsExtendedXml(
+    const commentsExtendedXml = updateCommentsExtendedXml(
       commentsWithParaIds,
-      updatedXml["word/commentsExtended.xml"]
+      updatedXml["word/commentsExtended.xml"],
+      exportStrategy
     );
-    relationships.push(generateRelationship("commentsExtended.xml"));
+    if (commentsExtendedXml !== null) {
+      updatedXml["word/commentsExtended.xml"] = commentsExtendedXml;
+      relationships.push(generateRelationship("commentsExtended.xml"));
+    } else {
+      delete updatedXml["word/commentsExtended.xml"];
+    }
     const { documentIdsUpdated, extensibleUpdated } = updateCommentsIdsAndExtensible(
       commentsWithParaIds,
       updatedXml["word/commentsIds.xml"],
@@ -36696,7 +36961,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.4.0") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.4.1-next.1") {
       return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -49228,11 +49493,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const matchingImportedComment = comments.find((c2) => c2.importedId == importedId);
     const resolvedCommentId = matchingImportedComment?.commentId ?? (importedId ? String(importedId) : 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 }) => {
@@ -49250,6 +49519,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       isDone: false
     });
   };
+  const TRACK_CHANGE_MARKS$1 = [TrackInsertMarkName$1, TrackDeleteMarkName$1, TrackFormatMarkName$1];
   const removeCommentsById = ({ commentId, state, tr, dispatch }) => {
     const positions = getCommentPositionsById(commentId, state.doc);
     positions.forEach(({ from: from2, to }) => {
@@ -49393,6 +49663,35 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           });
         });
       });
+      const trackedChangeMark = node2.marks?.find((mark2) => TRACK_CHANGE_MARKS$1.includes(mark2.type.name));
+      if (trackedChangeMark) {
+        const trackedChangeId = trackedChangeMark.attrs?.id;
+        if (trackedChangeId) {
+          const childComments = comments.filter((c2) => c2.parentCommentId === trackedChangeId && !c2.trackedChange).sort((a2, b2) => a2.createdTime - b2.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 + node2.nodeSize,
+              node: childEndNode,
+              commentId: c2.commentId,
+              parentCommentId: c2.parentCommentId
+            });
+          });
+        }
+      }
     });
     startNodes.sort((a2, b2) => {
       if (a2.pos !== b2.pos) return a2.pos - b2.pos;
@@ -49447,17 +49746,18 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       const { type } = node2;
       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: node2.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
           });
         }
@@ -49496,7 +49796,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         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 });
@@ -50058,26 +50359,30 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     if (emitParams) editor.emit("commentsUpdate", emitParams);
     return newTrackedChanges;
   };
-  const getTrackedChangeText = ({ nodes, mark: mark2, trackedChangeType, isDeletionInsertion }) => {
+  const getTrackedChangeText = ({ nodes, mark: mark2, trackedChangeType, isDeletionInsertion, marks }) => {
     let trackedChangeText = "";
     let deletionText = "";
-    if (trackedChangeType === TrackInsertMarkName$1) {
+    if (trackedChangeType === TrackDeleteMarkName$1 || isDeletionInsertion) {
+      deletionText = nodes.reduce((acc, node2) => {
+        const hasDeleteMark = node2.marks.find((nodeMark) => nodeMark.type.name === TrackDeleteMarkName$1);
+        if (!hasDeleteMark) return acc;
+        const nodeText = node2?.text || node2?.textContent || "";
+        acc += nodeText;
+        return acc;
+      }, "");
+    }
+    if (trackedChangeType === TrackInsertMarkName$1 || isDeletionInsertion) {
       trackedChangeText = nodes.reduce((acc, node2) => {
-        if (!node2.marks.find((nodeMark) => nodeMark.type.name === mark2.type.name)) return acc;
-        acc += node2?.text || node2?.textContent || "";
+        const hasInsertMark = node2.marks.find((nodeMark) => nodeMark.type.name === TrackInsertMarkName$1);
+        if (!hasInsertMark) return acc;
+        const nodeText = node2?.text || node2?.textContent || "";
+        acc += nodeText;
         return acc;
       }, "");
     }
     if (trackedChangeType === TrackFormatMarkName$1) {
       trackedChangeText = translateFormatChangesToEnglish(mark2.attrs);
     }
-    if (trackedChangeType === TrackDeleteMarkName$1 || isDeletionInsertion) {
-      deletionText = nodes.reduce((acc, node2) => {
-        if (!node2.marks.find((nodeMark) => nodeMark.type.name === TrackDeleteMarkName$1)) return acc;
-        acc += node2?.text || node2?.textContent || "";
-        return acc;
-      }, "");
-    }
     return {
       deletionText,
       trackedChangeText
@@ -50090,22 +50395,41 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const { author, authorEmail, authorImage, date, importedAuthor } = attrs;
     const id = attrs.id;
     const node2 = 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: mark2 }) => mark2.type.name === TrackInsertMarkName$1);
+      const hasDeleteMark = trackedChangesWithId.some(({ mark: mark2 }) => mark2.type.name === TrackDeleteMarkName$1);
+      isDeletionInsertion = hasInsertMark && hasDeleteMark;
+    }
     let nodesWithMark = [];
-    newEditorState.doc.descendants((node3) => {
-      const { marks: marks2 = [] } = node3;
-      const changeMarks = marks2.filter((mark2) => TRACK_CHANGE_MARKS.includes(mark2.type.name));
-      if (!changeMarks.length) return;
-      const hasMatchingId = changeMarks.find((mark2) => mark2.attrs.id === id);
-      if (hasMatchingId) nodesWithMark.push(node3);
-    });
-    const nodesToProcess = nodesWithMark.length ? nodesWithMark : node2 ? [node2] : [];
-    if (!nodesToProcess.length) {
+    trackedChangesWithId.forEach(({ from: from2, to, mark: mark2 }) => {
+      newEditorState.doc.nodesBetween(from2, to, (node3, pos) => {
+        if (node3.isText) {
+          const hasMatchingMark = node3.marks?.some((m2) => TRACK_CHANGE_MARKS.includes(m2.type.name) && m2.attrs.id === id);
+          if (hasMatchingMark) {
+            const alreadyAdded = nodesWithMark.some((n) => n === node3);
+            if (!alreadyAdded) {
+              nodesWithMark.push(node3);
+            }
+          }
+        }
+      });
+    });
+    let nodesToUse;
+    if (isDeletionInsertion) {
+      const allNodes = [...nodesWithMark, ...nodes, ...deletionNodes || []];
+      nodesToUse = Array.from(new Set(allNodes));
+    } else {
+      nodesToUse = nodesWithMark.length ? nodesWithMark : node2 ? [node2] : [];
+    }
+    if (!nodesToUse.length) {
       return;
     }
     const { deletionText, trackedChangeText } = getTrackedChangeText({
-      nodes: nodesToProcess,
+      nodes: nodesToUse,
       mark: trackedMark,
+      marks,
       trackedChangeType,
       isDeletionInsertion
     });
@@ -62512,7 +62836,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       return false;
     }
   };
-  const summaryVersion = "1.4.0";
+  const summaryVersion = "1.4.1-next.1";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -65145,7 +65469,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.4.0");
+      console.debug("[checkVersionMigrations] Current editor version", "1.4.1-next.1");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -74255,12 +74579,15 @@ ${l}
         }
       }
       applyRunStyles(elem, run2, isActiveLink);
-      const commentColor = getCommentHighlight(run2);
-      if (commentColor && !run2.highlight) {
+      const textRun = run2;
+      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 = run2.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";
@@ -88227,6 +88554,7 @@ ${l}
     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 = run2.comments ? [...run2.comments] : [];
     const key2 = `${commentId ?? ""}::${importedId ?? ""}`;
@@ -88235,7 +88563,8 @@ ${l}
       annotations.push({
         commentId: commentId ?? importedId,
         importedId,
-        internal
+        internal,
+        trackedChange
       });
     }
     run2.comments = annotations;
@@ -107132,6 +107461,10 @@ ${l}
         internal: {
           default: true,
           rendered: false
+        },
+        trackedChange: {
+          default: false,
+          rendered: false
         }
       };
     },
@@ -141843,11 +142176,14 @@ ${reason}`);
       trackFormat: "formatMark"
     };
     const grouped = [];
+    const processed = /* @__PURE__ */ new Set();
     for (let i2 = 0; i2 < changes.length; i2++) {
+      if (processed.has(i2)) continue;
       const c1 = changes[i2];
-      const c2 = changes[i2 + 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[i2 + 1];
+      if (c2 && c1.to === c2.from && c1Id === c2.mark.attrs.id) {
         const c2Key = markMetaKeys[c2.mark.type.name];
         grouped.push({
           from: c1.from,
@@ -141855,13 +142191,35 @@ ${reason}`);
           [c1Key]: c1,
           [c2Key]: c2
         });
-        i2++;
-      } else {
+        processed.add(i2);
+        processed.add(i2 + 1);
+        continue;
+      }
+      let foundMatch = false;
+      for (let j2 = i2 + 1; j2 < changes.length; j2++) {
+        if (processed.has(j2)) continue;
+        const c22 = changes[j2];
+        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(i2);
+          processed.add(j2);
+          foundMatch = true;
+          break;
+        }
+      }
+      if (!foundMatch) {
         grouped.push({
           from: c1.from,
           to: c1.to,
           [c1Key]: c1
         });
+        processed.add(i2);
       }
     }
     return grouped;
@@ -142163,7 +142521,12 @@ ${reason}`);
           trackedChange: comment2.trackedChange || false,
           trackedChangeText: comment2.trackedChangeText,
           trackedChangeType: comment2.trackedChangeType,
-          deletedText: comment2.trackedDeletedText
+          deletedText: comment2.trackedDeletedText,
+          // Preserve origin metadata for export
+          origin: comment2.origin || "word",
+          // Default to 'word' for backward compatibility
+          threadingMethod: comment2.threadingMethod,
+          originalXmlStructure: comment2.originalXmlStructure
         });
         addComment({ superdoc, comment: newComment });
       });
@@ -142943,7 +143306,11 @@ ${reason}`);
           const isThreadedComment = c2.parentCommentId === parentComment.commentId;
           const isThisComment = c2.commentId === props.comment.commentId;
           return isThreadedComment || isThisComment;
-        }).sort((a2, b2) => a2.commentId === props.comment.commentId && a2.createdTime - b2.createdTime);
+        }).sort((a2, b2) => {
+          if (a2.commentId === props.comment.commentId) return -1;
+          if (b2.commentId === props.comment.commentId) return 1;
+          return a2.createdTime - b2.createdTime;
+        });
       });
       const isInternalDropdownDisabled = computed(() => {
         if (props.comment.resolvedTime) return true;
@@ -143202,7 +143569,7 @@ ${reason}`);
       };
     }
   };
-  const CommentDialog = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__scopeId", "data-v-d50fd675"]]);
+  const CommentDialog = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__scopeId", "data-v-f9956635"]]);
   const _hoisted_1$b = { class: "comments-list" };
   const _hoisted_2$5 = { key: 0 };
   const _hoisted_3$3 = { class: "comment-item" };
@@ -145163,7 +145530,7 @@ ${reason}`);
       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.1";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;