@openpresentation/opf 0.11.4 → 0.12.1

package/dist/diff.js

@@ -0,0 +1,604 @@
+import { jsonEqual, formatPointer } from './chunk-RUC7L5DJ.js';
+import './chunk-JKVKYVWL.js';
+import './chunk-HOBSL7AJ.js';
+import './chunk-S5W34SIJ.js';
+import './chunk-E34DJ5LL.js';
+import './chunk-4LAM3N6S.js';
+
+// src/diff-match.ts
+var DEFAULT_MATCH_THRESHOLD = 0.5;
+var DIFFERENT_ID_THRESHOLD = 0.8;
+var MAX_SIMILARITY_PAIRS = 25e4;
+var MAX_LCS_CELLS = 4e6;
+var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var isComposite = (value) => !!value && typeof value === "object";
+var idOf = (value) => isObject(value) && typeof value.id === "string" && value.id !== "" ? value.id : void 0;
+var canonCache = /* @__PURE__ */ new WeakMap();
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  const cached = canonCache.get(value);
+  if (cached !== void 0) return cached;
+  const text = Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  canonCache.set(value, text);
+  return text;
+}
+var leafCache = /* @__PURE__ */ new WeakMap();
+function leaves(value) {
+  if (!isComposite(value)) return /* @__PURE__ */ new Map();
+  const cached = leafCache.get(value);
+  if (cached) return cached;
+  const out = /* @__PURE__ */ new Map();
+  const walk = (node, path) => {
+    if (Array.isArray(node)) {
+      for (const [i, item] of node.entries()) walk(item, `${path}/${i}`);
+    } else if (node && typeof node === "object") for (const key of Object.keys(node)) walk(node[key], `${path}/${key}`);
+    else out.set(path, node);
+  };
+  walk(value, "");
+  leafCache.set(value, out);
+  return out;
+}
+var words = (text) => new Set(text.toLowerCase().split(/\s+/u).filter(Boolean));
+function wordOverlap(a, b) {
+  const left = words(a), right = words(b);
+  if (!left.size || !right.size) return 0;
+  let shared = 0;
+  for (const word of left) if (right.has(word)) shared++;
+  return shared / (left.size + right.size - shared);
+}
+function similarity(a, b) {
+  if (canonical(a) === canonical(b)) return 1;
+  const left = leaves(a), right = leaves(b);
+  const size = Math.max(left.size, right.size);
+  if (!size) return 0;
+  let score = 0;
+  for (const [path, value] of left) {
+    if (!right.has(path)) continue;
+    const other = right.get(path);
+    if (value === other) score += 1;
+    else if (typeof value === "string" && typeof other === "string") score += 0.5 * wordOverlap(value, other);
+  }
+  return score / size;
+}
+function longestIncreasing(values) {
+  const tails = [], previous = new Array(values.length).fill(-1);
+  for (let i = 0; i < values.length; i++) {
+    let lo = 0, hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (values[tails[mid]] < values[i]) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo > 0) previous[i] = tails[lo - 1];
+    tails[lo] = i;
+  }
+  const chain = [];
+  for (let at = tails.length ? tails[tails.length - 1] : -1; at >= 0; at = previous[at]) chain.push(at);
+  return chain.reverse();
+}
+function lcsPairs(keysA, keysB) {
+  const n = keysA.length, m = keysB.length;
+  if (!n || !m) return [];
+  if (n * m > MAX_LCS_CELLS) {
+    const pairs2 = [];
+    let head = 0;
+    while (head < n && head < m && keysA[head] === keysB[head]) {
+      pairs2.push([head, head]);
+      head++;
+    }
+    let tail = 0;
+    while (tail < n - head && tail < m - head && keysA[n - 1 - tail] === keysB[m - 1 - tail]) tail++;
+    for (let k = tail; k > 0; k--) pairs2.push([n - k, m - k]);
+    return pairs2;
+  }
+  const width = m + 1, table = new Uint32Array((n + 1) * width);
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      table[i * width + j] = keysA[i] === keysB[j] ? table[(i + 1) * width + j + 1] + 1 : Math.max(table[(i + 1) * width + j], table[i * width + j + 1]);
+    }
+  }
+  const pairs = [];
+  for (let i = 0, j = 0; i < n && j < m; ) {
+    if (keysA[i] === keysB[j]) {
+      pairs.push([i, j]);
+      i++;
+      j++;
+    } else if (table[(i + 1) * width + j] >= table[i * width + j + 1]) i++;
+    else j++;
+  }
+  return pairs;
+}
+function matchArrays(a, b, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_MATCH_THRESHOLD;
+  const matchA = new Array(a.length).fill(-1), matchB = new Array(b.length).fill(-1);
+  const pairs = [];
+  const link = (i, j, by, score) => {
+    matchA[i] = j;
+    matchB[j] = i;
+    pairs.push(score === void 0 ? { a: i, b: j, by } : { a: i, b: j, by, similarity: score });
+  };
+  const free = (side) => side.map((value, index) => value < 0 ? index : -1).filter((index) => index >= 0);
+  const idsB = /* @__PURE__ */ new Map();
+  b.forEach((item, j) => {
+    const id = idOf(item);
+    if (id !== void 0) (idsB.get(id) ?? idsB.set(id, []).get(id)).push(j);
+  });
+  const used = /* @__PURE__ */ new Map();
+  a.forEach((item, i) => {
+    const id = idOf(item);
+    if (id === void 0) return;
+    const list = idsB.get(id), at = used.get(id) ?? 0;
+    if (list && at < list.length) {
+      link(i, list[at], "id");
+      used.set(id, at + 1);
+    }
+  });
+  let freeA = free(matchA), freeB = free(matchB);
+  const keysA = freeA.map((i) => canonical(a[i])), keysB = freeB.map((j) => canonical(b[j]));
+  for (const [x, y] of lcsPairs(keysA, keysB)) link(freeA[x], freeB[y], "equal");
+  freeA = free(matchA);
+  freeB = free(matchB);
+  const pool = /* @__PURE__ */ new Map();
+  freeB.forEach((j) => {
+    const key = canonical(b[j]);
+    (pool.get(key) ?? pool.set(key, []).get(key)).push(j);
+  });
+  for (const i of freeA) {
+    const list = pool.get(canonical(a[i]));
+    if (list?.length) link(i, list.shift(), "equal");
+  }
+  freeA = free(matchA).filter((i) => isComposite(a[i]));
+  freeB = free(matchB).filter((j) => isComposite(b[j]));
+  if (freeA.length && freeB.length && freeA.length * freeB.length <= MAX_SIMILARITY_PAIRS) {
+    const scored = [];
+    for (const i of freeA) for (const j of freeB) {
+      const idA = idOf(a[i]), idB = idOf(b[j]);
+      const needed = idA !== void 0 && idB !== void 0 && idA !== idB ? Math.max(threshold, DIFFERENT_ID_THRESHOLD) : threshold;
+      const score = similarity(a[i], b[j]);
+      if (score >= needed && score > 0) scored.push({ i, j, score });
+    }
+    scored.sort((x, y) => y.score - x.score || x.i - y.i || x.j - y.j);
+    for (const { i, j, score } of scored) if (matchA[i] < 0 && matchB[j] < 0) link(i, j, "similar", Math.round(score * 1e3) / 1e3);
+  }
+  pairs.sort((x, y) => x.a - y.a);
+  const chain = longestIncreasing(pairs.map((pair) => pair.b)).map((index) => pairs[index]);
+  const anchors = [[-1, -1], ...chain.map((pair) => [pair.a, pair.b]), [a.length, b.length]];
+  for (let k = 0; k + 1 < anchors.length; k++) {
+    const [a0, b0] = anchors[k], [a1, b1] = anchors[k + 1];
+    const gapA = [], gapB = [];
+    for (let i = a0 + 1; i < a1; i++) if (matchA[i] < 0 && !isComposite(a[i])) gapA.push(i);
+    for (let j = b0 + 1; j < b1; j++) if (matchB[j] < 0 && !isComposite(b[j])) gapB.push(j);
+    for (let n = 0; n < Math.min(gapA.length, gapB.length); n++) link(gapA[n], gapB[n], "position");
+  }
+  pairs.sort((x, y) => x.a - y.a);
+  const inChain = new Set(longestIncreasing(pairs.map((pair) => pair.b)));
+  const moved = /* @__PURE__ */ new Set();
+  pairs.forEach((pair, index) => {
+    if (!inChain.has(index)) moved.add(pair.a);
+  });
+  return { pairs, removed: free(matchA), added: free(matchB), moved };
+}
+
+// src/merge.ts
+var ABSENT = /* @__PURE__ */ Symbol("absent");
+var isObject2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var has = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var same = (x, y) => x === ABSENT || y === ABSENT ? x === y : jsonEqual(x, y);
+var MESSAGES = {
+  "modify-modify": "Both sides changed this value differently.",
+  "modify-delete": "We changed this value; they deleted it.",
+  "delete-modify": "We deleted this value; they changed it.",
+  "add-add": "Both sides added different values here.",
+  "move-move": "Both sides moved this element to different positions."
+};
+function conflict(ctx, kind, path, base, ours, theirs) {
+  const entry = { kind, path: formatPointer(path), resolution: ctx.prefer, message: MESSAGES[kind] };
+  if (base !== ABSENT) entry.base = structuredClone(base);
+  if (ours !== ABSENT) entry.ours = structuredClone(ours);
+  if (theirs !== ABSENT) entry.theirs = structuredClone(theirs);
+  if (kind === "modify-delete") entry.deletedBy = "theirs";
+  if (kind === "delete-modify") entry.deletedBy = "ours";
+  if (ctx.slide) entry.slide = { ...ctx.slide };
+  ctx.conflicts.push(entry);
+  return ctx.prefer === "ours" ? ours : theirs;
+}
+function mergeValue(base, ours, theirs, path, ctx) {
+  if (same(ours, theirs)) {
+    if (!same(ours, base)) ctx.applied.both++;
+    return ours;
+  }
+  if (same(ours, base)) {
+    ctx.applied.theirs++;
+    return theirs;
+  }
+  if (same(theirs, base)) {
+    ctx.applied.ours++;
+    return ours;
+  }
+  if (base !== ABSENT) {
+    if (ours === ABSENT) return conflict(ctx, "delete-modify", path, base, ours, theirs);
+    if (theirs === ABSENT) return conflict(ctx, "modify-delete", path, base, ours, theirs);
+    if (isObject2(base) && isObject2(ours) && isObject2(theirs)) return mergeObject(base, ours, theirs, path, ctx);
+    if (Array.isArray(base) && Array.isArray(ours) && Array.isArray(theirs)) return mergeArray(base, ours, theirs, path, ctx);
+    return conflict(ctx, "modify-modify", path, base, ours, theirs);
+  }
+  if (isObject2(ours) && isObject2(theirs)) return mergeObject({}, ours, theirs, path, ctx);
+  if (Array.isArray(ours) && Array.isArray(theirs)) return mergeArray([], ours, theirs, path, ctx);
+  return conflict(ctx, "add-add", path, base, ours, theirs);
+}
+function mergeObject(base, ours, theirs, path, ctx) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of [base, ours, theirs]) for (const key of Object.keys(source)) if (!seen.has(key)) {
+    seen.add(key);
+    keys.push(key);
+  }
+  const out = {};
+  for (const key of keys) {
+    const value = mergeValue(has(base, key) ? base[key] : ABSENT, has(ours, key) ? ours[key] : ABSENT, has(theirs, key) ? theirs[key] : ABSENT, [...path, key], ctx);
+    if (value !== ABSENT) Object.defineProperty(out, key, { value, enumerable: true, configurable: true, writable: true });
+  }
+  return out;
+}
+function mergeArray(base, ours, theirs, path, ctx) {
+  const mo = matchArrays(base, ours, ctx.match), mt = matchArrays(base, theirs, ctx.match);
+  const oOf = new Array(base.length).fill(-1), tOf = new Array(base.length).fill(-1);
+  const baseOfO = new Array(ours.length).fill(-1), baseOfT = new Array(theirs.length).fill(-1);
+  for (const pair of mo.pairs) {
+    oOf[pair.a] = pair.b;
+    baseOfO[pair.b] = pair.a;
+  }
+  for (const pair of mt.pairs) {
+    tOf[pair.a] = pair.b;
+    baseOfT[pair.b] = pair.a;
+  }
+  const spine = ours.map((_, o) => {
+    const b = baseOfO[o];
+    return { b, o, t: b >= 0 ? tOf[b] : -1 };
+  });
+  const oursAddedOnly = (node) => !!node && node.b < 0 && node.o >= 0 && node.t < 0;
+  const tNode = /* @__PURE__ */ new Map();
+  for (const node of spine) if (node.t >= 0) tNode.set(node.t, node);
+  const insertAfterPredecessor = (ti, node) => {
+    let anchor;
+    for (let p = ti - 1; p >= 0 && !anchor; p--) anchor = tNode.get(p);
+    let at = anchor ? spine.indexOf(anchor) + 1 : 0;
+    while (oursAddedOnly(spine[at])) at++;
+    spine.splice(at, 0, node);
+  };
+  for (let ti = 0; ti < theirs.length; ti++) {
+    const bi = baseOfT[ti];
+    if (bi >= 0) {
+      if (oOf[bi] >= 0) continue;
+      if (same(base[bi], theirs[ti])) {
+        ctx.applied.ours++;
+        continue;
+      }
+      const node2 = { b: bi, o: -1, t: ti };
+      tNode.set(ti, node2);
+      insertAfterPredecessor(ti, node2);
+      continue;
+    }
+    const id = idOf(theirs[ti]);
+    let twin = id !== void 0 ? spine.find((node2) => oursAddedOnly(node2) && idOf(ours[node2.o]) === id) : void 0;
+    if (!twin) {
+      let anchor;
+      for (let p = ti - 1; p >= 0 && !anchor; p--) anchor = tNode.get(p);
+      for (let at = anchor ? spine.indexOf(anchor) + 1 : 0; oursAddedOnly(spine[at]); at++) {
+        if (jsonEqual(ours[spine[at].o], theirs[ti])) {
+          twin = spine[at];
+          break;
+        }
+      }
+    }
+    if (twin) {
+      twin.t = ti;
+      tNode.set(ti, twin);
+      continue;
+    }
+    const node = { b: -1, o: -1, t: ti };
+    tNode.set(ti, node);
+    insertAfterPredecessor(ti, node);
+  }
+  const basePredecessor = (list, index) => {
+    for (let p = index - 1; p >= 0; p--) if (list[p] >= 0) return list[p];
+    return -1;
+  };
+  const movedByTheirs = mt.pairs.filter((pair) => mt.moved.has(pair.a)).sort((x, y) => x.b - y.b);
+  for (const pair of movedByTheirs) {
+    const node = spine.find((candidate) => candidate.b === pair.a && candidate.o >= 0 && candidate.t === pair.b);
+    if (!node) continue;
+    if (mo.moved.has(pair.a)) {
+      if (basePredecessor(baseOfO, node.o) === basePredecessor(baseOfT, pair.b)) continue;
+      node.moveConflict = true;
+      if (ctx.prefer === "ours") continue;
+    }
+    spine.splice(spine.indexOf(node), 1);
+    insertAfterPredecessor(pair.b, node);
+  }
+  const out = [];
+  const isSlides = path.length === 1 && path[0] === "slides";
+  for (const node of spine) {
+    const at = [...path, out.length];
+    const savedSlide = ctx.slide;
+    if (isSlides) {
+      const sample = node.o >= 0 ? ours[node.o] : node.t >= 0 ? theirs[node.t] : base[node.b];
+      ctx.slide = { index: out.length, ...idOf(sample) !== void 0 ? { id: idOf(sample) } : {}, ...isObject2(sample) && typeof sample.title === "string" ? { title: sample.title } : {} };
+    }
+    try {
+      const b = node.b >= 0 ? base[node.b] : ABSENT, o = node.o >= 0 ? ours[node.o] : ABSENT, t = node.t >= 0 ? theirs[node.t] : ABSENT;
+      if (node.b >= 0) {
+        if (o !== ABSENT && t !== ABSENT) {
+          const merged = mergeValue(b, o, t, at, ctx);
+          if (node.moveConflict) {
+            ctx.conflicts.push({ kind: "move-move", path: formatPointer(at), base: structuredClone(b), resolution: ctx.prefer, message: MESSAGES["move-move"], ...ctx.slide ? { slide: { ...ctx.slide } } : {} });
+          }
+          out.push(merged);
+        } else if (o !== ABSENT) {
+          if (same(b, o)) ctx.applied.theirs++;
+          else {
+            const kept = conflict(ctx, "modify-delete", at, b, o, ABSENT);
+            if (kept !== ABSENT) out.push(kept);
+          }
+        } else if (t !== ABSENT) {
+          const kept = conflict(ctx, "delete-modify", at, b, ABSENT, t);
+          if (kept !== ABSENT) out.push(kept);
+        }
+      } else if (o !== ABSENT && t !== ABSENT) {
+        out.push(mergeValue(ABSENT, o, t, at, ctx));
+      } else if (o !== ABSENT) {
+        ctx.applied.ours++;
+        out.push(o);
+      } else {
+        ctx.applied.theirs++;
+        out.push(t);
+      }
+    } finally {
+      ctx.slide = savedSlide;
+    }
+  }
+  return out;
+}
+function mergePresentations(base, ours, theirs, options = {}) {
+  const ctx = {
+    prefer: options.prefer === "theirs" ? "theirs" : "ours",
+    match: { threshold: options.threshold ?? DEFAULT_MATCH_THRESHOLD },
+    conflicts: [],
+    applied: { ours: 0, theirs: 0, both: 0 }
+  };
+  const merged = mergeValue(structuredClone(base), structuredClone(ours), structuredClone(theirs), [], ctx);
+  return { merged: merged === ABSENT ? void 0 : merged, conflicts: ctx.conflicts, clean: ctx.conflicts.length === 0, applied: ctx.applied };
+}
+
+// src/diff.ts
+var isObject3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var REGION_KEY = /^(top|middle|bottom|left|center|right)([:+].*)?$/u;
+var ROOT_CATEGORIES = { design: "design", assets: "assets", catalogs: "catalogs", variables: "variables", narrative: "narrative", extensions: "extensions" };
+function categoryOf(tokens) {
+  const [root] = tokens;
+  if (root === void 0) return "metadata";
+  if (root === "slides") {
+    if (tokens.length <= 2) return "slide";
+    if (tokens[2] === "design") return "design";
+    const last = tokens[tokens.length - 1] ?? "", parent = tokens[tokens.length - 2];
+    if (parent === "blocks" && /^\d+$/u.test(last)) return "block";
+    if (REGION_KEY.test(last)) return "block";
+    return "field";
+  }
+  return ROOT_CATEGORIES[root] ?? "metadata";
+}
+var pointer = (tokens) => formatPointer(tokens);
+var titleOf = (slide) => isObject3(slide) && typeof slide.title === "string" ? slide.title : void 0;
+var slideRef = (slide, aIndex, bIndex) => {
+  const ref = {};
+  const id = idOf(slide), title = titleOf(slide);
+  if (id !== void 0) ref.id = id;
+  if (title !== void 0) ref.title = title;
+  if (aIndex !== void 0) ref.aIndex = aIndex;
+  if (bIndex !== void 0) ref.bIndex = bIndex;
+  return ref;
+};
+function record(ctx, change) {
+  if (ctx.slide) change.slide = { ...ctx.slide };
+  ctx.changes.push(change);
+}
+function diffValue(a, b, aPath, bPath, ctx) {
+  if (jsonEqual(a, b)) return;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    diffArray(a, b, aPath, bPath, ctx);
+    return;
+  }
+  if (isObject3(a) && isObject3(b)) {
+    diffObject(a, b, aPath, bPath, ctx);
+    return;
+  }
+  ctx.patch.push({ op: "replace", path: pointer(bPath), value: structuredClone(b) });
+  record(ctx, { type: "changed", category: categoryOf(bPath.map(String)), aPath: pointer(aPath), bPath: pointer(bPath), before: structuredClone(a), after: structuredClone(b) });
+}
+function diffObject(a, b, aPath, bPath, ctx) {
+  const own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+  for (const key of Object.keys(a)) {
+    if (own(b, key)) continue;
+    ctx.patch.push({ op: "remove", path: pointer([...bPath, key]) });
+    record(ctx, { type: "removed", category: categoryOf([...aPath, key].map(String)), aPath: pointer([...aPath, key]), before: structuredClone(a[key]) });
+  }
+  for (const key of Object.keys(b)) {
+    if (!own(a, key)) {
+      ctx.patch.push({ op: "add", path: pointer([...bPath, key]), value: structuredClone(b[key]) });
+      record(ctx, { type: "added", category: categoryOf([...bPath, key].map(String)), bPath: pointer([...bPath, key]), after: structuredClone(b[key]) });
+    } else diffValue(a[key], b[key], [...aPath, key], [...bPath, key], ctx);
+  }
+}
+function diffArray(a, b, aPath, bPath, ctx) {
+  const match = matchArrays(a, b, ctx.options);
+  const isSlides = aPath.length === 1 && aPath[0] === "slides" && bPath.length === 1 && bPath[0] === "slides";
+  const category = (path) => categoryOf(path.map(String));
+  if (isSlides) {
+    const changedPairs = /* @__PURE__ */ new Set();
+    for (const pair of match.pairs) if (!jsonEqual(a[pair.a], b[pair.b])) changedPairs.add(pair.a);
+    const infos = [];
+    for (const pair of match.pairs) {
+      const moved = match.moved.has(pair.a), changed = changedPairs.has(pair.a);
+      infos.push({ ...slideRef(b[pair.b], pair.a, pair.b), matchedBy: pair.by, ...pair.similarity !== void 0 ? { similarity: pair.similarity } : {}, status: moved ? changed ? "moved-modified" : "moved" : changed ? "modified" : "unchanged" });
+    }
+    for (const i of match.removed) infos.push({ ...slideRef(a[i], i), status: "removed" });
+    for (const j of match.added) infos.push({ ...slideRef(b[j], void 0, j), status: "added" });
+    infos.sort((x, y) => (x.bIndex ?? Infinity) - (y.bIndex ?? Infinity) || (x.aIndex ?? 0) - (y.aIndex ?? 0));
+    ctx.slides.push(...infos);
+  }
+  const withSlide = (fn, aIndex, bIndex) => {
+    if (!isSlides) return fn();
+    const saved = ctx.slide;
+    ctx.slide = slideRef(bIndex !== void 0 ? b[bIndex] : a[aIndex], aIndex, bIndex);
+    try {
+      fn();
+    } finally {
+      ctx.slide = saved;
+    }
+  };
+  for (const i of [...match.removed].reverse()) ctx.patch.push({ op: "remove", path: pointer([...bPath, i]) });
+  for (const i of match.removed) withSlide(() => record(ctx, { type: "removed", category: category([...aPath, i]), aPath: pointer([...aPath, i]), before: structuredClone(a[i]) }), i, void 0);
+  const order = match.pairs.slice().sort((x, y) => x.b - y.b);
+  const current = match.pairs.map((pair) => pair.a);
+  order.forEach((pair, t) => {
+    if (!match.moved.has(pair.a)) return;
+    const from = current.indexOf(pair.a);
+    current.splice(from, 1);
+    const to = t === 0 ? 0 : current.indexOf(order[t - 1].a) + 1;
+    current.splice(to, 0, pair.a);
+    if (from !== to) ctx.patch.push({ op: "move", from: pointer([...bPath, from]), path: pointer([...bPath, to]) });
+    withSlide(() => record(ctx, { type: "moved", category: category([...bPath, pair.b]), aPath: pointer([...aPath, pair.a]), bPath: pointer([...bPath, pair.b]) }), pair.a, pair.b);
+  });
+  for (const j of match.added) {
+    ctx.patch.push({ op: "add", path: pointer([...bPath, j]), value: structuredClone(b[j]) });
+    withSlide(() => record(ctx, { type: "added", category: category([...bPath, j]), bPath: pointer([...bPath, j]), after: structuredClone(b[j]) }), void 0, j);
+  }
+  for (const pair of order) {
+    withSlide(() => diffValue(a[pair.a], b[pair.b], [...aPath, pair.a], [...bPath, pair.b], ctx), pair.a, pair.b);
+  }
+}
+function summarise(changes, slides) {
+  const summary = { total: changes.length, byCategory: {}, byType: {}, slides: { added: 0, removed: 0, moved: 0, modified: 0, unchanged: 0 } };
+  for (const change of changes) {
+    summary.byCategory[change.category] = (summary.byCategory[change.category] ?? 0) + 1;
+    summary.byType[change.type] = (summary.byType[change.type] ?? 0) + 1;
+  }
+  for (const slide of slides) {
+    if (slide.status === "added") summary.slides.added++;
+    else if (slide.status === "removed") summary.slides.removed++;
+    else if (slide.status === "unchanged") summary.slides.unchanged++;
+    else {
+      if (slide.status === "moved" || slide.status === "moved-modified") summary.slides.moved++;
+      if (slide.status === "modified" || slide.status === "moved-modified") summary.slides.modified++;
+    }
+  }
+  return summary;
+}
+function diffPresentations(a, b, options = {}) {
+  const ctx = { options: { threshold: options.threshold ?? DEFAULT_MATCH_THRESHOLD }, changes: [], patch: [], slides: [] };
+  diffValue(a, b, [], [], ctx);
+  return { equal: ctx.patch.length === 0, changes: ctx.changes, patch: ctx.patch, slides: ctx.slides, summary: summarise(ctx.changes, ctx.slides) };
+}
+var CONTENT_KINDS = ["blocks", "chart", "table", "code", "metric", "quote", "timeline", "image", "video", "items", "bullets", "text"];
+function shorten(text, max = 60) {
+  const flat = text.replace(/\s+/gu, " ");
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function describeValue(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return JSON.stringify(shorten(value));
+  if (value === null || typeof value !== "object") return String(value);
+  if (Array.isArray(value)) return `[${value.length} item${value.length === 1 ? "" : "s"}]`;
+  const keys = Object.keys(value);
+  const kind = CONTENT_KINDS.find((key) => key in value);
+  const record2 = value;
+  if (kind) {
+    const text = typeof record2.text === "string" ? ` ${JSON.stringify(shorten(record2.text, 40))}` : typeof record2.title === "string" ? ` ${JSON.stringify(shorten(record2.title, 40))}` : "";
+    return `${kind}${text}`;
+  }
+  if (typeof record2.id === "string") return `{id ${JSON.stringify(record2.id)}}`;
+  return `{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", \u2026" : ""}}`;
+}
+function displayPath(pointerText, prefixLength = 0) {
+  if (pointerText === void 0) return "";
+  const tokens = pointerText.split("/").slice(1).map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~")).slice(prefixLength);
+  if (!tokens.length) return "(whole value)";
+  return tokens.map((token, i) => /^\d+$/u.test(token) ? `[${token}]` : /^[A-Za-z_$][\w$-]*$/u.test(token) ? i ? `.${token}` : token : `[${JSON.stringify(token)}]`).join("");
+}
+function slideLabel(slide, side = "b") {
+  const index = side === "b" ? slide.bIndex ?? slide.aIndex : slide.aIndex ?? slide.bIndex;
+  const parts = [`#${(index ?? 0) + 1}`];
+  if (slide.title) parts.push(JSON.stringify(shorten(slide.title, 40)));
+  if (slide.id) parts.push(`(id ${slide.id})`);
+  return parts.join(" ");
+}
+function changeLine(change, prefixLength) {
+  switch (change.type) {
+    case "added":
+      return `+ ${displayPath(change.bPath, prefixLength)}  ${describeValue(change.after)}`.trimEnd();
+    case "removed":
+      return `- ${displayPath(change.aPath, prefixLength)}  ${describeValue(change.before)}`.trimEnd();
+    case "moved":
+      return `> ${displayPath(change.aPath, prefixLength)} -> ${displayPath(change.bPath, prefixLength)}`;
+    default:
+      return `~ ${displayPath(change.bPath, prefixLength)}  ${describeValue(change.before)} -> ${describeValue(change.after)}`;
+  }
+}
+var SECTION_TITLES = {
+  metadata: "Metadata",
+  design: "Design",
+  variables: "Variables",
+  narrative: "Narrative",
+  assets: "Assets",
+  catalogs: "Catalogs",
+  extensions: "Extensions",
+  slide: "Slides",
+  block: "Slides",
+  field: "Slides"
+};
+function formatDiffReport(diff) {
+  if (diff.equal) return "No differences.\n";
+  const lines = [];
+  const s = diff.summary.slides;
+  const headline = [];
+  const slideParts = [[s.added, "added"], [s.removed, "removed"], [s.moved, "moved"], [s.modified, "modified"]].filter(([n]) => n > 0).map(([n, label]) => `${n} ${label}`);
+  if (slideParts.length) headline.push(`slides: ${slideParts.join(", ")}`);
+  for (const category of ["metadata", "design", "variables", "narrative", "assets", "catalogs", "extensions"]) {
+    const count = diff.summary.byCategory[category];
+    if (count) headline.push(`${category}: ${count}`);
+  }
+  lines.push(`${diff.summary.total} change${diff.summary.total === 1 ? "" : "s"} (${headline.join("; ")})`, "");
+  for (const category of ["metadata", "design", "variables", "narrative", "assets", "catalogs", "extensions"]) {
+    const section = diff.changes.filter((change) => change.category === category);
+    if (!section.length) continue;
+    lines.push(SECTION_TITLES[category]);
+    for (const change of section) lines.push(`  ${changeLine(change, 0)}`);
+    lines.push("");
+  }
+  const slideChanges = diff.changes.filter((change) => change.category === "slide" || change.category === "block" || change.category === "field" || change.slide && change.category === "design");
+  if (slideChanges.length || diff.slides.some((slide) => slide.status !== "unchanged")) {
+    lines.push("Slides");
+    const whole = (change) => change.category === "slide" && !!change.slide && (change.bPath ?? change.aPath)?.split("/").length === 3;
+    for (const info of diff.slides) {
+      if (info.status === "unchanged") continue;
+      if (info.status === "added") {
+        lines.push(`  + slide ${slideLabel(info)}`);
+        continue;
+      }
+      if (info.status === "removed") {
+        lines.push(`  - slide ${slideLabel(info, "a")}`);
+        continue;
+      }
+      const moveNote = info.status === "moved" || info.status === "moved-modified" ? ` (moved from #${(info.aIndex ?? 0) + 1})` : "";
+      lines.push(`  ~ slide ${slideLabel(info)}${moveNote}${info.matchedBy === "similar" ? " (matched by content)" : ""}`);
+      const inner = slideChanges.filter((change) => !whole(change) && change.slide && change.slide.bIndex === info.bIndex && change.slide.aIndex === info.aIndex);
+      for (const change of inner) lines.push(`      ${changeLine(change, 2)}`);
+    }
+    for (const change of slideChanges) if (!change.slide) lines.push(`  ${changeLine(change, 0)}`);
+    lines.push("");
+  }
+  return `${lines.join("\n").replace(/\n+$/u, "")}
+`;
+}
+
+export { categoryOf, describeValue, diffPresentations, formatDiffReport, matchArrays, mergePresentations, similarity };