@pixerate/editor 0.21.0 → 0.22.0

package/dist/{chunk-TVRC4KVT.cjs → chunk-AA4ZEVCC.cjs}

@@ -246,10 +246,31 @@ var _state = require('@tiptap/pm/state');
 
 
 
+
+
 var _model = require('@tiptap/pm/model');
+
+
+
+
+
+
+
+
+
+
 var _transform = require('@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 = (_class2 = class {
   
@@ -281,6 +302,14 @@ var trackChangesPluginKey = new (0, _state.PluginKey)("trackChanges");
 function changeAttributes(mark) {
   return mark.attrs;
 }
+function parseJSON(value, fallback) {
+  if (!value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch (e2) {
+    return fallback;
+  }
+}
 var sharedAttributes = () => ({
   changeId: {
     default: null,
@@ -367,75 +396,537 @@ var TrackedDeletion = _core.Mark.create({
     ];
   }
 });
+var TrackedFormatChange = _core.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(_nullishCoalesce(attrs.before, () => ( []))) })
+      },
+      after: {
+        default: [],
+        parseHTML: (el) => parseJSON(el.getAttribute("data-format-after"), []),
+        renderHTML: (attrs) => ({ "data-format-after": JSON.stringify(_nullishCoalesce(attrs.after, () => ( []))) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-change-type="format"]', priority: 100 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      _core.mergeAttributes.call(void 0, 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 = _nullishCoalesce(mark.attrs, () => ( {}));
+    const otherAttrs = _nullishCoalesce(_optionalChain([other, 'optionalAccess', _2 => _2.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) => _nullishCoalesce(TEXT_STYLE_LABELS[key], () => ( humanize(key)))) : ["Text style"];
+  }
+  return [_nullishCoalesce(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(_nullishCoalesce(old.attrs, () => ( {})), _nullishCoalesce(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" && _optionalChain([attrs, 'optionalAccess', _3 => _3.level])) return `Heading ${attrs.level}`;
+  return _nullishCoalesce(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(_nullishCoalesce(previous.attrs, () => ( {}))), ...Object.keys(_nullishCoalesce(current.attrs, () => ( {})))])
+    ).filter(
+      (key) => key !== BLOCK_CHANGE_ATTRIBUTE && !ignoredAttributes.includes(key) && !(current.type === "heading" && key === "level") && !sameValue(_optionalChain([previous, 'access', _4 => _4.attrs, 'optionalAccess', _5 => _5[key]]), _optionalChain([current, 'access', _6 => _6.attrs, 'optionalAccess', _7 => _7[key]]))
+    );
+    keys.forEach((key) => {
+      if (key === "textAlign") {
+        parts.push(`Changed alignment to ${humanize(String(_nullishCoalesce(_optionalChain([current, 'access', _8 => _8.attrs, 'optionalAccess', _9 => _9.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 (_optionalChain([source, 'access', _2 => _2.state, 'optionalAccess', _3 => _3.doc])) return source.state.doc;
+  if (_optionalChain([source, 'access', _10 => _10.state, 'optionalAccess', _11 => _11.doc])) return source.state.doc;
   if (source.doc && typeof source.doc.descendants === "function") return source.doc;
   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(_nullishCoalesce(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 = _optionalChain([node, 'access', _12 => _12.attrs, 'optionalAccess', _13 => _13[BLOCK_CHANGE_ATTRIBUTE]]);
+    if (_optionalChain([block, 'optionalAccess', _14 => _14.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 ? _nullishCoalesce(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 ? _nullishCoalesce(node.text, () => ( "")) : ""
+      );
+      if (type === "format") {
+        const summary = diffFormatting(_nullishCoalesce(mark.attrs.before, () => ( [])), _nullishCoalesce(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 _nullishCoalesce(_nullishCoalesce(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 _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _4 => _4.state]), () => ( source));
+  const state = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _15 => _15.state]), () => ( source));
   if (!state || typeof state.plugins === "undefined") return false;
-  return _nullishCoalesce(_optionalChain([trackChangesPluginKey, 'access', _5 => _5.getState, 'call', _6 => _6(state), 'optionalAccess', _7 => _7.enabled]), () => ( false));
+  return _nullishCoalesce(_optionalChain([trackChangesPluginKey, 'access', _16 => _16.getState, 'call', _17 => _17(state), 'optionalAccess', _18 => _18.enabled]), () => ( false));
 }
 function getTrackChangesStore(editor) {
-  return _nullishCoalesce(_optionalChain([editor, 'optionalAccess', _8 => _8.storage, 'optionalAccess', _9 => _9.trackChanges, 'optionalAccess', _10 => _10.store]), () => ( null));
+  return _nullishCoalesce(_optionalChain([editor, 'optionalAccess', _19 => _19.storage, 'optionalAccess', _20 => _20.trackChanges, 'optionalAccess', _21 => _21.store]), () => ( null));
+}
+function marksFromJSON(schema, marks) {
+  const result = [];
+  (_nullishCoalesce(marks, () => ( []))).forEach((json) => {
+    try {
+      if (schema.marks[json.type]) result.push(schema.markFromJSON(json));
+    } catch (e3) {
+    }
+  });
+  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 = _nullishCoalesce(mark.attrs.before, () => ( []));
+    const after = _nullishCoalesce(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 = _optionalChain([nodeBefore, 'access', _22 => _22.lastChild, 'optionalAccess', _23 => _23.type]) === list.type;
+  const inner = _model.Fragment.from(nestedBefore ? itemType.create() : null);
+  const slice = new (0, _model.Slice)(
+    _model.Fragment.from(itemType.create(null, _model.Fragment.from(list.type.create(null, inner)))),
+    nestedBefore ? 3 : 1,
+    0
+  );
+  const before = $pos.before(itemDepth);
+  const after = $pos.after(itemDepth);
+  tr.step(
+    new (0, _transform.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 (0, _model.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 (0, _transform.ReplaceAroundStep)(
+        end - 1,
+        endOfList,
+        end,
+        endOfList,
+        new (0, _model.Slice)(_model.Fragment.from(itemType.create(null, range.parent.copy())), 1, 0),
+        1,
+        true
+      )
+    );
+    range = new (0, _model.NodeRange)(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+  }
+  const target = _transform.liftTarget.call(void 0, 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 ? _transform.liftTarget.call(void 0, 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 (_optionalChain([tr, 'access', _24 => _24.doc, 'access', _25 => _25.resolve, 'call', _26 => _26(end), 'access', _27 => _27.nodeAfter, 'optionalAccess', _28 => _28.type]) === wrapper.type && _transform.canJoin.call(void 0, tr.doc, end)) {
+      step(() => tr.join(end));
+    }
+    if (_optionalChain([tr, 'access', _29 => _29.doc, 'access', _30 => _30.resolve, 'call', _31 => _31(start), 'access', _32 => _32.nodeBefore, 'optionalAccess', _33 => _33.type]) === wrapper.type && _transform.canJoin.call(void 0, 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 = _optionalChain([node, 'access', _34 => _34.attrs, 'optionalAccess', _35 => _35[BLOCK_CHANGE_ATTRIBUTE]]);
+    if (node.isTextblock && _optionalChain([record, 'optionalAccess', _36 => _36.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 (e4) {
+      try {
+        tr.setBlockType(pos + 1, pos + 1, type, attrs);
+      } catch (e5) {
+        tr.setNodeAttribute(pos, BLOCK_CHANGE_ATTRIBUTE, null);
+      }
+    }
+    try {
+      restoreWrappers(tr, tr.mapping.slice(startIndex).map(original), _nullishCoalesce(previous.wrappers, () => ( [])));
+    } catch (e6) {
+    }
+  });
 }
 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 (_optionalChain([child, 'access', _37 => _37.attrs, 'optionalAccess', _38 => _38[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 (0, _model.Slice)(mapFragment(slice.content), slice.openStart, slice.openEnd);
 }
+function stripMarks(fragment) {
+  const children = [];
+  fragment.forEach((child) => {
+    children.push(child.isInline ? child.mark(_model.Mark.none) : child.copy(stripMarks(child.content)));
+  });
+  return _model.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: _nullishCoalesce(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 ? _nullishCoalesce(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(_nullishCoalesce(mark.attrs.before, () => ( [])), _nullishCoalesce(mark.attrs.after, () => ( [])))) === description) {
+              batch = baseAttributes(changeAttributes(mark));
+              break;
+            }
+          }
+          batch = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _39 => _39.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 = _nullishCoalesce(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: _nullishCoalesce(oldNode.attrs[BLOCK_CHANGE_ATTRIBUTE], () => ( null))
+    });
+  };
+  if (step instanceof _transform.AttrStep) {
+    const node = docBefore.nodeAt(step.pos);
+    if (_optionalChain([node, 'optionalAccess', _40 => _40.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 _transform.ReplaceStep)) return;
-      const { from, to, slice } = step;
+      if (skip) return;
       const rest = new (0, _transform.Mapping)(maps.slice(index + 1));
+      const docBefore = t.docs[i];
+      if (step instanceof _transform.AddMarkStep || step instanceof _transform.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 _transform.ReplaceAroundStep || step instanceof _transform.AttrStep) {
+        if (ctx.trackBlocks) {
+          const docAfter = _nullishCoalesce(t.docs[i + 1], () => ( t.doc));
+          collectBlockChanges(step, docBefore, docAfter, rest, blocks, ctx);
+        }
+        return;
+      }
+      if (!(step instanceof _transform.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 (0, _transform.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 = _nullishCoalesce(adjacentAttributes(tr.doc, from, to, ctx.insertion, ctx), () => ( newAttributes(ctx)));
     tr.addMark(from, to, ctx.insertion.create(attrs));
     changed = true;
@@ -596,7 +1292,7 @@ function trackTransactions(transactions, oldState, newState, ctx) {
     const sizeBefore = tr.doc.content.size;
     try {
       tr.replace(pos, pos, marked.slice);
-    } catch (e2) {
+    } catch (e7) {
       return;
     }
     changed = true;
@@ -608,7 +1304,7 @@ function trackTransactions(transactions, oldState, newState, ctx) {
   if (cursor !== null) {
     try {
       tr.setSelection(_state.TextSelection.create(tr.doc, cursor));
-    } catch (e3) {
+    } catch (e8) {
     }
   }
   tr.setMeta(TRACK_CHANGES_SKIP_META, true);
@@ -618,12 +1314,25 @@ function buildSnapshot(state, author) {
   const plugin = trackChangesPluginKey.getState(state);
   const changes = getTrackedChanges(state.doc);
   return {
-    enabled: _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _11 => _11.enabled]), () => ( false)),
-    author: _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _12 => _12.author]), () => ( author)),
+    enabled: _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _41 => _41.enabled]), () => ( false)),
+    author: _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _42 => _42.author]), () => ( author)),
     changes,
-    currentChangeId: _nullishCoalesce(_optionalChain([getTrackedChangeAt, 'call', _13 => _13(state, state.selection.from, changes), 'optionalAccess', _14 => _14.id]), () => ( null))
+    currentChangeId: _nullishCoalesce(_optionalChain([getTrackedChangeAt, 'call', _43 => _43(state, state.selection.from, changes), 'optionalAccess', _44 => _44.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 = _core.Extension.create({
   name: "trackChanges",
   addOptions() {
@@ -633,7 +1342,15 @@ var TrackChanges = _core.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 = _core.Extension.create({
       })
     };
   },
+  addGlobalAttributes() {
+    if (_optionalChain([this, 'access', _45 => _45.options, 'optionalAccess', _46 => _46.trackBlocks]) === false) return [];
+    const blockClass = _nullishCoalesce(_optionalChain([this, 'access', _47 => _47.options, 'optionalAccess', _48 => _48.blockChangeClass]), () => ( ""));
+    return [
+      {
+        types: _nullishCoalesce(_optionalChain([this, 'access', _49 => _49.options, 'optionalAccess', _50 => _50.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 = _nullishCoalesce(_optionalChain([this, 'access', _15 => _15.options, 'optionalAccess', _16 => _16.insertionHTMLAttributes]), () => ( {}));
-    const deletionAttrs = _nullishCoalesce(_optionalChain([this, 'access', _17 => _17.options, 'optionalAccess', _18 => _18.deletionHTMLAttributes]), () => ( {}));
+    const insertionAttrs = _nullishCoalesce(_optionalChain([this, 'access', _51 => _51.options, 'optionalAccess', _52 => _52.insertionHTMLAttributes]), () => ( {}));
+    const deletionAttrs = _nullishCoalesce(_optionalChain([this, 'access', _53 => _53.options, 'optionalAccess', _54 => _54.deletionHTMLAttributes]), () => ( {}));
+    const formatAttrs = _nullishCoalesce(_optionalChain([this, 'access', _55 => _55.options, 'optionalAccess', _56 => _56.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 = _core.Extension.create({
       const changes = getTrackedChanges(state.doc);
       if (changes.length === 0) return false;
       const { from } = state.selection;
-      const target = direction === 1 ? _nullishCoalesce(changes.find((c) => c.from > from), () => ( changes[0])) : _nullishCoalesce([...changes].reverse().find((c) => c.from < from), () => ( changes[changes.length - 1]));
+      const start = (c) => selectionRange(c)[0];
+      const target = direction === 1 ? _nullishCoalesce(changes.find((c) => start(c) > from), () => ( changes[0])) : _nullishCoalesce([...changes].reverse().find((c) => start(c) < from), () => ( changes[changes.length - 1]));
       if (dispatch) {
-        tr.setSelection(_state.TextSelection.create(tr.doc, target.from, target.to)).scrollIntoView();
+        const [anchor, head] = selectionRange(target);
+        tr.setSelection(_state.TextSelection.create(tr.doc, anchor, head)).scrollIntoView();
       }
       return true;
     };
@@ -702,6 +1450,8 @@ var TrackChanges = _core.Extension.create({
   addProseMirrorPlugins() {
     const options = this.options;
     const store = this.storage.store;
+    const ignoredMarks = new Set(_nullishCoalesce(options.ignoredMarks, () => ( [])));
+    const ignoredAttributes = new Set(_nullishCoalesce(options.ignoredBlockAttributes, () => ( [])));
     let editorView = null;
     let pending = null;
     let flushTimer = null;
@@ -734,9 +1484,9 @@ var TrackChanges = _core.Extension.create({
         },
         appendTransaction: (transactions, oldState, newState) => {
           const plugin = trackChangesPluginKey.getState(oldState);
-          const tracking = !!_optionalChain([plugin, 'optionalAccess', _19 => _19.enabled]);
+          const tracking = !!_optionalChain([plugin, 'optionalAccess', _57 => _57.enabled]);
           if (!tracking && !pending) return null;
-          if (_optionalChain([editorView, 'optionalAccess', _20 => _20.composing]) && transactions.some((t) => t.docChanged)) {
+          if (_optionalChain([editorView, 'optionalAccess', _58 => _58.composing]) && transactions.some((t) => t.docChanged)) {
             if (tracking) {
               if (!pending) pending = { oldState, transactions: [] };
               pending.transactions.push(...transactions);
@@ -751,21 +1501,21 @@ var TrackChanges = _core.Extension.create({
             pending = null;
           }
           if (!tracking && trs === transactions) return null;
-          const author = _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _21 => _21.author]), () => ( options.author));
+          const author = _nullishCoalesce(_optionalChain([plugin, 'optionalAccess', _59 => _59.author]), () => ( options.author));
           return trackTransactions(trs, fromState, newState, {
             author,
             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();
@@ -827,7 +1577,7 @@ function plainTextToSlice(text, schema) {
     }
     try {
       nodes.push(_model.Node.fromJSON(schema, nodeJson));
-    } catch (e4) {
+    } catch (e9) {
     }
   });
   return _model.Slice.maxOpen(_model.Fragment.fromArray(nodes));
@@ -929,7 +1679,7 @@ function getEditorText(editor, options = {}) {
   if (typeof editor.getText === "function") {
     try {
       return editor.getText({ blockSeparator: "\n" });
-    } catch (e5) {
+    } catch (e10) {
       return editor.getText();
     }
   }
@@ -938,10 +1688,10 @@ function getEditorText(editor, options = {}) {
 function extractMentionsFromDoc(docOrEditor) {
   if (!docOrEditor) return [];
   const mentions = [];
-  const doc = _optionalChain([docOrEditor, 'optionalAccess', _22 => _22.state, 'optionalAccess', _23 => _23.doc]) || (typeof _optionalChain([docOrEditor, 'optionalAccess', _24 => _24.descendants]) === "function" ? docOrEditor : null);
+  const doc = _optionalChain([docOrEditor, 'optionalAccess', _60 => _60.state, 'optionalAccess', _61 => _61.doc]) || (typeof _optionalChain([docOrEditor, 'optionalAccess', _62 => _62.descendants]) === "function" ? docOrEditor : null);
   if (doc && typeof doc.descendants === "function") {
     doc.descendants((node) => {
-      if (_optionalChain([node, 'access', _25 => _25.type, 'optionalAccess', _26 => _26.name]) === "mention" && node.attrs) {
+      if (_optionalChain([node, 'access', _63 => _63.type, 'optionalAccess', _64 => _64.name]) === "mention" && node.attrs) {
         mentions.push({
           id: node.attrs.id || "",
           label: node.attrs.label || "",
@@ -1109,25 +1859,25 @@ function preprocessMarkdownMentions(content, optionsOrMentionables = []) {
       if (!rawHandle) return match;
       const lowerHandle = rawHandle.toLowerCase();
       const entity = allMentionables.find((e) => {
-        if (_optionalChain([e, 'access', _27 => _27.label, 'optionalAccess', _28 => _28.toLowerCase, 'call', _29 => _29()]) === lowerHandle) return true;
-        if (_optionalChain([e, 'access', _30 => _30.handle, 'optionalAccess', _31 => _31.toLowerCase, 'call', _32 => _32()]) === lowerHandle) return true;
-        if (_optionalChain([e, 'access', _33 => _33.name, 'optionalAccess', _34 => _34.toLowerCase, 'call', _35 => _35()]) === lowerHandle) return true;
-        if (_optionalChain([e, 'access', _36 => _36.id, 'optionalAccess', _37 => _37.toLowerCase, 'call', _38 => _38()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _65 => _65.label, 'optionalAccess', _66 => _66.toLowerCase, 'call', _67 => _67()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _68 => _68.handle, 'optionalAccess', _69 => _69.toLowerCase, 'call', _70 => _70()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _71 => _71.name, 'optionalAccess', _72 => _72.toLowerCase, 'call', _73 => _73()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _74 => _74.id, 'optionalAccess', _75 => _75.toLowerCase, 'call', _76 => _76()]) === lowerHandle) return true;
         if (e.type === "agent" && `agent${(e.handle || e.label || "").toLowerCase()}` === lowerHandle) return true;
-        if (_optionalChain([e, 'access', _39 => _39.aliases, 'optionalAccess', _40 => _40.some, 'call', _41 => _41(
+        if (_optionalChain([e, 'access', _77 => _77.aliases, 'optionalAccess', _78 => _78.some, 'call', _79 => _79(
           (a) => a.toLowerCase() === lowerHandle || e.type === "agent" && `agent${a.toLowerCase()}` === lowerHandle
         )])) {
           return true;
         }
         return false;
       });
-      let id = _optionalChain([entity, 'optionalAccess', _42 => _42.id]);
-      let label = _optionalChain([entity, 'optionalAccess', _43 => _43.label]) || _optionalChain([entity, 'optionalAccess', _44 => _44.handle]) || rawHandle;
-      let type = _optionalChain([entity, 'optionalAccess', _45 => _45.type]);
-      let avatarUrl = _optionalChain([entity, 'optionalAccess', _46 => _46.avatarUrl]);
-      let color = _optionalChain([entity, 'optionalAccess', _47 => _47.color]) || _optionalChain([entity, 'optionalAccess', _48 => _48.hexColor]);
+      let id = _optionalChain([entity, 'optionalAccess', _80 => _80.id]);
+      let label = _optionalChain([entity, 'optionalAccess', _81 => _81.label]) || _optionalChain([entity, 'optionalAccess', _82 => _82.handle]) || rawHandle;
+      let type = _optionalChain([entity, 'optionalAccess', _83 => _83.type]);
+      let avatarUrl = _optionalChain([entity, 'optionalAccess', _84 => _84.avatarUrl]);
+      let color = _optionalChain([entity, 'optionalAccess', _85 => _85.color]) || _optionalChain([entity, 'optionalAccess', _86 => _86.hexColor]);
       if (!entity) {
-        const customResolved = _optionalChain([resolveMention, 'optionalCall', _49 => _49(rawHandle)]);
+        const customResolved = _optionalChain([resolveMention, 'optionalCall', _87 => _87(rawHandle)]);
         if (customResolved) {
           id = _nullishCoalesce(customResolved.id, () => ( id));
           label = _nullishCoalesce(_nullishCoalesce(customResolved.label, () => ( customResolved.handle)), () => ( label));
@@ -1287,8 +2037,8 @@ function sanitizeEmbeddedHtml(html, stripDisallowed = false) {
 }
 var defaultHtmlInline = md.renderer.rules.html_inline;
 var defaultHtmlBlock = md.renderer.rules.html_block;
-md.renderer.rules.html_inline = (tokens, idx, options, env, self) => _optionalChain([env, 'optionalAccess', _50 => _50.allowUnsafeHtml]) ? defaultHtmlInline(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
-md.renderer.rules.html_block = (tokens, idx, options, env, self) => _optionalChain([env, 'optionalAccess', _51 => _51.allowUnsafeHtml]) ? defaultHtmlBlock(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+md.renderer.rules.html_inline = (tokens, idx, options, env, self) => _optionalChain([env, 'optionalAccess', _88 => _88.allowUnsafeHtml]) ? defaultHtmlInline(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+md.renderer.rules.html_block = (tokens, idx, options, env, self) => _optionalChain([env, 'optionalAccess', _89 => _89.allowUnsafeHtml]) ? defaultHtmlBlock(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
 function preprocessMarkdownFileLinks(content) {
   if (!content) return "";
   return content.replace(
@@ -1304,23 +2054,23 @@ function preprocessMarkdownFileLinks(content) {
 function markdownToTipTapHtml(markdown, options) {
   if (!markdown) return "<p></p>";
   let content = markdown;
-  if (_optionalChain([options, 'optionalAccess', _52 => _52.preprocessFileLinks])) {
+  if (_optionalChain([options, 'optionalAccess', _90 => _90.preprocessFileLinks])) {
     content = preprocessMarkdownFileLinks(content);
   }
-  if (_optionalChain([options, 'optionalAccess', _53 => _53.preprocessMentions]) || _optionalChain([options, 'optionalAccess', _54 => _54.mentionables]) || _optionalChain([options, 'optionalAccess', _55 => _55.preprocessOptions])) {
+  if (_optionalChain([options, 'optionalAccess', _91 => _91.preprocessMentions]) || _optionalChain([options, 'optionalAccess', _92 => _92.mentionables]) || _optionalChain([options, 'optionalAccess', _93 => _93.preprocessOptions])) {
     const mentionOpts = options.preprocessOptions || {
       mentionables: options.mentionables
     };
     content = preprocessMarkdownMentions(content, mentionOpts);
   }
-  return md.render(content, { allowUnsafeHtml: _optionalChain([options, 'optionalAccess', _56 => _56.allowUnsafeHtml]) });
+  return md.render(content, { allowUnsafeHtml: _optionalChain([options, 'optionalAccess', _94 => _94.allowUnsafeHtml]) });
 }
 function getEditorMarkdown(editor, options = {}) {
   if (!editor) return "";
-  const markdown = _optionalChain([editor, 'access', _57 => _57.storage, 'optionalAccess', _58 => _58.markdown]);
-  if (typeof _optionalChain([markdown, 'optionalAccess', _59 => _59.getMarkdown]) === "function") {
-    const doc = _optionalChain([editor, 'access', _60 => _60.state, 'optionalAccess', _61 => _61.doc]);
-    if (doc && typeof _optionalChain([markdown, 'access', _62 => _62.serializer, 'optionalAccess', _63 => _63.serialize]) === "function") {
+  const markdown = _optionalChain([editor, 'access', _95 => _95.storage, 'optionalAccess', _96 => _96.markdown]);
+  if (typeof _optionalChain([markdown, 'optionalAccess', _97 => _97.getMarkdown]) === "function") {
+    const doc = _optionalChain([editor, 'access', _98 => _98.state, 'optionalAccess', _99 => _99.doc]);
+    if (doc && typeof _optionalChain([markdown, 'access', _100 => _100.serializer, 'optionalAccess', _101 => _101.serialize]) === "function") {
       const resolved = resolveTrackedChanges(doc, _nullishCoalesce(options.trackedChanges, () => ( "accepted")));
       if (resolved !== doc) return markdown.serializer.serialize(resolved);
     }
@@ -1363,5 +2113,10 @@ function getEditorMarkdown(editor, options = {}) {
 
 
 
-exports.createReviewId = createReviewId; exports.CommentStore = CommentStore; exports.createCommentStore = createCommentStore; exports.formatReviewTime = formatReviewTime; exports.INSERTION_MARK_NAME = INSERTION_MARK_NAME; exports.DELETION_MARK_NAME = DELETION_MARK_NAME; exports.TRACK_CHANGES_SKIP_META = TRACK_CHANGES_SKIP_META; exports.TrackChangesStore = TrackChangesStore; exports.trackChangesPluginKey = trackChangesPluginKey; exports.TrackedInsertion = TrackedInsertion; exports.TrackedDeletion = TrackedDeletion; exports.getTrackedChanges = getTrackedChanges; exports.getTrackedChangeAt = getTrackedChangeAt; exports.isTrackChangesEnabled = isTrackChangesEnabled; exports.getTrackChangesStore = getTrackChangesStore; exports.resolveTrackedChanges = resolveTrackedChanges; exports.TrackChanges = TrackChanges; exports.MENTION_REGEX = MENTION_REGEX; exports.MARKDOWN_MENTION_SPLIT_REGEX = MARKDOWN_MENTION_SPLIT_REGEX; exports.stripMarkdownCode = stripMarkdownCode; exports.extractMentions = extractMentions; exports.parseMentionSegments = parseMentionSegments; exports.preprocessMarkdownMentions = preprocessMarkdownMentions; exports.escapeHtml = escapeHtml; exports.plainTextToTipTapHtml = plainTextToTipTapHtml; exports.plainTextToSlice = plainTextToSlice; exports.htmlToPlainText = htmlToPlainText; exports.getEditorText = getEditorText; exports.extractMentionsFromDoc = extractMentionsFromDoc; exports.sanitizeHtml = sanitizeHtml; exports.preprocessMarkdownFileLinks = preprocessMarkdownFileLinks; exports.markdownToTipTapHtml = markdownToTipTapHtml; exports.getEditorMarkdown = getEditorMarkdown;
-//# sourceMappingURL=chunk-TVRC4KVT.cjs.map
+
+
+
+
+
+exports.createReviewId = createReviewId; exports.CommentStore = CommentStore; exports.createCommentStore = createCommentStore; exports.formatReviewTime = formatReviewTime; exports.INSERTION_MARK_NAME = INSERTION_MARK_NAME; exports.DELETION_MARK_NAME = DELETION_MARK_NAME; exports.FORMAT_CHANGE_MARK_NAME = FORMAT_CHANGE_MARK_NAME; exports.BLOCK_CHANGE_ATTRIBUTE = BLOCK_CHANGE_ATTRIBUTE; exports.TRACK_CHANGES_SKIP_META = TRACK_CHANGES_SKIP_META; exports.TrackChangesStore = TrackChangesStore; exports.trackChangesPluginKey = trackChangesPluginKey; exports.TrackedInsertion = TrackedInsertion; exports.TrackedDeletion = TrackedDeletion; exports.TrackedFormatChange = TrackedFormatChange; exports.describeFormatChange = describeFormatChange; exports.describeBlockChange = describeBlockChange; exports.getTrackedChanges = getTrackedChanges; exports.getTrackedChangeAt = getTrackedChangeAt; exports.isTrackChangesEnabled = isTrackChangesEnabled; exports.getTrackChangesStore = getTrackChangesStore; exports.resolveTrackedChanges = resolveTrackedChanges; exports.TrackChanges = TrackChanges; exports.MENTION_REGEX = MENTION_REGEX; exports.MARKDOWN_MENTION_SPLIT_REGEX = MARKDOWN_MENTION_SPLIT_REGEX; exports.stripMarkdownCode = stripMarkdownCode; exports.extractMentions = extractMentions; exports.parseMentionSegments = parseMentionSegments; exports.preprocessMarkdownMentions = preprocessMarkdownMentions; exports.escapeHtml = escapeHtml; exports.plainTextToTipTapHtml = plainTextToTipTapHtml; exports.plainTextToSlice = plainTextToSlice; exports.htmlToPlainText = htmlToPlainText; exports.getEditorText = getEditorText; exports.extractMentionsFromDoc = extractMentionsFromDoc; exports.sanitizeHtml = sanitizeHtml; exports.preprocessMarkdownFileLinks = preprocessMarkdownFileLinks; exports.markdownToTipTapHtml = markdownToTipTapHtml; exports.getEditorMarkdown = getEditorMarkdown;
+//# sourceMappingURL=chunk-AA4ZEVCC.cjs.map