@pixerate/editor 0.21.0 → 0.22.0

package/dist/{chunk-3TYMNULT.js → chunk-MJZBNWG7.js}

@@ -245,11 +245,32 @@ import {
 } from "@tiptap/pm/state";
 import {
   Fragment,
+  Mark as ProsemirrorMark,
+  NodeRange,
   Slice
 } from "@tiptap/pm/model";
-import { Mapping, ReplaceStep, Transform } from "@tiptap/pm/transform";
+import {
+  AddMarkStep,
+  AttrStep,
+  Mapping,
+  RemoveMarkStep,
+  ReplaceAroundStep,
+  ReplaceStep,
+  Transform,
+  canJoin,
+  liftTarget
+} from "@tiptap/pm/transform";
 var INSERTION_MARK_NAME = "insertion";
 var DELETION_MARK_NAME = "deletion";
+var FORMAT_CHANGE_MARK_NAME = "formatChange";
+var BLOCK_CHANGE_ATTRIBUTE = "blockChange";
+var REVIEW_MARK_NAMES = /* @__PURE__ */ new Set([
+  INSERTION_MARK_NAME,
+  DELETION_MARK_NAME,
+  FORMAT_CHANGE_MARK_NAME,
+  "comment",
+  "bookmark"
+]);
 var TRACK_CHANGES_SKIP_META = "trackChangesSkip";
 var TrackChangesStore = class {
   snapshot;
@@ -281,6 +302,14 @@ var trackChangesPluginKey = new PluginKey("trackChanges");
 function changeAttributes(mark) {
   return mark.attrs;
 }
+function parseJSON(value, fallback) {
+  if (!value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
 var sharedAttributes = () => ({
   changeId: {
     default: null,
@@ -367,6 +396,172 @@ var TrackedDeletion = Mark.create({
     ];
   }
 });
+var TrackedFormatChange = Mark.create({
+  name: FORMAT_CHANGE_MARK_NAME,
+  inclusive: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {
+        class: "pixerate-format-change underline decoration-dotted decoration-2 decoration-sky-500 underline-offset-4"
+      }
+    };
+  },
+  addStorage() {
+    return { markdown: { serialize: { open: "", close: "" }, parse: {} } };
+  },
+  addAttributes() {
+    return {
+      ...sharedAttributes(),
+      before: {
+        default: [],
+        parseHTML: (el) => parseJSON(el.getAttribute("data-format-before"), []),
+        renderHTML: (attrs) => ({ "data-format-before": JSON.stringify(attrs.before ?? []) })
+      },
+      after: {
+        default: [],
+        parseHTML: (el) => parseJSON(el.getAttribute("data-format-after"), []),
+        renderHTML: (attrs) => ({ "data-format-after": JSON.stringify(attrs.after ?? []) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-change-type="format"]', priority: 100 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-change-type": "format"
+      }),
+      0
+    ];
+  }
+});
+var MARK_LABELS = {
+  bold: "Bold",
+  italic: "Italic",
+  underline: "Underline",
+  strike: "Strikethrough",
+  code: "Code",
+  link: "Link",
+  highlight: "Highlight",
+  subscript: "Subscript",
+  superscript: "Superscript",
+  textStyle: "Text style"
+};
+var TEXT_STYLE_LABELS = {
+  fontSize: "Font size",
+  fontFamily: "Font",
+  color: "Color",
+  backgroundColor: "Background color",
+  lineHeight: "Line height"
+};
+var BLOCK_LABELS = {
+  paragraph: "Paragraph",
+  codeBlock: "Code block",
+  blockquote: "Quote",
+  bulletList: "Bulleted list",
+  orderedList: "Numbered list",
+  taskList: "Task list",
+  listItem: "List item",
+  taskItem: "Task item"
+};
+function humanize(name) {
+  const words = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+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 obj = value;
+  return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+var sameValue = (a, b) => stableStringify(a) === stableStringify(b);
+function markLabels(mark, other) {
+  if (mark.type === "textStyle") {
+    const attrs = mark.attrs ?? {};
+    const otherAttrs = other?.attrs ?? {};
+    const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(attrs), ...Object.keys(otherAttrs)])).filter(
+      (key) => other ? !sameValue(attrs[key], otherAttrs[key]) : attrs[key] != null
+    );
+    return keys.length ? keys.map((key) => TEXT_STYLE_LABELS[key] ?? humanize(key)) : ["Text style"];
+  }
+  return [MARK_LABELS[mark.type] ?? humanize(mark.type)];
+}
+function diffFormatting(before, after) {
+  const summary = { added: [], removed: [], changed: [] };
+  const push = (list, labels) => labels.forEach((label) => {
+    if (!list.includes(label)) list.push(label);
+  });
+  after.forEach((mark) => {
+    const old = before.find((m) => m.type === mark.type);
+    if (!old) push(summary.added, markLabels(mark));
+    else if (!sameValue(old.attrs ?? {}, mark.attrs ?? {})) push(summary.changed, markLabels(mark, old));
+  });
+  before.forEach((mark) => {
+    if (!after.some((m) => m.type === mark.type)) push(summary.removed, markLabels(mark));
+  });
+  return summary;
+}
+function mergeSummary(target, source) {
+  ["added", "removed", "changed"].forEach(
+    (key) => source[key].forEach((label) => {
+      if (!target[key].includes(label)) target[key].push(label);
+    })
+  );
+}
+function describeFormatChange(summary) {
+  const parts = [];
+  if (summary.added.length) parts.push(`Formatted: ${summary.added.join(", ")}`);
+  if (summary.removed.length) parts.push(`Removed formatting: ${summary.removed.join(", ")}`);
+  if (summary.changed.length) parts.push(`Changed formatting: ${summary.changed.join(", ")}`);
+  return parts.join("; ") || "Formatted";
+}
+function blockLabel(type, attrs) {
+  if (type === "heading" && attrs?.level) return `Heading ${attrs.level}`;
+  return BLOCK_LABELS[type] ?? humanize(type);
+}
+var containerLabels = (wrappers) => wrappers.filter((w) => w.type !== "listItem" && w.type !== "taskItem").map((w) => blockLabel(w.type, w.attrs));
+var isPrefix = (a, b) => a.every((label, i) => b[i] === label);
+function describeBlockChange(previous, current, ignoredAttributes = ["id"]) {
+  const parts = [];
+  const before = blockLabel(previous.type, previous.attrs);
+  const after = blockLabel(current.type, current.attrs);
+  if (before !== after) {
+    parts.push(`Changed ${before} to ${after}`);
+  } else {
+    const keys = Array.from(
+      /* @__PURE__ */ new Set([...Object.keys(previous.attrs ?? {}), ...Object.keys(current.attrs ?? {})])
+    ).filter(
+      (key) => key !== BLOCK_CHANGE_ATTRIBUTE && !ignoredAttributes.includes(key) && !(current.type === "heading" && key === "level") && !sameValue(previous.attrs?.[key], current.attrs?.[key])
+    );
+    keys.forEach((key) => {
+      if (key === "textAlign") {
+        parts.push(`Changed alignment to ${humanize(String(current.attrs?.textAlign ?? "default"))}`);
+      } else {
+        parts.push(`Changed ${humanize(key).toLowerCase()} of ${after}`);
+      }
+    });
+  }
+  const oldTypes = previous.wrappers.map((w) => w.type).join("/");
+  const newTypes = current.wrappers.map((w) => w.type).join("/");
+  if (oldTypes !== newTypes) {
+    const was = containerLabels(previous.wrappers);
+    const now = containerLabels(current.wrappers);
+    const last = (list) => list[list.length - 1];
+    if (was.length === 0 && now.length > 0) parts.push(`Wrapped in ${last(now)}`);
+    else if (now.length === 0 && was.length > 0) parts.push(`Removed from ${last(was)}`);
+    else if (now.length > was.length && isPrefix(was, now)) parts.push(`Indented in ${last(now)}`);
+    else if (now.length < was.length && isPrefix(now, was)) parts.push(`Outdented from ${last(was)}`);
+    else if (was.length && now.length) parts.push(`Changed ${last(was)} to ${last(now)}`);
+    else parts.push("Changed nesting");
+  }
+  return parts.join("; ") || `Changed ${after}`;
+}
+function truncate(text, max = 40) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
 function toDoc(source) {
   if (!source) return null;
   if (source.state?.doc) return source.state.doc;
@@ -374,55 +569,136 @@ function toDoc(source) {
   if (typeof source.descendants === "function") return source;
   return null;
 }
+function stripBlockChange(attrs) {
+  const copy = { ...attrs };
+  delete copy[BLOCK_CHANGE_ATTRIBUTE];
+  return copy;
+}
+function blockSnapshot(doc, pos) {
+  const $pos = doc.resolve(pos);
+  const node = $pos.nodeAfter;
+  const wrappers = [];
+  for (let depth = 1; depth <= $pos.depth; depth++) {
+    const wrapper = $pos.node(depth);
+    wrappers.push({ type: wrapper.type.name, attrs: stripBlockChange(wrapper.attrs) });
+  }
+  return { type: node.type.name, attrs: stripBlockChange(node.attrs), wrappers };
+}
+function sameBlock(a, b, ignored) {
+  if (a.type !== b.type) return false;
+  const filter = (attrs) => Object.fromEntries(
+    Object.entries(attrs ?? {}).filter(
+      ([key]) => key !== BLOCK_CHANGE_ATTRIBUTE && !ignored.has(key)
+    )
+  );
+  if (!sameValue(filter(a.attrs), filter(b.attrs))) return false;
+  if (a.wrappers.length !== b.wrappers.length) return false;
+  return a.wrappers.every((w, i) => w.type === b.wrappers[i].type);
+}
+var isMarkChange = (type) => type === INSERTION_MARK_NAME || type === DELETION_MARK_NAME || type === FORMAT_CHANGE_MARK_NAME;
 function getTrackedChanges(source) {
   const doc = toDoc(source);
   if (!doc) return [];
   const byKey = /* @__PURE__ */ new Map();
+  const add = (key, type, attrs, from, to, text) => {
+    let change = byKey.get(key);
+    if (!change) {
+      change = {
+        id: attrs.changeId,
+        type,
+        author: {
+          id: attrs.authorId,
+          name: attrs.authorName,
+          ...attrs.authorColor ? { color: attrs.authorColor } : {}
+        },
+        createdAt: attrs.createdAt,
+        from,
+        to,
+        ranges: [],
+        text: "",
+        description: ""
+      };
+      byKey.set(key, change);
+    }
+    const last = change.ranges[change.ranges.length - 1];
+    if (last && last.to === from) {
+      last.to = to;
+    } else {
+      change.ranges.push({ from, to });
+    }
+    change.to = to;
+    change.text += text;
+    return change;
+  };
   doc.descendants((node, pos) => {
+    const block = node.attrs?.[BLOCK_CHANGE_ATTRIBUTE];
+    if (block?.changeId && node.isTextblock) {
+      const change = add(
+        `block:${block.changeId}`,
+        "block",
+        block,
+        pos,
+        pos + node.nodeSize,
+        node.textContent
+      );
+      if (!change.block) {
+        change.block = { previous: block.previous, current: blockSnapshot(doc, pos) };
+      }
+    }
     if (!node.isInline) return;
     node.marks.forEach((mark) => {
-      const type = mark.type.name;
-      if (type !== INSERTION_MARK_NAME && type !== DELETION_MARK_NAME) return;
+      const markType = mark.type.name;
+      if (!isMarkChange(markType)) return;
       const attrs = changeAttributes(mark);
       if (!attrs.changeId) return;
-      const key = `${type}:${attrs.changeId}`;
-      const end = pos + node.nodeSize;
-      const text = node.isText ? node.text ?? "" : "";
-      let change = byKey.get(key);
-      if (!change) {
-        change = {
-          id: attrs.changeId,
-          type,
-          author: {
-            id: attrs.authorId,
-            name: attrs.authorName,
-            ...attrs.authorColor ? { color: attrs.authorColor } : {}
-          },
-          createdAt: attrs.createdAt,
-          from: pos,
-          to: end,
-          ranges: [],
-          text: ""
-        };
-        byKey.set(key, change);
+      const type = markType === FORMAT_CHANGE_MARK_NAME ? "format" : markType;
+      const change = add(
+        `${type}:${attrs.changeId}`,
+        type,
+        attrs,
+        pos,
+        pos + node.nodeSize,
+        node.isText ? node.text ?? "" : ""
+      );
+      if (type === "format") {
+        const summary = diffFormatting(mark.attrs.before ?? [], mark.attrs.after ?? []);
+        if (!change.format) change.format = { added: [], removed: [], changed: [] };
+        mergeSummary(change.format, summary);
       }
-      const last = change.ranges[change.ranges.length - 1];
-      if (last && last.to === pos) {
-        last.to = end;
-      } else {
-        change.ranges.push({ from: pos, to: end });
-      }
-      change.to = end;
-      change.text += text;
     });
   });
-  return Array.from(byKey.values()).sort((a, b) => a.from - b.from || a.to - b.to);
+  const changes = Array.from(byKey.values());
+  changes.forEach((change) => {
+    switch (change.type) {
+      case "insertion":
+        change.description = change.text ? `Inserted "${truncate(change.text)}"` : "Inserted content";
+        break;
+      case "deletion":
+        change.description = change.text ? `Deleted "${truncate(change.text)}"` : "Deleted content";
+        break;
+      case "format":
+        change.description = describeFormatChange(change.format);
+        break;
+      case "block":
+        change.description = describeBlockChange(change.block.previous, change.block.current);
+        break;
+    }
+  });
+  return changes.sort((a, b) => a.from - b.from || a.to - b.to);
 }
 function getTrackedChangeAt(state, pos = state.selection.from, changes = getTrackedChanges(state.doc)) {
   const { from, to } = state.selection;
-  const exact = changes.find((c) => c.from === from && c.to === to);
+  const exact = changes.find((c) => {
+    const [start, end] = selectionRange(c);
+    return start === from && end === to;
+  });
   if (exact) return exact;
-  return changes.find((c) => c.ranges.some((r) => r.from < pos && pos < r.to)) ?? changes.find((c) => c.ranges.some((r) => r.from <= pos && pos <= r.to)) ?? null;
+  const inline = changes.filter((c) => c.type !== "block");
+  const blocks = changes.filter((c) => c.type === "block");
+  return inline.find((c) => c.ranges.some((r) => r.from < pos && pos < r.to)) ?? inline.find((c) => c.ranges.some((r) => r.from <= pos && pos <= r.to)) ?? blocks.find((c) => c.ranges.some((r) => r.from < pos && pos < r.to)) ?? null;
+}
+function selectionRange(change) {
+  return change.type === "block" ? [change.from + 1, change.to - 1] : [change.from, change.to];
 }
 function isTrackChangesEnabled(source) {
   const state = source?.state ?? source;
@@ -432,10 +708,225 @@ function isTrackChangesEnabled(source) {
 function getTrackChangesStore(editor) {
   return editor?.storage?.trackChanges?.store ?? null;
 }
+function marksFromJSON(schema, marks) {
+  const result = [];
+  (marks ?? []).forEach((json) => {
+    try {
+      if (schema.marks[json.type]) result.push(schema.markFromJSON(json));
+    } catch {
+    }
+  });
+  return result;
+}
+function decideFormat(tr, changes, decision) {
+  const schema = tr.doc.type.schema;
+  const formatType = schema.marks[FORMAT_CHANGE_MARK_NAME];
+  if (!formatType) return;
+  const ids = new Set(changes.map((c) => c.id));
+  const segments = [];
+  changes.forEach(
+    (change) => change.ranges.forEach(
+      ({ from, to }) => tr.doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isInline) return true;
+        const mark = formatType.isInSet(node.marks);
+        if (mark && ids.has(mark.attrs.changeId)) {
+          segments.push({ from: Math.max(pos, from), to: Math.min(pos + node.nodeSize, to), node, mark });
+        }
+        return false;
+      })
+    )
+  );
+  segments.forEach(({ from, to, node, mark }) => {
+    tr.removeMark(from, to, formatType);
+    if (decision === "accept") return;
+    const before = mark.attrs.before ?? [];
+    const after = mark.attrs.after ?? [];
+    const involved = new Set([...before, ...after].map((m) => m.type));
+    node.marks.forEach((current) => {
+      if (involved.has(current.type.name)) tr.removeMark(from, to, current);
+    });
+    marksFromJSON(schema, before).forEach((restored) => tr.addMark(from, to, restored));
+  });
+}
+var LIST_ITEM_TYPES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+function listItemAt(tr, contentPos) {
+  const $pos = tr.doc.resolve(contentPos);
+  const itemDepth = $pos.depth - 1;
+  if (itemDepth < 2) return null;
+  if (!LIST_ITEM_TYPES.has($pos.node(itemDepth).type.name) || $pos.index(itemDepth) !== 0) {
+    return null;
+  }
+  return { $pos, itemDepth };
+}
+function sinkItem(tr, contentPos) {
+  const info = listItemAt(tr, contentPos);
+  if (!info) return false;
+  const { $pos, itemDepth } = info;
+  const list = $pos.node(itemDepth - 1);
+  const index = $pos.index(itemDepth - 1);
+  const itemType = $pos.node(itemDepth).type;
+  if (index === 0 || list.child(index - 1).type !== itemType) return false;
+  const nodeBefore = list.child(index - 1);
+  const nestedBefore = nodeBefore.lastChild?.type === list.type;
+  const inner = Fragment.from(nestedBefore ? itemType.create() : null);
+  const slice = new Slice(
+    Fragment.from(itemType.create(null, Fragment.from(list.type.create(null, inner)))),
+    nestedBefore ? 3 : 1,
+    0
+  );
+  const before = $pos.before(itemDepth);
+  const after = $pos.after(itemDepth);
+  tr.step(
+    new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true)
+  );
+  return true;
+}
+function outdentItem(tr, contentPos) {
+  const info = listItemAt(tr, contentPos);
+  if (!info) return false;
+  const { $pos, itemDepth } = info;
+  const listDepth = itemDepth - 1;
+  if (listDepth < 2 || !LIST_ITEM_TYPES.has($pos.node(listDepth - 1).type.name)) return false;
+  const itemType = $pos.node(itemDepth).type;
+  let range = new NodeRange(
+    tr.doc.resolve($pos.before(itemDepth)),
+    tr.doc.resolve($pos.after(itemDepth)),
+    listDepth
+  );
+  const end = range.end;
+  const endOfList = range.$to.end(range.depth);
+  if (end < endOfList) {
+    tr.step(
+      new ReplaceAroundStep(
+        end - 1,
+        endOfList,
+        end,
+        endOfList,
+        new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0),
+        1,
+        true
+      )
+    );
+    range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  const target = liftTarget(range);
+  if (target == null) return false;
+  tr.lift(range, target);
+  return true;
+}
+function restoreWrappers(tr, contentPos, wrappers) {
+  const schema = tr.doc.type.schema;
+  const step = (fn) => {
+    const index = tr.steps.length;
+    const result = fn();
+    contentPos = tr.mapping.slice(index).map(contentPos);
+    return result !== false && tr.steps.length > index;
+  };
+  const chain = () => {
+    const $pos = tr.doc.resolve(contentPos);
+    const types = [];
+    for (let depth = 1; depth < $pos.depth; depth++) types.push($pos.node(depth).type.name);
+    return types;
+  };
+  const target = wrappers.map((w) => w.type);
+  for (let guard = 0; guard < 24; guard++) {
+    const current = chain();
+    if (current.join("/") === target.join("/")) return;
+    if (current.length === target.length) {
+      const index = current.findIndex((type2, i) => type2 !== target[i]);
+      const type = schema.nodes[target[index]];
+      if (type && LIST_ITEM_TYPES.has(type.name) === LIST_ITEM_TYPES.has(current[index])) {
+        const $pos = tr.doc.resolve(contentPos);
+        if (step(() => tr.setNodeMarkup($pos.before(index + 1), type, wrappers[index].attrs))) {
+          continue;
+        }
+      }
+    }
+    let common = 0;
+    while (common < current.length && common < target.length && current[common] === target[common]) {
+      common++;
+    }
+    if (current.length > common) {
+      if (step(() => outdentItem(tr, contentPos))) continue;
+      const $from2 = tr.doc.resolve(contentPos);
+      const range2 = $from2.blockRange(tr.doc.resolve($from2.end()));
+      const lift = range2 ? liftTarget(range2) : null;
+      if (!range2 || lift == null || !step(() => tr.lift(range2, lift))) return;
+      continue;
+    }
+    const missing = wrappers.slice(current.length);
+    if (missing.length >= 2 && LIST_ITEM_TYPES.has(missing[1].type) && step(() => sinkItem(tr, contentPos))) {
+      continue;
+    }
+    const types = missing.map((w) => ({ type: schema.nodes[w.type], attrs: w.attrs }));
+    if (types.some((t) => !t.type)) return;
+    const $from = tr.doc.resolve(contentPos);
+    const range = $from.blockRange(tr.doc.resolve($from.end()));
+    if (!range) return;
+    const start = range.start;
+    step(() => tr.wrap(range, types));
+    const wrapper = tr.doc.nodeAt(start);
+    if (!wrapper) return;
+    const end = start + wrapper.nodeSize;
+    if (tr.doc.resolve(end).nodeAfter?.type === wrapper.type && canJoin(tr.doc, end)) {
+      step(() => tr.join(end));
+    }
+    if (tr.doc.resolve(start).nodeBefore?.type === wrapper.type && canJoin(tr.doc, start)) {
+      step(() => tr.join(start));
+    }
+    return;
+  }
+}
+function decideBlocks(tr, changes, decision) {
+  const ids = new Set(changes.map((c) => c.id));
+  const items = [];
+  tr.doc.descendants((node, pos) => {
+    const record = node.attrs?.[BLOCK_CHANGE_ATTRIBUTE];
+    if (node.isTextblock && record?.changeId && ids.has(record.changeId)) {
+      items.push({ contentPos: pos + 1, record });
+    }
+    return !node.isTextblock;
+  });
+  const schema = tr.doc.type.schema;
+  const startIndex = tr.steps.length;
+  items.reverse().forEach(({ contentPos: original, record }) => {
+    const contentPos = tr.mapping.slice(startIndex).map(original);
+    const $pos = tr.doc.resolve(contentPos);
+    if (!$pos.parent.isTextblock || $pos.parentOffset !== 0) return;
+    const pos = $pos.before();
+    if (decision === "accept") {
+      tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, null);
+      return;
+    }
+    const previous = record.previous;
+    const type = previous && schema.nodes[previous.type];
+    if (!type) {
+      tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, null);
+      return;
+    }
+    const attrs = { ...previous.attrs, [BLOCK_CHANGE_ATTRIBUTE]: null };
+    try {
+      tr.setNodeMarkup(pos, type, attrs);
+    } catch {
+      try {
+        tr.setBlockType(pos + 1, pos + 1, type, attrs);
+      } catch {
+        tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, null);
+      }
+    }
+    try {
+      restoreWrappers(tr, tr.mapping.slice(startIndex).map(original), previous.wrappers ?? []);
+    } catch {
+    }
+  });
+}
 function applyDecision(tr, changes, decision) {
   const schema = tr.doc.type.schema;
+  const format = changes.filter((c) => c.type === "format");
+  if (format.length) decideFormat(tr, format, decision);
   const deletions = [];
   changes.forEach((change) => {
+    if (change.type !== "insertion" && change.type !== "deletion") return;
     const markType = schema.marks[change.type];
     if (!markType) return;
     const keep = change.type === "insertion" === (decision === "accept");
@@ -450,6 +941,8 @@ function applyDecision(tr, changes, decision) {
   deletions.sort((a, b) => b.from - a.from).forEach(({ from, to }) => {
     tr.delete(tr.mapping.map(from), tr.mapping.map(to));
   });
+  const blocks = changes.filter((c) => c.type === "block");
+  if (blocks.length) decideBlocks(tr, blocks, decision);
 }
 function resolveTrackedChanges(doc, view = "accepted") {
   if (view === "all") return doc;
@@ -468,14 +961,27 @@ function hasInlineContent(fragment) {
   });
   return found;
 }
-function acceptSlice(slice, insertion, deletion) {
-  if (!insertion && !deletion) return slice;
+function acceptSlice(slice, schema) {
+  const insertion = schema.marks[INSERTION_MARK_NAME];
+  const deletion = schema.marks[DELETION_MARK_NAME];
+  const format = schema.marks[FORMAT_CHANGE_MARK_NAME];
   const mapFragment = (fragment) => {
     const children = [];
     fragment.forEach((child) => {
       if (child.isInline) {
         if (deletion && deletion.isInSet(child.marks)) return;
-        children.push(insertion ? child.mark(insertion.removeFromSet(child.marks)) : child);
+        let marks = child.marks;
+        if (insertion) marks = insertion.removeFromSet(marks);
+        if (format) marks = format.removeFromSet(marks);
+        children.push(marks === child.marks ? child : child.mark(marks));
+      } else if (child.attrs?.[BLOCK_CHANGE_ATTRIBUTE]) {
+        children.push(
+          child.type.create(
+            { ...child.attrs, [BLOCK_CHANGE_ATTRIBUTE]: null },
+            mapFragment(child.content),
+            child.marks
+          )
+        );
       } else {
         children.push(child.copy(mapFragment(child.content)));
       }
@@ -484,6 +990,13 @@ function acceptSlice(slice, insertion, deletion) {
   };
   return new Slice(mapFragment(slice.content), slice.openStart, slice.openEnd);
 }
+function stripMarks(fragment) {
+  const children = [];
+  fragment.forEach((child) => {
+    children.push(child.isInline ? child.mark(ProsemirrorMark.none) : child.copy(stripMarks(child.content)));
+  });
+  return Fragment.fromArray(children);
+}
 function newAttributes(ctx) {
   return {
     changeId: ctx.generateId(),
@@ -493,6 +1006,15 @@ function newAttributes(ctx) {
     createdAt: ctx.now()
   };
 }
+function baseAttributes(attrs) {
+  return {
+    changeId: attrs.changeId,
+    authorId: attrs.authorId,
+    authorName: attrs.authorName,
+    authorColor: attrs.authorColor ?? null,
+    createdAt: attrs.createdAt
+  };
+}
 function adjacentAttributes(doc, from, to, type, ctx) {
   const candidates = [doc.resolve(from).nodeBefore, doc.resolve(to).nodeAfter];
   for (const node of candidates) {
@@ -540,27 +1062,191 @@ function shouldSkip(tr) {
   !!tr.getMeta("y-sync$") || // Housekeeping appended by other plugins (e.g. trailing nodes).
   !!tr.getMeta("appendedTransaction");
 }
+function formattingOf(marks, ctx) {
+  return marks.filter((m) => !REVIEW_MARK_NAMES.has(m.type.name) && !ctx.ignoredMarks.has(m.type.name)).map((m) => m.toJSON());
+}
+function mergeRanges(ranges) {
+  const sorted = ranges.filter((r) => r.to > r.from).sort((a, b) => a.from - b.from);
+  const merged = [];
+  sorted.forEach((range) => {
+    const last = merged[merged.length - 1];
+    if (last && range.from <= last.to) last.to = Math.max(last.to, range.to);
+    else merged.push({ ...range });
+  });
+  return merged;
+}
+function trackFormatting(tr, ranges, oldDoc, back, inserted, ctx) {
+  const format = ctx.format;
+  const doc = tr.doc;
+  let changed = false;
+  let batch = null;
+  mergeRanges(ranges).forEach(({ from: a, to: b }) => {
+    const segments = [];
+    doc.nodesBetween(a, b, (node, pos, parent) => {
+      if (!node.isInline) return true;
+      const s = Math.max(a, pos);
+      const e = Math.min(b, pos + node.nodeSize);
+      if (e <= s || !parent || !parent.type.allowsMarkType(format)) return false;
+      if (ctx.insertion.isInSet(node.marks)) return false;
+      if (inserted.some((r) => s < r.to && e > r.from)) return false;
+      const os = back.map(s, 1);
+      const oe = back.map(e, -1);
+      if (oe - os !== e - s) return false;
+      oldDoc.nodesBetween(os, oe, (oldNode, oldPos) => {
+        if (!oldNode.isInline) return true;
+        const ss = Math.max(os, oldPos);
+        const ee = Math.min(oe, oldPos + oldNode.nodeSize);
+        if (ee > ss && !ctx.insertion.isInSet(oldNode.marks)) {
+          segments.push({ from: s + (ss - os), to: s + (ee - os), oldNode, node });
+        }
+        return false;
+      });
+      return false;
+    });
+    segments.forEach(({ from, to, oldNode, node }) => {
+      const existing = format.isInSet(oldNode.marks);
+      const original = existing ? existing.attrs.before ?? [] : formattingOf(oldNode.marks, ctx);
+      const current = formattingOf(node.marks, ctx);
+      if (sameValue(original, current)) {
+        if (existing || format.isInSet(node.marks)) {
+          tr.removeMark(from, to, format);
+          changed = true;
+        }
+        return;
+      }
+      let attrs;
+      if (existing && existing.attrs.authorId === ctx.author.id && existing.attrs.changeId) {
+        attrs = baseAttributes(changeAttributes(existing));
+      } else {
+        if (!batch) {
+          const description = describeFormatChange(diffFormatting(original, current));
+          const neighbours = [doc.resolve(from).nodeBefore, doc.resolve(to).nodeAfter];
+          for (const neighbour of neighbours) {
+            const mark = neighbour && format.isInSet(neighbour.marks);
+            if (mark && mark.attrs.authorId === ctx.author.id && mark.attrs.changeId && describeFormatChange(diffFormatting(mark.attrs.before ?? [], mark.attrs.after ?? [])) === description) {
+              batch = baseAttributes(changeAttributes(mark));
+              break;
+            }
+          }
+          batch = batch ?? newAttributes(ctx);
+        }
+        attrs = batch;
+      }
+      tr.addMark(from, to, format.create({ ...attrs, before: original, after: current }));
+      changed = true;
+    });
+  });
+  return changed;
+}
+function trackBlocks(tr, pending, ctx) {
+  let changed = false;
+  let batch = null;
+  pending.forEach(({ previous, existing }, contentPos) => {
+    if (contentPos < 0 || contentPos > tr.doc.content.size) return;
+    const $pos = tr.doc.resolve(contentPos);
+    const node = $pos.parent;
+    if (!node.isTextblock || $pos.parentOffset !== 0 || $pos.depth === 0) return;
+    if (!node.type.spec.attrs || !(BLOCK_CHANGE_ATTRIBUTE in node.type.spec.attrs)) return;
+    const pos = $pos.before();
+    const original = existing?.previous ?? previous;
+    const current = blockSnapshot(tr.doc, pos);
+    if (sameBlock(original, current, ctx.ignoredAttributes)) {
+      if (node.attrs[BLOCK_CHANGE_ATTRIBUTE]) {
+        tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, null);
+        changed = true;
+      }
+      return;
+    }
+    const base = existing && existing.authorId === ctx.author.id && existing.changeId ? baseAttributes(existing) : batch = batch ?? newAttributes(ctx);
+    const value = { ...base, previous: original };
+    if (!sameValue(node.attrs[BLOCK_CHANGE_ATTRIBUTE], value)) {
+      tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, value);
+      changed = true;
+    }
+  });
+  return changed;
+}
+function collectBlockChanges(step, docBefore, docAfter, rest, pending, ctx) {
+  const record = (oldPos, newPos) => {
+    const key = rest.map(newPos + 1);
+    if (pending.has(key)) return;
+    const oldNode = docBefore.nodeAt(oldPos);
+    const previous = blockSnapshot(docBefore, oldPos);
+    if (sameBlock(previous, blockSnapshot(docAfter, newPos), ctx.ignoredAttributes)) return;
+    pending.set(key, {
+      previous,
+      existing: oldNode.attrs[BLOCK_CHANGE_ATTRIBUTE] ?? null
+    });
+  };
+  if (step instanceof AttrStep) {
+    const node = docBefore.nodeAt(step.pos);
+    if (node?.isTextblock && step.attr !== BLOCK_CHANGE_ATTRIBUTE && !ctx.ignoredAttributes.has(step.attr)) {
+      record(step.pos, step.pos);
+    }
+    return;
+  }
+  const map = step.getMap();
+  const back = map.invert();
+  const start = map.map(step.from, -1);
+  const end = map.map(step.to, 1);
+  docAfter.nodesBetween(start, end, (node, pos) => {
+    if (!node.isTextblock) return true;
+    const oldContent = back.map(pos + 1);
+    if (oldContent < 1 || oldContent > docBefore.content.size) return false;
+    const $old = docBefore.resolve(oldContent);
+    if ($old.parent.isTextblock && $old.parentOffset === 0 && $old.parent.content.size === node.content.size) {
+      record($old.before(), pos);
+    }
+    return false;
+  });
+}
 function trackTransactions(transactions, oldState, newState, ctx) {
   const maps = [];
   transactions.forEach((t) => maps.push(...t.mapping.maps));
   const inserted = [];
   const restores = [];
+  const formatRanges = [];
+  const blocks = /* @__PURE__ */ new Map();
   let mapIndex = 0;
   const single = transactions.length === 1 && transactions[0].steps.length === 1;
   transactions.forEach((t) => {
     const skip = shouldSkip(t);
     t.steps.forEach((step, i) => {
       const index = mapIndex + i;
-      if (skip || !(step instanceof ReplaceStep)) return;
-      const { from, to, slice } = step;
+      if (skip) return;
       const rest = new Mapping(maps.slice(index + 1));
+      const docBefore = t.docs[i];
+      if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) {
+        const name = step.mark.type.name;
+        if (ctx.format && !REVIEW_MARK_NAMES.has(name) && !ctx.ignoredMarks.has(name)) {
+          formatRanges.push({ from: rest.map(step.from, 1), to: rest.map(step.to, -1) });
+        }
+        return;
+      }
+      if (step instanceof ReplaceAroundStep || step instanceof AttrStep) {
+        if (ctx.trackBlocks) {
+          const docAfter = t.docs[i + 1] ?? t.doc;
+          collectBlockChanges(step, docBefore, docAfter, rest, blocks, ctx);
+        }
+        return;
+      }
+      if (!(step instanceof ReplaceStep)) return;
+      const { from, to, slice } = step;
+      if (to > from && slice.size === to - from) {
+        const deleted = docBefore.slice(from, to);
+        if (slice.openStart === deleted.openStart && slice.openEnd === deleted.openEnd && stripMarks(slice.content).eq(stripMarks(deleted.content))) {
+          if (ctx.format && !slice.content.eq(deleted.content)) {
+            formatRanges.push({ from: rest.map(from, 1), to: rest.map(to, -1) });
+          }
+          return;
+        }
+      }
       if (slice.size > 0 && hasInlineContent(slice.content)) {
         const start = rest.map(from, 1);
         const end = rest.map(from + slice.size, -1);
         if (end > start) inserted.push({ from: start, to: end });
       }
       if (to > from) {
-        const docBefore = t.docs[i];
         const deleted = docBefore.slice(from, to);
         if (!hasInlineContent(deleted.content)) return;
         const $from = docBefore.resolve(from);
@@ -577,12 +1263,22 @@ function trackTransactions(transactions, oldState, newState, ctx) {
     });
     mapIndex += t.steps.length;
   });
-  if (inserted.length === 0 && restores.length === 0) return null;
+  if (inserted.length === 0 && restores.length === 0 && formatRanges.length === 0 && blocks.size === 0) {
+    return null;
+  }
   const tr = newState.tr;
   let changed = false;
+  if (formatRanges.length && ctx.format) {
+    const back = new Mapping(maps).invert();
+    changed = trackFormatting(tr, formatRanges, oldState.doc, back, inserted, ctx) || changed;
+  }
+  if (blocks.size) {
+    changed = trackBlocks(tr, blocks, ctx) || changed;
+  }
   inserted.forEach(({ from, to }) => {
     tr.removeMark(from, to, ctx.deletion);
     tr.removeMark(from, to, ctx.insertion);
+    if (ctx.format) tr.removeMark(from, to, ctx.format);
     const attrs = adjacentAttributes(tr.doc, from, to, ctx.insertion, ctx) ?? newAttributes(ctx);
     tr.addMark(from, to, ctx.insertion.create(attrs));
     changed = true;
@@ -624,6 +1320,19 @@ function buildSnapshot(state, author) {
     currentChangeId: getTrackedChangeAt(state, state.selection.from, changes)?.id ?? null
   };
 }
+function allowTrackingInCodeBlocks(schema) {
+  const marks = [schema.marks[INSERTION_MARK_NAME], schema.marks[DELETION_MARK_NAME]].filter(
+    Boolean
+  );
+  Object.values(schema.nodes).forEach((type) => {
+    const markSet = type.markSet;
+    if (!type.isTextblock || !type.spec.code || markSet === null) return;
+    const missing = marks.filter((mark) => !markSet.includes(mark));
+    if (missing.length) {
+      type.markSet = [...markSet, ...missing];
+    }
+  });
+}
 var TrackChanges = Extension.create({
   name: "trackChanges",
   addOptions() {
@@ -633,7 +1342,15 @@ var TrackChanges = Extension.create({
       now: () => Date.now(),
       generateId: () => createReviewId("change"),
       insertionHTMLAttributes: {},
-      deletionHTMLAttributes: {}
+      deletionHTMLAttributes: {},
+      formatChangeHTMLAttributes: {},
+      blockChangeClass: "pixerate-block-change border-l-2 border-amber-400 pl-2 dark:border-amber-500",
+      trackFormatting: true,
+      trackBlocks: true,
+      trackCodeBlocks: true,
+      blockTypes: ["paragraph", "heading", "codeBlock"],
+      ignoredMarks: [],
+      ignoredBlockAttributes: ["id"]
     };
   },
   addStorage() {
@@ -646,14 +1363,43 @@ var TrackChanges = Extension.create({
       })
     };
   },
+  addGlobalAttributes() {
+    if (this.options?.trackBlocks === false) return [];
+    const blockClass = this.options?.blockChangeClass ?? "";
+    return [
+      {
+        types: this.options?.blockTypes ?? ["paragraph", "heading", "codeBlock"],
+        attributes: {
+          [BLOCK_CHANGE_ATTRIBUTE]: {
+            default: null,
+            keepOnSplit: false,
+            parseHTML: (el) => parseJSON(el.getAttribute("data-block-change"), null),
+            renderHTML: (attrs) => {
+              const value = attrs[BLOCK_CHANGE_ATTRIBUTE];
+              if (!value) return {};
+              return {
+                "data-block-change": JSON.stringify(value),
+                ...blockClass ? { class: blockClass } : {}
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
   addExtensions() {
     const insertionAttrs = this.options?.insertionHTMLAttributes ?? {};
     const deletionAttrs = this.options?.deletionHTMLAttributes ?? {};
+    const formatAttrs = this.options?.formatChangeHTMLAttributes ?? {};
     return [
       Object.keys(insertionAttrs).length ? TrackedInsertion.configure({ HTMLAttributes: insertionAttrs }) : TrackedInsertion,
-      Object.keys(deletionAttrs).length ? TrackedDeletion.configure({ HTMLAttributes: deletionAttrs }) : TrackedDeletion
+      Object.keys(deletionAttrs).length ? TrackedDeletion.configure({ HTMLAttributes: deletionAttrs }) : TrackedDeletion,
+      Object.keys(formatAttrs).length ? TrackedFormatChange.configure({ HTMLAttributes: formatAttrs }) : TrackedFormatChange
     ];
   },
+  onBeforeCreate() {
+    if (this.options.trackCodeBlocks) allowTrackingInCodeBlocks(this.editor.schema);
+  },
   addCommands() {
     const decide = (decision, id) => ({ state, tr, dispatch }) => {
       const all = getTrackedChanges(state.doc);
@@ -669,9 +1415,11 @@ var TrackChanges = Extension.create({
       const changes = getTrackedChanges(state.doc);
       if (changes.length === 0) return false;
       const { from } = state.selection;
-      const target = direction === 1 ? changes.find((c) => c.from > from) ?? changes[0] : [...changes].reverse().find((c) => c.from < from) ?? changes[changes.length - 1];
+      const start = (c) => selectionRange(c)[0];
+      const target = direction === 1 ? changes.find((c) => start(c) > from) ?? changes[0] : [...changes].reverse().find((c) => start(c) < from) ?? changes[changes.length - 1];
       if (dispatch) {
-        tr.setSelection(TextSelection.create(tr.doc, target.from, target.to)).scrollIntoView();
+        const [anchor, head] = selectionRange(target);
+        tr.setSelection(TextSelection.create(tr.doc, anchor, head)).scrollIntoView();
       }
       return true;
     };
@@ -702,6 +1450,8 @@ var TrackChanges = Extension.create({
   addProseMirrorPlugins() {
     const options = this.options;
     const store = this.storage.store;
+    const ignoredMarks = new Set(options.ignoredMarks ?? []);
+    const ignoredAttributes = new Set(options.ignoredBlockAttributes ?? []);
     let editorView = null;
     let pending = null;
     let flushTimer = null;
@@ -757,15 +1507,15 @@ var TrackChanges = Extension.create({
             now: options.now,
             generateId: options.generateId,
             insertion: newState.schema.marks[INSERTION_MARK_NAME],
-            deletion: newState.schema.marks[DELETION_MARK_NAME]
+            deletion: newState.schema.marks[DELETION_MARK_NAME],
+            format: options.trackFormatting !== false ? newState.schema.marks[FORMAT_CHANGE_MARK_NAME] : void 0,
+            trackBlocks: options.trackBlocks !== false,
+            ignoredMarks,
+            ignoredAttributes
           });
         },
         props: {
-          transformPasted: (slice, view) => acceptSlice(
-            slice,
-            view.state.schema.marks[INSERTION_MARK_NAME],
-            view.state.schema.marks[DELETION_MARK_NAME]
-          ),
+          transformPasted: (slice, view) => acceptSlice(slice, view.state.schema),
           handleDOMEvents: {
             compositionend: () => {
               if (pending) scheduleFlush();
@@ -1336,11 +2086,16 @@ export {
   formatReviewTime,
   INSERTION_MARK_NAME,
   DELETION_MARK_NAME,
+  FORMAT_CHANGE_MARK_NAME,
+  BLOCK_CHANGE_ATTRIBUTE,
   TRACK_CHANGES_SKIP_META,
   TrackChangesStore,
   trackChangesPluginKey,
   TrackedInsertion,
   TrackedDeletion,
+  TrackedFormatChange,
+  describeFormatChange,
+  describeBlockChange,
   getTrackedChanges,
   getTrackedChangeAt,
   isTrackChangesEnabled,
@@ -1364,4 +2119,4 @@ export {
   markdownToTipTapHtml,
   getEditorMarkdown
 };
-//# sourceMappingURL=chunk-3TYMNULT.js.map
+//# sourceMappingURL=chunk-MJZBNWG7.js.map