docx-diff-editor 1.0.0

package/dist/index.js

@@ -0,0 +1,1194 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+var DiffMatchPatch = require('diff-match-patch');
+var uuid = require('uuid');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DiffMatchPatch__default = /*#__PURE__*/_interopDefault(DiffMatchPatch);
+
+// src/DocxDiffEditor.tsx
+
+// src/blankTemplate.ts
+var BLANK_DOCX_BASE64 = `UEsDBBQAAAAIAAAAAACHTuJAXQAAAABgAAAACwAIAF9yZWxzLy5yZWxzIKIEACigAAAAAAAAAK2O
+wQrCMBBE7wv+Q9i7TetBRKT2IoIHr7Jsm0KzCdkV9e9N8QNc5jDMvGGql9eb8KCIOgQNs6IA4VgG
+E1yr4dQcZksQmNAZ9MGRhpchrKrJpCYfE+dD7GOPBSuc4g5TyvMlELeEPuJ0EJjzpgnRY8pjbGnG
+9oYt0XlRLCj+D+FvK/HJ9e1j0NTUU0i/rYCtOnW7kCnGagD/n1BLAQI/AxQAAAAIAAAAAACHTuJA
+XQAAAABgAAAACwAYAAAAAAAAAAAArYEAAAAAX3JlbHMvLnJlbHNVVAUABx4AAABQSWECAAAAAFBL
+AQIfAxQAAAAIAAAAAABU+/yzrQEAAKYFAAARABgAAAAAAAEAAACkgZMAAABkb2NQcm9wcy9jb3Jl
+LnhtbFVUBQAHHgAAAFBLAQIfAxQAAAAIAAAAAABJ8bJvAwEAABcDAAAQABgAAAAAAAEAAACkgZMC
+AABkb2NQcm9wcy9hcHAueG1sVVQFAAceAAAAUEsBAh8DFAAAAAgAAAAAANeufwOOAQAA2AMAABEA
+GAAAAAAAAQAAAKSByAMAAHdvcmQvZG9jdW1lbnQueG1sVVQFAAceAAAAUEsBAh8DFAAAAAgAAAAA
+ADlvn/FGBAAALAIAAB8AGAAAAAAAAQAAAKSBiQUAAHdvcmQvX3JlbHMvZG9jdW1lbnQueG1sLnJl
+bHNVVAUABx4AAABQSwECHwMUAAAACAAAAAAATbh/e0oBAACtAgAAEQAYAAAAAAABAAAApIEWBgAA
+d29yZC9zdHlsZXMueG1sVVQFAAceAAAAUEsBAh8DFAAAAAgAAAAAAMxe3mTsAAAA/AEAABMAGAAA
+AAAAAQAAAKSBkwcAAFtDb250ZW50X1R5cGVzXS54bWxVVAUABx4AAABQSwUGAAAAAAcABwBdAQAA
+uggAAAAA`;
+function base64ToBlob(base64, mimeType) {
+  const byteCharacters = atob(base64.replace(/\s/g, ""));
+  const byteNumbers = new Array(byteCharacters.length);
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  const byteArray = new Uint8Array(byteNumbers);
+  return new Blob([byteArray], { type: mimeType });
+}
+function base64ToFile(base64, filename, mimeType) {
+  const blob = base64ToBlob(base64, mimeType);
+  return new File([blob], filename, { type: mimeType });
+}
+function getBlankTemplateFile() {
+  return base64ToFile(
+    BLANK_DOCX_BASE64,
+    "blank-template.docx",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  );
+}
+function getBlankTemplateBlob() {
+  return base64ToBlob(
+    BLANK_DOCX_BASE64,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  );
+}
+function isValidDocxFile(file) {
+  const validTypes = [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/msword"
+  ];
+  return validTypes.includes(file.type) || file.name.endsWith(".docx");
+}
+
+// src/constants.ts
+var DEFAULT_AUTHOR = {
+  name: "DocxDiff Editor",
+  email: "editor@docxdiff.local"
+};
+var DEFAULT_SUPERDOC_USER = {
+  name: "DocxDiff User",
+  email: "user@docxdiff.local"
+};
+var TRACK_CHANGE_PERMISSIONS = [
+  "RESOLVE_OWN",
+  "RESOLVE_OTHER",
+  "REJECT_OWN",
+  "REJECT_OTHER"
+];
+var CSS_PREFIX = "dde";
+var TIMEOUTS = {
+  /** Timeout for document parsing (ms) */
+  PARSE_TIMEOUT: 3e4,
+  /** Small delay for React settling (ms) */
+  INIT_DELAY: 100,
+  /** Cleanup delay (ms) */
+  CLEANUP_DELAY: 100
+};
+
+// src/services/contentResolver.ts
+function detectContentType(content) {
+  if (content instanceof File) {
+    return "file";
+  }
+  if (typeof content === "string") {
+    return "html";
+  }
+  return "json";
+}
+function isProseMirrorJSON(content) {
+  if (!content || typeof content !== "object") return false;
+  const obj = content;
+  return typeof obj.type === "string" && (obj.type === "doc" || Array.isArray(obj.content));
+}
+async function parseDocxFile(file, SuperDoc) {
+  const container = document.createElement("div");
+  container.style.cssText = "position:absolute;top:-9999px;left:-9999px;width:800px;height:600px;visibility:hidden;";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let superdoc = null;
+    let resolved = false;
+    const cleanup = () => {
+      setTimeout(() => {
+        if (superdoc) {
+          try {
+            const sd = superdoc;
+            superdoc = null;
+            sd.destroy?.();
+          } catch {
+          }
+        }
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+      }, TIMEOUTS.CLEANUP_DELAY);
+    };
+    setTimeout(async () => {
+      if (resolved) return;
+      try {
+        superdoc = new SuperDoc({
+          selector: container,
+          document: file,
+          documentMode: "viewing",
+          rulers: false,
+          user: { name: "Parser", email: "parser@local" },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          onReady: ({ superdoc: sd }) => {
+            if (resolved) return;
+            try {
+              const editor = sd?.activeEditor;
+              if (!editor) {
+                throw new Error("No active editor found");
+              }
+              const json = editor.getJSON();
+              resolved = true;
+              cleanup();
+              resolve(json);
+            } catch (err) {
+              resolved = true;
+              cleanup();
+              reject(err);
+            }
+          },
+          onException: ({ error: err }) => {
+            if (resolved) return;
+            resolved = true;
+            cleanup();
+            reject(err);
+          }
+        });
+        setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            cleanup();
+            reject(new Error("Document parsing timed out"));
+          }
+        }, TIMEOUTS.PARSE_TIMEOUT);
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
+    }, 50);
+  });
+}
+async function parseHtmlContent(html, SuperDoc, templateDocx) {
+  const template = templateDocx || getBlankTemplateFile();
+  const container = document.createElement("div");
+  container.style.cssText = "position:absolute;top:-9999px;left:-9999px;width:800px;height:600px;visibility:hidden;";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let superdoc = null;
+    let resolved = false;
+    const cleanup = () => {
+      setTimeout(() => {
+        if (superdoc) {
+          try {
+            const sd = superdoc;
+            superdoc = null;
+            sd.destroy?.();
+          } catch {
+          }
+        }
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+      }, TIMEOUTS.CLEANUP_DELAY);
+    };
+    setTimeout(async () => {
+      if (resolved) return;
+      try {
+        superdoc = new SuperDoc({
+          selector: container,
+          document: template,
+          html,
+          // SuperDoc's HTML initialization option
+          documentMode: "viewing",
+          rulers: false,
+          user: { name: "Parser", email: "parser@local" },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          onReady: ({ superdoc: sd }) => {
+            if (resolved) return;
+            try {
+              const editor = sd?.activeEditor;
+              if (!editor) {
+                throw new Error("No active editor found");
+              }
+              const json = editor.getJSON();
+              resolved = true;
+              cleanup();
+              resolve(json);
+            } catch (err) {
+              resolved = true;
+              cleanup();
+              reject(err);
+            }
+          },
+          onException: ({ error: err }) => {
+            if (resolved) return;
+            resolved = true;
+            cleanup();
+            reject(err);
+          }
+        });
+        setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            cleanup();
+            reject(new Error("HTML parsing timed out"));
+          }
+        }, TIMEOUTS.PARSE_TIMEOUT);
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
+    }, 50);
+  });
+}
+async function resolveContent(content, SuperDoc, templateDocx) {
+  const type = detectContentType(content);
+  switch (type) {
+    case "file":
+      return {
+        json: await parseDocxFile(content, SuperDoc),
+        type: "file"
+      };
+    case "html":
+      return {
+        json: await parseHtmlContent(content, SuperDoc, templateDocx),
+        type: "html"
+      };
+    case "json":
+      if (!isProseMirrorJSON(content)) {
+        throw new Error("Invalid ProseMirror JSON structure");
+      }
+      return {
+        json: content,
+        type: "json"
+      };
+    default:
+      throw new Error(`Unknown content type: ${type}`);
+  }
+}
+var dmp = new DiffMatchPatch__default.default();
+var DIFF_DELETE = -1;
+var DIFF_INSERT = 1;
+var DIFF_EQUAL = 0;
+function extractTextSpans(node, offset = 0) {
+  const spans = [];
+  if (!node) return spans;
+  if (node.type === "text" && node.text) {
+    spans.push({
+      text: node.text,
+      from: offset,
+      to: offset + node.text.length,
+      marks: node.marks || []
+    });
+    return spans;
+  }
+  if (node.content && Array.isArray(node.content)) {
+    let currentOffset = offset;
+    for (const child of node.content) {
+      const childSpans = extractTextSpans(child, currentOffset);
+      spans.push(...childSpans);
+      for (const span of childSpans) {
+        currentOffset = Math.max(currentOffset, span.to);
+      }
+      if (childSpans.length === 0 && child.type === "text" && child.text) {
+        currentOffset += child.text.length;
+      }
+    }
+  }
+  return spans;
+}
+function extractTextContent(node) {
+  if (!node) return "";
+  if (node.type === "text" && node.text) {
+    return node.text;
+  }
+  if (node.content && Array.isArray(node.content)) {
+    return node.content.map(extractTextContent).join("");
+  }
+  return "";
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object" || a === null || b === null) return false;
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(objA[key], objB[key])) return false;
+  }
+  return true;
+}
+function marksEqual(marksA, marksB) {
+  if (marksA.length !== marksB.length) return false;
+  const sortedA = [...marksA].sort((a, b) => (a.type || "").localeCompare(b.type || ""));
+  const sortedB = [...marksB].sort((a, b) => (a.type || "").localeCompare(b.type || ""));
+  return deepEqual(sortedA, sortedB);
+}
+function getMarksAtPosition(spans, pos) {
+  for (const span of spans) {
+    if (pos >= span.from && pos < span.to) {
+      return span.marks;
+    }
+  }
+  return [];
+}
+function detectFormatChanges(spansA, spansB, segments) {
+  const formatChanges = [];
+  let posA = 0;
+  let posB = 0;
+  for (const segment of segments) {
+    if (segment.type === "equal") {
+      let i = 0;
+      while (i < segment.text.length) {
+        const marksA = getMarksAtPosition(spansA, posA + i);
+        const marksB = getMarksAtPosition(spansB, posB + i);
+        if (!marksEqual(marksA, marksB)) {
+          const startI = i;
+          const startMarksA = marksA;
+          const startMarksB = marksB;
+          while (i < segment.text.length) {
+            const currentMarksA = getMarksAtPosition(spansA, posA + i);
+            const currentMarksB = getMarksAtPosition(spansB, posB + i);
+            if (marksEqual(currentMarksA, startMarksA) && marksEqual(currentMarksB, startMarksB)) {
+              i++;
+            } else {
+              break;
+            }
+          }
+          formatChanges.push({
+            from: posA + startI,
+            to: posA + i,
+            text: segment.text.substring(startI, i),
+            before: startMarksA,
+            after: startMarksB
+          });
+        } else {
+          i++;
+        }
+      }
+      posA += segment.text.length;
+      posB += segment.text.length;
+    } else if (segment.type === "delete") {
+      posA += segment.text.length;
+    } else if (segment.type === "insert") {
+      posB += segment.text.length;
+    }
+  }
+  return formatChanges;
+}
+function diffDocuments(docA, docB) {
+  const textA = extractTextContent(docA);
+  const textB = extractTextContent(docB);
+  const diffs = dmp.diff_main(textA, textB);
+  dmp.diff_cleanupSemantic(diffs);
+  const segments = [];
+  let insertCount = 0;
+  let deleteCount = 0;
+  for (const [op, text] of diffs) {
+    if (op === DIFF_EQUAL) {
+      segments.push({ type: "equal", text });
+    } else if (op === DIFF_INSERT) {
+      segments.push({ type: "insert", text });
+      insertCount++;
+    } else if (op === DIFF_DELETE) {
+      segments.push({ type: "delete", text });
+      deleteCount++;
+    }
+  }
+  const spansA = extractTextSpans(docA);
+  const spansB = extractTextSpans(docB);
+  const formatChanges = detectFormatChanges(spansA, spansB, segments);
+  const summary = [];
+  if (insertCount > 0) {
+    summary.push(`${insertCount} insertion(s)`);
+  }
+  if (deleteCount > 0) {
+    summary.push(`${deleteCount} deletion(s)`);
+  }
+  if (formatChanges.length > 0) {
+    summary.push(`${formatChanges.length} format change(s)`);
+  }
+  if (insertCount === 0 && deleteCount === 0 && formatChanges.length === 0) {
+    summary.push("No changes detected");
+  }
+  return {
+    segments,
+    formatChanges,
+    textA,
+    textB,
+    summary
+  };
+}
+function createTrackInsertMark(author = DEFAULT_AUTHOR) {
+  return {
+    type: "trackInsert",
+    attrs: {
+      id: uuid.v4(),
+      author: author.name,
+      authorEmail: author.email,
+      authorImage: "",
+      date: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTrackDeleteMark(author = DEFAULT_AUTHOR) {
+  return {
+    type: "trackDelete",
+    attrs: {
+      id: uuid.v4(),
+      author: author.name,
+      authorEmail: author.email,
+      authorImage: "",
+      date: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTrackFormatMark(before, after, author = DEFAULT_AUTHOR) {
+  return {
+    type: "trackFormat",
+    attrs: {
+      id: uuid.v4(),
+      author: author.name,
+      authorEmail: author.email,
+      authorImage: "",
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      before,
+      after
+    }
+  };
+}
+
+// src/services/mergeDocuments.ts
+function cloneNode(node) {
+  return JSON.parse(JSON.stringify(node));
+}
+function mergeDocuments(docA, docB, diffResult, author = DEFAULT_AUTHOR) {
+  const merged = cloneNode(docA);
+  const charStates = [];
+  let insertions = [];
+  const formatChanges = diffResult.formatChanges || [];
+  function getFormatChangeAt(pos) {
+    for (const fc of formatChanges) {
+      if (pos >= fc.from && pos < fc.to) {
+        return fc;
+      }
+    }
+    return null;
+  }
+  let docAOffset = 0;
+  for (const segment of diffResult.segments) {
+    if (segment.type === "equal") {
+      for (let i = 0; i < segment.text.length; i++) {
+        charStates[docAOffset + i] = { type: "equal" };
+      }
+      docAOffset += segment.text.length;
+    } else if (segment.type === "delete") {
+      for (let i = 0; i < segment.text.length; i++) {
+        charStates[docAOffset + i] = { type: "delete" };
+      }
+      docAOffset += segment.text.length;
+    } else if (segment.type === "insert") {
+      insertions.push({
+        afterOffset: docAOffset,
+        text: segment.text
+      });
+    }
+  }
+  function transformNode(node, nodeOffset, path) {
+    if (node.type === "text" && node.text) {
+      const text = node.text;
+      const result = [];
+      let i = 0;
+      while (i < text.length) {
+        const charOffset = nodeOffset + i;
+        const charState = charStates[charOffset] || { type: "equal" };
+        const insertionsHere = insertions.filter((ins) => ins.afterOffset === charOffset);
+        for (const ins of insertionsHere) {
+          result.push({
+            type: "text",
+            text: ins.text,
+            marks: [...node.marks || [], createTrackInsertMark(author)]
+          });
+        }
+        const currentFormatChange = getFormatChangeAt(nodeOffset + i);
+        let j = i + 1;
+        while (j < text.length) {
+          const nextState = charStates[nodeOffset + j] || { type: "equal" };
+          if (nextState.type !== charState.type) break;
+          if (insertions.some((ins) => ins.afterOffset === nodeOffset + j)) break;
+          const nextFormatChange = getFormatChangeAt(nodeOffset + j);
+          if (currentFormatChange !== nextFormatChange) break;
+          j++;
+        }
+        const chunk = text.substring(i, j);
+        let marks = [...node.marks || []];
+        if (charState.type === "delete") {
+          marks.push(createTrackDeleteMark(author));
+        } else if (charState.type === "equal") {
+          if (currentFormatChange) {
+            const trackFormatMark = createTrackFormatMark(
+              currentFormatChange.before,
+              currentFormatChange.after,
+              author
+            );
+            marks = [...currentFormatChange.after, trackFormatMark];
+          }
+        }
+        result.push({
+          type: "text",
+          text: chunk,
+          marks: marks.length > 0 ? marks : void 0
+        });
+        i = j;
+      }
+      const endOffset = nodeOffset + text.length;
+      const endInsertions = insertions.filter((ins) => ins.afterOffset === endOffset);
+      for (const ins of endInsertions) {
+        result.push({
+          type: "text",
+          text: ins.text,
+          marks: [...node.marks || [], createTrackInsertMark(author)]
+        });
+      }
+      insertions = insertions.filter(
+        (ins) => ins.afterOffset < nodeOffset || ins.afterOffset > endOffset
+      );
+      return { nodes: result, consumedLength: text.length };
+    }
+    if (node.content && Array.isArray(node.content)) {
+      const newContent = [];
+      let offset = nodeOffset;
+      for (const child of node.content) {
+        const { nodes, consumedLength } = transformNode(child, offset);
+        newContent.push(...nodes);
+        offset += consumedLength;
+      }
+      return {
+        nodes: [{ ...node, content: newContent }],
+        consumedLength: offset - nodeOffset
+      };
+    }
+    return { nodes: [node], consumedLength: 0 };
+  }
+  if (merged.content && Array.isArray(merged.content)) {
+    const newContent = [];
+    let offset = 0;
+    for (let i = 0; i < merged.content.length; i++) {
+      const child = merged.content[i];
+      const { nodes, consumedLength } = transformNode(child, offset);
+      newContent.push(...nodes);
+      offset += consumedLength;
+    }
+    merged.content = newContent;
+  }
+  if (insertions.length > 0) {
+    for (const ins of insertions) {
+      const insertNode = {
+        type: "paragraph",
+        content: [
+          {
+            type: "run",
+            content: [
+              {
+                type: "text",
+                text: ins.text,
+                marks: [createTrackInsertMark(author)]
+              }
+            ]
+          }
+        ]
+      };
+      if (!merged.content) merged.content = [];
+      merged.content.push(insertNode);
+    }
+  }
+  return merged;
+}
+
+// src/services/changeContextExtractor.ts
+function extractEnrichedChanges(mergedJson) {
+  const changes = [];
+  const context = {
+    currentSection: null,
+    currentParagraphText: "",
+    currentNodeType: "unknown"
+  };
+  traverseDocument(mergedJson, context, changes);
+  return groupReplacements(changes);
+}
+function traverseDocument(node, context, changes) {
+  if (!node) return;
+  if (node.type === "heading") {
+    context.currentSection = extractAllText(node);
+    context.headingLevel = node.attrs?.level || 1;
+    context.currentNodeType = "heading";
+    context.currentParagraphText = context.currentSection;
+  } else if (node.type === "paragraph") {
+    context.currentNodeType = "paragraph";
+    context.currentParagraphText = extractAllText(node);
+  } else if (node.type === "listItem") {
+    context.currentNodeType = "listItem";
+    context.currentParagraphText = extractAllText(node);
+  } else if (node.type === "tableCell") {
+    context.currentNodeType = "tableCell";
+    context.currentParagraphText = extractAllText(node);
+  }
+  if (node.type === "text" && node.marks) {
+    const trackMark = findTrackChangeMark(node.marks);
+    if (trackMark) {
+      const change = createEnrichedChange(node, trackMark, context);
+      if (change) changes.push(change);
+    }
+  }
+  if (node.content && Array.isArray(node.content)) {
+    for (const child of node.content) {
+      traverseDocument(child, context, changes);
+    }
+  }
+}
+function extractAllText(node) {
+  if (!node) return "";
+  if (node.type === "text") {
+    return node.text || "";
+  }
+  if (node.content && Array.isArray(node.content)) {
+    return node.content.map(extractAllText).join("");
+  }
+  return "";
+}
+function findTrackChangeMark(marks) {
+  return marks.find(
+    (m) => m.type === "trackInsert" || m.type === "trackDelete" || m.type === "trackFormat"
+  ) || null;
+}
+function createEnrichedChange(node, trackMark, context) {
+  const text = node.text || "";
+  const location = buildLocation(context);
+  const surroundingText = extractSurroundingSentence(text, context.currentParagraphText);
+  if (trackMark.type === "trackInsert") {
+    return {
+      type: "insertion",
+      text,
+      location,
+      surroundingText,
+      charCount: text.length
+    };
+  }
+  if (trackMark.type === "trackDelete") {
+    return {
+      type: "deletion",
+      text,
+      location,
+      surroundingText,
+      charCount: text.length
+    };
+  }
+  if (trackMark.type === "trackFormat") {
+    const before = trackMark.attrs?.before || [];
+    const after = trackMark.attrs?.after || [];
+    return {
+      type: "format",
+      text,
+      location,
+      surroundingText,
+      formatDetails: {
+        added: after.map((m) => m.type).filter((t) => !before.some((b) => b.type === t)),
+        removed: before.map((m) => m.type).filter((t) => !after.some((a) => a.type === t))
+      },
+      charCount: text.length
+    };
+  }
+  return null;
+}
+function extractSurroundingSentence(changedText, paragraphText) {
+  if (!paragraphText || !changedText) return "";
+  const changeIndex = paragraphText.indexOf(changedText);
+  if (changeIndex === -1) {
+    return truncate(paragraphText, 150);
+  }
+  const sentenceBreaks = /([.;!?]\s+)/g;
+  const sentences = [];
+  let lastEnd = 0;
+  let match;
+  while ((match = sentenceBreaks.exec(paragraphText)) !== null) {
+    sentences.push({
+      text: paragraphText.slice(lastEnd, match.index + match[0].length).trim(),
+      start: lastEnd,
+      end: match.index + match[0].length
+    });
+    lastEnd = match.index + match[0].length;
+  }
+  if (lastEnd < paragraphText.length) {
+    sentences.push({
+      text: paragraphText.slice(lastEnd).trim(),
+      start: lastEnd,
+      end: paragraphText.length
+    });
+  }
+  const changeEnd = changeIndex + changedText.length;
+  for (const sentence of sentences) {
+    if (changeIndex >= sentence.start && changeIndex < sentence.end) {
+      return truncate(sentence.text, 200);
+    }
+  }
+  const windowSize = 100;
+  const start = Math.max(0, changeIndex - windowSize);
+  const end = Math.min(paragraphText.length, changeEnd + windowSize);
+  let result = paragraphText.slice(start, end);
+  if (start > 0) result = "..." + result;
+  if (end < paragraphText.length) result = result + "...";
+  return result;
+}
+function truncate(text, maxLen) {
+  if (!text) return "";
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (cleaned.length <= maxLen) return cleaned;
+  return cleaned.slice(0, maxLen - 3).trim() + "...";
+}
+function buildLocation(context) {
+  const nodeType = context.currentNodeType;
+  let description;
+  if (nodeType === "heading") {
+    description = context.headingLevel === 1 ? "document title" : "section heading";
+  } else if (context.currentSection) {
+    description = `"${truncate(context.currentSection, 50)}" section`;
+  } else {
+    description = "document body";
+  }
+  return {
+    nodeType,
+    headingLevel: context.headingLevel,
+    sectionTitle: context.currentSection || void 0,
+    description
+  };
+}
+function groupReplacements(changes) {
+  const result = [];
+  let i = 0;
+  while (i < changes.length) {
+    const current = changes[i];
+    const next = changes[i + 1];
+    if (current.type === "deletion" && next?.type === "insertion" && current.location.sectionTitle === next.location.sectionTitle) {
+      result.push({
+        type: "replacement",
+        oldText: current.text,
+        newText: next.text,
+        location: current.location,
+        surroundingText: current.surroundingText || next.surroundingText,
+        charCount: (current.charCount || 0) + (next.charCount || 0)
+      });
+      i += 2;
+    } else {
+      result.push(current);
+      i++;
+    }
+  }
+  return result;
+}
+var permissionResolver = ({ permission }) => {
+  return TRACK_CHANGE_PERMISSIONS.includes(permission) ? true : void 0;
+};
+var DocxDiffEditor = react.forwardRef(
+  function DocxDiffEditor2({
+    initialSource,
+    templateDocx,
+    showRulers = false,
+    showToolbar = true,
+    author = DEFAULT_AUTHOR,
+    onReady,
+    onSourceLoaded,
+    onComparisonComplete,
+    onError,
+    className = "",
+    toolbarClassName = "",
+    editorClassName = ""
+  }, ref) {
+    const containerRef = react.useRef(null);
+    const toolbarRef = react.useRef(null);
+    const superdocRef = react.useRef(null);
+    const SuperDocRef = react.useRef(null);
+    const mountedRef = react.useRef(true);
+    const initRef = react.useRef(false);
+    const readyRef = react.useRef(false);
+    const [isLoading, setIsLoading] = react.useState(true);
+    const [error, setError] = react.useState(null);
+    const [sourceJson, setSourceJson] = react.useState(null);
+    const [mergedJson, setMergedJson] = react.useState(null);
+    const [diffResult, setDiffResult] = react.useState(null);
+    const instanceId = react.useRef(`dde-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    const editorId = `dde-editor-${instanceId.current}`;
+    const toolbarId = `dde-toolbar-${instanceId.current}`;
+    const setEditorContent = react.useCallback((editor, json) => {
+      if (editor.commands?.setContent) {
+        editor.commands.setContent(json);
+      } else if (editor.setContent) {
+        editor.setContent(json);
+      } else {
+        const { state, view } = editor;
+        if (state?.doc && view && json.content) {
+          const newDoc = state.schema.nodeFromJSON(json);
+          const tr = state.tr.replaceWith(0, state.doc.content.size, newDoc.content);
+          view.dispatch(tr);
+        }
+      }
+    }, []);
+    const enableReviewMode = react.useCallback((sd) => {
+      if (sd.setTrackedChangesPreferences) {
+        sd.setTrackedChangesPreferences({ mode: "review", enabled: true });
+      } else if (sd.activeEditor?.commands?.enableTrackChanges) {
+        sd.activeEditor.commands.enableTrackChanges();
+      }
+    }, []);
+    const setEditingMode = react.useCallback((sd) => {
+      if (sd.setTrackedChangesPreferences) {
+        sd.setTrackedChangesPreferences({ mode: "editing", enabled: false });
+      }
+    }, []);
+    const getTemplateFile = react.useCallback(() => {
+      return templateDocx || getBlankTemplateFile();
+    }, [templateDocx]);
+    const handleError = react.useCallback(
+      (err) => {
+        const error2 = err instanceof Error ? err : new Error(err);
+        setError(error2.message);
+        onError?.(error2);
+      },
+      [onError]
+    );
+    const initialize = react.useCallback(async () => {
+      if (initRef.current || !containerRef.current || !mountedRef.current) return;
+      if (!showToolbar && !toolbarRef.current) ; else if (showToolbar && !toolbarRef.current) {
+        return;
+      }
+      initRef.current = true;
+      await new Promise((resolve) => setTimeout(resolve, TIMEOUTS.INIT_DELAY));
+      if (!mountedRef.current || !containerRef.current) {
+        initRef.current = false;
+        return;
+      }
+      setIsLoading(true);
+      setError(null);
+      if (superdocRef.current) {
+        try {
+          superdocRef.current.destroy?.();
+        } catch {
+        }
+        superdocRef.current = null;
+      }
+      containerRef.current.id = editorId;
+      if (toolbarRef.current) {
+        toolbarRef.current.id = toolbarId;
+      }
+      try {
+        const { SuperDoc } = await import('superdoc');
+        await import('superdoc/style.css');
+        SuperDocRef.current = SuperDoc;
+        let initialDoc;
+        let initialContent = null;
+        if (initialSource) {
+          const contentType = detectContentType(initialSource);
+          if (contentType === "file") {
+            initialDoc = initialSource;
+          } else {
+            initialDoc = getTemplateFile();
+            try {
+              const resolved = await resolveContent(initialSource, SuperDoc, templateDocx);
+              initialContent = resolved.json;
+            } catch (err) {
+              handleError(err instanceof Error ? err : new Error("Failed to resolve initial content"));
+            }
+          }
+        } else {
+          initialDoc = getTemplateFile();
+        }
+        const superdoc = new SuperDoc({
+          selector: `#${editorId}`,
+          toolbar: showToolbar ? `#${toolbarId}` : void 0,
+          document: initialDoc,
+          documentMode: "editing",
+          role: "editor",
+          rulers: showRulers,
+          user: DEFAULT_SUPERDOC_USER,
+          permissionResolver,
+          onReady: ({ superdoc: sd }) => {
+            superdocRef.current = sd;
+            readyRef.current = true;
+            if (initialContent && sd?.activeEditor) {
+              try {
+                setEditorContent(sd.activeEditor, initialContent);
+                setSourceJson(initialContent);
+                onSourceLoaded?.(initialContent);
+              } catch (err) {
+                console.error("Failed to set initial content:", err);
+              }
+            } else if (sd?.activeEditor) {
+              try {
+                const json = sd.activeEditor.getJSON();
+                setSourceJson(json);
+                onSourceLoaded?.(json);
+              } catch (err) {
+                console.error("Failed to extract JSON:", err);
+              }
+            }
+            setIsLoading(false);
+            onReady?.();
+          },
+          onException: ({ error: err }) => {
+            console.error("SuperDoc error:", err);
+            handleError(err);
+            setIsLoading(false);
+          }
+        });
+        superdocRef.current = superdoc;
+      } catch (err) {
+        console.error("Failed to initialize SuperDoc:", err);
+        handleError(err instanceof Error ? err : new Error("Failed to load editor"));
+        setIsLoading(false);
+      }
+      initRef.current = false;
+    }, [
+      initialSource,
+      showRulers,
+      showToolbar,
+      templateDocx,
+      editorId,
+      toolbarId,
+      onReady,
+      onSourceLoaded,
+      getTemplateFile,
+      setEditorContent,
+      handleError
+    ]);
+    react.useEffect(() => {
+      mountedRef.current = true;
+      initialize();
+      return () => {
+        mountedRef.current = false;
+        if (superdocRef.current) {
+          try {
+            superdocRef.current.destroy?.();
+          } catch {
+          }
+          superdocRef.current = null;
+        }
+      };
+    }, [initialize]);
+    react.useImperativeHandle(
+      ref,
+      () => ({
+        /**
+         * Set the source/base document
+         */
+        async setSource(content) {
+          if (!SuperDocRef.current) {
+            throw new Error("Editor not initialized");
+          }
+          setIsLoading(true);
+          try {
+            const resolved = await resolveContent(content, SuperDocRef.current, templateDocx);
+            setSourceJson(resolved.json);
+            setMergedJson(null);
+            setDiffResult(null);
+            if (superdocRef.current?.activeEditor) {
+              setEditorContent(superdocRef.current.activeEditor, resolved.json);
+              setEditingMode(superdocRef.current);
+            }
+            onSourceLoaded?.(resolved.json);
+          } catch (err) {
+            handleError(err instanceof Error ? err : new Error("Failed to set source"));
+            throw err;
+          } finally {
+            setIsLoading(false);
+          }
+        },
+        /**
+         * Compare source with new content, show track changes
+         */
+        async compareWith(content) {
+          if (!SuperDocRef.current) {
+            throw new Error("Editor not initialized");
+          }
+          if (!sourceJson) {
+            throw new Error("No source document set. Call setSource() first.");
+          }
+          setIsLoading(true);
+          try {
+            const resolved = await resolveContent(content, SuperDocRef.current, templateDocx);
+            const diff = diffDocuments(sourceJson, resolved.json);
+            setDiffResult(diff);
+            const merged = mergeDocuments(sourceJson, resolved.json, diff, author);
+            setMergedJson(merged);
+            if (superdocRef.current?.activeEditor) {
+              setEditorContent(superdocRef.current.activeEditor, merged);
+              enableReviewMode(superdocRef.current);
+            }
+            const insertions = diff.segments.filter((s) => s.type === "insert").length;
+            const deletions = diff.segments.filter((s) => s.type === "delete").length;
+            const formatChanges = diff.formatChanges?.length || 0;
+            const result = {
+              totalChanges: insertions + deletions + formatChanges,
+              insertions,
+              deletions,
+              formatChanges,
+              summary: diff.summary,
+              mergedJson: merged
+            };
+            onComparisonComplete?.(result);
+            return result;
+          } catch (err) {
+            handleError(err instanceof Error ? err : new Error("Comparison failed"));
+            throw err;
+          } finally {
+            setIsLoading(false);
+          }
+        },
+        /**
+         * Get raw diff segments
+         */
+        getDiffSegments() {
+          return diffResult?.segments || [];
+        },
+        /**
+         * Get enriched changes with context for LLM processing
+         */
+        getEnrichedChangesContext() {
+          if (!mergedJson) return [];
+          return extractEnrichedChanges(mergedJson);
+        },
+        /**
+         * Get current document content as JSON
+         */
+        getContent() {
+          if (superdocRef.current?.activeEditor) {
+            return superdocRef.current.activeEditor.getJSON();
+          }
+          return mergedJson || sourceJson || { type: "doc", content: [] };
+        },
+        /**
+         * Get source document JSON (before comparison)
+         */
+        getSourceContent() {
+          return sourceJson;
+        },
+        /**
+         * Export current document to DOCX blob
+         */
+        async exportDocx() {
+          if (!superdocRef.current?.activeEditor) {
+            throw new Error("Editor not ready");
+          }
+          const blob = await superdocRef.current.activeEditor.exportDocx({
+            isFinalDoc: false
+          });
+          if (!blob) {
+            throw new Error("Export returned no data");
+          }
+          return blob;
+        },
+        /**
+         * Reset to source state (clear comparison)
+         */
+        resetComparison() {
+          if (sourceJson && superdocRef.current?.activeEditor) {
+            setEditorContent(superdocRef.current.activeEditor, sourceJson);
+            setEditingMode(superdocRef.current);
+            setMergedJson(null);
+            setDiffResult(null);
+          }
+        },
+        /**
+         * Check if editor is ready
+         */
+        isReady() {
+          return readyRef.current;
+        }
+      }),
+      [
+        sourceJson,
+        mergedJson,
+        diffResult,
+        templateDocx,
+        author,
+        setEditorContent,
+        enableReviewMode,
+        setEditingMode,
+        onSourceLoaded,
+        onComparisonComplete,
+        handleError
+      ]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `dde-container ${className}`.trim(), children: [
+      isLoading && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "dde-loading", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "dde-loading__spinner" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "dde-loading__text", children: "Loading document..." })
+      ] }),
+      error && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "dde-error", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "dde-error__icon", children: /* @__PURE__ */ jsxRuntime.jsx(
+          "svg",
+          {
+            className: "dde-error__svg",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: "2",
+                d: "M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
+              }
+            )
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "dde-error__title", children: "Failed to load document" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "dde-error__message", children: error })
+      ] }),
+      showToolbar && /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: toolbarRef,
+          className: `dde-toolbar ${toolbarClassName}`.trim()
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: containerRef,
+          className: `dde-editor ${editorClassName}`.trim()
+        }
+      )
+    ] });
+  }
+);
+var DocxDiffEditor_default = DocxDiffEditor;
+
+exports.CSS_PREFIX = CSS_PREFIX;
+exports.DEFAULT_AUTHOR = DEFAULT_AUTHOR;
+exports.DEFAULT_SUPERDOC_USER = DEFAULT_SUPERDOC_USER;
+exports.DocxDiffEditor = DocxDiffEditor;
+exports.createTrackDeleteMark = createTrackDeleteMark;
+exports.createTrackFormatMark = createTrackFormatMark;
+exports.createTrackInsertMark = createTrackInsertMark;
+exports.default = DocxDiffEditor_default;
+exports.detectContentType = detectContentType;
+exports.diffDocuments = diffDocuments;
+exports.extractEnrichedChanges = extractEnrichedChanges;
+exports.getBlankTemplateBlob = getBlankTemplateBlob;
+exports.getBlankTemplateFile = getBlankTemplateFile;
+exports.isProseMirrorJSON = isProseMirrorJSON;
+exports.isValidDocxFile = isValidDocxFile;
+exports.mergeDocuments = mergeDocuments;
+exports.parseDocxFile = parseDocxFile;
+exports.parseHtmlContent = parseHtmlContent;
+exports.resolveContent = resolveContent;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map