@json-to-office/shared-docx 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   generateUnifiedDocumentSchema
-} from "./chunk-25SAKHVN.js";
+} from "./chunk-PQGT7BU5.js";
 import {
   DOC_LINKS,
   ERROR_TEMPLATES,
@@ -32,21 +32,21 @@ import {
   validateTheme,
   validateThemeJson,
   validateThemeWithEnhancement
-} from "./chunk-ANU2V2BM.js";
+} from "./chunk-HJIS6RRQ.js";
 import {
   ThemeConfigSchema,
   isValidThemeConfig
-} from "./chunk-YK2UUG65.js";
+} from "./chunk-X2B5OVWA.js";
 import {
   GenerateDocumentRequestSchema,
   GenerateDocumentResponseSchema,
   ValidateDocumentRequestSchema,
   ValidateDocumentResponseSchema
-} from "./chunk-IHZIO72A.js";
+} from "./chunk-QUA2GDH7.js";
 import {
   JSON_SCHEMA_URLS,
   JsonComponentDefinitionSchema
-} from "./chunk-VBZC5WT6.js";
+} from "./chunk-FA6FKO3L.js";
 import {
   comprehensiveValidateDocument,
   createDocumentValidator,
@@ -68,11 +68,11 @@ import {
   validateJsonComponent,
   validateJsonDocument,
   validateWithEnhancement
-} from "./chunk-7LRSVYGN.js";
+} from "./chunk-5BKZFYJL.js";
 import {
   ComponentDefinitionSchema,
   StandardComponentDefinitionSchema
-} from "./chunk-ZQNAWKEI.js";
+} from "./chunk-52PV5JQK.js";
 import {
   CustomComponentDefinitionSchema,
   TextSpaceAfterComponentSchema,
@@ -86,13 +86,13 @@ import {
   createComponentSchema,
   exportSchemaToFile,
   fixSchemaReferences
-} from "./chunk-CIBMJ7QA.js";
+} from "./chunk-6IXK54YE.js";
 import {
   HighchartsPropsSchema,
   ReportPropsSchema,
   TextBoxPropsSchema,
   TocPropsSchema
-} from "./chunk-BFJJ5HYD.js";
+} from "./chunk-CY6IVMEZ.js";
 import {
   AlignmentSchema,
   BaseComponentPropsSchema,
@@ -108,13 +108,686 @@ import {
   MarginsSchema,
   NumberingSchema,
   ParagraphPropsSchema,
+  RevisionSchema,
+  RevisionSegmentSchema,
   SectionPropsSchema,
   SpacingSchema,
   StatisticPropsSchema,
   TablePropsSchema
-} from "./chunk-YUV5CJMG.js";
+} from "./chunk-CGMJ665Z.js";
 import "./chunk-H56RLQOF.js";
 
