wordinweb 0.3.5 → 0.3.7

package/dist/{chunk-QU3LB5BC.js → chunk-ULPL55MT.js}

@@ -2131,6 +2131,22 @@ function serializeXml(el26, declaration = false) {
   write2(el26);
   return out.join("");
 }
+function isEmptyPlaceholder(e) {
+  return !!e.omitWhenEmpty && Object.keys(e.attrs).length === 0 && e.text.length === 0 && e.children.length === 1 && localName(e.children[0].name) === "t" && e.children[0].children.length === 0 && e.children[0].text.length === 0 && Object.keys(e.children[0].attrs).every((key) => key === "xml:space" && e.children[0].attrs[key] === "preserve");
+}
+function sameXml(a, b) {
+  if (a.name !== b.name) return false;
+  const ak = Object.keys(a.attrs);
+  if (ak.length !== Object.keys(b.attrs).length) return false;
+  for (const k of ak) if (a.attrs[k] !== b.attrs[k]) return false;
+  if (a.children.length === 0 && b.children.length === 0) return a.text === b.text;
+  const ac = a.children.filter((c) => !isEmptyPlaceholder(c));
+  const bc = b.children.filter((c) => !isEmptyPlaceholder(c));
+  if (ac.length !== bc.length) return false;
+  if (ac.length === 0) return (a.children.length > 0 ? "" : a.text) === (b.children.length > 0 ? "" : b.text);
+  for (let i = 0; i < ac.length; i++) if (!sameXml(ac[i], bc[i])) return false;
+  return true;
+}
 function cloneXml(el26) {
   return {
     name: el26.name,
@@ -2176,6 +2192,12 @@ var Package = class _Package {
   static from(data) {
     return new _Package(data instanceof Uint8Array ? data : new Uint8Array(data));
   }
+  /** A package over an already-unzipped entry map (DocxDocument.clone). */
+  static fromFiles(files) {
+    const pkg = Object.create(_Package.prototype);
+    pkg.files = files;
+    return pkg;
+  }
   has(name) {
     return this.normalize(name) in this.files;
   }
@@ -2198,6 +2220,13 @@ var Package = class _Package {
     return name.startsWith("/") ? name.slice(1) : name;
   }
 };
+function relativePartPath(fromPart, toPart) {
+  const fromDir = fromPart.split("/").slice(0, -1);
+  const to = toPart.split("/");
+  let i = 0;
+  while (i < fromDir.length && i < to.length - 1 && fromDir[i] === to[i]) i++;
+  return [...fromDir.slice(i).map(() => ".."), ...to.slice(i)].join("/");
+}
 function resolvePartPath(sourcePart, target) {
   if (target.startsWith("/")) return target.slice(1);
   const baseDir = sourcePart.includes("/") ? sourcePart.slice(0, sourcePart.lastIndexOf("/")) : "";
@@ -4432,6 +4461,11 @@ function parseParagraph(p, ctx) {
     }
   }
   ensureCaretAnchor(p, para);
+  if (ctx.revisionView === "markup" && pPr) {
+    const markRPr = child(pPr, "rPr");
+    if (markRPr && child(markRPr, "del")) para.markRevision = "del";
+    else if (markRPr && child(markRPr, "ins")) para.markRevision = "ins";
+  }
   return para;
 }
 function hasVisibleContent(c) {
@@ -8798,6 +8832,10 @@ var _DocxDocument = class _DocxDocument {
   /** The header part roots, in package order. A watermark is authored into
    * every one of them: Word paints it on every page, and a document with a
    * first-page or even-page header has more than one header part. */
+  /** The root of the header or footer part at `target`, if this document has one. */
+  headerFooterRoot(target) {
+    return this.hfParts.find((p) => p.target === target)?.root;
+  }
   headerRoots() {
     return this.hfParts.filter((p) => p.isHeader).map((p) => p.root);
   }
@@ -8961,6 +8999,22 @@ var _DocxDocument = class _DocxDocument {
       this.saveJournal = null;
     }
   }
+  /**
+   * An independent copy: what `DocxDocument.load(doc.save())` gives, without
+   * zipping the package and unzipping it again. compareDocuments starts from a
+   * copy of the revised document, and the round trip through the zip was a
+   * third of its time on a document that had not changed at all.
+   */
+  clone() {
+    const journal = [];
+    this.saveJournal = journal;
+    try {
+      return new _DocxDocument(Package.fromFiles(this.buildPackageFiles()));
+    } finally {
+      for (let i = journal.length - 1; i >= 0; i--) journal[i]();
+      this.saveJournal = null;
+    }
+  }
   saveAsync() {
     const journal = [];
     this.saveJournal = journal;
@@ -9162,8 +9216,91 @@ var _DocxDocument = class _DocxDocument {
     return this.relsRoot;
   }
   /** Register an external hyperlink relationship and return its rId. */
-  addHyperlinkRel(url) {
-    const rels = this.ensureRelsRoot();
+  /**
+   * Copy the part that `source`'s main-document relationship `relId` points
+   * at into this package, with every part it references in turn (a chart's
+   * embedded workbook, SmartArt's layout, style and colour parts) and their
+   * content types, and add a relationship to it. Returns the new
+   * relationship id, or null when the source has no such internal part.
+   *
+   * compareDocuments needs this for struck content: a removed picture keeps
+   * its w:drawing, and without its image part the result's reject-all
+   * brought the picture back as an empty frame.
+   */
+  adoptRelFrom(source, relId, scope = {}) {
+    const rel = source.relationshipsOf(scope.from).get(relId);
+    if (!rel || rel.external) return null;
+    const copied = /* @__PURE__ */ new Map();
+    const sameBytes = (path2, bytes) => {
+      const have = this.pkg.binary(path2);
+      return !!have && have.length === bytes.length && have.every((b, i) => b === bytes[i]);
+    };
+    const copyPart = (from) => {
+      const known = copied.get(from);
+      if (known) return known;
+      const bytes = source.pkg.binary(from);
+      if (!bytes) return null;
+      let to = from;
+      for (let n = 2; this.pkg.has(to) && !sameBytes(to, bytes); n++) to = from.replace(/(\.[^./]+)?$/, `-${n}$1`);
+      copied.set(from, to);
+      if (this.pkg.has(to)) return to;
+      this.pkg.raw()[to] = bytes;
+      this.adoptContentType(source, from, to);
+      const relsXml = source.pkg.text(relsPathFor(from));
+      if (relsXml) {
+        const root = parseXml(relsXml);
+        for (const r of root.children) {
+          if (r.attrs.TargetMode === "External" || !r.attrs.Target) continue;
+          const sub = copyPart(resolvePartPath(from, r.attrs.Target));
+          if (sub) r.attrs.Target = relativePartPath(to, sub);
+        }
+        this.pkg.raw()[relsPathFor(to)] = strToU82(serializeXml(root, true));
+      }
+      return to;
+    };
+    const part = copyPart(rel.target);
+    if (!part) return null;
+    const owner = this.relsOwnerOf(scope.into);
+    const rels = owner.relsRoot;
+    let maxId = 0;
+    for (const r of rels.children) {
+      const m = /^rId(\d+)$/.exec(r.attrs["Id"] ?? "");
+      if (m) maxId = Math.max(maxId, parseInt(m[1], 10));
+    }
+    const id = `rId${maxId + 1}`;
+    rels.children.push({
+      name: "Relationship",
+      attrs: { Id: id, Type: rel.type, Target: relativePartPath(owner.partPath, part) },
+      children: [],
+      text: ""
+    });
+    owner.relationships.set(id, { id, type: rel.type, target: part, external: false });
+    return id;
+  }
+  /** Give a part copied from `source` the content type it had there. */
+  adoptContentType(source, from, to) {
+    const types = this.contentTypesRoot;
+    const theirs = source.contentTypesRoot;
+    if (!types || !theirs) return;
+    const override = theirs.children.find((c) => localName(c.name) === "Override" && c.attrs.PartName === `/${from}`);
+    const prefixEnd = types.name.indexOf(":") + 1;
+    const prefix = prefixEnd > 0 ? types.name.slice(0, prefixEnd) : "";
+    if (override) {
+      if (!types.children.some((c) => localName(c.name) === "Override" && c.attrs.PartName === `/${to}`)) {
+        types.children.push({ name: `${prefix}Override`, attrs: { PartName: `/${to}`, ContentType: override.attrs.ContentType }, children: [], text: "" });
+      }
+      return;
+    }
+    const ext = from.slice(from.lastIndexOf(".") + 1).toLowerCase();
+    const byExt = (root) => root.children.find((c) => localName(c.name) === "Default" && c.attrs.Extension?.toLowerCase() === ext);
+    const fallback = byExt(theirs);
+    if (fallback && !byExt(types)) {
+      types.children.unshift({ name: `${prefix}Default`, attrs: { Extension: ext, ContentType: fallback.attrs.ContentType }, children: [], text: "" });
+    }
+  }
+  addHyperlinkRel(url, ownerPart) {
+    const owner = this.relsOwnerOf(ownerPart);
+    const rels = owner.relsRoot;
     let maxId = 0;
     for (const r of rels.children) {
       const m = /^rId(\d+)$/.exec(r.attrs["Id"] ?? "");
@@ -9181,7 +9318,7 @@ var _DocxDocument = class _DocxDocument {
       children: [],
       text: ""
     });
-    this.documentRels.set(id, { id, type: "hyperlink", target: url, external: true });
+    owner.relationships.set(id, { id, type: "hyperlink", target: url, external: true });
     return id;
   }
   /** Retarget an existing external relationship (hyperlink href edit). */
@@ -9193,6 +9330,23 @@ var _DocxDocument = class _DocxDocument {
     if (el26) el26.attrs["Target"] = url;
     return true;
   }
+  /** The relationships owned by `part` (a header or footer part), or by the
+   * document part when null; a header or footer gets a rels root on demand. */
+  relsOwnerOf(part) {
+    const owner = part ? this.hfParts.find((p) => p.target === part) : void 0;
+    if (!owner) return { relsRoot: this.ensureRelsRoot(), relationships: this.documentRels, partPath: this.docPart };
+    owner.relsRoot ?? (owner.relsRoot = {
+      name: "Relationships",
+      attrs: { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" },
+      children: [],
+      text: ""
+    });
+    return { relsRoot: owner.relsRoot, relationships: owner.rels, partPath: owner.target };
+  }
+  /** The relationships of `part` (a header or footer), or of the document part. */
+  relationshipsOf(part) {
+    return (part ? this.hfParts.find((p) => p.target === part)?.rels : void 0) ?? this.documentRels;
+  }
   /** The relationships of the part that holds `source`: a header or footer
    * part when the element is inside one, else the document part. */
   imageRelsOwner(source) {
@@ -13702,6 +13856,20 @@ function buildAtoms(doc, para, measurer, fields, fallbackFamily, gridPitch) {
     if (childEl.type === "run") pushRun(childEl);
     else for (const r of childEl.runs) pushRun(r, childEl.href ?? (childEl.anchor ? "#" + childEl.anchor : void 0));
   }
+  if (para.markRevision) {
+    const last = para.children.at(-1);
+    const lastRun = last?.type === "hyperlink" ? last.runs.at(-1) : last;
+    const deleted = para.markRevision === "del";
+    pushRun({
+      type: "run",
+      props: {
+        ...lastRun?.props ?? {},
+        color: deleted ? "#D93025" : "#188038",
+        ...deleted ? { strike: true } : { underline: "single" }
+      },
+      content: [{ kind: "text", text: "\xB6" }]
+    });
+  }
   if (gridPitch) {
     for (let i = 0; i + 1 < atoms.length; i++) {
       const punct = atoms[i];
@@ -19232,15 +19400,20 @@ var Engine = class {
       while (out.length < nCols) out.push(bw(fallback));
       return out;
     };
+    const colTopPads = (r) => {
+      const fallback = this.cellMarginsOf(tbl, false).top ?? 0;
+      return rows[r].cells.flatMap((c) => Array(Math.max(1, c.props.gridSpan)).fill(c.props.margins?.top ?? fallback));
+    };
     const boundary = (k) => {
       if (k === 0) return Math.max(0, ...colWidths(0, "top", tb?.top));
       if (k === rows.length)
         return Math.max(0, ...colWidths(rows.length - 1, "bottom", tb?.bottom));
       const above = colWidths(k - 1, "bottom", tb?.insideH);
       const below = colWidths(k, "top", tb?.insideH);
+      const topPads = colTopPads(k);
       const n = Math.max(above.length, below.length);
       let w = 0;
-      for (let i = 0; i < n; i++) w = Math.max(w, Math.max(above[i] ?? 0, below[i] ?? 0));
+      for (let i = 0; i < n; i++) w = Math.max(w, below[i] ?? 0, (above[i] ?? 0) - (topPads[i] ?? 0));
       return w;
     };
     return { top: boundary(ri), bottom: boundary(ri + 1) };
@@ -21446,6 +21619,8 @@ function renderPageShell(page, zoom, options) {
   if (options.pageShadow !== false) {
     el26.style.boxShadow = "var(--dxw-page-shadow, 0 1px 3px rgba(0,0,0,.28), 0 4px 14px rgba(0,0,0,.12))";
   }
+  el26.dataset.pageWidth = String(page.width);
+  el26.dataset.pageHeight = String(page.height);
   el26.dataset.bodyTop = String(page.bodyTop);
   el26.dataset.bodyBottom = String(page.bodyBottom);
   el26.dataset.columnBands = JSON.stringify(page.columnBands);
@@ -21762,9 +21937,21 @@ function trackPaint(work) {
 async function paintsSettled() {
   while (pendingPaints.size > 0) await Promise.allSettled([...pendingPaints]);
 }
-function printStylesheet(pageWidthPx, pageHeightPx) {
+function printStylesheet(pageWidthPx, pageHeightPx, root) {
+  const inches = (px) => `${Math.round(px / 96 * 1e3) / 1e3}in`;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const el26 of root ? Array.from(root.querySelectorAll(".dxw-page[data-page-width]")) : []) {
+    sizes.add(`${el26.dataset.pageWidth}x${el26.dataset.pageHeight}`);
+  }
+  const named = [...sizes].map((key) => {
+    const [w, h] = key.split("x");
+    const name = `dxw-${key.replace(/\./g, "_")}`;
+    return `@page ${name} { size: ${inches(Number(w))} ${inches(Number(h))}; margin: 0; }
+    .dxw-page[data-page-width="${w}"][data-page-height="${h}"] { page: ${name}; }`;
+  });
   return `
-    @page { size: ${pageWidthPx / 96}in ${pageHeightPx / 96}in; margin: 0; }
+    @page { size: ${inches(pageWidthPx)} ${inches(pageHeightPx)}; margin: 0; }
+    ${named.join("\n    ")}
     html, body { margin: 0; padding: 0; }
     .dxw-pages { display: block !important; padding: 0 !important; gap: 0 !important; }
     .dxw-pages, .dxw-pages * {
@@ -21775,13 +21962,25 @@ function printStylesheet(pageWidthPx, pageHeightPx) {
     .dxw-comment-card, .dxw-hf-marker { display: none !important; }
   `;
 }
+function pruneBlankSpans(root) {
+  let removed = 0;
+  for (const el26 of Array.from(root.querySelectorAll(".dxw-page span"))) {
+    if (el26.childElementCount > 0 || el26.textContent?.trim()) continue;
+    if (el26.style.textDecoration.includes("underline")) continue;
+    el26.remove();
+    removed++;
+  }
+  return removed;
+}
 function buildPrintHtml(root, pageWidthPx, pageHeightPx) {
   const head = [`<base href="${document.location.href}">`];
   for (const node of Array.from(document.head.querySelectorAll("style, link[rel=stylesheet]"))) {
     head.push(node.outerHTML);
   }
-  head.push(`<style>${printStylesheet(pageWidthPx, pageHeightPx)}</style>`);
-  return `<!doctype html><html><head>${head.join("")}</head><body>${root.outerHTML}</body></html>`;
+  head.push(`<style>${printStylesheet(pageWidthPx, pageHeightPx, root)}</style>`);
+  const pages = root.cloneNode(true);
+  pruneBlankSpans(pages);
+  return `<!doctype html><html><head>${head.join("")}</head><body>${pages.outerHTML}</body></html>`;
 }
 function printPages(root, pageWidthPx, pageHeightPx) {
   const iframe = document.createElement("iframe");
@@ -23828,7 +24027,9 @@ function revisionWrapper(sample, kind, content, meta) {
 }
 function markDeletedText(el26) {
   const walk2 = (e) => {
+    if (localName(e.name) === "txbxContent") return;
     if (localName(e.name) === "t") e.name = e.name.replace(/t$/, "delText");
+    else if (localName(e.name) === "instrText") e.name = e.name.replace(/instrText$/, "delInstrText");
     for (const c of e.children) walk2(c);
   };
   walk2(el26);
@@ -24087,7 +24288,8 @@ function ensurePPrRPr(pEl) {
   let rPr = pPr.children.find((c) => localName(c.name) === "rPr");
   if (!rPr) {
     rPr = el2(`${w}rPr`);
-    pPr.children.push(rPr);
+    const at = pPr.children.findIndex((c) => localName(c.name) === "sectPr" || localName(c.name) === "pPrChange");
+    pPr.children.splice(at === -1 ? pPr.children.length : at, 0, rPr);
   }
   return rPr;
 }
@@ -24247,6 +24449,8 @@ function convertDelTextToText(el26) {
   const walk2 = (e) => {
     if (localName(e.name) === "delText") {
       e.name = e.name.replace(/delText$/, "t");
+    } else if (localName(e.name) === "delInstrText") {
+      e.name = e.name.replace(/delInstrText$/, "instrText");
     }
     for (const c of e.children) walk2(c);
   };
@@ -24268,7 +24472,7 @@ function removeEl(doc, el26) {
   parent.children.splice(idx, 1);
   return true;
 }
-var RUN_CONTAINERS = ["hyperlink", "smartTag", "dir", "bdo"];
+var RUN_CONTAINERS = ["hyperlink", "smartTag", "dir", "bdo", "fldSimple"];
 function removeRevisionAndEmptyHost(doc, el26) {
   const parent = doc.findParentOf(el26);
   if (!removeEl(doc, el26)) return false;
@@ -24277,26 +24481,57 @@ function removeRevisionAndEmptyHost(doc, el26) {
   }
   return true;
 }
-function joinWithNext(doc, pEl) {
+function joinWithNext(doc, pEl, gone) {
   const parent = doc.findParentOf(pEl);
   if (!parent) return false;
   const idx = parent.children.indexOf(pEl);
-  const next = parent.children[idx + 1];
-  if (!next || localName(next.name) !== "p") return false;
+  let at = idx + 1;
+  while (at < parent.children.length && MARKERS.includes(localName(parent.children[at].name))) at++;
+  const next = parent.children[at];
+  if (!next || localName(next.name) !== "p") {
+    const goes = gone === "del" ? ["pPr", "del", "moveFrom", "proofErr", ...MOVE_RANGES] : ["pPr", "ins", "moveTo", "proofErr", ...MOVE_RANGES];
+    const stays = MARKERS.filter((m) => m !== "proofErr");
+    const removable = (c) => goes.includes(localName(c.name)) || stays.includes(localName(c.name)) || isEmptyPlaceholder(c) || RUN_CONTAINERS.includes(localName(c.name)) && c.children.every(removable);
+    if (!pEl.children.every(removable)) return false;
+    parent.children.splice(idx, 1, ...pEl.children.filter((c) => stays.includes(localName(c.name))));
+    dropEmptiedControl(doc, parent);
+    return true;
+  }
+  const between = parent.children.slice(idx + 1, at);
   const moved = next.children.filter((c) => localName(c.name) !== "pPr");
-  pEl.children.push(...moved);
-  parent.children.splice(idx + 1, 1);
+  pEl.children.push(...between, ...moved);
+  parent.children.splice(idx + 1, at - idx);
+  carrySectionBreak(pEl, next);
   return true;
 }
+var MARKERS = ["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "permStart", "permEnd", "proofErr"];
+function carrySectionBreak(pEl, next) {
+  const pPrOf = (p) => p.children.find((c) => localName(c.name) === "pPr");
+  const sectOf = (p) => pPrOf(p)?.children.find((c) => localName(c.name) === "sectPr");
+  const mine = sectOf(pEl);
+  const theirs = sectOf(next);
+  if (!mine && !theirs) return;
+  let pPr = pPrOf(pEl);
+  if (!pPr) {
+    pPr = { name: "w:pPr", attrs: {}, children: [], text: "" };
+    pEl.children.unshift(pPr);
+  }
+  pPr.children = pPr.children.filter((c) => c !== mine);
+  if (theirs) {
+    const at = pPr.children.findIndex((c) => localName(c.name) === "pPrChange");
+    pPr.children.splice(at === -1 ? pPr.children.length : at, 0, theirs);
+  }
+  if (pPr.children.length === 0) pEl.children.splice(pEl.children.indexOf(pPr), 1);
+}
 function collectRevisions(doc) {
   const out = [];
   const walk2 = (el26) => {
     const ln = localName(el26.name);
     if (ln === "pPr") return;
-    if (ln === "ins" || ln === "del") {
+    if (ln === "ins" || ln === "del" || ln === "moveTo" || ln === "moveFrom") {
       out.push({
         el: el26,
-        kind: ln === "ins" ? "insertion" : "deletion",
+        kind: ln === "ins" || ln === "moveTo" ? "insertion" : "deletion",
         author: attrByLocal(el26, "author")
       });
     }
@@ -24330,10 +24565,10 @@ function collectRevisions(doc) {
       const rPr = pPr?.children.find((c) => localName(c.name) === "rPr");
       for (const c of rPr?.children ?? []) {
         const cn = localName(c.name);
-        if (cn === "ins" || cn === "del") {
+        if (cn === "ins" || cn === "del" || cn === "moveTo" || cn === "moveFrom") {
           out.push({
             el: c,
-            kind: cn === "ins" ? "markInsertion" : "markDeletion",
+            kind: cn === "ins" || cn === "moveTo" ? "markInsertion" : "markDeletion",
             paragraph: el26,
             author: attrByLocal(c, "author")
           });
@@ -24355,7 +24590,7 @@ function applyAccept(doc, ref) {
     case "markDeletion":
       if (!ref.paragraph) return false;
       removeMarkRevision(ref);
-      return joinWithNext(doc, ref.paragraph);
+      return joinWithNext(doc, ref.paragraph, "del");
     case "rowInsertion":
       return removeRowRevision(doc, ref);
     case "rowDeletion":
@@ -24426,7 +24661,7 @@ function applyReject(doc, ref) {
     case "markInsertion":
       if (!ref.paragraph) return false;
       removeMarkRevision(ref);
-      return joinWithNext(doc, ref.paragraph);
+      return joinWithNext(doc, ref.paragraph, "ins");
     case "markDeletion":
       return removeMarkRevision(ref);
     case "rowInsertion":
@@ -24477,11 +24712,23 @@ function applyToAll(doc, apply, author) {
     for (const part of held) notes.add(part);
   }
   if (n > 0) {
+    dropSettledMoveRanges(doc);
     doc.markNotePartsChanged([...notes]);
     doc.refresh();
   }
   return n;
 }
+var MOVE_RANGES = ["moveFromRangeStart", "moveFromRangeEnd", "moveToRangeStart", "moveToRangeEnd"];
+function dropSettledMoveRanges(doc) {
+  const roots = doc.revisionRoots();
+  const has = (el26) => ["moveFrom", "moveTo"].includes(localName(el26.name)) || el26.children.some(has);
+  if (roots.some(has)) return;
+  const strip = (el26) => {
+    el26.children = el26.children.filter((c) => !MOVE_RANGES.includes(localName(c.name)));
+    for (const c of el26.children) strip(c);
+  };
+  for (const root of roots) strip(root);
+}
 function removeMarkRevision(ref) {
   const pPr = ref.paragraph?.children.find((c) => localName(c.name) === "pPr");
   const rPr = pPr?.children.find((c) => localName(c.name) === "rPr");
@@ -24513,9 +24760,24 @@ function removeRow(doc, ref) {
   const idx = tbl.children.indexOf(ref.row);
   if (idx === -1) return false;
   tbl.children.splice(idx, 1);
-  if (!tbl.children.some((c) => localName(c.name) === "tr")) removeEl(doc, tbl);
+  if (!tbl.children.some((c) => localName(c.name) === "tr")) {
+    const holder = doc.findParentOf(tbl);
+    removeEl(doc, tbl);
+    if (holder) dropEmptiedControl(doc, holder);
+  }
   return true;
 }
+function dropEmptiedControl(doc, container) {
+  const ln = localName(container.name);
+  const control = ln === "sdtContent" ? doc.findParentOf(container) : ln === "customXml" ? container : void 0;
+  if (!control) return;
+  const left = container.children.filter((c) => localName(c.name) !== "customXmlPr");
+  if (left.some((c) => !MARKERS.includes(localName(c.name)))) return;
+  const holder = doc.findParentOf(control);
+  if (!holder) return;
+  holder.children.splice(holder.children.indexOf(control), 1, ...left.filter((c) => localName(c.name) !== "proofErr"));
+  dropEmptiedControl(doc, holder);
+}
 
 // ../core/src/edit/blocks.ts
 function el3(name, attrs = {}, children3 = [], text = "") {
@@ -24859,8 +25121,32 @@ function mergeParagraphBackward(doc, pEl) {
   const moved = pEl.children.filter((c) => localName(c.name) !== "pPr" && !isPlaceholderRun(c));
   prev.children.push(...moved);
   parent.children.splice(idx, 1);
+  carryMarkRevision(prev, pEl);
   return finishMerge(prev);
 }
+function carryMarkRevision(survivor, gone) {
+  const markOf = (p) => p.children.find((c) => localName(c.name) === "pPr")?.children.find((c) => localName(c.name) === "rPr");
+  const isRev = (c) => localName(c.name) === "ins" || localName(c.name) === "del";
+  const theirs = markOf(gone)?.children.filter(isRev) ?? [];
+  let pPr = survivor.children.find((c) => localName(c.name) === "pPr");
+  let rPr = markOf(survivor);
+  if (!rPr && theirs.length === 0) return;
+  if (!rPr) {
+    const w = survivor.name.includes(":") ? survivor.name.slice(0, survivor.name.indexOf(":") + 1) : "";
+    if (!pPr) {
+      pPr = { name: `${w}pPr`, attrs: {}, children: [], text: "" };
+      survivor.children.unshift(pPr);
+    }
+    rPr = { name: `${w}rPr`, attrs: {}, children: [], text: "" };
+    const at = pPr.children.findIndex((c) => localName(c.name) === "sectPr" || localName(c.name) === "pPrChange");
+    pPr.children.splice(at === -1 ? pPr.children.length : at, 0, rPr);
+  }
+  rPr.children = [...theirs, ...rPr.children.filter((c) => !isRev(c))];
+  if (rPr.children.length === 0 && pPr) {
+    pPr.children.splice(pPr.children.indexOf(rPr), 1);
+    if (pPr.children.length === 0) survivor.children.splice(survivor.children.indexOf(pPr), 1);
+  }
+}
 function firstTextOf(pEl) {
   const walk2 = (el26) => {
     for (const c of el26.children) {
@@ -27815,7 +28101,7 @@ function sortTableRows(doc, tblEl, colIdx, order, compare, hasHeader = false) {
     return tc ? cellText(tc).trim() : "";
   };
   const numeric2 = (s) => parseFloat(s.replace(/[^0-9.eE+-]/g, ""));
-  const compareRows = (a, b) => {
+  const compareRows2 = (a, b) => {
     const ka = keyOf2(a);
     const kb = keyOf2(b);
     let d;
@@ -27831,7 +28117,7 @@ function sortTableRows(doc, tblEl, colIdx, order, compare, hasHeader = false) {
     }
     return order === "asc" ? d : -d;
   };
-  const sorted = [...body].sort(compareRows);
+  const sorted = [...body].sort(compareRows2);
   if (sorted.every((tr, i) => tr === body[i])) return false;
   const slots = body.map((tr) => tblEl.children.indexOf(tr));
   sorted.forEach((tr, i) => {
@@ -41791,17 +42077,7 @@ var _DocxEditor = class _DocxEditor {
         if (pEl && firstTextOf(pEl) === caret.t) {
           this.host.history?.checkpoint();
           if (this.clearListAtCaret()) return;
-          const prev = siblingParagraph(this.host.doc, pEl, -1);
-          if (!prev) return;
-          const junction = lastTextOf(prev);
-          const mergeBlockId = this.host.onIntent && this.host.doc.stableIds ? this.host.doc.stableIds.idOf(pEl) : void 0;
-          if (mergeParagraphBackward(this.host.doc, pEl)) {
-            if (mergeBlockId !== void 0) this.host.onIntent?.({ kind: "mergeParagraph", blockId: mergeBlockId });
-            const target = junction && paragraphOf(this.host.doc, junction) ? junction : caret.t;
-            this.caret = { t: target, run: caret.run, offset: target === junction ? target.text.length : 0 };
-            invalidateParagraphSignature(paragraphOf(this.host.doc, target) ?? pEl);
-            this.commit(false, "local", true);
-          }
+          this.mergeIntoPrevious(pEl);
           return;
         }
         if (!this.stepToNeighbor(-1)) return;
@@ -41817,19 +42093,8 @@ var _DocxEditor = class _DocxEditor {
       if (caret.offset >= caret.t.text.length) {
         const pEl = paragraphOf(this.host.doc, caret.t);
         if (pEl && lastTextOf(pEl) === caret.t) {
-          const next = siblingParagraph(this.host.doc, pEl, 1);
-          if (!next) return;
           this.host.history?.checkpoint();
-          const mergeNextId = this.host.onIntent && this.host.doc.stableIds ? this.host.doc.stableIds.idOf(next) : void 0;
-          if (mergeParagraphBackward(this.host.doc, next)) {
-            if (mergeNextId !== void 0) this.host.onIntent?.({ kind: "mergeParagraph", blockId: mergeNextId });
-            if (!paragraphOf(this.host.doc, caret.t)) {
-              const t = firstTextOf(next);
-              if (t) this.caret = { t, run: caret.run, offset: 0 };
-            }
-            invalidateParagraphSignature(paragraphOf(this.host.doc, this.caret?.t ?? caret.t) ?? pEl);
-            this.commit(false, "local", true);
-          }
+          this.mergeNextInto(pEl);
           return;
         }
         if (!this.stepToNeighbor(1)) return;
@@ -41847,6 +42112,44 @@ var _DocxEditor = class _DocxEditor {
   emitDelete(blockId, runId, start, end) {
     if (end > start) this.host.onIntent?.({ kind: "deleteText", blockId, runId, start, end });
   }
+  /** Backspace at the start of `pEl`: merge it into the previous paragraph. */
+  mergeIntoPrevious(pEl) {
+    const caret = this.caret;
+    if (!caret) return;
+    const prev = siblingParagraph(this.host.doc, pEl, -1);
+    if (!prev) return;
+    const junction = lastTextOf(prev);
+    const mergeBlockId = this.host.onIntent && this.host.doc.stableIds ? this.host.doc.stableIds.idOf(pEl) : void 0;
+    if (mergeParagraphBackward(this.host.doc, pEl)) {
+      if (mergeBlockId !== void 0) this.host.onIntent?.({ kind: "mergeParagraph", blockId: mergeBlockId });
+      const target = junction && paragraphOf(this.host.doc, junction) ? junction : caret.t;
+      this.caret = { t: target, run: caret.run, offset: target === junction ? target.text.length : 0 };
+      invalidateParagraphSignature(paragraphOf(this.host.doc, target) ?? pEl);
+      this.commit(false, "local", true);
+    }
+  }
+  /** Delete at the end of `pEl`: merge the next paragraph into it. */
+  mergeNextInto(pEl) {
+    const caret = this.caret;
+    if (!caret) return;
+    const next = siblingParagraph(this.host.doc, pEl, 1);
+    if (!next) return;
+    const mergeNextId = this.host.onIntent && this.host.doc.stableIds ? this.host.doc.stableIds.idOf(next) : void 0;
+    if (mergeParagraphBackward(this.host.doc, next)) {
+      if (mergeNextId !== void 0) this.host.onIntent?.({ kind: "mergeParagraph", blockId: mergeNextId });
+      if (!paragraphOf(this.host.doc, caret.t)) {
+        const t = firstTextOf(next);
+        if (t) this.caret = { t, run: caret.run, offset: 0 };
+      }
+      invalidateParagraphSignature(paragraphOf(this.host.doc, this.caret?.t ?? caret.t) ?? pEl);
+      this.commit(false, "local", true);
+    }
+  }
+  /** True when `pEl`'s paragraph mark is a break this author suggested. */
+  ownSuggestedBreak(pEl) {
+    const mark = paragraphGlyphRevision(pEl, "ins");
+    return !!mark && attr(mark, "author") === this.revisionAuthor;
+  }
   /** Backspace/Delete in suggesting mode: mark one character (or a paragraph
    * mark at a boundary) as a tracked deletion instead of removing it. Skips over
    * text already struck by this author so a repeated press keeps eating real
@@ -41867,6 +42170,10 @@ var _DocxEditor = class _DocxEditor {
           if (this.suggestUnbulletAtCaret()) return;
           const prev = siblingParagraph(doc, pEl, -1);
           if (!prev) return;
+          if (this.ownSuggestedBreak(prev)) {
+            this.mergeIntoPrevious(pEl);
+            return;
+          }
           if (paragraphGlyphRevision(prev, "del")) {
             this.stepToNeighbor(-1);
             this.positionCaret();
@@ -41896,6 +42203,10 @@ var _DocxEditor = class _DocxEditor {
     if (caret.offset >= caret.t.text.length) {
       const pEl = paragraphOf(doc, caret.t);
       if (pEl && lastTextOf(pEl) === caret.t) {
+        if (this.ownSuggestedBreak(pEl)) {
+          this.mergeNextInto(pEl);
+          return;
+        }
         if (paragraphGlyphRevision(pEl, "del")) {
           this.stepToNeighbor(1);
           this.positionCaret();
@@ -43010,6 +43321,15 @@ var COMPARE_TUNING = {
   shortParagraphTokens: 5,
   /** Levenshtein ratio a short paragraph pair must reach instead of minDice. */
   minShortRatio: 0.8,
+  /**
+   * Or the share of words a short pair has in common (Dice over words), which
+   * a one-word edit in a short heading or list item keeps at half or more
+   * ("Bullet one" / "Bullet updated", "Alignment and flow" / "Alignment and
+   * flow as amended") while its character ratio falls under minShortRatio.
+   * Below it, those came out struck and reinserted whole: 99% of the compare
+   * benchmark's whole-paragraph misses were paragraphs under five words.
+   */
+  minShortWordDice: 0.5,
   /**
    * ABSOLUTE floor for the coalescing pass: a matched run shorter than this,
    * sitting between two changes in the inner word diff, is absorbed into the
@@ -43028,15 +43348,19 @@ var COMPARE_TUNING = {
    * next to 1) while a rewritten clause becomes one (3 is small next to 7).
    *
    * Both numbers were settled against test/compare-corpus.test.ts; see the
-   * calibration note there for what each fixture pins down.
+   * calibration note there for what each fixture pins down. The ratio was 2
+   * while spaces rode on words: "hardware," and "hardware " differed, so the
+   * rewritten sentence of fixture 3 shared only three words. Matched exactly,
+   * it shares four ("shortage of test hardware") beside seven changed, which
+   * 1.5 absorbs (6 < 7) and 2 does not.
    */
-  coalesceRatio: 2
+  coalesceRatio: 1.5
 };
 function normalizeText(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 function wordTokens(s) {
-  return s.match(/\S+\s*|\s+/g) ?? [];
+  return s.match(/[\p{L}\p{M}\p{N}]+(?:['\u2019][\p{L}\p{M}\p{N}]+)*|[^\s\p{L}\p{M}\p{N}]|\s+/gu) ?? [];
 }
 function similarityTokens(s) {
   const n = normalizeText(s).toLowerCase();
@@ -43082,14 +43406,16 @@ function similarity(a, b) {
     const nb = normalizeText(b).toLowerCase();
     const longest = Math.max(na.length, nb.length);
     if (longest === 0) return 1;
-    return 1 - levenshtein(na, nb) / longest;
+    const ratio = 1 - levenshtein(na, nb) / longest;
+    const words2 = dice(new Set(ta), new Set(tb));
+    return Math.max(words2, ratio >= COMPARE_TUNING.minShortRatio ? ratio : 0);
   }
   return dice(bigrams(ta), bigrams(tb));
 }
 function similarityFloor(a, b) {
   const la = similarityTokens(a).length;
   const lb = similarityTokens(b).length;
-  return isShortPair(la, lb) ? COMPARE_TUNING.minShortRatio : COMPARE_TUNING.minDice;
+  return isShortPair(la, lb) ? COMPARE_TUNING.minShortWordDice : COMPARE_TUNING.minDice;
 }
 function isShortPair(la, lb) {
   return Math.min(la, lb) < COMPARE_TUNING.shortParagraphTokens;
@@ -43100,6 +43426,25 @@ var PASSENGERS = /* @__PURE__ */ new Set(["proofErr", "bookmarkStart", "bookmark
 function isPassenger(ln) {
   return PASSENGERS.has(ln);
 }
+var WORD_CHAR = /[\p{L}\p{M}\p{N}]/u;
+var CONTAINERS = /* @__PURE__ */ new Set(["hyperlink", "smartTag", "fldSimple", "customXml", "dir", "bdo", "sdt"]);
+var CONTAINER_PROPS = /* @__PURE__ */ new Set(["pPr", "sdtPr", "sdtEndPr", "smartTagPr", "customXmlPr"]);
+function atomKey(atom, noteKey) {
+  const ln = localName(atom.name);
+  if (ln === "footnoteReference" || ln === "endnoteReference") {
+    const { "w:id": _id, ...rest } = atom.attrs;
+    return serializeXml({ ...atom, attrs: rest }) + (noteKey ? "\0" + noteKey(atom) : "");
+  }
+  const strip = (e) => localName(e.name) === "txbxContent" ? { ...e, children: [], text: "" } : { ...e, children: e.children.map(strip) };
+  return serializeXml(hasTextBox(atom) ? strip(atom) : atom);
+}
+function hasTextBox(el26) {
+  return localName(el26.name) === "txbxContent" || el26.children.some(hasTextBox);
+}
+function textBoxesIn(el26) {
+  if (localName(el26.name) === "txbxContent") return [el26];
+  return el26.children.flatMap(textBoxesIn);
+}
 function readParagraph(pEl, options = {}) {
   const keyOf2 = options.whitespace === false ? (word) => word.trimEnd() : (word) => word;
   const tokens = [];
@@ -43112,31 +43457,80 @@ function readParagraph(pEl, options = {}) {
     }
     tokens.push(token);
   };
-  for (const cEl of pEl.children) {
-    const ln = localName(cEl.name);
-    if (ln === "pPr") continue;
-    if (PASSENGERS.has(ln)) {
-      pending.push(cEl);
-      continue;
-    }
-    if (ln !== "r") {
-      inlineDiffable = false;
-      continue;
-    }
-    for (const rc of cEl.children) {
-      const rln = localName(rc.name);
-      if (rln === "rPr") continue;
-      if (rln === "t") {
-        let at = 0;
-        for (const word of wordTokens(rc.text)) {
-          push({ key: "w\0" + keyOf2(word), text: word, run: cEl, t: rc, start: at, end: at + word.length });
-          at += word.length;
-        }
+  let segment = [];
+  let segmentPath = [];
+  const flush = () => {
+    if (segment.length === 0) return;
+    const text = segment.map((p) => p.text).join("");
+    const cuts = [];
+    let base = 0;
+    for (let i = 0; i + 1 < segment.length; i++) {
+      base += segment[i].text.length;
+      if (WORD_CHAR.test(text[base - 1] ?? "") && WORD_CHAR.test(text[base] ?? "") && runPropsKey(segment[i].run) !== runPropsKey(segment[i + 1].run)) {
+        cuts.push(base);
+      }
+    }
+    const words2 = [];
+    let from = 0;
+    for (const cut of [...cuts, text.length]) {
+      words2.push(...wordTokens(text.slice(from, cut)));
+      from = cut;
+    }
+    let at = 0;
+    for (const word of words2) {
+      const end = at + word.length;
+      const pieces = [];
+      let base2 = 0;
+      for (const p of segment) {
+        const from2 = Math.max(at, base2);
+        const to = Math.min(end, base2 + p.text.length);
+        if (from2 < to) pieces.push({ run: p.run, t: p.t, start: from2 - base2, end: to - base2, text: text.slice(from2, to) });
+        base2 += p.text.length;
+      }
+      const first = pieces[0];
+      push({ key: "w\0" + keyOf2(word), text: word, run: first.run, t: first.t, start: first.start, end: first.end, pieces, path: segmentPath });
+      at = end;
+    }
+    segment = [];
+  };
+  const walk2 = (kids, path2) => {
+    for (const cEl of kids) {
+      const ln = localName(cEl.name);
+      if (CONTAINER_PROPS.has(ln)) continue;
+      if (PASSENGERS.has(ln)) {
+        flush();
+        pending.push(cEl);
+        continue;
+      }
+      if (CONTAINERS.has(ln)) {
+        const inner = ln === "sdt" ? cEl.children.find((c) => localName(c.name) === "sdtContent") : cEl;
+        if (!inner) continue;
+        flush();
+        walk2(inner.children, [...path2, cEl]);
+        flush();
         continue;
       }
-      push({ key: "a\0" + serializeXml(rc), text: "", run: cEl, atom: rc });
+      if (ln !== "r") {
+        flush();
+        inlineDiffable = false;
+        continue;
+      }
+      if (segment.length > 0 && segmentPath !== path2) flush();
+      segmentPath = path2;
+      for (const rc of cEl.children) {
+        const rln = localName(rc.name);
+        if (rln === "rPr") continue;
+        if (rln === "t") {
+          segment.push({ run: cEl, t: rc, text: rc.text });
+          continue;
+        }
+        flush();
+        push({ key: "a\0" + atomKey(rc, options.noteKey), text: "", run: cEl, atom: rc, path: path2 });
+      }
     }
-  }
+  };
+  walk2(pEl.children, []);
+  flush();
   return { tokens, tail: pending, text: paragraphText3(pEl), inlineDiffable };
 }
 function paragraphText3(el26) {
@@ -43153,31 +43547,41 @@ function paragraphText3(el26) {
   }
   return out;
 }
-function sliceContent(tokens, from, to, deleted) {
+function sliceItems(tokens, from, to, deleted) {
   const out = [];
-  let i = from;
-  while (i < to) {
-    const token = tokens[i];
-    if (!deleted && token.lead) out.push(...token.lead.map(cloneXml));
-    const run = token.run;
+  let open = null;
+  let text = null;
+  const runFor = (run, path2) => {
+    if (open?.run === run) return open.el;
     const rPr = run.children.find((c) => localName(c.name) === "rPr");
-    const children3 = rPr ? [cloneXml(rPr)] : [];
-    while (i < to && tokens[i].run === run) {
-      const cur = tokens[i];
-      if (cur.atom) {
-        children3.push(cloneXml(cur.atom));
-        i++;
+    const el26 = { name: run.name, attrs: { ...run.attrs }, children: rPr ? [cloneXml(rPr)] : [], text: "" };
+    out.push({ el: el26, path: path2 });
+    open = { run, el: el26 };
+    text = null;
+    return el26;
+  };
+  for (let i = from; i < to; i++) {
+    const token = tokens[i];
+    if (!deleted && token.lead) {
+      out.push(...token.lead.map((el26) => ({ el: cloneXml(el26), path: token.path })));
+      open = null;
+      text = null;
+    }
+    if (token.atom) {
+      runFor(token.run, token.path).children.push(cloneXml(token.atom));
+      text = null;
+      continue;
+    }
+    for (const piece of token.pieces ?? []) {
+      const el26 = runFor(piece.run, token.path);
+      if (text && text.t === piece.t) {
+        text.el.text += piece.text;
         continue;
       }
-      const t = cur.t;
-      let text = "";
-      while (i < to && tokens[i].run === run && tokens[i].t === t) {
-        text += tokens[i].text;
-        i++;
-      }
-      children3.push(textElement2(t, text, deleted));
+      const te = textElement2(piece.t, piece.text, deleted);
+      el26.children.push(te);
+      text = { t: piece.t, el: te };
     }
-    out.push({ name: run.name, attrs: { ...run.attrs }, children: children3, text: "" });
   }
   return out;
 }
@@ -43284,46 +43688,232 @@ function lcsFallback(a, b, aLo, aHi, bLo, bHi, out) {
 
 // ../core/src/edit/compare/index.ts
 function compareDocuments(original, revised, options) {
-  const merged = DocxDocument.load(revised.save());
+  const note = options.onNote ?? (() => {
+  });
+  const accepted = (doc, which) => {
+    if (collectRevisions(doc).length === 0) return doc;
+    const copy = doc.clone();
+    acceptAllRevisions(copy);
+    note({ code: "existing-revisions-accepted", detail: `the ${which} document held tracked changes; it was compared as if they were accepted` });
+    return copy;
+  };
+  const merged = accepted(revised, "revised");
+  return compareInto(accepted(original, "original"), merged === revised ? revised.clone() : merged, options);
+}
+function compareInto(original, merged, options) {
+  let issued = 0;
   const ctx = {
     doc: merged,
     original,
     meta: {
       author: options.author,
       date: options.date,
-      nextId: () => merged.nextRevisionId()
+      nextId: () => {
+        issued++;
+        return merged.nextRevisionId();
+      }
     },
     formatting: options.formatting !== false,
     whitespace: options.whitespace !== false,
     note: options.onNote ?? (() => {
-    })
+    }),
+    scope: { from: null, into: null },
+    noteIds: { footnote: /* @__PURE__ */ new Map(), endnote: /* @__PURE__ */ new Map() }
   };
   const originalBody = child(original.docRoot, "body");
   const mergedBody = child(merged.docRoot, "body");
   if (!originalBody || !mergedBody) throw new Error("document.xml has no w:body");
-  reportUncomparedParts(original, revised, ctx);
+  reportUncomparedParts(original, merged, ctx);
+  const headerFooterPairs = pairHeadersFooters(original, merged);
+  compareNotes("footnote", original, merged, ctx);
+  compareNotes("endnote", original, merged, ctx);
   const tail = mergedBody.children.filter((c) => localName(c.name) === "sectPr");
   const entries = alignBlocks(blockList(originalBody, "sectPr"), blockList(mergedBody, "sectPr"), ctx);
   applyParagraphMarks(entries, ctx);
   mergedBody.children = [...entries.map((e) => e.el), ...tail];
-  merged.refresh();
+  giveStruckReferencesTheirOwnNotes("footnote", merged, ctx);
+  giveStruckReferencesTheirOwnNotes("endnote", merged, ctx);
+  for (const [from, into] of headerFooterPairs) {
+    const oRoot = original.headerFooterRoot(from);
+    const mRoot = merged.headerFooterRoot(into);
+    if (oRoot && mRoot) compareContainer(oRoot, mRoot, { ...ctx, scope: { from, into } });
+  }
+  if (issued > 0) merged.refresh();
   return merged;
 }
+function compareContainer(oRoot, mRoot, ctx) {
+  const o = blockList(oRoot);
+  const m = blockList(mRoot);
+  if (o.length === m.length && o.every((el26, i) => sameXml(el26, m[i]))) return;
+  const entries = alignBlocks(o, m, ctx);
+  applyParagraphMarks(entries, ctx);
+  const blocks = new Set(m);
+  mRoot.children = [...mRoot.children.filter((c) => !blocks.has(c) && !["p", "tbl", "sdt"].includes(localName(c.name))), ...entries.map((e) => e.el)];
+}
+function pairHeadersFooters(original, merged) {
+  const refs = (doc) => {
+    const out = /* @__PURE__ */ new Map();
+    const body = child(doc.docRoot, "body");
+    const sects = (body?.children ?? []).flatMap(
+      (c) => localName(c.name) === "sectPr" ? [c] : localName(c.name) === "p" ? [child(child(c, "pPr"), "sectPr")].filter((x) => !!x) : []
+    );
+    sects.forEach((sp, i) => {
+      for (const ref of sp.children) {
+        const ln = localName(ref.name);
+        if (ln !== "headerReference" && ln !== "footerReference") continue;
+        const target = doc.documentRels.get(ref.attrs["r:id"])?.target;
+        if (target) out.set(`${i}:${ln}:${ref.attrs["w:type"] ?? "default"}`, target);
+      }
+    });
+    return out;
+  };
+  const mine = refs(merged);
+  const pairs = [];
+  const done = /* @__PURE__ */ new Set();
+  for (const [key, from] of refs(original)) {
+    const into = mine.get(key);
+    if (!into || done.has(into)) continue;
+    done.add(into);
+    pairs.push([from, into]);
+  }
+  return pairs;
+}
+function compareNotes(kind, original, merged, ctx) {
+  const tree = (doc, create = false) => kind === "footnote" ? doc.footnotesTree(create) : doc.endnotesTree(create);
+  const oRoot = tree(original);
+  const mRoot = tree(merged);
+  if (!oRoot && !mRoot) return;
+  const refName = `${kind}Reference`;
+  const inOrder = (doc, root) => {
+    if (!root) return [];
+    const byId = new Map(
+      root.children.filter((c) => localName(c.name) === kind && !c.attrs["w:type"]).map((c) => [c.attrs["w:id"], c])
+    );
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const walk2 = (e) => {
+      if (localName(e.name) === refName) {
+        const id = e.attrs["w:id"];
+        const note = byId.get(id);
+        if (note && !seen.has(id)) {
+          seen.add(id);
+          out.push(note);
+        }
+      }
+      for (const c of e.children) walk2(c);
+    };
+    walk2(doc.docRoot);
+    return out;
+  };
+  const oNotes = inOrder(original, oRoot);
+  const rNotes = inOrder(merged, mRoot);
+  const text = (n) => normalizeText(paragraphText3(n));
+  const pairs = [];
+  const waiting = /* @__PURE__ */ new Map();
+  rNotes.forEach((n, j) => {
+    const list = waiting.get(text(n));
+    if (list) list.push(j);
+    else waiting.set(text(n), [j]);
+  });
+  oNotes.forEach((n, i) => {
+    const j = waiting.get(text(n))?.shift();
+    if (j !== void 0) pairs.push([i, j]);
+  });
+  const exactO = new Set(pairs.map((p) => p[0]));
+  const exactR = new Set(pairs.map((p) => p[1]));
+  const oRest = oNotes.map((_, i) => i).filter((i) => !exactO.has(i));
+  const rRest = rNotes.map((_, j) => j).filter((j) => !exactR.has(j));
+  let oAt = 0;
+  let rAt = 0;
+  const rest = histogramMatch(oRest.map((i) => text(oNotes[i])), rRest.map((j) => text(rNotes[j])));
+  for (const a of [...rest, { a: oRest.length, b: rRest.length }]) {
+    if (a.a - oAt === 1 && a.b - rAt === 1) pairs.push([oRest[oAt], rRest[rAt]]);
+    if (a.a < oRest.length && a.b < rRest.length) pairs.push([oRest[a.a], rRest[a.b]]);
+    oAt = a.a + 1;
+    rAt = a.b + 1;
+  }
+  const ids = ctx.noteIds[kind];
+  const pairedO = new Set(pairs.map((p) => p[0]));
+  const pairedR = new Set(pairs.map((p) => p[1]));
+  let changed = false;
+  for (const [i, j] of pairs) {
+    ids.set(oNotes[i].attrs["w:id"], rNotes[j].attrs["w:id"]);
+    const before = ctx.meta.nextId;
+    let touched = false;
+    compareContainer(oNotes[i], rNotes[j], { ...ctx, meta: { ...ctx.meta, nextId: () => (touched = true, before()) } });
+    changed || (changed = touched);
+  }
+  rNotes.forEach((note, j) => {
+    if (pairedR.has(j)) return;
+    for (const block of blockList(note)) if (localName(block.name) === "p") wrapContainerContent(block, "ins", ctx);
+    changed = true;
+  });
+  const removed = oNotes.filter((_, i) => !pairedO.has(i));
+  if (removed.length > 0) {
+    const root = tree(merged, true);
+    if (root) {
+      let next = 1 + Math.max(0, ...root.children.map((c) => Number(c.attrs["w:id"]) || 0));
+      for (const o of removed) {
+        const copy = cloneXml(o);
+        copy.attrs["w:id"] = String(next);
+        ids.set(o.attrs["w:id"], String(next++));
+        for (const block of blockList(copy)) {
+          if (localName(block.name) !== "p") continue;
+          adoptFromOriginal(block, { ...ctx, scope: { from: null, into: null } });
+          wrapContainerContent(block, "del", ctx);
+        }
+        root.children.push(copy);
+      }
+      changed = true;
+    }
+  }
+  if (changed) merged.markNotePartsChanged([kind === "footnote" ? "footnotes" : "endnotes"]);
+}
+function giveStruckReferencesTheirOwnNotes(kind, merged, ctx) {
+  const root = kind === "footnote" ? merged.footnotesTree() : merged.endnotesTree();
+  if (!root) return;
+  const refName = `${kind}Reference`;
+  const refs = /* @__PURE__ */ new Map();
+  const walk2 = (e, struck) => {
+    if (localName(e.name) === refName) {
+      const list = refs.get(e.attrs["w:id"]) ?? [];
+      list.push({ ref: e, struck });
+      refs.set(e.attrs["w:id"], list);
+    }
+    for (const c of e.children) walk2(c, struck || localName(c.name) === "del" || rowDeleted(c));
+  };
+  const rowDeleted = (tr) => localName(tr.name) === "tr" && !!child(child(tr, "trPr"), "del");
+  walk2(merged.docRoot, false);
+  let next = 1 + Math.max(0, ...root.children.map((c) => Number(c.attrs["w:id"]) || 0));
+  let changed = false;
+  for (const [id, list] of refs) {
+    if (list.length < 2) continue;
+    const note = root.children.find((c) => localName(c.name) === kind && c.attrs["w:id"] === id);
+    if (!note) continue;
+    const keep = list.find((r) => !r.struck) ?? list[0];
+    for (const r of list) {
+      if (r === keep || !r.struck) continue;
+      const copy = cloneXml(note);
+      copy.attrs["w:id"] = String(next);
+      r.ref.attrs["w:id"] = String(next++);
+      for (const block of blockList(copy)) if (localName(block.name) === "p") wrapContainerContent(block, "del", ctx);
+      root.children.push(copy);
+      changed = true;
+    }
+  }
+  if (changed) merged.markNotePartsChanged([kind === "footnote" ? "footnotes" : "endnotes"]);
+}
 function blockList(container, ...skip) {
   return container.children.filter((c) => !skip.includes(localName(c.name)));
 }
 function reportUncomparedParts(original, revised, ctx) {
   const parts = [
     ["styles.xml", original.stylesTree()],
-    ["numbering.xml", original.numberingTree()],
-    ["footnotes.xml", original.footnotesTree()],
-    ["endnotes.xml", original.endnotesTree()]
+    ["numbering.xml", original.numberingTree()]
   ];
   const revisedTrees = {
     "styles.xml": revised.stylesTree(),
-    "numbering.xml": revised.numberingTree(),
-    "footnotes.xml": revised.footnotesTree(),
-    "endnotes.xml": revised.endnotesTree()
+    "numbering.xml": revised.numberingTree()
   };
   for (const [name, tree] of parts) {
     const other = revisedTrees[name];
@@ -43333,13 +43923,12 @@ function reportUncomparedParts(original, revised, ctx) {
       ctx.note({ code: "part-not-compared", detail: `${name} differs; the result carries the revised document's` });
     }
   }
-  const hf = (doc) => [...doc.headerRoots(), ...doc.footerRoots()].map((root) => serializeXml(root)).join("");
-  if (hf(original) !== hf(revised)) {
-    ctx.note({ code: "part-not-compared", detail: "headers/footers differ; the result carries the revised document's" });
-  }
 }
 function alignBlocks(oBlocks, rBlocks, ctx) {
-  const anchors = histogramMatch(oBlocks.map(blockFingerprint), rBlocks.map(blockFingerprint));
+  const anchors = histogramMatch(
+    oBlocks.map((el26) => blockFingerprint(el26, ctx.original)),
+    rBlocks.map((el26) => blockFingerprint(el26, ctx.doc))
+  );
   const entries = [];
   let oAt = 0;
   let rAt = 0;
@@ -43353,19 +43942,23 @@ function alignBlocks(oBlocks, rBlocks, ctx) {
   }
   return entries;
 }
-function blockFingerprint(el26) {
+function blockFingerprint(el26, doc) {
   const ln = localName(el26.name);
   if (ln === "p") {
     const pPr = child(el26, "pPr");
     const style = child(pPr, "pStyle")?.attrs["w:val"] ?? "";
     const numPr = child(pPr, "numPr");
-    return `P\0${normalizeText(paragraphText3(el26))}\0${style}\0${numPr ? serializeXml(numPr) : ""}`;
+    const jc = child(pPr, "jc")?.attrs["w:val"] ?? "";
+    const sect = sectionKey(el26, doc);
+    return `P\0${normalizeText(paragraphText3(el26))}\0${style}\0${numPr ? serializeXml(numPr) : ""}\0${jc}\0${sect}`;
   }
   if (ln === "tbl") return `T\0${normalizeText(paragraphText3(el26))}`;
   return `X\0${serializeXml(el26)}`;
 }
 function emitGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, entries, ctx) {
-  const pairings = resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, oLo === 0 && rLo === 0);
+  const before = entries[entries.length - 1];
+  const unanchored = (!before || !isParagraph(before.el)) && (rHi >= rBlocks.length || !isParagraph(rBlocks[rHi]));
+  const pairings = resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, oLo === 0 && rLo === 0 || unanchored);
   let oAt = oLo;
   let rAt = rLo;
   for (const pairing of [...pairings, { kind: "pair", o: oHi, r: rHi, other: -1 }]) {
@@ -43397,16 +43990,43 @@ function emitGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, entries, ctx) {
     }
   }
 }
+var GAP_PAIR_CAP = 200 * 200;
+var GAP_WINDOW = 50;
 function resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, needsAnchor = false) {
   const out = [];
   const oUsed = /* @__PURE__ */ new Set();
   const rUsed = /* @__PURE__ */ new Set();
-  const crosses = (o, r) => out.some((p) => o < p.o !== r < p.r);
+  const placed = [];
+  const crosses = (o, r) => {
+    let lo = 0;
+    let hi = placed.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (placed[mid].o < o) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo > 0 && placed[lo - 1].r >= r || lo < placed.length && placed[lo].r <= r;
+  };
+  const accept = (p) => {
+    out.push(p);
+    let at = placed.length;
+    while (at > 0 && placed[at - 1].o > p.o) at--;
+    placed.splice(at, 0, p);
+  };
+  const oLen = oHi - oLo;
+  const rLen = rHi - rLo;
+  const windowed = oLen * rLen > GAP_PAIR_CAP;
+  const span = (i) => {
+    if (!windowed) return [rLo, rHi];
+    const centre = rLo + Math.round((i - oLo) * rLen / Math.max(1, oLen));
+    return [Math.max(rLo, centre - GAP_WINDOW), Math.min(rHi, centre + GAP_WINDOW + 1)];
+  };
   for (let i = oLo; i < oHi; i++) {
-    for (let j = rLo; j + 1 < rHi; j++) {
+    const [jLo, jHi] = span(i);
+    for (let j = jLo; j + 1 < jHi; j++) {
       if (oUsed.has(i) || rUsed.has(j) || rUsed.has(j + 1) || crosses(i, j)) continue;
       if (concatMatches([oBlocks[i]], [rBlocks[j], rBlocks[j + 1]], ctx)) {
-        out.push({ kind: "split", o: i, r: j, other: j + 1 });
+        accept({ kind: "split", o: i, r: j, other: j + 1 });
         oUsed.add(i);
         rUsed.add(j);
         rUsed.add(j + 1);
@@ -43414,10 +44034,11 @@ function resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, needsAnchor = fal
     }
   }
   for (let i = oLo; i + 1 < oHi; i++) {
-    for (let j = rLo; j < rHi; j++) {
+    const [jLo, jHi] = span(i);
+    for (let j = jLo; j < jHi; j++) {
       if (oUsed.has(i) || oUsed.has(i + 1) || rUsed.has(j) || crosses(i, j)) continue;
       if (concatMatches([oBlocks[i], oBlocks[i + 1]], [rBlocks[j]], ctx)) {
-        out.push({ kind: "merge", o: i, r: j, other: i + 1 });
+        accept({ kind: "merge", o: i, r: j, other: i + 1 });
         oUsed.add(i);
         oUsed.add(i + 1);
         rUsed.add(j);
@@ -43427,9 +44048,10 @@ function resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, needsAnchor = fal
   const scored = [];
   for (let i = oLo; i < oHi; i++) {
     if (oUsed.has(i)) continue;
-    for (let j = rLo; j < rHi; j++) {
+    const [jLo, jHi] = span(i);
+    for (let j = jLo; j < jHi; j++) {
       if (rUsed.has(j)) continue;
-      if (localName(oBlocks[i].name) !== localName(rBlocks[j].name)) continue;
+      if (!pairable(oBlocks[i], rBlocks[j], ctx)) continue;
       const a = paragraphText3(oBlocks[i]);
       const b = paragraphText3(rBlocks[j]);
       const score = similarity(a, b);
@@ -43440,30 +44062,74 @@ function resolveGap(oBlocks, rBlocks, oLo, oHi, rLo, rHi, ctx, needsAnchor = fal
   for (const cand of scored) {
     if (oUsed.has(cand.o) || rUsed.has(cand.r)) continue;
     if (crosses(cand.o, cand.r)) continue;
-    out.push({ kind: "pair", o: cand.o, r: cand.r, other: -1 });
+    accept({ kind: "pair", o: cand.o, r: cand.r, other: -1 });
     oUsed.add(cand.o);
     rUsed.add(cand.r);
   }
+  const settled = [...out].sort((a, b) => a.o - b.o);
+  let oFrom = oLo;
+  let rFrom = rLo;
+  for (const p of [...settled, { kind: "pair", o: oHi, r: rHi, other: -1 }]) {
+    const os = [];
+    const rs = [];
+    for (let i = oFrom; i < p.o; i++) if (!oUsed.has(i)) os.push(i);
+    for (let j = rFrom; j < p.r; j++) if (!rUsed.has(j)) rs.push(j);
+    if (os.length === 1 && rs.length === 1 && sameShape2(oBlocks[os[0]], rBlocks[rs[0]], ctx)) {
+      accept({ kind: "pair", o: os[0], r: rs[0], other: -1 });
+      oUsed.add(os[0]);
+      rUsed.add(rs[0]);
+    }
+    oFrom = p.kind === "merge" ? p.other + 1 : p.o + 1;
+    rFrom = p.kind === "split" ? p.other + 1 : p.r + 1;
+  }
   if (needsAnchor && out.length === 0) {
     for (let i = oLo; i < oHi && out.length === 0; i++) {
       if (oUsed.has(i)) continue;
       for (let j = rLo; j < rHi; j++) {
-        if (rUsed.has(j) || localName(oBlocks[i].name) !== localName(rBlocks[j].name)) continue;
-        out.push({ kind: "pair", o: i, r: j, other: -1 });
+        if (rUsed.has(j) || !pairable(oBlocks[i], rBlocks[j], ctx)) continue;
+        accept({ kind: "pair", o: i, r: j, other: -1 });
         break;
       }
     }
   }
   return out.sort((a, b) => a.o - b.o);
 }
+function pairable(a, b, ctx) {
+  if (localName(a.name) !== localName(b.name)) return false;
+  if (!isParagraph(a)) return true;
+  return sectionKey(a, ctx.original) === sectionKey(b, ctx.doc);
+}
+function sectionKey(el26, doc) {
+  const sectPr = child(child(el26, "pPr"), "sectPr");
+  if (!sectPr) return "";
+  return serializeXml(sectPr).replace(/r:id="([^"]*)"/g, (_, id) => `r:id="${doc.documentRels.get(id)?.target ?? id}"`);
+}
+function sameShape2(a, b, ctx) {
+  if (isParagraph(a) && isParagraph(b)) return pairable(a, b, ctx);
+  if (localName(a.name) === localName(b.name) && ["tbl", "sdt", "customXml"].includes(localName(a.name))) return true;
+  const cells = (tr) => tr.children.filter((c) => localName(c.name) === "tc").length;
+  return localName(a.name) === "tr" && localName(b.name) === "tr" && cells(a) === cells(b);
+}
+function readOptions(ctx, original) {
+  const noteKey = (ref) => {
+    const kind = localName(ref.name) === "footnoteReference" ? "footnote" : "endnote";
+    const id = ref.attrs["w:id"];
+    return original ? `${ctx.noteIds[kind].get(id) ?? `original ${id}`}` : id;
+  };
+  return { whitespace: ctx.whitespace, noteKey };
+}
 function concatMatches(oEls, rEls, ctx) {
   const key = (els) => {
     const parts = [];
     for (const el26 of els) {
       if (localName(el26.name) !== "p") return null;
-      const content = readParagraph(el26, { whitespace: ctx.whitespace });
+      if (child(child(el26, "pPr"), "sectPr")) return null;
+      const content = readParagraph(el26, readOptions(ctx, oEls.includes(el26)));
       if (!content.inlineDiffable) return null;
-      for (const token of content.tokens) parts.push(token.key + "" + runPropsKey(token.run));
+      for (const token of content.tokens) {
+        const props = token.pieces ? token.pieces.map((p) => `${p.text.length}:${runPropsKey(p.run)}`).join("|") : runPropsKey(token.run);
+        parts.push(token.key + "" + props + "" + token.path.map((c) => serializeXml({ ...c, children: c.children.filter((k) => /Pr$/.test(localName(k.name))) })).join(">"));
+      }
     }
     return parts.join("
");
   };
@@ -43475,14 +44141,24 @@ function emitMatched(oEl, rEl, ctx) {
   const ln = localName(oEl.name);
   if (ln === "p") comparePair(oEl, rEl, ctx);
   else if (ln === "tbl") compareTable(oEl, rEl, ctx);
+  else if (ln === "sdt") {
+    const o = child(oEl, "sdtContent");
+    const r = child(rEl, "sdtContent");
+    if (o && r) compareContainer(o, r, ctx);
+  } else if (ln === "customXml") compareContainer(oEl, rEl, ctx);
   return { el: rEl, cls: "kept" };
 }
 var REL_ATTRS = ["id", "embed", "link", "pict", "dm", "lo", "qs", "cs"];
 function adoptFromOriginal(root, ctx) {
-  const mine = ctx.doc.documentRels;
-  const theirs = ctx.original.documentRels;
+  const mine = ctx.doc.relationshipsOf(ctx.scope.into);
+  const theirs = ctx.original.relationshipsOf(ctx.scope.from);
   const remapped = /* @__PURE__ */ new Map();
   const walk2 = (el26) => {
+    const ln = localName(el26.name);
+    if (ln === "footnoteReference" || ln === "endnoteReference") {
+      const to = ctx.noteIds[ln === "footnoteReference" ? "footnote" : "endnote"].get(el26.attrs["w:id"]);
+      if (to !== void 0) el26.attrs["w:id"] = to;
+    }
     for (const key of Object.keys(el26.attrs)) {
       if (!key.startsWith("r:") || !REL_ATTRS.includes(localName(key))) continue;
       const id = el26.attrs[key];
@@ -43492,7 +44168,7 @@ function adoptFromOriginal(root, ctx) {
       if (here && here.target === source.target && here.type === source.type) continue;
       let replacement = remapped.get(id);
       if (replacement === void 0) {
-        replacement = source.external ? ctx.doc.addHyperlinkRel(source.target) : null;
+        replacement = source.external ? ctx.doc.addHyperlinkRel(source.target, ctx.scope.into) : ctx.doc.adoptRelFrom(ctx.original, id, ctx.scope);
         if (replacement === null) {
           ctx.note({
             code: "unresolved-relationship",
@@ -43511,32 +44187,31 @@ function adoptFromOriginal(root, ctx) {
 function emitDeleted(el26, ctx) {
   const clone = cloneXml(el26);
   adoptFromOriginal(clone, ctx);
-  const ln = localName(clone.name);
-  if (ln === "p") {
-    wrapContainerContent(clone, "del", ctx);
-  } else if (ln === "tbl") {
-    for (const row of clone.children.filter((c) => localName(c.name) === "tr")) {
-      markRowRevision(row, "del", ctx.meta);
-      wrapRowContent(row, "del", ctx);
-    }
-  } else if (!isPassenger(ln)) {
-    ctx.note({ code: "untracked-block", detail: `a <${clone.name}> block was removed and is not expressible as a revision` });
-  }
+  markWholeBlock(clone, "del", ctx);
   return { el: clone, cls: "deleted" };
 }
 function emitInserted(el26, ctx) {
+  markWholeBlock(el26, "ins", ctx);
+  return { el: el26, cls: "inserted" };
+}
+function markWholeBlock(el26, kind, ctx) {
   const ln = localName(el26.name);
   if (ln === "p") {
-    wrapContainerContent(el26, "ins", ctx);
+    wrapContainerContent(el26, kind, ctx);
   } else if (ln === "tbl") {
     for (const row of el26.children.filter((c) => localName(c.name) === "tr")) {
-      markRowRevision(row, "ins", ctx.meta);
-      wrapRowContent(row, "ins", ctx);
+      markRowRevision(row, kind, ctx.meta);
+      wrapRowContent(row, kind, ctx);
     }
-  } else if (!isPassenger(ln)) {
-    ctx.note({ code: "untracked-block", detail: `a <${el26.name}> block was added and is not expressible as a revision` });
+  } else if (ln === "sdt" || ln === "customXml") {
+    const inner = ln === "sdt" ? child(el26, "sdtContent") : el26;
+    for (const block of inner?.children ?? []) {
+      markWholeBlock(block, kind, ctx);
+      if (isParagraph(block)) markParagraphGlyph(block, kind, ctx.meta);
+    }
+  } else if (!isPassenger(ln) && ln !== "sdtPr" && ln !== "sdtEndPr" && ln !== "customXmlPr") {
+    ctx.note({ code: "untracked-block", detail: `a <${el26.name}> block was ${kind === "ins" ? "added" : "removed"} and is not expressible as a revision` });
   }
-  return { el: el26, cls: "inserted" };
 }
 function wrapRowContent(row, kind, ctx) {
   for (const cell of row.children.filter((c) => localName(c.name) === "tc")) {
@@ -43546,7 +44221,8 @@ function wrapRowContent(row, kind, ctx) {
   }
 }
 function wrapContainerContent(container, kind, ctx) {
-  const NESTED = ["hyperlink", "smartTag", "dir", "bdo"];
+  const NESTED = ["hyperlink", "smartTag", "dir", "bdo", "fldSimple"];
+  const WRAPPABLE = ["r", "sdt", "customXml"];
   const out = [];
   let group = [];
   const flush = () => {
@@ -43557,7 +44233,7 @@ function wrapContainerContent(container, kind, ctx) {
   };
   for (const c of container.children) {
     const ln = localName(c.name);
-    if (ln === "r") {
+    if (WRAPPABLE.includes(ln)) {
       group.push(c);
       continue;
     }
@@ -43575,10 +44251,10 @@ function wrapContainerContent(container, kind, ctx) {
   container.children = out;
 }
 function comparePair(oEl, rEl, ctx) {
-  if (serializeXml(oEl) === serializeXml(rEl)) return;
+  if (sameXml(oEl, rEl)) return;
   if (ctx.formatting) alignParagraphProps(rEl, child(rEl, "pPr"), child(oEl, "pPr"), ctx);
-  const oc = readParagraph(oEl, { whitespace: ctx.whitespace });
-  const rc = readParagraph(rEl, { whitespace: ctx.whitespace });
+  const oc = readParagraph(oEl, readOptions(ctx, true));
+  const rc = readParagraph(rEl, readOptions(ctx, false));
   if (!oc.inlineDiffable || !rc.inlineDiffable) {
     if (oc.text !== rc.text || serializeXml(stripProps(oEl)) !== serializeXml(stripProps(rEl))) {
       const deleted = cloneXml(oEl);
@@ -43593,70 +44269,180 @@ function comparePair(oEl, rEl, ctx) {
       ];
       ctx.note({
         code: "coarse-paragraph",
-        detail: "a paragraph holding a hyperlink, content control, smart tag or inline math changed; struck and reinserted whole"
+        detail: "a paragraph holding inline math or other content a word diff cannot rebuild changed; struck and reinserted whole"
       });
     }
     return;
   }
   const segments = wordSegments(oc.tokens, rc.tokens);
   const changed = segments.some((s) => !s.equal);
-  if (!changed) {
-    if (ctx.formatting) alignRunPropsInPlace(oEl, rEl, ctx);
-    return;
-  }
+  const flat = oc.tokens.every((t) => t.path.length === 0) && rc.tokens.every((t) => t.path.length === 0);
+  if (!changed && (!ctx.formatting || flat && alignRunPropsInPlace(oEl, rEl, ctx))) return;
   const pPr = child(rEl, "pPr");
-  const out = [];
+  const items = [];
+  const counterpart = /* @__PURE__ */ new Map();
   for (const seg of segments) {
     if (seg.equal) {
-      out.push(...emitEqualSpan(oc.tokens, rc.tokens, seg, ctx));
+      for (const it of emitEqualSpan(oc.tokens, rc.tokens, seg, ctx, counterpart)) items.push({ ...it, kind: null });
       continue;
     }
     if (seg.aEnd > seg.aStart) {
-      const struck = sliceContent(oc.tokens, seg.aStart, seg.aEnd, true);
-      for (const run of struck) adoptFromOriginal(run, ctx);
-      out.push(revisionWrapper(rEl, "del", struck, ctx.meta));
+      for (const it of sliceItems(oc.tokens, seg.aStart, seg.aEnd, true)) {
+        adoptFromOriginal(it.el, ctx);
+        markDeletedText(it.el);
+        items.push({ ...it, kind: "del" });
+      }
     }
     if (seg.bEnd > seg.bStart) {
-      out.push(revisionWrapper(rEl, "ins", sliceContent(rc.tokens, seg.bStart, seg.bEnd, false), ctx.meta));
+      for (const it of sliceItems(rc.tokens, seg.bStart, seg.bEnd, false)) items.push({ ...it, kind: "ins" });
     }
   }
-  out.push(...rc.tail.map(cloneXml));
-  rEl.children = [...pPr ? [pPr] : [], ...out];
+  for (const it of items) if (it.kind === "del") it.path = it.path.map((c) => counterpart.get(c) ?? c);
+  for (const el26 of rc.tail) items.push({ el: cloneXml(el26), path: [], kind: null });
+  const fromOriginal = new Set(oc.tokens.flatMap((t) => t.path));
+  rEl.children = [...pPr ? [pPr] : [], ...nestItems(items, 0, rEl, ctx, fromOriginal)];
+}
+var WRAPPABLE_CONTAINERS = /* @__PURE__ */ new Set(["sdt", "customXml"]);
+function compareTextBoxes(oAtom, rAtom, ctx) {
+  const theirs = textBoxesIn(oAtom);
+  const mine = textBoxesIn(rAtom);
+  for (let i = 0; i < Math.min(theirs.length, mine.length); i++) {
+    if (sameXml(theirs[i], mine[i])) continue;
+    const entries = alignBlocks(blockList(theirs[i]), blockList(mine[i]), ctx);
+    applyParagraphMarks(entries, ctx);
+    mine[i].children = entries.map((e) => e.el);
+  }
+}
+function nestItems(items, depth, rEl, ctx, fromOriginal) {
+  const out = [];
+  let i = 0;
+  while (i < items.length) {
+    const c = items[i].path[depth];
+    let j = i + 1;
+    if (c) {
+      while (j < items.length && items[j].path[depth] === c) j++;
+      const group = items.slice(i, j);
+      const kind = group[0].kind;
+      if (kind && WRAPPABLE_CONTAINERS.has(localName(c.name)) && group.every((it) => it.kind === kind)) {
+        const plain = group.map((it) => ({ ...it, kind: null }));
+        out.push(revisionWrapper(rEl, kind, [containerShell(c, nestItems(plain, depth + 1, rEl, ctx, fromOriginal), fromOriginal.has(c), ctx)], ctx.meta));
+      } else {
+        out.push(containerShell(c, nestItems(group, depth + 1, rEl, ctx, fromOriginal), fromOriginal.has(c), ctx));
+      }
+    } else {
+      const kind = items[i].kind;
+      while (j < items.length && !items[j].path[depth] && items[j].kind === kind) j++;
+      const els = items.slice(i, j).map((it) => it.el);
+      if (kind) out.push(revisionWrapper(rEl, kind, els, ctx.meta));
+      else out.push(...els);
+    }
+    i = j;
+  }
+  return out;
+}
+function containerShell(c, content, fromOriginal, ctx) {
+  const isSdt = localName(c.name) === "sdt";
+  const inner = isSdt ? c.children.find((k) => localName(k.name) === "sdtContent") : void 0;
+  const shell = {
+    name: c.name,
+    attrs: { ...c.attrs },
+    // Property children only (sdtPr, smartTagPr, ...): the content is new.
+    children: c.children.filter((k) => /Pr$/.test(localName(k.name))).map(cloneXml),
+    text: ""
+  };
+  if (fromOriginal) adoptFromOriginal(shell, ctx);
+  if (isSdt) shell.children.push({ name: inner?.name ?? c.name.replace(/sdt$/, "sdtContent"), attrs: { ...inner?.attrs ?? {} }, children: content, text: "" });
+  else shell.children.push(...content);
+  return shell;
 }
 function stripProps(el26) {
   return { ...el26, children: el26.children.filter((c) => localName(c.name) !== "pPr") };
 }
-function emitEqualSpan(oTokens, rTokens, seg, ctx) {
+function emitEqualSpan(oTokens, rTokens, seg, ctx, counterpart) {
+  const units = [];
+  const pieceAt = (pieces, offset) => {
+    let base = 0;
+    for (const p of pieces) {
+      if (offset < base + p.text.length) return p;
+      base += p.text.length;
+    }
+    return pieces[pieces.length - 1];
+  };
+  for (let k = 0; k < seg.bEnd - seg.bStart; k++) {
+    const o = oTokens[seg.aStart + k];
+    const r = rTokens[seg.bStart + k];
+    for (let d = 0; d < Math.min(o.path.length, r.path.length); d++) {
+      if (localName(o.path[d].name) === localName(r.path[d].name)) counterpart.set(o.path[d], r.path[d]);
+    }
+    if (r.atom || !r.pieces || !o.pieces || o.text !== r.text) {
+      if (r.atom) units.push({ token: r, run: r.run, text: "", atom: r.atom, oAtom: o.atom, was: o.run });
+      else for (const p of r.pieces ?? []) units.push({ token: r, run: p.run, t: p.t, text: p.text, was: o.run });
+      continue;
+    }
+    const cuts = /* @__PURE__ */ new Set([0, r.text.length]);
+    for (const pieces of [o.pieces, r.pieces]) {
+      let base = 0;
+      for (const p of pieces) cuts.add(base += p.text.length);
+    }
+    const sorted = [...cuts].sort((x, y) => x - y);
+    for (let c = 0; c + 1 < sorted.length; c++) {
+      const from = sorted[c];
+      const to = sorted[c + 1];
+      if (from === to) continue;
+      const rp = pieceAt(r.pieces, from);
+      units.push({ token: r, run: rp.run, t: rp.t, text: r.text.slice(from, to), was: pieceAt(o.pieces, from).run });
+    }
+  }
   const out = [];
-  let at = seg.bStart;
-  while (at < seg.bEnd) {
-    const run = rTokens[at].run;
-    const oKey = runPropsKey(oTokens[seg.aStart + (at - seg.bStart)].run);
-    let end = at + 1;
-    while (end < seg.bEnd && rTokens[end].run === run && runPropsKey(oTokens[seg.aStart + (end - seg.bStart)].run) === oKey) {
-      end++;
+  let open = null;
+  let text = null;
+  const close = () => {
+    if (open && ctx.formatting && open.was !== runPropsKey(open.run)) swapRunProps(open.el, open.prev, ctx);
+    open = null;
+    text = null;
+  };
+  let lastToken = null;
+  for (const u of units) {
+    if (u.token !== lastToken && u.token.lead) {
+      close();
+      out.push(...u.token.lead.map((el26) => ({ el: cloneXml(el26), path: u.token.path })));
+    }
+    lastToken = u.token;
+    const was = runPropsKey(u.was);
+    if (!open || open.run !== u.run || open.was !== was) {
+      close();
+      const rPr = u.run.children.find((c) => localName(c.name) === "rPr");
+      const el26 = { name: u.run.name, attrs: { ...u.run.attrs }, children: rPr ? [cloneXml(rPr)] : [], text: "" };
+      out.push({ el: el26, path: u.token.path });
+      open = { run: u.run, was, el: el26, prev: child(u.was, "rPr") };
+    }
+    if (u.atom) {
+      const atom = cloneXml(u.atom);
+      if (u.oAtom && !sameXml(u.oAtom, u.atom)) compareTextBoxes(u.oAtom, atom, ctx);
+      open.el.children.push(atom);
+      text = null;
+      continue;
     }
-    const piece = sliceContent(rTokens, at, end, false);
-    if (ctx.formatting && oKey !== runPropsKey(run)) {
-      for (const el26 of piece) {
-        if (localName(el26.name) === "r") {
-          swapRunProps(el26, child(oTokens[seg.aStart + (at - seg.bStart)].run, "rPr"), ctx);
-        }
-      }
+    if (text && text.t === u.t) {
+      text.el.text += u.text;
+      continue;
     }
-    out.push(...piece);
-    at = end;
+    const te = { name: u.t.name, attrs: { ...u.t.attrs, "xml:space": "preserve" }, children: [], text: u.text };
+    open.el.children.push(te);
+    text = { t: u.t, el: te };
   }
+  close();
   return out;
 }
 function alignRunPropsInPlace(oEl, rEl, ctx) {
   const oRuns = oEl.children.filter((c) => localName(c.name) === "r");
   const rRuns = rEl.children.filter((c) => localName(c.name) === "r");
-  if (oRuns.length !== rRuns.length) return;
+  if (oRuns.length !== rRuns.length) return false;
   for (let i = 0; i < rRuns.length; i++) {
-    if (paragraphText3(oRuns[i]) !== paragraphText3(rRuns[i])) return;
+    if (paragraphText3(oRuns[i]) !== paragraphText3(rRuns[i])) return false;
   }
   for (let i = 0; i < rRuns.length; i++) swapRunProps(rRuns[i], child(oRuns[i], "rPr"), ctx);
+  return true;
 }
 function wordSegments(a, b) {
   const raw = [];
@@ -43685,8 +44471,8 @@ function wordSegments(a, b) {
     for (let i = 1; i + 1 < segments.length; i++) {
       const seg = segments[i];
       if (!seg.equal) continue;
-      const len = seg.aEnd - seg.aStart;
-      const beside = Math.min(changeSize(segments[i - 1]), changeSize(segments[i + 1]));
+      const len = words(a, seg.aStart, seg.aEnd);
+      const beside = Math.min(changeSize(segments[i - 1], a, b), changeSize(segments[i + 1], a, b));
       if (len < COMPARE_TUNING.coalesceWindow || len * COMPARE_TUNING.coalesceRatio < beside) {
         seg.equal = false;
         absorbed = true;
@@ -43710,17 +44496,26 @@ function mergeChanges(segments) {
   }
   return out;
 }
-function changeSize(seg) {
-  return Math.max(seg.aEnd - seg.aStart, seg.bEnd - seg.bStart);
+function changeSize(seg, a, b) {
+  return Math.max(words(a, seg.aStart, seg.aEnd), words(b, seg.bStart, seg.bEnd));
+}
+function words(tokens, from, to) {
+  let n = 0;
+  for (let i = from; i < to; i++) if (tokens[i].atom || !/^\s+$/.test(tokens[i].text)) n++;
+  return n;
 }
 function compareTable(oTbl, rTbl, ctx) {
-  if (serializeXml(oTbl) === serializeXml(rTbl)) return;
+  if (sameXml(oTbl, rTbl)) return;
   if (ctx.formatting) {
     swapProps(rTbl, "tblPr", recordTableFormatChange, child(oTbl, "tblPr"), ctx);
     alignTableGrid(oTbl, rTbl, ctx);
   }
-  const oRows = oTbl.children.filter((c) => localName(c.name) === "tr");
-  const rRows = rTbl.children.filter((c) => localName(c.name) === "tr");
+  compareRows(oTbl, rTbl, ctx);
+}
+var ROW_LEVEL = ["tr", "sdt", "customXml"];
+function compareRows(oParent, rParent, ctx) {
+  const oRows = oParent.children.filter((c) => ROW_LEVEL.includes(localName(c.name)));
+  const rRows = rParent.children.filter((c) => ROW_LEVEL.includes(localName(c.name)));
   const anchors = histogramMatch(oRows.map(rowFingerprint), rRows.map(rowFingerprint));
   const rows = [];
   let oAt = 0;
@@ -43745,24 +44540,41 @@ function compareTable(oTbl, rTbl, ctx) {
     oAt = anchor.a + 1;
     rAt = anchor.b + 1;
   }
-  rTbl.children = [...rTbl.children.filter((c) => localName(c.name) !== "tr"), ...rows];
+  rParent.children = [...rParent.children.filter((c) => !ROW_LEVEL.includes(localName(c.name))), ...rows];
 }
 function rowFingerprint(tr) {
+  if (localName(tr.name) !== "tr") return `X\0${serializeXml(tr)}`;
   const cells = tr.children.filter((c) => localName(c.name) === "tc");
   return `${cells.length}\0${normalizeText(paragraphText3(tr))}`;
 }
-function deletedRow(tr, ctx) {
-  const clone = cloneXml(tr);
-  markRowRevision(clone, "del", ctx.meta);
-  wrapRowContent(clone, "del", ctx);
+function rowsIn(el26) {
+  if (localName(el26.name) === "tr") return [el26];
+  const inner = localName(el26.name) === "sdt" ? child(el26, "sdtContent") : el26;
+  return (inner?.children ?? []).filter((c) => ROW_LEVEL.includes(localName(c.name))).flatMap(rowsIn);
+}
+function deletedRow(el26, ctx) {
+  const clone = cloneXml(el26);
+  for (const tr of rowsIn(clone)) {
+    markRowRevision(tr, "del", ctx.meta);
+    wrapRowContent(tr, "del", ctx);
+  }
   return clone;
 }
-function insertedRow(tr, ctx) {
-  markRowRevision(tr, "ins", ctx.meta);
-  wrapRowContent(tr, "ins", ctx);
-  return tr;
+function insertedRow(el26, ctx) {
+  for (const tr of rowsIn(el26)) {
+    markRowRevision(tr, "ins", ctx.meta);
+    wrapRowContent(tr, "ins", ctx);
+  }
+  return el26;
 }
 function compareRow(oTr, rTr, ctx) {
+  if (localName(oTr.name) !== "tr") {
+    const inner = (el26) => localName(el26.name) === "sdt" ? child(el26, "sdtContent") : el26;
+    const o = inner(oTr);
+    const r = inner(rTr);
+    if (o && r) compareRows(o, r, ctx);
+    return [rTr];
+  }
   const oCells = oTr.children.filter((c) => localName(c.name) === "tc");
   const rCells = rTr.children.filter((c) => localName(c.name) === "tc");
   if (oCells.length !== rCells.length) {
@@ -43785,7 +44597,7 @@ function compareRow(oTr, rTr, ctx) {
 function alignTableGrid(oTbl, rTbl, ctx) {
   const oGrid = child(oTbl, "tblGrid");
   const rGrid = child(rTbl, "tblGrid");
-  if (!oGrid || !rGrid || serializeXml(oGrid) === serializeXml(rGrid)) return;
+  if (!oGrid || !rGrid || sameXml(oGrid, rGrid)) return;
   const live = rGrid.children.map(cloneXml);
   rGrid.children = oGrid.children.map(cloneXml);
   recordTableGridChange(rTbl, ctx.meta);
@@ -43872,7 +44684,22 @@ function applyParagraphMarks(entries, ctx) {
   }
 }
 function markRun(entries, start, end, ctx) {
-  const shifted = start > 0 && isParagraph(entries[start - 1].el);
+  let at = start;
+  while (at <= end) {
+    if (!isParagraph(entries[at].el)) {
+      at++;
+      continue;
+    }
+    let last = at;
+    while (last + 1 <= end && isParagraph(entries[last + 1].el)) last++;
+    markParagraphRun(entries, at, last, ctx);
+    at = last + 1;
+  }
+}
+function markParagraphRun(entries, start, end, ctx) {
+  const endsSection = (el26) => isParagraph(el26) && !!child(child(el26, "pPr"), "sectPr");
+  const before = start > 0 ? entries[start - 1].el : void 0;
+  const shifted = !!before && isParagraph(before) && !endsSection(before) && !entries.slice(start, end + 1).some((e) => endsSection(e.el));
   if (shifted) {
     for (let i = start; i <= end; i++) {
       if (!isParagraph(entries[i].el) || !isParagraph(entries[i - 1].el)) continue;
@@ -45359,9 +46186,10 @@ async function renderForPrint(bytes, container) {
   const doc = DocxDocument.load(bytes);
   const layout = layoutDocument(doc);
   renderToDom(doc, layout, container, { zoom: 1, pageGap: 0, pageShadow: false, comments: false });
+  pruneBlankSpans(container);
   const first = layout.pages[0];
   const style = document.createElement("style");
-  style.textContent = printStylesheet(first?.width ?? 816, first?.height ?? 1056);
+  style.textContent = printStylesheet(first?.width ?? 816, first?.height ?? 1056, container);
   document.head.append(style);
   await paintsSettled();
   await Promise.all(Array.from(container.querySelectorAll("img"), (img) => img.decode().catch(() => void 0)));
@@ -55815,4 +56643,4 @@ export {
 cfb/cfb.js:
   (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
 */
-//# sourceMappingURL=chunk-QU3LB5BC.js.map
+//# sourceMappingURL=chunk-ULPL55MT.js.map