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

package/dist/chunks/{PdfViewer-BFLlmRke.cjs → PdfViewer-BaDWswEX.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("./vue-De9wkgLl.cjs");
-const superdoc = require("./index-D3X3kMWD.cjs");
-const index = require("./index-C0kuhYCD.cjs");
+const superdoc = require("./index-lAO6pLM-.cjs");
+const index = require("./index-Bpm2bUws.cjs");
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{PdfViewer-D859yVUF.es.js → PdfViewer-D_1Yi2Kj.es.js}

@@ -1,6 +1,6 @@
 import { d as defineComponent, h, T as Transition, p as process$1, w as watchEffect, c as computed, r as ref, f as onMounted, X as onUnmounted, E as createElementBlock, G as openBlock, K as createBaseVNode, M as createCommentVNode, I as createVNode, v as unref } from "./vue-BnBKJwCW.es.js";
-import { N as NBaseLoading, u as useSuperdocStore, s as storeToRefs, a as useSelection } from "./index-DF3OVaQj.es.js";
-import { C as derived, r as c, q as cB, aF as fadeInTransition, y as cM, I as warnOnce, J as useConfig, N as useTheme, aG as pxfy, P as createKey, Q as useThemeClass, aH as useCompitable, ai as _export_sfc } from "./index-B-20lDKU.es.js";
+import { N as NBaseLoading, u as useSuperdocStore, s as storeToRefs, a as useSelection } from "./index-BGllXGwn.es.js";
+import { C as derived, r as c, q as cB, aF as fadeInTransition, y as cM, I as warnOnce, J as useConfig, N as useTheme, aG as pxfy, P as createKey, Q as useThemeClass, aH as useCompitable, ai as _export_sfc } from "./index-DwUAu2hL.es.js";
 function self(vars) {
   const {
     opacityDisabled,

package/dist/chunks/{SuperConverter-MYkKoPrv.es.js → SuperConverter-BuK6B5Kx.es.js}

@@ -7256,8 +7256,11 @@ const validXmlAttributes$e = [
   createAttributeHandler("w:authorEmail", "authorEmail")
 ];
 const encode$K = (params, encodedAttrs = {}) => {
-  const { nodeListHandler, extraParams = {} } = params;
+  const { nodeListHandler, extraParams = {}, converter } = params;
   const { node } = extraParams;
+  if (encodedAttrs.id && converter?.trackedChangeIdMap?.has(encodedAttrs.id)) {
+    encodedAttrs.id = converter.trackedChangeIdMap.get(encodedAttrs.id);
+  }
   const subs = nodeListHandler.handler({
     ...params,
     insideTrackChange: true,
@@ -7265,6 +7268,9 @@ const encode$K = (params, encodedAttrs = {}) => {
     path: [...params.path || [], node]
   });
   encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+  if (converter?.documentOrigin) {
+    encodedAttrs.origin = converter.documentOrigin;
+  }
   subs.forEach((subElement) => {
     subElement.marks = [];
     if (subElement?.content?.[0]) {
@@ -27324,8 +27330,11 @@ const validXmlAttributes$2 = [
   createAttributeHandler("w:authorEmail", "authorEmail")
 ];
 const encode$2 = (params, encodedAttrs = {}) => {
-  const { nodeListHandler, extraParams = {} } = params;
+  const { nodeListHandler, extraParams = {}, converter } = params;
   const { node } = extraParams;
+  if (encodedAttrs.id && converter?.trackedChangeIdMap?.has(encodedAttrs.id)) {
+    encodedAttrs.id = converter.trackedChangeIdMap.get(encodedAttrs.id);
+  }
   const subs = nodeListHandler.handler({
     ...params,
     insideTrackChange: true,
@@ -27333,6 +27342,9 @@ const encode$2 = (params, encodedAttrs = {}) => {
     path: [...params.path || [], node]
   });
   encodedAttrs.importedAuthor = `${encodedAttrs.author} (imported)`;
+  if (converter?.documentOrigin) {
+    encodedAttrs.origin = converter.documentOrigin;
+  }
   subs.forEach((subElement) => {
     subElement.marks = [];
     if (subElement?.content?.[0]) {
@@ -28052,6 +28064,8 @@ function importCommentData({ docx, editor, converter }) {
     });
     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,
@@ -28066,19 +28080,31 @@ function importCommentData({ docx, editor, converter }) {
       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((comment) => ({ ...comment, isDone: comment.isDone ?? false }));
+    const commentsWithThreading = detectThreadingFromRanges(comments, rangeData);
+    return commentsWithThreading.map((comment) => ({
+      ...comment,
+      isDone: comment.isDone ?? false
+    }));
   }
   const { elements: initialElements = [] } = commentsExtended;
   if (!initialElements?.length) return comments.map((comment) => ({ ...comment, isDone: comment.isDone ?? false }));
@@ -28086,25 +28112,30 @@ const generateCommentsWithExtendedData = ({ docx, comments }) => {
   const commentEx = elements.filter((el) => el.name === "w15:commentEx");
   return comments.map((comment) => {
     const extendedDef = commentEx.find((ce2) => {
-      const isIncludedInCommentElements = comment.elements?.some(
-        (el) => el.attrs?.["w14:paraId"] === ce2.attributes["w15:paraId"]
-      );
-      return isIncludedInCommentElements;
+      return comment.elements?.some((el) => el.attrs?.["w14:paraId"] === ce2.attributes["w15:paraId"]);
     });
-    if (!extendedDef) return { ...comment, isDone: comment.isDone ?? false };
-    const { isDone, paraIdParent } = getExtendedDetails(extendedDef);
-    let parentComment;
-    if (paraIdParent) {
-      parentComment = comments.find(
-        (c) => c.paraId === paraIdParent || c.elements?.some((el) => el.attrs?.["w14:paraId"] === paraIdParent)
-      );
+    let isDone = comment.isDone ?? false;
+    let parentCommentId = void 0;
+    const trackedChangeParent = trackedChangeParentMap.get(comment.importedId);
+    const isInsideTrackedChange = trackedChangeParent?.isTrackedChangeParent;
+    if (extendedDef) {
+      const details = getExtendedDetails(extendedDef);
+      isDone = details.isDone ?? false;
+      if (!isInsideTrackedChange && details.paraIdParent) {
+        const parentComment = comments.find(
+          (c) => c.paraId === details.paraIdParent || c.elements?.some((el) => el.attrs?.["w14:paraId"] === details.paraIdParent)
+        );
+        parentCommentId = parentComment?.commentId;
+      }
+    }
+    if (isInsideTrackedChange) {
+      parentCommentId = trackedChangeParent.trackedChangeId;
     }
-    const newComment = {
+    return {
       ...comment,
-      isDone: isDone ?? false,
-      parentCommentId: parentComment?.commentId
+      isDone,
+      parentCommentId
     };
-    return newComment;
   });
 };
 const getExtendedDetails = (commentEx) => {
@@ -28114,34 +28145,117 @@ const getExtendedDetails = (commentEx) => {
   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((element) => {
-      if (element.name === "w:commentRangeStart") {
+      const isCommentStart = element.name === "w:commentRangeStart";
+      const isCommentEnd = element.name === "w:commentRangeEnd";
+      const isTrackedChange = element.name === "w:ins" || element.name === "w:del";
+      if (isCommentStart) {
         const commentId = element.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 (element.name === "w:commentRangeEnd") {
+        lastElementWasCommentMarker = true;
+        recentlyClosedComments.clear();
+      } else if (isCommentEnd) {
         const commentId = element.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 = element.attributes?.["w:id"];
+        const author = element.attributes?.["w:author"];
+        const date = element.attributes?.["w:date"];
+        const elementType = element.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 (element.elements && Array.isArray(element.elements)) {
+          walkElements(element.elements, mappedId !== void 0 ? String(mappedId) : currentTrackedChangeId);
+        }
+      } else {
+        if (lastElementWasCommentMarker) {
+          positionIndex++;
+          lastElementWasCommentMarker = false;
+        }
+        if (element.name === "w:p") {
+          recentlyClosedComments.clear();
+          lastTrackedChange = null;
+        }
+        if (element.elements && Array.isArray(element.elements)) {
+          walkElements(element.elements, currentTrackedChangeId);
         }
-      }
-      if (element.elements && Array.isArray(element.elements)) {
-        walkElements(element.elements);
       }
     });
   };
@@ -28151,19 +28265,20 @@ const extractCommentRangesFromDocument = (docx) => {
       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 i = openRanges.length - 1; i >= 0; i--) {
+          if (!skipComments.has(openRanges[i])) {
+            parentMap.set(event.commentId, openRanges[i]);
+            break;
+          }
+        }
       }
       openRanges.push(event.commentId);
     } else if (event.type === "end") {
@@ -28173,10 +28288,113 @@ const detectThreadingFromRanges = (comments, rangeEvents) => {
       }
     }
   });
+  return parentMap;
+};
+const detectThreadingFromSharedPosition = (comments, rangePositions) => {
+  const parentMap = /* @__PURE__ */ new Map();
+  const commentsByStartPosition = /* @__PURE__ */ new Map();
+  comments.forEach((comment) => {
+    const position = rangePositions.get(comment.importedId);
+    if (position && position.startIndex >= 0) {
+      const startKey = position.startIndex;
+      if (!commentsByStartPosition.has(startKey)) {
+        commentsByStartPosition.set(startKey, []);
+      }
+      commentsByStartPosition.get(startKey).push(comment);
+    }
+  });
+  commentsByStartPosition.forEach((commentsAtPosition) => {
+    if (commentsAtPosition.length <= 1) return;
+    const sorted = [...commentsAtPosition].sort((a, b2) => a.createdTime - b2.createdTime);
+    const parentComment = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+      parentMap.set(sorted[i].importedId, parentComment.importedId);
+    }
+  });
+  return parentMap;
+};
+const detectThreadingFromMissingRanges = (comments, rangePositions) => {
+  const parentMap = /* @__PURE__ */ new Map();
+  const commentsWithRanges = [];
+  const commentsWithoutRanges = [];
+  comments.forEach((comment) => {
+    const position = rangePositions.get(comment.importedId);
+    if (position && position.startIndex >= 0) {
+      commentsWithRanges.push(comment);
+    } else {
+      commentsWithoutRanges.push(comment);
+    }
+  });
+  commentsWithoutRanges.forEach((comment) => {
+    const potentialParents = commentsWithRanges.filter((c) => c.createdTime < comment.createdTime).sort((a, b2) => b2.createdTime - a.createdTime);
+    if (potentialParents.length > 0) {
+      parentMap.set(comment.importedId, potentialParents[0].importedId);
+    }
+  });
+  return parentMap;
+};
+const detectThreadingFromTrackedChanges = (comments, commentsInTrackedChanges) => {
+  const parentMap = /* @__PURE__ */ new Map();
+  if (!commentsInTrackedChanges || commentsInTrackedChanges.size === 0) {
+    return parentMap;
+  }
+  comments.forEach((comment) => {
+    const trackedChangeId = commentsInTrackedChanges.get(comment.importedId);
+    if (trackedChangeId !== void 0) {
+      parentMap.set(comment.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((comment) => {
+    const position = rangePositions.get(comment.importedId);
+    if (position && position.startIndex >= 0) {
+      const startKey = position.startIndex;
+      if (!commentsByStartPosition.has(startKey)) {
+        commentsByStartPosition.set(startKey, []);
+      }
+      commentsByStartPosition.get(startKey).push(comment.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((comment) => {
-    const parentCommentId = parentMap.get(comment.importedId);
-    if (parentCommentId) {
-      const parentComment = comments.find((c) => c.importedId === parentCommentId);
+    const trackedChangeParent = trackedChangeParentMap.get(comment.importedId);
+    if (trackedChangeParent && trackedChangeParent.isTrackedChangeParent) {
+      return {
+        ...comment,
+        parentCommentId: trackedChangeParent.trackedChangeId
+      };
+    }
+    const parentImportedId = parentMap.get(comment.importedId);
+    if (parentImportedId) {
+      const parentComment = comments.find((c) => c.importedId === parentImportedId);
       if (parentComment) {
         return {
           ...comment,
@@ -29052,9 +29270,30 @@ const commentRangeEndHandlerEntity = generateV2HandlerEntity(
 );
 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("/");
@@ -30626,7 +30865,9 @@ const getCommentDefinition = (comment, commentId, allComments, editor) => {
   };
   if (comment?.parentCommentId) {
     const parentComment = allComments.find((c) => c.commentId === comment.parentCommentId);
-    attributes["w15:paraIdParent"] = parentComment.commentParaId;
+    if (parentComment && !parentComment.trackedChange) {
+      attributes["w15:paraIdParent"] = parentComment.commentParaId;
+    }
   }
   return {
     type: "element",
@@ -30671,7 +30912,22 @@ const updateCommentsXml = (commentDefs = [], commentsXml) => {
   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((c) => c.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((c) => c.originalXmlStructure?.hasCommentsExtended);
+  if (!shouldGenerateCommentsExtended && exportStrategy === "google-docs") {
+    return null;
+  }
   const xmlCopy = carbonCopy(commentsExtendedXml);
   const commentsEx = comments.map((comment) => {
     const isResolved = comment.resolvedTime || comment.isDone;
@@ -30680,9 +30936,11 @@ const updateCommentsExtendedXml = (comments = [], commentsExtendedXml) => {
       "w15:done": isResolved ? "1" : "0"
     };
     const parentId = comment.parentCommentId;
-    if (parentId) {
+    if (parentId && (exportStrategy === "word" || comment.originalXmlStructure?.hasCommentsExtended)) {
       const parentComment = comments.find((c) => c.commentId === parentId);
-      attributes["w15:paraIdParent"] = parentComment.commentParaId;
+      if (parentComment && !parentComment.trackedChange) {
+        attributes["w15:paraIdParent"] = parentComment.commentParaId;
+      }
     }
     return {
       type: "element",
@@ -30752,14 +31010,21 @@ const prepareCommentsXmlFilesForExport = ({ convertedXml, defs, commentsWithPara
     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"],
@@ -31268,7 +31533,7 @@ class SuperConverter {
   static getStoredSuperdocVersion(docx) {
     return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.4.0-next.3") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version = "1.4.1-next.1") {
     return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version, false);
   }
   /**