+// src/diff/word-diff.ts
+var MAX_LCS_CELLS = 1e6;
+function tokenizeWords(text) {
+  if (!text) return [];
+  return text.split(/(\s+)/).filter((t) => t.length > 0);
+}
+function mergeSegments(segments) {
+  const merged = [];
+  for (const seg of segments) {
+    if (!seg.text) continue;
+    const last = merged[merged.length - 1];
+    if (last && last.type === seg.type) {
+      last.text += seg.text;
+    } else {
+      merged.push({ ...seg });
+    }
+  }
+  return merged;
+}
+function normalizeSegments(segments) {
+  const folded = [];
+  for (let k2 = 0; k2 < segments.length; k2++) {
+    const seg = segments[k2];
+    if (seg.type === "equal" && /^\s+$/.test(seg.text)) {
+      const prev = folded[folded.length - 1];
+      const next = segments[k2 + 1];
+      if (prev && prev.type !== "equal" && next && next.type !== "equal") {
+        folded.push(
+          { type: "delete", text: seg.text },
+          { type: "insert", text: seg.text }
+        );
+        continue;
+      }
+    }
+    folded.push({ ...seg });
+  }
+  const out = [];
+  let k = 0;
+  while (k < folded.length) {
+    if (folded[k].type === "equal") {
+      out.push(folded[k]);
+      k++;
+      continue;
+    }
+    let deleted = "";
+    let inserted = "";
+    while (k < folded.length && folded[k].type !== "equal") {
+      if (folded[k].type === "delete") deleted += folded[k].text;
+      else inserted += folded[k].text;
+      k++;
+    }
+    if (deleted) out.push({ type: "delete", text: deleted });
+    if (inserted) out.push({ type: "insert", text: inserted });
+  }
+  return mergeSegments(out);
+}
+function diffWords(oldText, newText) {
+  if (oldText === newText) {
+    return oldText ? [{ type: "equal", text: oldText }] : [];
+  }
+  const oldTokens = tokenizeWords(oldText);
+  const newTokens = tokenizeWords(newText);
+  if (oldTokens.length === 0) {
+    return mergeSegments([{ type: "insert", text: newText }]);
+  }
+  if (newTokens.length === 0) {
+    return mergeSegments([{ type: "delete", text: oldText }]);
+  }
+  if (oldTokens.length * newTokens.length > MAX_LCS_CELLS) {
+    return mergeSegments([
+      { type: "delete", text: oldText },
+      { type: "insert", text: newText }
+    ]);
+  }
+  const n = oldTokens.length;
+  const m = newTokens.length;
+  const lcs = Array.from(
+    { length: n + 1 },
+    () => new Int32Array(m + 1)
+  );
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = oldTokens[i2] === newTokens[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const segments = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (oldTokens[i] === newTokens[j]) {
+      segments.push({ type: "equal", text: oldTokens[i] });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      segments.push({ type: "delete", text: oldTokens[i] });
+      i++;
+    } else {
+      segments.push({ type: "insert", text: newTokens[j] });
+      j++;
+    }
+  }
+  while (i < n) {
+    segments.push({ type: "delete", text: oldTokens[i] });
+    i++;
+  }
+  while (j < m) {
+    segments.push({ type: "insert", text: newTokens[j] });
+    j++;
+  }
+  return normalizeSegments(segments);
+}
+function stripMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(
+    /(\*\*\*|___)([\s\S]*?)\1|(\*\*|__)([\s\S]*?)\3|(\*|_)([\s\S]*?)\5/g,
+    (_match, _d1, bi, _d2, b, _d3, i) => bi ?? b ?? i ?? ""
+  );
+}
+
+// src/diff/document-diff.ts
+var TEXT_COMPONENTS = /* @__PURE__ */ new Set(["paragraph", "heading"]);
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function makeRevision(ctx, segments) {
+  return {
+    ...ctx.author && { author: ctx.author },
+    ...ctx.date && { date: ctx.date },
+    segments
+  };
+}
+function rawText(node) {
+  const text = node.props?.text;
+  return typeof text === "string" ? text.normalize("NFC") : "";
+}
+function plainText(node) {
+  return stripMarkdown(rawText(node));
+}
+var PLACEHOLDER_PATTERN = /\{[^}]+\}/;
+function isEnabled(node) {
+  return node.enabled !== false;
+}
+function notePlaceholdersInChanges(segments, path, component, ctx) {
+  if (segments.some((s) => s.type !== "equal" && PLACEHOLDER_PATTERN.test(s.text))) {
+    ctx.summary.untracked.push({
+      path,
+      kind: "modified",
+      component,
+      detail: "placeholder (e.g. {DATE}) inside inserted/deleted text renders literally in the redline"
+    });
+  }
+}
+function propsWithout(props, ...keys) {
+  const copy = { ...props || {} };
+  for (const key of keys) delete copy[key];
+  return copy;
+}
+var MAX_ALIGN_CELLS = 4e6;
+function alignByLcs(oldItems, newItems, key) {
+  const oldKeys = oldItems.map(key);
+  const newKeys = newItems.map(key);
+  let start = 0;
+  while (start < oldItems.length && start < newItems.length && oldKeys[start] === newKeys[start]) {
+    start++;
+  }
+  let oldEnd = oldItems.length;
+  let newEnd = newItems.length;
+  while (oldEnd > start && newEnd > start && oldKeys[oldEnd - 1] === newKeys[newEnd - 1]) {
+    oldEnd--;
+    newEnd--;
+  }
+  const prefix = [];
+  for (let k = 0; k < start; k++) {
+    prefix.push({ op: "equal", oldItem: oldItems[k], newItem: newItems[k] });
+  }
+  const suffix = [];
+  for (let k = 0; k < oldItems.length - oldEnd; k++) {
+    suffix.push({
+      op: "equal",
+      oldItem: oldItems[oldEnd + k],
+      newItem: newItems[newEnd + k]
+    });
+  }
+  const n = oldEnd - start;
+  const m = newEnd - start;
+  const middle = [];
+  if (n * m > MAX_ALIGN_CELLS) {
+    for (let k = 0; k < n; k++) {
+      middle.push({ op: "delete", oldItem: oldItems[start + k] });
+    }
+    for (let k = 0; k < m; k++) {
+      middle.push({ op: "insert", newItem: newItems[start + k] });
+    }
+    return [...prefix, ...middle, ...suffix];
+  }
+  const lcs = Array.from(
+    { length: n + 1 },
+    () => new Int32Array(m + 1)
+  );
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = oldKeys[start + i2] === newKeys[start + j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (oldKeys[start + i] === newKeys[start + j]) {
+      middle.push({
+        op: "equal",
+        oldItem: oldItems[start + i],
+        newItem: newItems[start + j]
+      });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      middle.push({ op: "delete", oldItem: oldItems[start + i] });
+      i++;
+    } else {
+      middle.push({ op: "insert", newItem: newItems[start + j] });
+      j++;
+    }
+  }
+  while (i < n) middle.push({ op: "delete", oldItem: oldItems[start + i++] });
+  while (j < m) middle.push({ op: "insert", newItem: newItems[start + j++] });
+  return [...prefix, ...middle, ...suffix];
+}
+function pairGap(deleted, inserted, pairable) {
+  const usedOld = new Array(deleted.length).fill(false);
+  const pairing = new Array(inserted.length).fill(-1);
+  let searchFrom = 0;
+  for (let j = 0; j < inserted.length; j++) {
+    for (let i = searchFrom; i < deleted.length; i++) {
+      if (!usedOld[i] && pairable(deleted[i], inserted[j])) {
+        usedOld[i] = true;
+        pairing[j] = i;
+        searchFrom = i + 1;
+        break;
+      }
+    }
+  }
+  const plan = [];
+  const pairs = [];
+  let emittedOld = 0;
+  for (let j = 0; j < inserted.length; j++) {
+    const i = pairing[j];
+    if (i >= 0) {
+      while (emittedOld < i) {
+        if (!usedOld[emittedOld]) {
+          plan.push({ kind: "deleted", oldItem: deleted[emittedOld] });
+        }
+        emittedOld++;
+      }
+      emittedOld = i + 1;
+      plan.push({ kind: "paired", oldItem: deleted[i], newItem: inserted[j] });
+      pairs.push({ oldItem: deleted[i], newItem: inserted[j] });
+    } else {
+      plan.push({ kind: "inserted", newItem: inserted[j] });
+    }
+  }
+  for (let i = emittedOld; i < deleted.length; i++) {
+    if (!usedOld[i]) plan.push({ kind: "deleted", oldItem: deleted[i] });
+  }
+  return { pairs, plan };
+}
+function diffTextComponent(oldNode, newNode, path, ctx) {
+  const oldText = plainText(oldNode);
+  const newText = plainText(newNode);
+  const propsChanged = !deepEqual(
+    propsWithout(oldNode.props, "text", "revision"),
+    propsWithout(newNode.props, "text", "revision")
+  );
+  if (propsChanged) {
+    ctx.summary.untracked.push({
+      path,
+      kind: "modified",
+      component: newNode.name,
+      detail: "formatting/props changed (not expressible as a tracked change); new version rendered"
+    });
+  }
+  if (oldText === newText) {
+    if (rawText(oldNode) !== rawText(newNode)) {
+      ctx.summary.untracked.push({
+        path,
+        kind: "modified",
+        component: newNode.name,
+        detail: "inline formatting or link target changed (markdown-only); new version rendered without a tracked change"
+      });
+    } else if (!propsChanged) {
+      ctx.summary.unchangedBlocks++;
+    }
+    return newNode;
+  }
+  ctx.summary.tracked.modified++;
+  const segments = diffWords(oldText, newText);
+  notePlaceholdersInChanges(segments, path, newNode.name, ctx);
+  if (rawText(oldNode) !== oldText || rawText(newNode) !== newText) {
+    ctx.summary.untracked.push({
+      path,
+      kind: "modified",
+      component: newNode.name,
+      detail: "inline formatting or links flattened to plain text in the redline (revision segments render literally)"
+    });
+  }
+  return {
+    ...newNode,
+    props: {
+      ...newNode.props,
+      text: newText,
+      revision: makeRevision(ctx, segments)
+    }
+  };
+}
+function insertedTextComponent(node, path, ctx) {
+  ctx.summary.tracked.inserted++;
+  const text = plainText(node);
+  const segments = [{ type: "insert", text }];
+  notePlaceholdersInChanges(segments, path, node.name, ctx);
+  return {
+    ...node,
+    props: {
+      ...node.props,
+      text,
+      revision: makeRevision(ctx, segments)
+    }
+  };
+}
+function deletedTextComponent(node, path, ctx) {
+  ctx.summary.tracked.deleted++;
+  const text = plainText(node);
+  const segments = [{ type: "delete", text }];
+  notePlaceholdersInChanges(segments, path, node.name, ctx);
+  return {
+    ...node,
+    props: {
+      ...node.props,
+      text: "",
+      revision: makeRevision(ctx, segments)
+    }
+  };
+}
+function normalizeListItems(node) {
+  const items = node.props?.items || [];
+  return items.map((item) => {
+    const raw = typeof item === "string" ? item : item.text;
+    const level = typeof item === "string" ? 0 : item.level || 0;
+    return { raw, text: stripMarkdown(raw.normalize("NFC")), level };
+  });
+}
+function diffListComponent(oldNode, newNode, path, ctx) {
+  const propsChanged = !deepEqual(
+    propsWithout(oldNode.props, "items"),
+    propsWithout(newNode.props, "items")
+  );
+  if (propsChanged) {
+    ctx.summary.untracked.push({
+      path,
+      kind: "modified",
+      component: "list",
+      detail: "list configuration changed (format/levels/spacing); new version rendered"
+    });
+  }
+  const oldItems = normalizeListItems(oldNode);
+  const newItems = normalizeListItems(newNode);
+  const stripped = (items) => items.map((i) => ({ text: i.text, level: i.level }));
+  if (deepEqual(stripped(oldItems), stripped(newItems))) {
+    if (!deepEqual(
+      oldItems.map((i) => i.raw),
+      newItems.map((i) => i.raw)
+    )) {
+      ctx.summary.untracked.push({
+        path,
+        kind: "modified",
+        component: "list",
+        detail: "inline formatting or link target changed in list items (markdown-only); new version rendered without a tracked change"
+      });
+    } else if (!propsChanged) {
+      ctx.summary.unchangedBlocks++;
+    }
+    return newNode;
+  }
+  const ops = alignByLcs(
+    oldItems,
+    newItems,
+    (item) => `${item.level}:${item.text}`
+  );
+  const outItems = [];
+  let changed = false;
+  let k = 0;
+  while (k < ops.length) {
+    const op = ops[k];
+    if (op.op === "equal") {
+      outItems.push({ text: op.newItem.raw, level: op.newItem.level });
+      k++;
+      continue;
+    }
+    const deleted = [];
+    const inserted = [];
+    while (k < ops.length && ops[k].op !== "equal") {
+      const gapOp = ops[k];
+      if (gapOp.op === "delete") deleted.push(gapOp.oldItem);
+      else if (gapOp.op === "insert") inserted.push(gapOp.newItem);
+      k++;
+    }
+    const { plan } = pairGap(
+      deleted,
+      inserted,
+      (oldItem, newItem) => oldItem.level === newItem.level
+    );
+    for (const step of plan) {
+      changed = true;
+      if (step.kind === "paired") {
+        const segments = diffWords(step.oldItem.text, step.newItem.text);
+        notePlaceholdersInChanges(segments, path, "list", ctx);
+        outItems.push({
+          text: step.newItem.text,
+          level: step.newItem.level,
+          revision: makeRevision(ctx, segments)
+        });
+      } else if (step.kind === "inserted") {
+        outItems.push({
+          text: step.newItem.text,
+          level: step.newItem.level,
+          revision: makeRevision(ctx, [
+            { type: "insert", text: step.newItem.text }
+          ])
+        });
+      } else {
+        outItems.push({
+          text: "",
+          level: step.oldItem.level,
+          revision: makeRevision(ctx, [
+            { type: "delete", text: step.oldItem.text }
+          ])
+        });
+      }
+    }
+  }
+  if (changed) ctx.summary.tracked.modified++;
+  return {
+    ...newNode,
+    props: { ...newNode.props, items: outItems }
+  };
+}
+function listWithAllItems(node, type, ctx) {
+  if (type === "insert") ctx.summary.tracked.inserted++;
+  else ctx.summary.tracked.deleted++;
+  const items = normalizeListItems(node).map((item) => ({
+    text: type === "insert" ? item.text : "",
+    level: item.level,
+    revision: makeRevision(ctx, [{ type, text: item.text }])
+  }));
+  return { ...node, props: { ...node.props, items } };
+}
+function isContainer(node) {
+  return Array.isArray(node.children);
+}
+function nodesPairable(oldNode, newNode) {
+  return oldNode.name === newNode.name;
+}
+function diffPairedNode(oldNode, newNode, path, ctx) {
+  const oldEnabled = isEnabled(oldNode);
+  const newEnabled = isEnabled(newNode);
+  if (!oldEnabled && !newEnabled) {
+    ctx.summary.unchangedBlocks++;
+    return newNode;
+  }
+  if (!oldEnabled && newEnabled) {
+    return emitInserted(newNode, path, ctx);
+  }
+  if (oldEnabled && !newEnabled) {
+    const deletedNode = emitDeleted(oldNode, path, ctx);
+    return deletedNode ?? newNode;
+  }
+  if (TEXT_COMPONENTS.has(newNode.name)) {
+    return diffTextComponent(oldNode, newNode, path, ctx);
+  }
+  if (newNode.name === "list") {
+    return diffListComponent(oldNode, newNode, path, ctx);
+  }
+  if (isContainer(newNode) || isContainer(oldNode)) {
+    const propsChanged = !deepEqual(oldNode.props, newNode.props);
+    if (propsChanged) {
+      ctx.summary.untracked.push({
+        path,
+        kind: "modified",
+        component: newNode.name,
+        detail: "container props changed; new version rendered"
+      });
+    }
+    return {
+      ...newNode,
+      children: diffChildren(
+        oldNode.children || [],
+        newNode.children || [],
+        `${path}/children`,
+        ctx
+      )
+    };
+  }
+  ctx.summary.untracked.push({
+    path,
+    kind: "modified",
+    component: newNode.name,
+    detail: `"${newNode.name}" changed (no native tracked-change support); new version rendered`
+  });
+  return newNode;
+}
+function emitInserted(node, path, ctx) {
+  if (!isEnabled(node)) {
+    return node;
+  }
+  if (TEXT_COMPONENTS.has(node.name)) {
+    return insertedTextComponent(node, path, ctx);
+  }
+  if (node.name === "list") {
+    return listWithAllItems(node, "insert", ctx);
+  }
+  if (isContainer(node)) {
+    if (typeof node.props?.title === "string") {
+      ctx.summary.untracked.push({
+        path,
+        kind: "inserted",
+        component: node.name,
+        detail: `"${node.name}" title rendered without insertion mark (titles are props, not text blocks)`
+      });
+    }
+    return {
+      ...node,
+      children: diffChildren([], node.children || [], `${path}/children`, ctx)
+    };
+  }
+  ctx.summary.untracked.push({
+    path,
+    kind: "inserted",
+    component: node.name,
+    detail: `"${node.name}" added (rendered, but not marked as a tracked insertion)`
+  });
+  return node;
+}
+function emitDeleted(node, path, ctx) {
+  if (!isEnabled(node)) {
+    return null;
+  }
+  if (TEXT_COMPONENTS.has(node.name)) {
+    return deletedTextComponent(node, path, ctx);
+  }
+  if (node.name === "list") {
+    return listWithAllItems(node, "delete", ctx);
+  }
+  if (isContainer(node)) {
+    if (typeof node.props?.title === "string") {
+      ctx.summary.untracked.push({
+        path,
+        kind: "deleted",
+        component: node.name,
+        detail: `"${node.name}" title still rendered without deletion mark (titles are props, not text blocks)`
+      });
+    }
+    const children = diffChildren(
+      node.children || [],
+      [],
+      `${path}/children`,
+      ctx
+    );
+    return { ...node, children };
+  }
+  ctx.summary.untracked.push({
+    path,
+    kind: "deleted",
+    component: node.name,
+    detail: `"${node.name}" removed (dropped from the redline; Word cannot mark it as a tracked deletion)`
+  });
+  return null;
+}
+function diffChildren(oldChildren, newChildren, path, ctx) {
+  const ops = alignByLcs(
+    oldChildren,
+    newChildren,
+    (node) => JSON.stringify(node)
+  );
+  const out = [];
+  let k = 0;
+  let newIndex = 0;
+  while (k < ops.length) {
+    const op = ops[k];
+    if (op.op === "equal") {
+      ctx.summary.unchangedBlocks++;
+      out.push(op.newItem);
+      k++;
+      newIndex++;
+      continue;
+    }
+    const deleted = [];
+    const inserted = [];
+    while (k < ops.length && ops[k].op !== "equal") {
+      const gapOp = ops[k];
+      if (gapOp.op === "delete") deleted.push(gapOp.oldItem);
+      else if (gapOp.op === "insert") inserted.push(gapOp.newItem);
+      k++;
+    }
+    const { plan } = pairGap(deleted, inserted, nodesPairable);
+    for (const step of plan) {
+      if (step.kind === "paired") {
+        out.push(
+          diffPairedNode(step.oldItem, step.newItem, `${path}/${newIndex}`, ctx)
+        );
+        newIndex++;
+      } else if (step.kind === "inserted") {
+        out.push(emitInserted(step.newItem, `${path}/${newIndex}`, ctx));
+        newIndex++;
+      } else {
+        const deletedNode = emitDeleted(
+          step.oldItem,
+          `${path}/${newIndex}`,
+          ctx
+        );
+        if (deletedNode) out.push(deletedNode);
+      }
+    }
+  }
+  return out;
+}
+function diffDocuments(oldDoc, newDoc, options = {}) {
+  if (!oldDoc || oldDoc.name !== "docx") {
+    throw new Error('Old document: top-level component must be "docx"');
+  }
+  if (!newDoc || newDoc.name !== "docx") {
+    throw new Error('New document: top-level component must be "docx"');
+  }
+  const summary = {
+    tracked: { modified: 0, inserted: 0, deleted: 0 },
+    untracked: [],
+    unchangedBlocks: 0,
+    notes: []
+  };
+  const ctx = {
+    author: options.author,
+    date: options.date,
+    summary
+  };
+  const rootPropsChanged = !deepEqual(
+    propsWithout(oldDoc.props, "trackRevisions"),
+    propsWithout(newDoc.props, "trackRevisions")
+  );
+  if (rootPropsChanged) {
+    summary.untracked.push({
+      path: "/props",
+      kind: "modified",
+      component: "docx",
+      detail: "document props changed (theme/metadata/defaults); new version used"
+    });
+  }
+  const children = diffChildren(
+    oldDoc.children || [],
+    newDoc.children || [],
+    "/children",
+    ctx
+  );
+  if (summary.tracked.deleted > 0) {
+    summary.notes.push(
+      `${summary.tracked.deleted} fully deleted block(s): accepting all changes leaves an empty paragraph behind (OOXML paragraph-mark deletion is not supported by the renderer)`
+    );
+  }
+  const document = {
+    ...newDoc,
+    props: { ...newDoc.props, trackRevisions: true },
+    children
+  };
+  return { document, summary };
+}
+
 // src/index.ts
 import {
   fixSchemaReferences as fixSchemaReferences2,
@@ -980,6 +1653,8 @@ export {
   NumberingSchema,
   ParagraphPropsSchema,
   ReportPropsSchema,
+  RevisionSchema,
+  RevisionSegmentSchema,
   SHARED_DOCX_VERSION,
   STANDARD_COMPONENTS,
   STANDARD_COMPONENTS_SET,
@@ -1014,6 +1689,8 @@ export {
   createValidatedComponent,
   createValidator,
   deepValidateDocument,
+  diffDocuments,
+  diffWords,
   documentValidator,
   exportSchemaToFile as exportDocxSchemaToFile,
   exportSchemaToFile2 as exportSchemaToFile,
@@ -1082,6 +1759,7 @@ export {
   strictComponentValidator,
   strictDocumentValidator,
   strictThemeValidator,
+  stripMarkdown,
   themeValidator,
   transformAndValidate,
   transformValueError as transformDocxValueError,