@pixerate/editor 0.23.0 → 0.25.0

package/dist/chunk-AL6JMGWW.cjs

@@ -0,0 +1,783 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+var _chunkX4N4WUKBcjs = require('./chunk-X4N4WUKB.cjs');
+
+// src/compare/diff.ts
+var EQUAL = 0;
+var DELETE = 1;
+var INSERT = 2;
+function pushRepeat(out, op, count) {
+  for (let i = 0; i < count; i++) out.push(op);
+}
+function myers(aLo, aHi, bLo, bHi, eq, out, maxD) {
+  const n = aHi - aLo;
+  const m = bHi - bLo;
+  if (n === 0 || m === 0) {
+    pushRepeat(out, DELETE, n);
+    pushRepeat(out, INSERT, m);
+    return true;
+  }
+  const max = n + m;
+  const off = max + 1;
+  const v = new Int32Array(2 * max + 3);
+  const trace = [];
+  const limit = Math.min(max, maxD);
+  let found = false;
+  outer: for (let d = 0; d <= limit; d++) {
+    trace.push(v.slice(Math.max(off - d - 1, 0), off + d + 2));
+    for (let k = -d; k <= d; k += 2) {
+      const i = k + off;
+      let x2 = k === -d || k !== d && v[i - 1] < v[i + 1] ? v[i + 1] : v[i - 1] + 1;
+      let y2 = x2 - k;
+      while (x2 < n && y2 < m && eq(aLo + x2, bLo + y2)) {
+        x2++;
+        y2++;
+      }
+      v[i] = x2;
+      if (x2 >= n && y2 >= m) {
+        found = true;
+        break outer;
+      }
+    }
+  }
+  if (!found) return false;
+  const ops = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const frontier = trace[d];
+    const base = Math.max(off - d - 1, 0);
+    const at = (k2) => frontier[k2 + off - base];
+    const k = x - y;
+    const prevK = k === -d || k !== d && at(k - 1) < at(k + 1) ? k + 1 : k - 1;
+    const prevX = at(prevK);
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      ops.push(EQUAL);
+      x--;
+      y--;
+    }
+    if (d > 0) ops.push(x === prevX ? INSERT : DELETE);
+    x = prevX;
+    y = prevY;
+  }
+  for (let i = ops.length - 1; i >= 0; i--) out.push(ops[i]);
+  return true;
+}
+function anchors(ids, aLo, aHi, bLo, bHi) {
+  const count = /* @__PURE__ */ new Map();
+  for (let i = aLo; i < aHi; i++) {
+    const id = ids.a[i];
+    const entry = count.get(id);
+    if (entry) {
+      entry[0]++;
+    } else {
+      count.set(id, [1, 0, i, -1]);
+    }
+  }
+  for (let j = bLo; j < bHi; j++) {
+    const entry = count.get(ids.b[j]);
+    if (entry) {
+      entry[1]++;
+      entry[3] = j;
+    }
+  }
+  const pairs = [];
+  count.forEach((entry) => {
+    if (entry[0] === 1 && entry[1] === 1) pairs.push([entry[2], entry[3]]);
+  });
+  pairs.sort((p, q) => p[0] - q[0]);
+  const tails = [];
+  const prev = new Int32Array(pairs.length).fill(-1);
+  for (let k2 = 0; k2 < pairs.length; k2++) {
+    const y = pairs[k2][1];
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (pairs[tails[mid]][1] < y) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo > 0) prev[k2] = tails[lo - 1];
+    if (lo === tails.length) tails.push(k2);
+    else tails[lo] = k2;
+  }
+  const result = [];
+  let k = tails.length ? tails[tails.length - 1] : -1;
+  while (k !== -1) {
+    result.push(pairs[k]);
+    k = prev[k];
+  }
+  return result.reverse();
+}
+function diffRange(ctx, aLo, aHi, bLo, bHi, out, depth) {
+  const { eq } = ctx;
+  let prefix = 0;
+  while (aLo + prefix < aHi && bLo + prefix < bHi && eq(aLo + prefix, bLo + prefix)) prefix++;
+  let suffix = 0;
+  while (aHi - suffix > aLo + prefix && bHi - suffix > bLo + prefix && eq(aHi - suffix - 1, bHi - suffix - 1)) {
+    suffix++;
+  }
+  pushRepeat(out, EQUAL, prefix);
+  const ma = aLo + prefix;
+  const mb = bLo + prefix;
+  const ea = aHi - suffix;
+  const eb = bHi - suffix;
+  const replace = () => {
+    pushRepeat(out, DELETE, ea - ma);
+    pushRepeat(out, INSERT, eb - mb);
+  };
+  if (ea - ma + (eb - mb) <= ctx.direct) {
+    myers(ma, ea, mb, eb, eq, out, Infinity);
+  } else if (!ctx.ids) {
+    if (!myers(ma, ea, mb, eb, eq, out, ctx.direct)) replace();
+  } else {
+    const found = depth >= ctx.maxDepth ? [] : anchors(ctx.ids, ma, ea, mb, eb);
+    if (found.length === 0) {
+      replace();
+    } else {
+      let i = ma;
+      let j = mb;
+      for (const [x, y] of found) {
+        diffRange(ctx, i, x, j, y, out, depth + 1);
+        out.push(EQUAL);
+        i = x + 1;
+        j = y + 1;
+      }
+      diffRange(ctx, i, ea, j, eb, out, depth + 1);
+    }
+  }
+  pushRepeat(out, EQUAL, suffix);
+}
+var defaultHash = (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean" ? item : JSON.stringify(item);
+function diffSequences(a, b, options = {}) {
+  const direct = Math.max(2, _nullishCoalesce(options.direct, () => ( 3e3)));
+  const maxDepth = _nullishCoalesce(options.maxDepth, () => ( 8));
+  let ids = null;
+  let eq;
+  if (options.equals && !options.hash) {
+    const equals = options.equals;
+    eq = (i2, j2) => equals(a[i2], b[j2]);
+  } else {
+    const hash = _nullishCoalesce(options.hash, () => ( defaultHash));
+    const table = /* @__PURE__ */ new Map();
+    const idOf = (item) => {
+      const key = hash(item);
+      let id = table.get(key);
+      if (id === void 0) {
+        id = table.size;
+        table.set(key, id);
+      }
+      return id;
+    };
+    ids = { a: Int32Array.from(a, idOf), b: Int32Array.from(b, idOf) };
+    const { a: ia, b: ib } = ids;
+    eq = (i2, j2) => ia[i2] === ib[j2];
+  }
+  const ops = [];
+  diffRange({ eq, ids, direct, maxDepth }, 0, a.length, 0, b.length, ops, 0);
+  const runs = [];
+  const push = (type, aIndex, bIndex, length) => {
+    if (length === 0) return;
+    const last = runs[runs.length - 1];
+    if (last && last.type === type) {
+      last.length += length;
+    } else {
+      runs.push({ type, aIndex, bIndex, length });
+    }
+  };
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  while (k < ops.length) {
+    if (ops[k] === EQUAL) {
+      let n = 0;
+      while (k < ops.length && ops[k] === EQUAL) {
+        n++;
+        k++;
+      }
+      push("equal", i, j, n);
+      i += n;
+      j += n;
+      continue;
+    }
+    let dels = 0;
+    let inss = 0;
+    while (k < ops.length && ops[k] !== EQUAL) {
+      if (ops[k] === DELETE) dels++;
+      else inss++;
+      k++;
+    }
+    push("delete", i, j, dels);
+    push("insert", i + dels, j, inss);
+    i += dels;
+    j += inss;
+  }
+  return runs;
+}
+function diffChanges(a, b, options = {}) {
+  const changes = [];
+  let current = null;
+  for (const run of diffSequences(a, b, options)) {
+    if (run.type === "equal") {
+      current = null;
+      continue;
+    }
+    if (!current) {
+      current = {
+        kind: run.type === "delete" ? "deleted" : "inserted",
+        aStart: run.aIndex,
+        aEnd: run.aIndex,
+        bStart: run.bIndex,
+        bEnd: run.bIndex
+      };
+      changes.push(current);
+    }
+    if (run.type === "delete") {
+      current.aEnd = run.aIndex + run.length;
+    } else {
+      current.bEnd = run.bIndex + run.length;
+    }
+    if (current.aEnd > current.aStart && current.bEnd > current.bStart) current.kind = "replaced";
+  }
+  return changes;
+}
+
+// src/compare/documents.ts
+var _core = require('@tiptap/core');
+
+
+
+var _model = require('@tiptap/pm/model');
+var REVIEW_MARK_NAMES = /* @__PURE__ */ new Set([
+  _chunkX4N4WUKBcjs.INSERTION_MARK_NAME,
+  _chunkX4N4WUKBcjs.DELETION_MARK_NAME,
+  _chunkX4N4WUKBcjs.FORMAT_CHANGE_MARK_NAME,
+  "comment",
+  "bookmark"
+]);
+var LIST_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList"]);
+var OBJECT_REPLACEMENT = "\uFFFC";
+function stableStringify(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+function toTime(date) {
+  if (date instanceof Date) return date.getTime();
+  if (typeof date === "string") {
+    const time = Date.parse(date);
+    return Number.isNaN(time) ? Date.now() : time;
+  }
+  return typeof date === "number" ? date : Date.now();
+}
+function toNode(source, schema) {
+  if (typeof source === "string") return _core.createDocument.call(void 0, source, schema);
+  if (typeof source.descendants === "function") {
+    const node = source;
+    return node.type.schema === schema ? node : schema.nodeFromJSON(node.toJSON());
+  }
+  return schema.nodeFromJSON(source);
+}
+function newAttributes(ctx) {
+  return {
+    changeId: ctx.generateId(),
+    authorId: ctx.author.id,
+    authorName: ctx.author.name,
+    authorColor: _nullishCoalesce(ctx.author.color, () => ( null)),
+    createdAt: ctx.createdAt
+  };
+}
+function lazyAttributes(ctx) {
+  let attrs = null;
+  return () => attrs = _nullishCoalesce(attrs, () => ( newAttributes(ctx)));
+}
+function stripBlockChange(attrs) {
+  const copy = { ...attrs };
+  delete copy[_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE];
+  return copy;
+}
+function wrapperOf(node) {
+  return { type: node.type.name, attrs: stripBlockChange(node.attrs) };
+}
+function snapshot(node, wrappers) {
+  return { type: node.type.name, attrs: stripBlockChange(node.attrs), wrappers };
+}
+function filteredAttributes(attrs, ctx) {
+  return stableStringify(
+    Object.fromEntries(
+      Object.entries(_nullishCoalesce(attrs, () => ( {}))).filter(
+        ([key]) => key !== _chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE && !ctx.ignoredAttributes.has(key)
+      )
+    )
+  );
+}
+function sameBlock(a, b, ctx) {
+  if (a.type !== b.type) return false;
+  if (filteredAttributes(a.attrs, ctx) !== filteredAttributes(b.attrs, ctx)) return false;
+  if (a.wrappers.length !== b.wrappers.length) return false;
+  return a.wrappers.every((w, i) => w.type === b.wrappers[i].type);
+}
+var hasBlockChange = (node) => !!node.type.spec.attrs && _chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE in node.type.spec.attrs;
+var label = (node) => node.type.name;
+function normalize(text, ctx) {
+  let result = ctx.ignoreWhitespace ? text.replace(/\s+/g, " ") : text;
+  if (ctx.ignoreCase) result = result.toLowerCase();
+  return result;
+}
+function leafKey(node) {
+  return `${node.type.name}${stableStringify(stripBlockChange(node.attrs))}`;
+}
+function group(node) {
+  return LIST_TYPES.has(node.type.name) ? "list" : node.type.name;
+}
+function blockKey(node, ctx) {
+  const cached = ctx.keys.get(node);
+  if (cached !== void 0) return cached;
+  let key;
+  if (node.isTextblock) {
+    let text = "";
+    node.forEach((child) => {
+      text += child.isText ? child.text : `${OBJECT_REPLACEMENT}${leafKey(child)}${OBJECT_REPLACEMENT}`;
+    });
+    text = normalize(text, ctx);
+    key = `T\0${ctx.ignoreWhitespace ? text.trim() : text}`;
+  } else if (node.isLeaf) {
+    key = `A\0${leafKey(node)}`;
+  } else {
+    const parts = [];
+    node.forEach((child) => parts.push(blockKey(child, ctx)));
+    key = `C\0${group(node)}\0${parts.join("
")}`;
+  }
+  ctx.keys.set(node, key);
+  return key;
+}
+function compatible(a, b) {
+  if (a.isTextblock || b.isTextblock) return a.isTextblock && b.isTextblock;
+  if (a.isLeaf || b.isLeaf) return a.isLeaf && b.isLeaf && a.type === b.type;
+  return group(a) === group(b);
+}
+function markInline(content, mark) {
+  const nodes = [];
+  content.forEach((child) => nodes.push(child.mark(mark.addToSet(child.marks))));
+  return _model.Fragment.from(nodes);
+}
+function wholeBlock(node, operation, wrappers, attrs, ctx) {
+  const verb = operation === "insert" ? "Inserted" : "Deleted";
+  if (node.isTextblock) {
+    if (hasBlockChange(node)) {
+      const record = {
+        ...attrs(),
+        previous: snapshot(node, wrappers),
+        operation
+      };
+      return [node.type.create({ ...node.attrs, [_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE]: record }, node.content, node.marks)];
+    }
+    const markType = operation === "insert" ? ctx.insertion : ctx.deletion;
+    if (markType && node.type.allowsMarkType(markType) && node.content.size > 0) {
+      ctx.notes.add(
+        `${verb} ${label(node)} blocks have no "${_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE}" attribute: only their text is tracked, so an empty block remains when the change is ${operation === "insert" ? "rejected" : "accepted"}.`
+      );
+      return [node.type.create(node.attrs, markInline(node.content, markType.create(attrs())), node.marks)];
+    }
+    ctx.notes.add(`${verb} ${label(node)} blocks cannot be tracked.`);
+    return operation === "insert" ? [node] : [];
+  }
+  if (node.isLeaf) {
+    ctx.notes.add(`${verb} ${label(node)} blocks cannot be tracked.`);
+    return operation === "insert" ? [node] : [];
+  }
+  const inner = [...wrappers, wrapperOf(node)];
+  const children = [];
+  node.forEach((child) => children.push(...wholeBlock(child, operation, inner, attrs, ctx)));
+  try {
+    return [node.type.createChecked(node.attrs, children, node.marks)];
+  } catch (e) {
+    ctx.notes.add(`${verb} ${label(node)} blocks cannot be tracked.`);
+    return operation === "insert" ? [node] : [];
+  }
+}
+function units(node) {
+  const result = [];
+  node.forEach((child) => {
+    if (child.isText) {
+      for (const ch of _nullishCoalesce(child.text, () => ( ""))) result.push({ text: ch, node: null, marks: child.marks });
+    } else {
+      result.push({ text: "", node: child, marks: child.marks });
+    }
+  });
+  return result;
+}
+var SPACE = /\s/u;
+var WORD = /[\p{L}\p{N}\p{M}_]/u;
+var isSpace = (u) => !u.node && SPACE.test(u.text);
+var isWord = (u) => !u.node && WORD.test(u.text);
+function tokenize(list, chars) {
+  const tokens = [];
+  if (chars) {
+    for (let i2 = 0; i2 < list.length; i2++) tokens.push([i2, i2 + 1]);
+    return tokens;
+  }
+  let i = 0;
+  while (i < list.length) {
+    const start = i;
+    const unit = list[i];
+    if (isSpace(unit)) {
+      while (i < list.length && isSpace(list[i])) i++;
+    } else if (isWord(unit)) {
+      while (i < list.length && isWord(list[i])) i++;
+    } else {
+      i++;
+    }
+    tokens.push([start, i]);
+  }
+  return tokens;
+}
+function stretches(runs, list, tokens) {
+  const spaceOnly = (bIndex, length) => {
+    for (let t = bIndex; t < bIndex + length; t++) {
+      const [from, to] = tokens[t];
+      for (let k = from; k < to; k++) if (!isSpace(list[k])) return false;
+    }
+    return true;
+  };
+  const result = [];
+  runs.forEach((run, index) => {
+    const prev = runs[index - 1];
+    const next = runs[index + 1];
+    const absorbed = run.type === "equal" && prev && next && prev.type !== "equal" && next.type !== "equal" && spaceOnly(run.bIndex, run.length);
+    if (run.type === "equal" && !absorbed) {
+      result.push({ type: "equal", aIndex: run.aIndex, bIndex: run.bIndex, length: run.length });
+      return;
+    }
+    let last = result[result.length - 1];
+    if (!last || last.type !== "change") {
+      last = { type: "change", aFrom: run.aIndex, aTo: run.aIndex, bFrom: run.bIndex, bTo: run.bIndex };
+      result.push(last);
+    }
+    if (run.type !== "insert") last.aTo = run.aIndex + run.length;
+    if (run.type !== "delete") last.bTo = run.bIndex + run.length;
+  });
+  return result;
+}
+function tokenKey(list, [from, to], ctx) {
+  let text = "";
+  for (let i = from; i < to; i++) {
+    const unit = list[i];
+    text += unit.node ? `${OBJECT_REPLACEMENT}${leafKey(unit.node)}${OBJECT_REPLACEMENT}` : unit.text;
+  }
+  return normalize(text, ctx);
+}
+function formattingOf(marks, ctx) {
+  return marks.filter(
+    (mark) => !REVIEW_MARK_NAMES.has(mark.type.name) && !ctx.ignoredMarks.has(mark.type.name)
+  );
+}
+function withoutReviewMarks(marks) {
+  return marks.filter(
+    (mark) => mark.type.name !== _chunkX4N4WUKBcjs.INSERTION_MARK_NAME && mark.type.name !== _chunkX4N4WUKBcjs.DELETION_MARK_NAME && mark.type.name !== _chunkX4N4WUKBcjs.FORMAT_CHANGE_MARK_NAME
+  );
+}
+function mergeInline(original, revised, parentType, ctx) {
+  const a = units(original);
+  const b = units(revised);
+  let chars = ctx.granularity === "char";
+  if (chars && Math.max(a.length, b.length) > ctx.maxCharDiff) {
+    chars = false;
+    ctx.notes.add(
+      `Paragraphs longer than ${ctx.maxCharDiff} characters were compared by words instead of characters.`
+    );
+  }
+  const ta = tokenize(a, chars);
+  const tb = tokenize(b, chars);
+  const runs = diffSequences(
+    ta.map((t) => tokenKey(a, t, ctx)),
+    tb.map((t) => tokenKey(b, t, ctx))
+  );
+  const format = ctx.formatting && ctx.format && parentType.allowsMarkType(ctx.format) ? ctx.format : null;
+  const out = [];
+  let formatRun = null;
+  const emit = (source, tokens, from, to, markType) => {
+    if (to <= from) return;
+    const mark = markType.create(newAttributes(ctx));
+    for (let k = tokens[from][0]; k < tokens[to - 1][1]; k++) {
+      const unit = source[k];
+      out.push({ ...unit, marks: mark.addToSet(withoutReviewMarks(unit.marks)) });
+    }
+  };
+  for (const run of stretches(runs, b, tb)) {
+    if (run.type === "equal") {
+      for (let t = 0; t < run.length; t++) {
+        const [aFrom, aTo] = ta[run.aIndex + t];
+        const [bFrom, bTo] = tb[run.bIndex + t];
+        for (let k = bFrom; k < bTo; k++) {
+          const unit = b[k];
+          const before = a[Math.min(aFrom + (k - bFrom), aTo - 1)];
+          const marks = withoutReviewMarks(unit.marks);
+          if (!format) {
+            formatRun = null;
+            out.push({ ...unit, marks });
+            continue;
+          }
+          const oldFormat = formattingOf(before.marks, ctx);
+          const newFormat = formattingOf(unit.marks, ctx);
+          if (_model.Mark.sameSet(oldFormat, newFormat)) {
+            formatRun = null;
+            out.push({ ...unit, marks });
+            continue;
+          }
+          const beforeJSON = oldFormat.map((m) => m.toJSON());
+          const afterJSON = newFormat.map((m) => m.toJSON());
+          const key = stableStringify([beforeJSON, afterJSON]);
+          if (!formatRun || formatRun.key !== key) formatRun = { attrs: newAttributes(ctx), key };
+          const mark = format.create({ ...formatRun.attrs, before: beforeJSON, after: afterJSON });
+          out.push({ ...unit, marks: mark.addToSet(marks) });
+        }
+      }
+      continue;
+    }
+    formatRun = null;
+    emit(a, ta, run.aFrom, run.aTo, ctx.deletion);
+    emit(b, tb, run.bFrom, run.bTo, ctx.insertion);
+  }
+  const nodes = [];
+  let i = 0;
+  while (i < out.length) {
+    const unit = out[i];
+    if (unit.node) {
+      nodes.push(unit.node.mark(unit.marks));
+      i++;
+      continue;
+    }
+    let text = unit.text;
+    let j = i + 1;
+    while (j < out.length && !out[j].node && _model.Mark.sameSet(out[j].marks, unit.marks)) {
+      text += out[j].text;
+      j++;
+    }
+    nodes.push(ctx.schema.text(text, unit.marks));
+    i = j;
+  }
+  return _model.Fragment.from(nodes);
+}
+function mergeTextblocks(original, revised, oPath, rPath, ctx) {
+  const replaceWhole = () => [
+    ...wholeBlock(original, "delete", rPath, lazyAttributes(ctx), ctx),
+    ...wholeBlock(revised, "insert", rPath, lazyAttributes(ctx), ctx)
+  ];
+  let attrs = { ...revised.attrs };
+  const previous = snapshot(original, oPath);
+  if (!sameBlock(previous, snapshot(revised, rPath), ctx)) {
+    if (hasBlockChange(revised)) {
+      const onlyWrappers = ctx.wrapperChange && sameBlock(previous, { ...snapshot(revised, rPath), wrappers: previous.wrappers }, ctx);
+      const base = onlyWrappers ? ctx.wrapperChange() : newAttributes(ctx);
+      attrs = { ...attrs, [_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE]: { ...base, previous } };
+    } else {
+      ctx.notes.add(`Block changes to ${label(revised)} blocks cannot be tracked.`);
+    }
+  } else if (_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE in attrs) {
+    attrs[_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE] = null;
+  }
+  const type = revised.type;
+  const inlineTracking = !!ctx.insertion && !!ctx.deletion && type.allowsMarkType(ctx.insertion) && type.allowsMarkType(ctx.deletion);
+  if (!inlineTracking) {
+    if (!original.content.eq(revised.content)) return replaceWhole();
+    return [type.create(attrs, revised.content, revised.marks)];
+  }
+  const content = mergeInline(original, revised, type, ctx);
+  if (!type.validContent(content)) {
+    ctx.notes.add(`Changes between ${label(original)} and ${label(revised)} blocks were tracked as whole-block replacements.`);
+    return replaceWhole();
+  }
+  return [type.create(attrs, content, revised.marks)];
+}
+function mergePair(original, revised, oPath, rPath, ctx) {
+  if (original.isTextblock) return mergeTextblocks(original, revised, oPath, rPath, ctx);
+  const replaceWhole = () => [
+    ...wholeBlock(original, "delete", rPath, lazyAttributes(ctx), ctx),
+    ...wholeBlock(revised, "insert", rPath, lazyAttributes(ctx), ctx)
+  ];
+  if (original.isLeaf) {
+    return original.eq(revised) ? [revised] : replaceWhole();
+  }
+  if (original.type === revised.type && filteredAttributes(original.attrs, ctx) !== filteredAttributes(revised.attrs, ctx)) {
+    ctx.notes.add(`Attribute changes of ${label(revised)} nodes are not tracked.`);
+  }
+  const outer = ctx.wrapperChange;
+  if (original.type !== revised.type) ctx.wrapperChange = lazyAttributes(ctx);
+  let children;
+  try {
+    children = compareChildren(
+      original,
+      revised,
+      [...oPath, wrapperOf(original)],
+      [...rPath, wrapperOf(revised)],
+      ctx
+    );
+  } finally {
+    ctx.wrapperChange = outer;
+  }
+  try {
+    return [revised.type.createChecked(revised.attrs, children, revised.marks)];
+  } catch (e2) {
+    ctx.notes.add(`Changes inside ${label(revised)} nodes were tracked as whole-block replacements.`);
+    return replaceWhole();
+  }
+}
+function compareChildren(original, revised, oPath, rPath, ctx) {
+  const a = [];
+  const b = [];
+  original.forEach((child) => a.push(child));
+  revised.forEach((child) => b.push(child));
+  const runs = diffSequences(a, b, { hash: (node) => blockKey(node, ctx) });
+  const out = [];
+  for (let r = 0; r < runs.length; r++) {
+    const run = runs[r];
+    if (run.type === "equal") {
+      for (let t = 0; t < run.length; t++) {
+        out.push(...mergePair(a[run.aIndex + t], b[run.bIndex + t], oPath, rPath, ctx));
+      }
+      continue;
+    }
+    let dels = [];
+    let inss = [];
+    if (run.type === "delete") {
+      dels = a.slice(run.aIndex, run.aIndex + run.length);
+      const next = runs[r + 1];
+      if (_optionalChain([next, 'optionalAccess', _ => _.type]) === "insert") {
+        inss = b.slice(next.bIndex, next.bIndex + next.length);
+        r++;
+      }
+    } else {
+      inss = b.slice(run.bIndex, run.bIndex + run.length);
+    }
+    const deleted = lazyAttributes(ctx);
+    const inserted = lazyAttributes(ctx);
+    for (let x = 0; x < Math.max(dels.length, inss.length); x++) {
+      const del = dels[x];
+      const ins = inss[x];
+      if (del && ins && compatible(del, ins)) {
+        out.push(...mergePair(del, ins, oPath, rPath, ctx));
+        continue;
+      }
+      if (del) out.push(...wholeBlock(del, "delete", rPath, deleted, ctx));
+      if (ins) out.push(...wholeBlock(ins, "insert", rPath, inserted, ctx));
+    }
+  }
+  return out;
+}
+function detectMovedBlocks(children, ctx) {
+  const keyOf = (node) => `${node.type.name}\0${filteredAttributes(node.attrs, ctx)}\0${stableStringify(node.content.toJSON())}`;
+  const candidates = /* @__PURE__ */ new Map();
+  children.forEach((node, index) => {
+    const operation = _optionalChain([node, 'access', _2 => _2.attrs, 'optionalAccess', _3 => _3[_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE], 'optionalAccess', _4 => _4.operation]);
+    if (!operation || !node.isTextblock || !node.textContent.trim()) return;
+    if (!node.type.allowsMarkType(ctx.insertion) || !node.type.allowsMarkType(ctx.deletion)) return;
+    const key = keyOf(node);
+    const entry = _nullishCoalesce(candidates.get(key), () => ( { del: [], ins: [] }));
+    (operation === "delete" ? entry.del : entry.ins).push(index);
+    candidates.set(key, entry);
+  });
+  const out = [...children];
+  candidates.forEach(({ del, ins }) => {
+    if (del.length !== 1 || ins.length !== 1) return;
+    const attrs = newAttributes(ctx);
+    const moved = { ...attrs, [_chunkX4N4WUKBcjs.MOVE_ID_ATTRIBUTE]: attrs.changeId };
+    const relink = (index, markType) => {
+      const node = out[index];
+      out[index] = node.type.create(
+        { ...node.attrs, [_chunkX4N4WUKBcjs.BLOCK_CHANGE_ATTRIBUTE]: null },
+        markInline(node.content, markType.create(moved)),
+        node.marks
+      );
+    };
+    relink(del[0], ctx.deletion);
+    relink(ins[0], ctx.insertion);
+  });
+  return out;
+}
+function summarize(doc, notes) {
+  const summary = {
+    insertions: 0,
+    deletions: 0,
+    formatChanges: 0,
+    blockChanges: 0,
+    moves: 0,
+    notHonoured: [...notes]
+  };
+  _chunkX4N4WUKBcjs.getTrackedChanges.call(void 0, doc).forEach((change) => {
+    if (change.type === "move") summary.moves++;
+    else if (change.type === "insertion" || _optionalChain([change, 'access', _5 => _5.block, 'optionalAccess', _6 => _6.operation]) === "insert") summary.insertions++;
+    else if (change.type === "deletion" || _optionalChain([change, 'access', _7 => _7.block, 'optionalAccess', _8 => _8.operation]) === "delete") summary.deletions++;
+    else if (change.type === "format") summary.formatChanges++;
+    else summary.blockChanges++;
+  });
+  return summary;
+}
+function compareDocuments(original, revised, options = {}) {
+  const schema = _nullishCoalesce(options.schema, () => ( (typeof _optionalChain([original, 'optionalAccess', _9 => _9.descendants]) === "function" ? original.type.schema : typeof _optionalChain([revised, 'optionalAccess', _10 => _10.descendants]) === "function" ? revised.type.schema : null)));
+  if (!schema) throw new Error("compareDocuments: `schema` is required for JSON or HTML sources.");
+  const ctx = {
+    schema,
+    author: _nullishCoalesce(options.author, () => ( { id: "compare", name: "Compare" })),
+    createdAt: toTime(options.date),
+    generateId: _nullishCoalesce(options.generateId, () => ( (() => _chunkX4N4WUKBcjs.createReviewId.call(void 0, "change")))),
+    granularity: _nullishCoalesce(options.granularity, () => ( "word")),
+    ignoreCase: !!options.ignoreCase,
+    ignoreWhitespace: !!options.ignoreWhitespace,
+    formatting: options.formatting !== false,
+    maxCharDiff: _nullishCoalesce(options.maxCharDiff, () => ( 2e3)),
+    ignoredMarks: new Set(_nullishCoalesce(options.ignoredMarks, () => ( []))),
+    ignoredAttributes: new Set(_nullishCoalesce(options.ignoredBlockAttributes, () => ( ["id"]))),
+    insertion: schema.marks[_chunkX4N4WUKBcjs.INSERTION_MARK_NAME],
+    deletion: schema.marks[_chunkX4N4WUKBcjs.DELETION_MARK_NAME],
+    format: schema.marks[_chunkX4N4WUKBcjs.FORMAT_CHANGE_MARK_NAME],
+    notes: /* @__PURE__ */ new Set(),
+    keys: /* @__PURE__ */ new Map(),
+    wrapperChange: null
+  };
+  if (!ctx.insertion || !ctx.deletion) {
+    throw new Error("compareDocuments: the schema needs the TrackChanges extension (insertion/deletion marks).");
+  }
+  if (ctx.formatting && !ctx.format) {
+    ctx.notes.add("Formatting differences cannot be tracked: the schema has no formatChange mark.");
+  }
+  const prepare = (source) => {
+    const doc2 = toNode(source, schema);
+    if (_chunkX4N4WUKBcjs.getTrackedChanges.call(void 0, doc2).length === 0) return doc2;
+    ctx.notes.add("Tracked changes already in the documents were accepted before comparing.");
+    return _chunkX4N4WUKBcjs.resolveTrackedChanges.call(void 0, doc2, "accepted");
+  };
+  const a = prepare(original);
+  const b = prepare(revised);
+  let children = compareChildren(a, b, [], [], ctx);
+  if (options.detectMoves) children = detectMovedBlocks(children, ctx);
+  let doc;
+  try {
+    doc = b.type.createChecked(b.attrs, children, b.marks);
+  } catch (e3) {
+    doc = _nullishCoalesce(b.type.createAndFill(b.attrs, children, b.marks), () => ( b));
+    ctx.notes.add("The compared document had to be repaired to fit the schema.");
+  }
+  return { doc, summary: summarize(doc, ctx.notes) };
+}
+function compareHtml(originalHtml, revisedHtml, options) {
+  return compareDocuments(originalHtml, revisedHtml, options);
+}
+
+
+
+
+
+
+exports.diffSequences = diffSequences; exports.diffChanges = diffChanges; exports.compareDocuments = compareDocuments; exports.compareHtml = compareHtml;
+//# sourceMappingURL=chunk-AL6JMGWW.cjs.map