@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/compare/index.js

@@ -0,0 +1,731 @@
+import {
+  DOCX_DOCUMENT_CONTENT_TYPE,
+  DOCX_MIME_TYPE,
+  WORD_NUMBERING_CONTENT_TYPE,
+  createCommentExportIdMap,
+  createExportSession,
+  readOpcPackage,
+  serializeCommentAnchorsIntoDocumentXml,
+  serializeMainDocument,
+  serializeMergedCommentsXml,
+  serializeNumberingXml,
+  serializeRuntimeRevisionsIntoDocumentXml,
+  splitDocumentAtReviewBoundaries,
+  writeDocxPackage
+} from "../chunk-WGBAKP3Q.js";
+import "../chunk-FUDY333O.js";
+import {
+  createCommentStoreFromRuntimeComments
+} from "../chunk-2S7W4KFO.js";
+import "../chunk-SWKWQZXM.js";
+import {
+  createCanonicalDocumentSignature,
+  projectCanonicalDocument
+} from "../chunk-5FN54NDH.js";
+import "../chunk-EBI3BX6U.js";
+
+// src/compare/diff-engine.ts
+function compareDocumentSnapshots(base, target, options = {}) {
+  const comparedAt = options.comparedAt ?? target.createdAt;
+  const authorId = options.authorId ?? "Version Compare";
+  const baseDocument = base.canonicalDocument;
+  const targetDocument = target.canonicalDocument;
+  const baseBlocks = baseDocument.content.children;
+  const targetBlocks = targetDocument.content.children;
+  const matches = computeLcs(
+    baseBlocks.map(getComparableBlockKey),
+    targetBlocks.map(getComparableBlockKey)
+  );
+  const buildEntries = [];
+  const changes = [];
+  let nextBaseIndex = 0;
+  let nextTargetIndex = 0;
+  let nextChangeNumber = 1;
+  for (const match of [...matches, { baseIndex: baseBlocks.length, targetIndex: targetBlocks.length }]) {
+    while (nextBaseIndex < match.baseIndex || nextTargetIndex < match.targetIndex) {
+      const deleteBlock = nextBaseIndex < match.baseIndex ? baseBlocks[nextBaseIndex] : void 0;
+      const insertBlock = nextTargetIndex < match.targetIndex ? targetBlocks[nextTargetIndex] : void 0;
+      if (deleteBlock && insertBlock) {
+        if (deleteBlock.type === "paragraph" && insertBlock.type === "paragraph") {
+          const modificationId = `change-${nextChangeNumber}`;
+          nextChangeNumber += 1;
+          addParagraphModificationEntry(
+            buildEntries,
+            changes,
+            modificationId,
+            deleteBlock,
+            insertBlock,
+            nextTargetIndex
+          );
+          nextBaseIndex += 1;
+          nextTargetIndex += 1;
+          continue;
+        }
+        const deletionId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          deletionId,
+          deleteBlock,
+          "deletion",
+          nextTargetIndex
+        );
+        const insertionId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          insertionId,
+          insertBlock,
+          "insertion",
+          nextTargetIndex
+        );
+        nextBaseIndex += 1;
+        nextTargetIndex += 1;
+        continue;
+      }
+      if (deleteBlock) {
+        const changeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          changeId,
+          deleteBlock,
+          "deletion",
+          nextTargetIndex
+        );
+        nextBaseIndex += 1;
+        continue;
+      }
+      if (insertBlock) {
+        const changeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addTrackedOrStructuralEntry(
+          buildEntries,
+          changes,
+          changeId,
+          insertBlock,
+          "insertion",
+          nextTargetIndex
+        );
+        nextTargetIndex += 1;
+      }
+    }
+    if (match.baseIndex < baseBlocks.length && match.targetIndex < targetBlocks.length) {
+      const baseText = getBlockDisplayText(baseBlocks[match.baseIndex]);
+      const targetText = getBlockDisplayText(targetBlocks[match.targetIndex]);
+      const isModified = baseBlocks[match.baseIndex].type === "paragraph" && targetBlocks[match.targetIndex].type === "paragraph" && baseText !== targetText;
+      if (isModified) {
+        const modChangeId = `change-${nextChangeNumber}`;
+        nextChangeNumber += 1;
+        addParagraphModificationEntry(
+          buildEntries,
+          changes,
+          modChangeId,
+          baseBlocks[match.baseIndex],
+          targetBlocks[match.targetIndex],
+          match.targetIndex
+        );
+      } else {
+        buildEntries.push({
+          block: cloneBlock(targetBlocks[match.targetIndex]),
+          tracked: false,
+          blockType: targetBlocks[match.targetIndex].type,
+          beforeText: baseText,
+          afterText: targetText
+        });
+      }
+      nextBaseIndex = match.baseIndex + 1;
+      nextTargetIndex = match.targetIndex + 1;
+    }
+  }
+  const built = buildComparedDocument(baseDocument, targetDocument, buildEntries, comparedAt, authorId);
+  return {
+    compareVersion: "version-compare-result/1",
+    comparedAt,
+    base: {
+      versionId: base.versionId,
+      name: base.name,
+      signature: base.documentSignature
+    },
+    target: {
+      versionId: target.versionId,
+      name: target.name,
+      signature: target.documentSignature
+    },
+    changes,
+    comparedDocument: built
+  };
+}
+function addTrackedOrStructuralEntry(buildEntries, changes, changeId, block, direction, targetIndex) {
+  const tracked = block.type === "paragraph";
+  const cloned = cloneBlock(block);
+  const text = getBlockDisplayText(block);
+  buildEntries.push({
+    ...tracked ? { changeId } : {},
+    block: cloned,
+    ...tracked ? { trackChange: direction } : {},
+    tracked,
+    blockType: cloned.type,
+    ...direction === "deletion" ? { beforeText: text } : { afterText: text }
+  });
+  changes.push({
+    changeId,
+    kind: block.type === "paragraph" ? direction === "insertion" ? "paragraph-insertion" : "paragraph-deletion" : direction === "insertion" ? "structural-insertion" : "structural-deletion",
+    tracked,
+    blockType: cloned.type,
+    ...direction === "deletion" ? { beforeText: text } : { afterText: text },
+    targetIndex
+  });
+}
+function addParagraphModificationEntry(buildEntries, changes, changeId, baseParagraph, targetParagraph, targetIndex) {
+  const beforeText = getBlockDisplayText(baseParagraph);
+  const afterText = getBlockDisplayText(targetParagraph);
+  buildEntries.push({
+    changeId: `${changeId}-before`,
+    block: cloneBlock(baseParagraph),
+    trackChange: "deletion",
+    tracked: true,
+    blockType: "paragraph",
+    beforeText
+  });
+  buildEntries.push({
+    changeId: `${changeId}-after`,
+    block: cloneBlock(targetParagraph),
+    trackChange: "insertion",
+    tracked: true,
+    blockType: "paragraph",
+    afterText
+  });
+  changes.push({
+    changeId,
+    kind: "paragraph-modification",
+    tracked: true,
+    blockType: "paragraph",
+    beforeText,
+    afterText,
+    targetIndex
+  });
+}
+function buildComparedDocument(base, target, entries, comparedAt, authorId) {
+  const contentChildren = [];
+  const pendingRevisions = [];
+  const diagnosticsWarnings = [...target.diagnostics.warnings];
+  let paragraphIndex = 0;
+  let warningNumber = 1;
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (!entry) {
+      continue;
+    }
+    contentChildren.push(entry.block);
+    if (entry.block.type === "paragraph") {
+      if (entry.trackChange) {
+        pendingRevisions.push({
+          changeId: entry.changeId ?? `change-${pendingRevisions.length + 1}`,
+          kind: entry.trackChange,
+          paragraphIndex
+        });
+      }
+      paragraphIndex += 1;
+      continue;
+    }
+    if (!entry.tracked) {
+      diagnosticsWarnings.push({
+        diagnosticId: `diagnostic:compare-structural-${warningNumber}`,
+        warningId: `warning:compare-structural-${warningNumber}`,
+        source: "review",
+        message: `Version compare preserved a ${entry.blockType} ${entry.beforeText ? "deletion" : "insertion"} without a Word revision wrapper.`
+      });
+      warningNumber += 1;
+    }
+  }
+  const revisions = createParagraphRevisionRecords(
+    contentChildren,
+    pendingRevisions,
+    comparedAt,
+    authorId
+  );
+  return {
+    ...projectCanonicalDocument(target),
+    updatedAt: comparedAt,
+    styles: mergeStyleCatalogs(base.styles, target.styles),
+    numbering: mergeRecordCatalog(base.numbering, target.numbering),
+    media: mergeRecordCatalog(base.media, target.media),
+    content: {
+      type: "doc",
+      children: contentChildren
+    },
+    review: {
+      comments: projectValue(target.review.comments),
+      revisions
+    },
+    preservation: mergePreservationStores(base.preservation, target.preservation),
+    diagnostics: {
+      warnings: diagnosticsWarnings,
+      errors: [...target.diagnostics.errors]
+    },
+    ...target.subParts ?? base.subParts ? { subParts: projectValue(target.subParts ?? base.subParts) } : {}
+  };
+}
+function createParagraphRevisionRecords(children, pendingRevisions, createdAt, authorId) {
+  const positionByParagraphIndex = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  let paragraphIndex = 0;
+  let previousWasParagraph = false;
+  for (const block of children) {
+    if (block.type === "paragraph") {
+      if (previousWasParagraph) {
+        cursor += 1;
+      }
+      cursor += getParagraphLength(block);
+      positionByParagraphIndex.set(paragraphIndex, cursor);
+      paragraphIndex += 1;
+      previousWasParagraph = true;
+      continue;
+    }
+    cursor += 1;
+    previousWasParagraph = false;
+  }
+  const entries = [];
+  pendingRevisions.forEach((revision) => {
+    const position = positionByParagraphIndex.get(revision.paragraphIndex);
+    if (position === void 0) {
+      return;
+    }
+    const record = {
+      changeId: revision.changeId,
+      kind: revision.kind,
+      anchor: {
+        kind: "range",
+        range: { from: position, to: position },
+        assoc: { start: -1, end: 1 }
+      },
+      authorId,
+      createdAt,
+      status: "open",
+      warningIds: [],
+      metadata: {
+        source: "runtime",
+        importedRevisionForm: revision.kind === "insertion" ? "paragraph-insertion" : "paragraph-deletion"
+      }
+    };
+    entries.push([revision.changeId, record]);
+  });
+  return Object.fromEntries(entries);
+}
+function getComparableBlockKey(block) {
+  if (block.type === "paragraph") {
+    return `paragraph:${createCanonicalDocumentSignature({
+      ...block,
+      children: normalizeInlineChildren(block.children)
+    })}`;
+  }
+  return `${block.type}:${createCanonicalDocumentSignature(block)}`;
+}
+function normalizeInlineChildren(children) {
+  return children.map((child) => {
+    if (child.type === "hyperlink") {
+      return {
+        ...child,
+        children: normalizeInlineChildren(child.children)
+      };
+    }
+    if (child.type === "field") {
+      return {
+        ...child,
+        children: normalizeInlineChildren(child.children)
+      };
+    }
+    return projectValue(child);
+  });
+}
+function computeLcs(baseKeys, targetKeys) {
+  const widths = targetKeys.length + 1;
+  const matrix = Array.from(
+    { length: baseKeys.length + 1 },
+    () => Array.from({ length: widths }, () => 0)
+  );
+  for (let baseIndex2 = baseKeys.length - 1; baseIndex2 >= 0; baseIndex2 -= 1) {
+    for (let targetIndex2 = targetKeys.length - 1; targetIndex2 >= 0; targetIndex2 -= 1) {
+      matrix[baseIndex2][targetIndex2] = baseKeys[baseIndex2] === targetKeys[targetIndex2] ? matrix[baseIndex2 + 1][targetIndex2 + 1] + 1 : Math.max(matrix[baseIndex2 + 1][targetIndex2], matrix[baseIndex2][targetIndex2 + 1]);
+    }
+  }
+  const matches = [];
+  let baseIndex = 0;
+  let targetIndex = 0;
+  while (baseIndex < baseKeys.length && targetIndex < targetKeys.length) {
+    if (baseKeys[baseIndex] === targetKeys[targetIndex]) {
+      matches.push({ baseIndex, targetIndex });
+      baseIndex += 1;
+      targetIndex += 1;
+      continue;
+    }
+    if (matrix[baseIndex + 1][targetIndex] >= matrix[baseIndex][targetIndex + 1]) {
+      baseIndex += 1;
+    } else {
+      targetIndex += 1;
+    }
+  }
+  return matches;
+}
+function getParagraphLength(paragraph) {
+  return paragraph.children.reduce((length, child) => length + getInlineLength(child), 0);
+}
+function getInlineLength(node) {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "hyperlink":
+      return node.children.reduce((length, child) => length + getInlineLength(child), 0);
+    case "field":
+      return node.children.reduce((length, child) => length + getInlineLength(child), 0);
+    case "tab":
+    case "hard_break":
+    case "column_break":
+    case "symbol":
+    case "image":
+    case "opaque_inline":
+    case "footnote_ref":
+    case "bookmark_start":
+    case "bookmark_end":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      return 1;
+  }
+}
+function getBlockDisplayText(block) {
+  switch (block.type) {
+    case "paragraph":
+      return block.children.map(getInlineDisplayText).join("");
+    case "table":
+      return "[Table]";
+    case "sdt":
+      return "[Structured content]";
+    case "custom_xml":
+      return "[Custom XML block]";
+    case "alt_chunk":
+      return "[Alt chunk]";
+    case "section_break":
+      return "[Section break]";
+    case "opaque_block":
+      return "[Preserved block]";
+  }
+}
+function getInlineDisplayText(node) {
+  switch (node.type) {
+    case "text":
+      return node.text;
+    case "tab":
+      return "	";
+    case "hard_break":
+    case "column_break":
+      return "\n";
+    case "symbol":
+      return node.char;
+    case "hyperlink":
+      return node.children.map(getInlineDisplayText).join("");
+    case "field":
+      return node.children.map(getInlineDisplayText).join("");
+    case "image":
+      return node.altText ?? "[Image]";
+    case "opaque_inline":
+      return "[Preserved]";
+    case "footnote_ref":
+      return "[Footnote]";
+    case "bookmark_start":
+    case "bookmark_end":
+      return "";
+    case "chart_preview":
+      return "[Chart]";
+    case "smartart_preview":
+      return "[SmartArt]";
+    case "shape":
+      return node.text ?? "[Shape]";
+    case "wordart":
+      return node.text;
+    case "vml_shape":
+      return node.text ?? "[VML Shape]";
+  }
+}
+function mergeStyleCatalogs(base, target) {
+  return {
+    paragraphs: { ...base.paragraphs, ...target.paragraphs },
+    characters: { ...base.characters, ...target.characters },
+    tables: { ...base.tables, ...target.tables },
+    ...base.latentStyles || target.latentStyles ? { latentStyles: { ...base.latentStyles ?? {}, ...target.latentStyles ?? {} } } : {}
+  };
+}
+function mergePreservationStores(base, target) {
+  return {
+    opaqueFragments: {
+      ...base.opaqueFragments,
+      ...target.opaqueFragments
+    },
+    packageParts: {
+      ...base.packageParts,
+      ...target.packageParts
+    }
+  };
+}
+function mergeRecordCatalog(base, target) {
+  return projectValue({ ...base, ...target });
+}
+function cloneBlock(block) {
+  return projectValue(block);
+}
+function projectValue(value) {
+  return structuredClone(value);
+}
+
+// src/compare/export-redlines.ts
+var MAIN_DOCUMENT_PATH = "/word/document.xml";
+var NUMBERING_PART_PATH = "/word/numbering.xml";
+var COMMENTS_PART_PATH = "/word/comments.xml";
+var COMMENTS_EXTENDED_PART_PATH = "/word/commentsExtended.xml";
+var COMMENTS_IDS_PART_PATH = "/word/commentsIds.xml";
+var PEOPLE_PART_PATH = "/word/people.xml";
+var NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+var COMMENTS_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+var COMMENTS_EXTENDED_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
+var COMMENTS_IDS_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds";
+var PEOPLE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/office/2011/relationships/people";
+var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
+var COMMENTS_IDS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml";
+var PEOPLE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml";
+function exportComparedDocumentRedlines(result, options = {}) {
+  const sourcePackage = options.sourcePackage ?? readOpcPackage(
+    writeDocxPackage({
+      documentXml: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p/><w:sectPr/></w:body></w:document>`
+    })
+  );
+  const existingRelationships = sourcePackage.parts.get(MAIN_DOCUMENT_PATH)?.relationships ?? [];
+  const commentThreads = Object.values(
+    createCommentStoreFromRuntimeComments(result.comparedDocument.review.comments).threads
+  );
+  const actionableRevisions = toReviewRevisionRecords(result.comparedDocument.review.revisions);
+  const serialized = serializeMainDocument(
+    splitDocumentAtReviewBoundaries(
+      result.comparedDocument.content,
+      commentThreads,
+      actionableRevisions
+    ),
+    result.comparedDocument.preservation,
+    existingRelationships,
+    {
+      media: result.comparedDocument.media
+    }
+  );
+  const revisionDocument = serializeRuntimeRevisionsIntoDocumentXml(
+    serialized.documentXml,
+    actionableRevisions,
+    serialized.paragraphBoundaries
+  );
+  if (revisionDocument.skippedRevisionIds.length > 0) {
+    throw new Error(
+      `Compare export skipped ${revisionDocument.skippedRevisionIds.length} revision markers.`
+    );
+  }
+  const exportCommentIds = createCommentExportIdMap(commentThreads);
+  const serializedComments = serializeMergedCommentsXml(commentThreads, {
+    exportCommentIds
+  });
+  const annotatedDocument = serializeCommentAnchorsIntoDocumentXml(
+    revisionDocument.documentXml,
+    commentThreads,
+    void 0,
+    {
+      exportCommentIds
+    }
+  );
+  if (annotatedDocument.skippedCommentIds.length > 0) {
+    throw new Error(
+      `Compare export skipped ${annotatedDocument.skippedCommentIds.length} comment anchors.`
+    );
+  }
+  const numberingXml = hasNumberingEntries(result.comparedDocument.numbering) ? serializeNumberingXml(result.comparedDocument.numbering) : void 0;
+  const relationships = withOptionalRelatedPart(
+    withOptionalRelatedPart(
+      withOptionalRelatedPart(
+        withOptionalRelatedPart(
+          withOptionalRelatedPart(
+            serialized.relationships,
+            existingRelationships,
+            NUMBERING_RELATIONSHIP_TYPE,
+            "numbering.xml",
+            Boolean(numberingXml)
+          ),
+          existingRelationships,
+          COMMENTS_RELATIONSHIP_TYPE,
+          "comments.xml",
+          serializedComments.serializedCommentIds.length > 0
+        ),
+        existingRelationships,
+        COMMENTS_EXTENDED_RELATIONSHIP_TYPE,
+        "commentsExtended.xml",
+        Boolean(serializedComments.commentsExtendedXml)
+      ),
+      existingRelationships,
+      COMMENTS_IDS_RELATIONSHIP_TYPE,
+      "commentsIds.xml",
+      Boolean(serializedComments.commentsIdsXml)
+    ),
+    existingRelationships,
+    PEOPLE_RELATIONSHIP_TYPE,
+    "people.xml",
+    Boolean(serializedComments.peopleXml)
+  );
+  const exportSession = createExportSession(sourcePackage, [
+    MAIN_DOCUMENT_PATH,
+    ...numberingXml ? [NUMBERING_PART_PATH] : [],
+    ...serializedComments.serializedCommentIds.length > 0 ? [COMMENTS_PART_PATH] : [],
+    ...serializedComments.commentsExtendedXml ? [COMMENTS_EXTENDED_PART_PATH] : [],
+    ...serializedComments.commentsIdsXml ? [COMMENTS_IDS_PART_PATH] : [],
+    ...serializedComments.peopleXml ? [PEOPLE_PART_PATH] : []
+  ]);
+  exportSession.replaceOwnedPart({
+    path: MAIN_DOCUMENT_PATH,
+    bytes: new TextEncoder().encode(annotatedDocument.documentXml),
+    contentType: DOCX_DOCUMENT_CONTENT_TYPE,
+    relationships
+  });
+  if (numberingXml) {
+    exportSession.replaceOwnedPart({
+      path: NUMBERING_PART_PATH,
+      bytes: new TextEncoder().encode(numberingXml),
+      contentType: sourcePackage.parts.get(NUMBERING_PART_PATH)?.contentType ?? WORD_NUMBERING_CONTENT_TYPE
+    });
+  }
+  if (serializedComments.serializedCommentIds.length > 0) {
+    exportSession.replaceOwnedPart({
+      path: COMMENTS_PART_PATH,
+      bytes: new TextEncoder().encode(serializedComments.commentsXml),
+      contentType: sourcePackage.parts.get(COMMENTS_PART_PATH)?.contentType ?? COMMENTS_CONTENT_TYPE
+    });
+  }
+  if (serializedComments.commentsExtendedXml) {
+    exportSession.replaceOwnedPart({
+      path: COMMENTS_EXTENDED_PART_PATH,
+      bytes: new TextEncoder().encode(serializedComments.commentsExtendedXml),
+      contentType: sourcePackage.parts.get(COMMENTS_EXTENDED_PART_PATH)?.contentType ?? COMMENTS_EXTENDED_CONTENT_TYPE
+    });
+  }
+  if (serializedComments.commentsIdsXml) {
+    exportSession.replaceOwnedPart({
+      path: COMMENTS_IDS_PART_PATH,
+      bytes: new TextEncoder().encode(serializedComments.commentsIdsXml),
+      contentType: sourcePackage.parts.get(COMMENTS_IDS_PART_PATH)?.contentType ?? COMMENTS_IDS_CONTENT_TYPE
+    });
+  }
+  if (serializedComments.peopleXml) {
+    exportSession.replaceOwnedPart({
+      path: PEOPLE_PART_PATH,
+      bytes: new TextEncoder().encode(serializedComments.peopleXml),
+      contentType: sourcePackage.parts.get(PEOPLE_PART_PATH)?.contentType ?? PEOPLE_CONTENT_TYPE
+    });
+  }
+  return {
+    bytes: exportSession.serialize(),
+    mimeType: DOCX_MIME_TYPE,
+    fileName: options.fileName ?? `${result.target.name}-compared.docx`
+  };
+}
+function toReviewRevisionRecords(revisions) {
+  return Object.values(revisions).map((revision) => ({
+    revisionId: revision.changeId,
+    kind: revision.kind,
+    anchor: revision.anchor,
+    authorId: revision.authorId ?? "Version Compare",
+    createdAt: revision.createdAt,
+    warningIds: [...revision.warningIds ?? []],
+    metadata: {
+      source: revision.metadata?.source ?? "runtime",
+      preserveOnlyReason: revision.metadata?.preserveOnlyReason,
+      importedRevisionForm: revision.metadata?.importedRevisionForm,
+      originalRevisionType: revision.metadata?.originalRevisionType,
+      ooxmlRevisionId: revision.metadata?.ooxmlRevisionId
+    },
+    status: revision.status === "open" ? "active" : revision.status
+  }));
+}
+function hasNumberingEntries(numbering) {
+  return Object.keys(numbering.abstractDefinitions).length > 0 || Object.keys(numbering.instances).length > 0;
+}
+function withOptionalRelatedPart(relationships, existingRelationships, relationshipType, target, includePart) {
+  const next = relationships.map((relationship) => ({ ...relationship }));
+  if (!includePart) {
+    return next;
+  }
+  const existing = next.find((relationship) => relationship.type === relationshipType);
+  if (existing) {
+    return next;
+  }
+  const fallbackId = existingRelationships.find((relationship) => relationship.type === relationshipType)?.id ?? `rId${next.length + 1}`;
+  next.push({
+    id: fallbackId,
+    type: relationshipType,
+    target,
+    targetMode: "internal"
+  });
+  return next;
+}
+
+// src/compare/snapshot.ts
+function createDocumentVersionSnapshotId(document, name) {
+  return `${document.docId}:${name}`;
+}
+function createDocumentVersionSnapshot(document, options) {
+  const canonicalDocument = projectCanonicalDocument(document);
+  return {
+    snapshotVersion: "document-version-snapshot/1",
+    versionId: options.versionId ?? createDocumentVersionSnapshotId(canonicalDocument, options.name),
+    name: options.name,
+    createdAt: options.createdAt ?? canonicalDocument.updatedAt,
+    documentId: canonicalDocument.docId,
+    documentSignature: createCanonicalDocumentSignature(canonicalDocument),
+    canonicalDocument
+  };
+}
+function saveDocumentVersionSnapshot(snapshots, snapshot) {
+  const next = snapshots.filter((entry) => entry.versionId !== snapshot.versionId);
+  next.push(snapshot);
+  return next.sort(compareDocumentVersionSnapshots);
+}
+function buildVersionAuditTrail(snapshots) {
+  return snapshots.map((snapshot) => ({
+    versionId: snapshot.versionId,
+    name: snapshot.name,
+    createdAt: snapshot.createdAt,
+    documentSignature: snapshot.documentSignature,
+    action: "created"
+  }));
+}
+function lockDocumentVersionSnapshot(snapshot) {
+  return {
+    ...snapshot,
+    name: snapshot.name.startsWith("[locked] ") ? snapshot.name : `[locked] ${snapshot.name}`
+  };
+}
+function compareDocumentVersionSnapshots(left, right) {
+  const createdAtComparison = right.createdAt.localeCompare(left.createdAt);
+  if (createdAtComparison !== 0) {
+    return createdAtComparison;
+  }
+  return left.versionId.localeCompare(right.versionId);
+}
+export {
+  buildVersionAuditTrail,
+  compareDocumentSnapshots,
+  createDocumentVersionSnapshot,
+  createDocumentVersionSnapshotId,
+  exportComparedDocumentRedlines,
+  lockDocumentVersionSnapshot,
+  saveDocumentVersionSnapshot
+};
+//# sourceMappingURL=index.js.map