@pixerate/editor 0.19.0 → 0.20.0

package/dist/chunk-3TYMNULT.js

@@ -0,0 +1,1367 @@
+// src/extensions/comment-store.ts
+var idCounter = 0;
+function createReviewId(prefix = "c") {
+  idCounter = (idCounter + 1) % 1e6;
+  return `${prefix}-${Date.now().toString(36)}-${idCounter.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function sameAnchor(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.from === b.from && a.to === b.to && a.quote === b.quote;
+}
+function normalizeThread(raw) {
+  return {
+    id: String(raw.id),
+    anchor: raw.anchor ?? null,
+    author: raw.author ?? { id: "unknown", name: "Unknown" },
+    createdAt: Number(raw.createdAt ?? 0),
+    body: String(raw.body ?? ""),
+    ...raw.editedAt !== void 0 ? { editedAt: raw.editedAt } : {},
+    replies: Array.isArray(raw.replies) ? raw.replies.map((r) => ({ ...r })) : [],
+    resolved: !!raw.resolved,
+    ...raw.resolvedAt !== void 0 ? { resolvedAt: raw.resolvedAt } : {},
+    ...raw.resolvedBy !== void 0 ? { resolvedBy: raw.resolvedBy } : {},
+    orphaned: !!raw.orphaned,
+    ...raw.lastQuote !== void 0 ? { lastQuote: String(raw.lastQuote) } : {}
+  };
+}
+var CommentStore = class _CommentStore {
+  threads = [];
+  activeThreadId = null;
+  snapshot;
+  listeners = /* @__PURE__ */ new Set();
+  /** Deleted threads, kept so undoing a "Delete Comment" can restore them. */
+  deleted = /* @__PURE__ */ new Map();
+  generateId;
+  now;
+  constructor(options = {}) {
+    this.generateId = options.generateId ?? (() => createReviewId("comment"));
+    this.now = options.now ?? (() => Date.now());
+    if (options.threads) {
+      this.threads = _CommentStore.parse(options.threads);
+    }
+    this.snapshot = this.computeSnapshot();
+  }
+  /** Parses `toJSON()` output (or a plain thread array). */
+  static parse(json) {
+    const value = typeof json === "string" ? JSON.parse(json) : json;
+    const list = Array.isArray(value) ? value : value?.threads;
+    if (!Array.isArray(list)) return [];
+    return list.filter((t) => t && t.id != null).map(normalizeThread);
+  }
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    listener(this.snapshot);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.snapshot;
+  getThread(id) {
+    return this.threads.find((t) => t.id === id);
+  }
+  createThread(input) {
+    const thread = {
+      id: input.id ?? this.generateId(),
+      anchor: input.anchor ?? null,
+      author: input.author,
+      createdAt: input.createdAt ?? this.now(),
+      body: input.body,
+      replies: [],
+      resolved: false,
+      orphaned: false
+    };
+    this.threads = [...this.threads.filter((t) => t.id !== thread.id), thread];
+    this.deleted.delete(thread.id);
+    this.emit();
+    return thread;
+  }
+  /** Edits the thread's body, or one of its replies when `replyId` is given. */
+  editComment(threadId, body, replyId) {
+    const editedAt = this.now();
+    return this.updateThread(threadId, (t) => {
+      if (!replyId) return { ...t, body, editedAt };
+      if (!t.replies.some((r) => r.id === replyId)) return t;
+      return {
+        ...t,
+        replies: t.replies.map((r) => r.id === replyId ? { ...r, body, editedAt } : r)
+      };
+    });
+  }
+  addReply(threadId, input) {
+    const reply = {
+      id: input.id ?? this.generateId(),
+      author: input.author,
+      body: input.body,
+      createdAt: this.now()
+    };
+    const ok = this.updateThread(threadId, (t) => ({
+      ...t,
+      replies: [...t.replies, reply],
+      // Replying to a resolved thread re-opens it, as in Word and Pages.
+      resolved: false,
+      resolvedAt: void 0,
+      resolvedBy: void 0
+    }));
+    return ok ? reply : null;
+  }
+  deleteReply(threadId, replyId) {
+    return this.updateThread(
+      threadId,
+      (t) => t.replies.some((r) => r.id === replyId) ? { ...t, replies: t.replies.filter((r) => r.id !== replyId) } : t
+    );
+  }
+  resolveThread(id, resolved = true, by) {
+    return this.updateThread(
+      id,
+      (t) => t.resolved === resolved ? t : resolved ? { ...t, resolved, resolvedAt: this.now(), ...by ? { resolvedBy: by } : {} } : { ...t, resolved, resolvedAt: void 0, resolvedBy: void 0 }
+    );
+  }
+  deleteThread(id) {
+    const thread = this.getThread(id);
+    if (!thread) return false;
+    this.deleted.set(id, thread);
+    this.threads = this.threads.filter((t) => t.id !== id);
+    if (this.activeThreadId === id) this.activeThreadId = null;
+    this.emit();
+    return true;
+  }
+  /** Deletes every thread whose text is no longer in the document. */
+  removeOrphanedThreads() {
+    const ids = this.threads.filter((t) => t.orphaned).map((t) => t.id);
+    if (ids.length === 0) return ids;
+    ids.forEach((id) => this.deleted.set(id, this.getThread(id)));
+    this.threads = this.threads.filter((t) => !t.orphaned);
+    if (this.activeThreadId && ids.includes(this.activeThreadId)) {
+      this.activeThreadId = null;
+    }
+    this.emit();
+    return ids;
+  }
+  setActiveThread(id) {
+    const next = id && this.getThread(id) ? id : null;
+    if (next === this.activeThreadId) return;
+    this.activeThreadId = next;
+    this.emit();
+  }
+  /**
+   * Updates anchors from the document. Threads missing from `anchors` become
+   * orphaned. Threads that were deleted but whose mark re-appeared (e.g. after
+   * undoing "Delete Comment") are restored. Returns true if anything changed.
+   */
+  syncAnchors(anchors) {
+    let changed = false;
+    const restored = [];
+    anchors.forEach((_anchor, id) => {
+      if (!this.getThread(id) && this.deleted.has(id)) {
+        restored.push(this.deleted.get(id));
+        this.deleted.delete(id);
+      }
+    });
+    const next = [...this.threads, ...restored].map((t) => {
+      const anchor = anchors.get(t.id) ?? null;
+      const orphaned = anchor === null;
+      if (sameAnchor(t.anchor, anchor) && t.orphaned === orphaned) return t;
+      changed = true;
+      return orphaned ? { ...t, anchor: null, orphaned, ...t.anchor ? { lastQuote: t.anchor.quote } : {} } : { ...t, anchor, orphaned };
+    });
+    if (!changed && restored.length === 0) return false;
+    this.threads = next;
+    this.emit();
+    return true;
+  }
+  /** Replaces all threads, e.g. with data loaded from a server. */
+  load(json) {
+    this.threads = _CommentStore.parse(json);
+    this.deleted.clear();
+    if (this.activeThreadId && !this.getThread(this.activeThreadId)) {
+      this.activeThreadId = null;
+    }
+    this.emit();
+  }
+  clear() {
+    this.threads = [];
+    this.deleted.clear();
+    this.activeThreadId = null;
+    this.emit();
+  }
+  toJSON() {
+    return {
+      version: 1,
+      threads: this.threads.map((t) => ({ ...t, replies: t.replies.map((r) => ({ ...r })) }))
+    };
+  }
+  updateThread(id, fn) {
+    const index = this.threads.findIndex((t) => t.id === id);
+    if (index === -1) return false;
+    const updated = fn(this.threads[index]);
+    if (updated === this.threads[index]) return true;
+    this.threads = this.threads.map((t, i) => i === index ? updated : t);
+    this.emit();
+    return true;
+  }
+  computeSnapshot() {
+    const threads = [...this.threads].sort((a, b) => {
+      if (a.anchor && b.anchor) {
+        return a.anchor.from - b.anchor.from || a.createdAt - b.createdAt;
+      }
+      if (a.anchor) return -1;
+      if (b.anchor) return 1;
+      return a.createdAt - b.createdAt;
+    });
+    return { threads, activeThreadId: this.activeThreadId };
+  }
+  emit() {
+    this.snapshot = this.computeSnapshot();
+    const snapshot = this.snapshot;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error("[CommentStore] Error in listener:", err);
+      }
+    });
+  }
+};
+function createCommentStore(options) {
+  return new CommentStore(options);
+}
+function formatReviewTime(timestamp, now = Date.now()) {
+  const seconds = Math.round((now - timestamp) / 1e3);
+  if (seconds < 45) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return new Date(timestamp).toLocaleDateString();
+}
+
+// src/extensions/track-changes.ts
+import { Extension, Mark, mergeAttributes } from "@tiptap/core";
+import {
+  Plugin,
+  PluginKey,
+  TextSelection
+} from "@tiptap/pm/state";
+import {
+  Fragment,
+  Slice
+} from "@tiptap/pm/model";
+import { Mapping, ReplaceStep, Transform } from "@tiptap/pm/transform";
+var INSERTION_MARK_NAME = "insertion";
+var DELETION_MARK_NAME = "deletion";
+var TRACK_CHANGES_SKIP_META = "trackChangesSkip";
+var TrackChangesStore = class {
+  snapshot;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.snapshot = initial;
+  }
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    listener(this.snapshot);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.snapshot;
+  /** @internal Called by the extension's plugin view. */
+  set(snapshot) {
+    this.snapshot = snapshot;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error("[TrackChangesStore] Error in listener:", err);
+      }
+    });
+  }
+};
+var trackChangesPluginKey = new PluginKey("trackChanges");
+function changeAttributes(mark) {
+  return mark.attrs;
+}
+var sharedAttributes = () => ({
+  changeId: {
+    default: null,
+    parseHTML: (el) => el.getAttribute("data-change-id"),
+    renderHTML: (attrs) => ({ "data-change-id": attrs.changeId })
+  },
+  authorId: {
+    default: "",
+    parseHTML: (el) => el.getAttribute("data-author-id") ?? "",
+    renderHTML: (attrs) => ({ "data-author-id": attrs.authorId })
+  },
+  authorName: {
+    default: "",
+    parseHTML: (el) => el.getAttribute("data-author-name") ?? "",
+    renderHTML: (attrs) => ({ "data-author-name": attrs.authorName })
+  },
+  authorColor: {
+    default: null,
+    parseHTML: (el) => el.getAttribute("data-author-color"),
+    renderHTML: (attrs) => attrs.authorColor ? { "data-author-color": attrs.authorColor } : {}
+  },
+  createdAt: {
+    default: 0,
+    parseHTML: (el) => Number(el.getAttribute("data-created-at") ?? 0),
+    renderHTML: (attrs) => ({ "data-created-at": String(attrs.createdAt) })
+  }
+});
+var TrackedInsertion = Mark.create({
+  name: INSERTION_MARK_NAME,
+  inclusive: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {
+        class: "pixerate-insertion underline decoration-emerald-500 text-emerald-700 dark:text-emerald-400"
+      }
+    };
+  },
+  addStorage() {
+    return { markdown: { serialize: { open: "", close: "" }, parse: {} } };
+  },
+  addAttributes: sharedAttributes,
+  parseHTML() {
+    return [{ tag: 'ins[data-change-type="insertion"]', priority: 100 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "ins",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-change-type": "insertion"
+      }),
+      0
+    ];
+  }
+});
+var TrackedDeletion = Mark.create({
+  name: DELETION_MARK_NAME,
+  inclusive: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {
+        class: "pixerate-deletion line-through decoration-red-500 text-red-600 dark:text-red-400"
+      }
+    };
+  },
+  addStorage() {
+    return {
+      markdown: {
+        serialize: { open: "~~", close: "~~", mixable: true, expelEnclosingWhitespace: true },
+        parse: {}
+      }
+    };
+  },
+  addAttributes: sharedAttributes,
+  parseHTML() {
+    return [{ tag: 'del[data-change-type="deletion"]', priority: 100 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "del",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-change-type": "deletion"
+      }),
+      0
+    ];
+  }
+});
+function toDoc(source) {
+  if (!source) return null;
+  if (source.state?.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 getTrackedChanges(source) {
+  const doc = toDoc(source);
+  if (!doc) return [];
+  const byKey = /* @__PURE__ */ new Map();
+  doc.descendants((node, 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 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 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);
+}
+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);
+  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;
+}
+function isTrackChangesEnabled(source) {
+  const state = source?.state ?? source;
+  if (!state || typeof state.plugins === "undefined") return false;
+  return trackChangesPluginKey.getState(state)?.enabled ?? false;
+}
+function getTrackChangesStore(editor) {
+  return editor?.storage?.trackChanges?.store ?? null;
+}
+function applyDecision(tr, changes, decision) {
+  const schema = tr.doc.type.schema;
+  const deletions = [];
+  changes.forEach((change) => {
+    const markType = schema.marks[change.type];
+    if (!markType) return;
+    const keep = change.type === "insertion" === (decision === "accept");
+    change.ranges.forEach(({ from, to }) => {
+      if (keep) {
+        tr.removeMark(from, to, markType);
+      } else {
+        deletions.push({ from, to });
+      }
+    });
+  });
+  deletions.sort((a, b) => b.from - a.from).forEach(({ from, to }) => {
+    tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+  });
+}
+function resolveTrackedChanges(doc, view = "accepted") {
+  if (view === "all") return doc;
+  const changes = getTrackedChanges(doc);
+  if (changes.length === 0) return doc;
+  const tr = new Transform(doc);
+  applyDecision(tr, changes, view === "accepted" ? "accept" : "reject");
+  return tr.doc;
+}
+function hasInlineContent(fragment) {
+  let found = false;
+  fragment.descendants((node) => {
+    if (found) return false;
+    if (node.isInline) found = true;
+    return !found;
+  });
+  return found;
+}
+function acceptSlice(slice, insertion, deletion) {
+  if (!insertion && !deletion) return slice;
+  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);
+      } else {
+        children.push(child.copy(mapFragment(child.content)));
+      }
+    });
+    return Fragment.from(children);
+  };
+  return new Slice(mapFragment(slice.content), slice.openStart, slice.openEnd);
+}
+function newAttributes(ctx) {
+  return {
+    changeId: ctx.generateId(),
+    authorId: ctx.author.id,
+    authorName: ctx.author.name,
+    authorColor: ctx.author.color ?? null,
+    createdAt: ctx.now()
+  };
+}
+function adjacentAttributes(doc, from, to, type, ctx) {
+  const candidates = [doc.resolve(from).nodeBefore, doc.resolve(to).nodeAfter];
+  for (const node of candidates) {
+    const mark = node && type.isInSet(node.marks);
+    if (mark && mark.attrs.authorId === ctx.author.id && mark.attrs.changeId) {
+      return changeAttributes(mark);
+    }
+  }
+  return null;
+}
+function markDeletedSlice(slice, parentType, attrs, ctx) {
+  let ok = true;
+  let hasContent = false;
+  const deletionMark = ctx.deletion.create(attrs);
+  const mapFragment = (fragment, parent) => {
+    const children = [];
+    fragment.forEach((child) => {
+      if (child.isInline) {
+        const insertion = ctx.insertion.isInSet(child.marks);
+        if (insertion && insertion.attrs.authorId === ctx.author.id) return;
+        hasContent = true;
+        if (ctx.deletion.isInSet(child.marks)) {
+          children.push(child);
+          return;
+        }
+        if (!parent.allowsMarkType(ctx.deletion)) {
+          ok = false;
+          children.push(child);
+          return;
+        }
+        children.push(child.mark(deletionMark.addToSet(child.marks)));
+      } else {
+        children.push(child.copy(mapFragment(child.content, child.type)));
+      }
+    });
+    return Fragment.from(children);
+  };
+  const content = mapFragment(slice.content, parentType);
+  if (!ok) return null;
+  return { slice: new Slice(content, slice.openStart, slice.openEnd), hasContent };
+}
+function shouldSkip(tr) {
+  return !tr.docChanged || tr.getMeta(TRACK_CHANGES_SKIP_META) === true || !!tr.getMeta(trackChangesPluginKey) || // Undo/redo replays already-tracked history.
+  !!tr.getMeta("history$") || // Remote collaborative changes were tracked by their author.
+  !!tr.getMeta("y-sync$") || // Housekeeping appended by other plugins (e.g. trailing nodes).
+  !!tr.getMeta("appendedTransaction");
+}
+function trackTransactions(transactions, oldState, newState, ctx) {
+  const maps = [];
+  transactions.forEach((t) => maps.push(...t.mapping.maps));
+  const inserted = [];
+  const restores = [];
+  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;
+      const rest = new Mapping(maps.slice(index + 1));
+      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);
+        const before = i === 0 ? t.before : null;
+        const sel = before === oldState.doc ? oldState.selection : null;
+        restores.push({
+          pos: rest.map(from, -1),
+          slice: deleted,
+          parentType: $from.node(Math.max(0, $from.depth - deleted.openStart)).type,
+          pureDelete: slice.size === 0,
+          backspace: single && slice.size === 0 && !!sel && sel.empty && sel.from === to
+        });
+      }
+    });
+    mapIndex += t.steps.length;
+  });
+  if (inserted.length === 0 && restores.length === 0) return null;
+  const tr = newState.tr;
+  let changed = false;
+  inserted.forEach(({ from, to }) => {
+    tr.removeMark(from, to, ctx.deletion);
+    tr.removeMark(from, to, ctx.insertion);
+    const attrs = adjacentAttributes(tr.doc, from, to, ctx.insertion, ctx) ?? newAttributes(ctx);
+    tr.addMark(from, to, ctx.insertion.create(attrs));
+    changed = true;
+  });
+  let cursor = null;
+  restores.sort((a, b) => b.pos - a.pos).forEach((restore) => {
+    const pos = tr.mapping.map(restore.pos, -1);
+    const attrs = adjacentAttributes(tr.doc, pos, pos, ctx.deletion, ctx) ?? newAttributes(ctx);
+    const marked = markDeletedSlice(restore.slice, restore.parentType, attrs, ctx);
+    if (!marked || !marked.hasContent) return;
+    const sizeBefore = tr.doc.content.size;
+    try {
+      tr.replace(pos, pos, marked.slice);
+    } catch {
+      return;
+    }
+    changed = true;
+    if (restores.length === 1 && restore.pureDelete && newState.selection.empty) {
+      cursor = restore.backspace ? pos : pos + (tr.doc.content.size - sizeBefore);
+    }
+  });
+  if (!changed) return null;
+  if (cursor !== null) {
+    try {
+      tr.setSelection(TextSelection.create(tr.doc, cursor));
+    } catch {
+    }
+  }
+  tr.setMeta(TRACK_CHANGES_SKIP_META, true);
+  return tr;
+}
+function buildSnapshot(state, author) {
+  const plugin = trackChangesPluginKey.getState(state);
+  const changes = getTrackedChanges(state.doc);
+  return {
+    enabled: plugin?.enabled ?? false,
+    author: plugin?.author ?? author,
+    changes,
+    currentChangeId: getTrackedChangeAt(state, state.selection.from, changes)?.id ?? null
+  };
+}
+var TrackChanges = Extension.create({
+  name: "trackChanges",
+  addOptions() {
+    return {
+      enabled: false,
+      author: { id: "anonymous", name: "Anonymous" },
+      now: () => Date.now(),
+      generateId: () => createReviewId("change"),
+      insertionHTMLAttributes: {},
+      deletionHTMLAttributes: {}
+    };
+  },
+  addStorage() {
+    return {
+      store: new TrackChangesStore({
+        enabled: this.options.enabled,
+        author: this.options.author,
+        changes: [],
+        currentChangeId: null
+      })
+    };
+  },
+  addExtensions() {
+    const insertionAttrs = this.options?.insertionHTMLAttributes ?? {};
+    const deletionAttrs = this.options?.deletionHTMLAttributes ?? {};
+    return [
+      Object.keys(insertionAttrs).length ? TrackedInsertion.configure({ HTMLAttributes: insertionAttrs }) : TrackedInsertion,
+      Object.keys(deletionAttrs).length ? TrackedDeletion.configure({ HTMLAttributes: deletionAttrs }) : TrackedDeletion
+    ];
+  },
+  addCommands() {
+    const decide = (decision, id) => ({ state, tr, dispatch }) => {
+      const all = getTrackedChanges(state.doc);
+      const changes = id === null ? all : all.filter((c) => c.id === id);
+      if (changes.length === 0) return false;
+      if (dispatch) {
+        applyDecision(tr, changes, decision);
+        tr.setMeta(TRACK_CHANGES_SKIP_META, true);
+      }
+      return true;
+    };
+    const select = (direction) => ({ state, tr, dispatch }) => {
+      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];
+      if (dispatch) {
+        tr.setSelection(TextSelection.create(tr.doc, target.from, target.to)).scrollIntoView();
+      }
+      return true;
+    };
+    return {
+      setTrackChanges: (enabled) => ({ tr, dispatch }) => {
+        if (dispatch) {
+          tr.setMeta(trackChangesPluginKey, { type: "setEnabled", enabled });
+          tr.setMeta("addToHistory", false);
+        }
+        return true;
+      },
+      toggleTrackChanges: () => ({ state, commands }) => commands.setTrackChanges(!isTrackChangesEnabled(state)),
+      setTrackChangesAuthor: (author) => ({ tr, dispatch }) => {
+        if (dispatch) {
+          tr.setMeta(trackChangesPluginKey, { type: "setAuthor", author });
+          tr.setMeta("addToHistory", false);
+        }
+        return true;
+      },
+      acceptChange: (id) => decide("accept", id),
+      rejectChange: (id) => decide("reject", id),
+      acceptAllChanges: () => decide("accept", null),
+      rejectAllChanges: () => decide("reject", null),
+      selectNextChange: () => select(1),
+      selectPreviousChange: () => select(-1)
+    };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    const store = this.storage.store;
+    let editorView = null;
+    let pending = null;
+    let flushTimer = null;
+    const scheduleFlush = () => {
+      if (flushTimer) clearTimeout(flushTimer);
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        const view = editorView;
+        if (!view || !pending) return;
+        if (view.composing) {
+          scheduleFlush();
+          return;
+        }
+        view.dispatch(view.state.tr.setMeta("trackChangesFlush", true));
+      }, 0);
+    };
+    return [
+      new Plugin({
+        key: trackChangesPluginKey,
+        state: {
+          init: () => ({ enabled: options.enabled, author: options.author }),
+          apply: (tr, value) => {
+            const meta = tr.getMeta(trackChangesPluginKey);
+            if (!meta) return value;
+            if (meta.type === "setEnabled") {
+              return meta.enabled === value.enabled ? value : { ...value, enabled: meta.enabled };
+            }
+            return { ...value, author: meta.author };
+          }
+        },
+        appendTransaction: (transactions, oldState, newState) => {
+          const plugin = trackChangesPluginKey.getState(oldState);
+          const tracking = !!plugin?.enabled;
+          if (!tracking && !pending) return null;
+          if (editorView?.composing && transactions.some((t) => t.docChanged)) {
+            if (tracking) {
+              if (!pending) pending = { oldState, transactions: [] };
+              pending.transactions.push(...transactions);
+            }
+            return null;
+          }
+          let trs = transactions;
+          let fromState = oldState;
+          if (pending) {
+            trs = [...pending.transactions, ...transactions];
+            fromState = pending.oldState;
+            pending = null;
+          }
+          if (!tracking && trs === transactions) return null;
+          const author = plugin?.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]
+          });
+        },
+        props: {
+          transformPasted: (slice, view) => acceptSlice(
+            slice,
+            view.state.schema.marks[INSERTION_MARK_NAME],
+            view.state.schema.marks[DELETION_MARK_NAME]
+          ),
+          handleDOMEvents: {
+            compositionend: () => {
+              if (pending) scheduleFlush();
+              return false;
+            }
+          }
+        },
+        view: (view) => {
+          editorView = view;
+          store.set(buildSnapshot(view.state, options.author));
+          return {
+            update(view2, prevState) {
+              if (prevState.doc !== view2.state.doc || !prevState.selection.eq(view2.state.selection) || trackChangesPluginKey.getState(prevState) !== trackChangesPluginKey.getState(view2.state)) {
+                store.set(buildSnapshot(view2.state, options.author));
+              }
+              if (pending && !view2.composing) scheduleFlush();
+            },
+            destroy() {
+              editorView = null;
+              pending = null;
+              if (flushTimer) clearTimeout(flushTimer);
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+
+// src/serializers/plain-text.ts
+import { Slice as Slice2, Fragment as Fragment2, Node as ProsemirrorNode } from "@tiptap/pm/model";
+var TRACKED_DELETION_REGEX = /<del\b(?=[^>]*\bdata-change-type=["']deletion["'])[^>]*>[\s\S]*?<\/del>/gi;
+var TRACKED_INSERTION_REGEX = /<ins\b(?=[^>]*\bdata-change-type=["']insertion["'])[^>]*>[\s\S]*?<\/ins>/gi;
+function stripTrackedChanges(html, view) {
+  if (view === "all" || !html.includes("data-change-type")) return html;
+  return html.replace(
+    view === "accepted" ? TRACKED_DELETION_REGEX : TRACKED_INSERTION_REGEX,
+    ""
+  );
+}
+function escapeHtml(text) {
+  if (!text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+var PARAGRAPH_HTML_REGEX = /^\s*<p[\s>][\s\S]*<\/p>\s*$/i;
+function plainTextToTipTapHtml(text) {
+  if (!text) return "<p></p>";
+  if (PARAGRAPH_HTML_REGEX.test(text)) {
+    return text;
+  }
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => `<p>${escapeHtml(line)}</p>`).join("");
+}
+function plainTextToSlice(text, schema) {
+  const nodes = [];
+  text.replace(/\r\n?/g, "\n").split("\n").forEach((line) => {
+    const nodeJson = { type: "paragraph" };
+    if (line.length > 0) {
+      nodeJson.content = [{ type: "text", text: line }];
+    }
+    try {
+      nodes.push(ProsemirrorNode.fromJSON(schema, nodeJson));
+    } catch {
+    }
+  });
+  return Slice2.maxOpen(Fragment2.fromArray(nodes));
+}
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "P",
+  "DIV",
+  "LI",
+  "UL",
+  "OL",
+  "PRE",
+  "BLOCKQUOTE",
+  "TABLE",
+  "TR",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "HR"
+]);
+var MENTION_SPAN_REGEX = /<span\b(?=[^>]*\bdata-type=["']mention["'])([^>]*)>[\s\S]*?<\/span>/gi;
+function getHtmlAttribute(attrs, name) {
+  const match = new RegExp(`\\b${name}=(?:"([^"]*)"|'([^']*)')`, "i").exec(
+    attrs
+  );
+  return match ? match[1] ?? match[2] : void 0;
+}
+function parseHtmlFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0*39;/g, "'").replace(/&nbsp;/g, "\xA0").replace(/&amp;/g, "&");
+}
+function htmlToPlainText(html, options = {}) {
+  if (!html) return "";
+  const mentionNormalized = stripTrackedChanges(
+    html,
+    options.trackedChanges ?? "accepted"
+  ).replace(MENTION_SPAN_REGEX, (match, attrs) => {
+    const label = getHtmlAttribute(attrs, "data-label") || getHtmlAttribute(attrs, "data-id");
+    return label ? `@${label}` : match;
+  });
+  if (typeof document !== "undefined") {
+    const fragment = parseHtmlFragment(mentionNormalized);
+    fragment.querySelectorAll("br.ProseMirror-trailingBreak").forEach((br) => br.remove());
+    const lines = [];
+    let current = null;
+    const flush = () => {
+      if (current !== null) {
+        lines.push(current);
+        current = null;
+      }
+    };
+    const visit = (node) => {
+      if (node.nodeType === 3) {
+        const value = node.nodeValue ?? "";
+        if (current === null && value.trim() === "") return;
+        current = (current ?? "") + value;
+        return;
+      }
+      if (node.nodeType !== 1) return;
+      const tag = node.tagName.toUpperCase();
+      if (tag === "BR") {
+        current = (current ?? "") + "\n";
+        return;
+      }
+      if (!BLOCK_TAGS.has(tag)) {
+        node.childNodes.forEach(visit);
+        return;
+      }
+      flush();
+      const linesBefore = lines.length;
+      node.childNodes.forEach(visit);
+      flush();
+      if (lines.length === linesBefore && tag !== "HR") {
+        lines.push("");
+      }
+    };
+    fragment.childNodes.forEach(visit);
+    flush();
+    return lines.join("\n");
+  }
+  const text = mentionNormalized.replace(/<br\s*\/?>/gi, "\n").replace(
+    /<\/(?:p|div|li|pre|blockquote|h[1-6])>(?:\s*<\/(?:li|ul|ol|blockquote|div)>)*/gi,
+    "\n"
+  ).replace(/<[^>]+>/g, "");
+  return decodeHtmlEntities(text).replace(/\n$/, "");
+}
+function getEditorText(editor, options = {}) {
+  if (!editor) return "";
+  const html = typeof editor.getHTML === "function" ? editor.getHTML() : "";
+  if (html) {
+    return htmlToPlainText(html, options);
+  }
+  if (typeof editor.getText === "function") {
+    try {
+      return editor.getText({ blockSeparator: "\n" });
+    } catch {
+      return editor.getText();
+    }
+  }
+  return "";
+}
+function extractMentionsFromDoc(docOrEditor) {
+  if (!docOrEditor) return [];
+  const mentions = [];
+  const doc = docOrEditor?.state?.doc || (typeof docOrEditor?.descendants === "function" ? docOrEditor : null);
+  if (doc && typeof doc.descendants === "function") {
+    doc.descendants((node) => {
+      if (node.type?.name === "mention" && node.attrs) {
+        mentions.push({
+          id: node.attrs.id || "",
+          label: node.attrs.label || "",
+          type: node.attrs.type,
+          avatarUrl: node.attrs.avatarUrl,
+          color: node.attrs.color,
+          ...node.attrs
+        });
+      }
+    });
+    return mentions;
+  }
+  if (typeof docOrEditor === "object" && docOrEditor.content) {
+    const walk = (nodes) => {
+      for (const node of nodes) {
+        if (node.type === "mention" && node.attrs) {
+          mentions.push({
+            id: node.attrs.id || "",
+            label: node.attrs.label || "",
+            type: node.attrs.type,
+            avatarUrl: node.attrs.avatarUrl,
+            color: node.attrs.color,
+            ...node.attrs
+          });
+        }
+        if (Array.isArray(node.content)) {
+          walk(node.content);
+        }
+      }
+    };
+    walk(docOrEditor.content);
+    return mentions;
+  }
+  if (typeof docOrEditor === "string") {
+    if (typeof document !== "undefined") {
+      parseHtmlFragment(docOrEditor).querySelectorAll('span[data-type="mention"]').forEach((el) => {
+        mentions.push({
+          id: el.getAttribute("data-id") || "",
+          label: el.getAttribute("data-label") || "",
+          type: el.getAttribute("data-type-name") || void 0,
+          avatarUrl: el.getAttribute("data-avatar-url") || void 0,
+          color: el.getAttribute("data-color") || void 0
+        });
+      });
+    } else {
+      const spanRegex = /<span([^>]*data-type=["']mention["'][^>]*)>/gi;
+      let match;
+      while ((match = spanRegex.exec(docOrEditor)) !== null) {
+        const attrStr = match[1];
+        const getAttr = (name) => {
+          const m = new RegExp(`${name}=["']([^"']*)["']`, "i").exec(attrStr);
+          return m ? m[1] : void 0;
+        };
+        mentions.push({
+          id: getAttr("data-id") || "",
+          label: getAttr("data-label") || "",
+          type: getAttr("data-type-name") || getAttr("data-entity-type"),
+          avatarUrl: getAttr("data-avatar-url"),
+          color: getAttr("data-color")
+        });
+      }
+    }
+    if (mentions.length === 0) {
+      const rawHandles = extractMentions(docOrEditor);
+      for (const handle of rawHandles) {
+        mentions.push({
+          id: handle,
+          label: handle,
+          type: "user"
+        });
+      }
+    }
+  }
+  return mentions;
+}
+
+// src/serializers/mentions.ts
+var MENTION_REGEX = /(?:^|[\s>(*_"';\\/[\]{}~`:]|&quot;|&gt;|&lt;|&amp;)@(?:"([^"]+)"|&quot;([^&]+)&quot;|([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*))/g;
+var MARKDOWN_MENTION_SPLIT_REGEX = /(```[\s\S]*?```|~~~[\s\S]*?~~~|<pre[\s\S]*?<\/pre>|<code[\s\S]*?<\/code>|`[^`\n]+`|<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["']|data-mention=["'][^"']*["'])[^>]*>[\s\S]*?<\/span>|<[^>]+>|\]\([^)]+\)|(?:https?|file|vscode|cursor|mailto):\/\/[^\s<)]+)/gi;
+function stripMarkdownCode(content) {
+  if (!content || typeof content !== "string") return "";
+  return content.replace(/```[\s\S]*?```/g, "").replace(/~~~[\s\S]*?~~~/g, "").replace(/<pre[\s\S]*?<\/pre>/gi, "").replace(/<code[\s\S]*?<\/code>/gi, "").replace(/`[^`\n]*`/g, "");
+}
+function extractMentions(content) {
+  if (!content || typeof content !== "string") return [];
+  const normalizedMentionNodes = content.replace(
+    /<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["'])[^>]*>([\s\S]*?)<\/span>/gi,
+    (match2, inner) => {
+      const labelMatch = match2.match(/\bdata-label=["']([^"']+)["']/i);
+      if (labelMatch) return ` @${labelMatch[1]} `;
+      const idMatch = match2.match(/\bdata-id=["']([^"']+)["']/i);
+      if (idMatch) return ` @${idMatch[1]} `;
+      return ` ${inner} `;
+    }
+  );
+  const cleanContent = stripMarkdownCode(normalizedMentionNodes);
+  const withoutUrls = cleanContent.replace(/(?:https?|ftp|file|vscode|cursor|mailto):\/\/[^\s<>()]+/gi, "").replace(/\]\([^)]*\)/g, "]");
+  const textOnly = withoutUrls.replace(/<[^>]+>/g, " ");
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  let match;
+  while ((match = regex.exec(textOnly)) !== null) {
+    const handle = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    if (handle && !seen.has(handle)) {
+      seen.add(handle);
+      mentions.push(handle);
+    }
+  }
+  return mentions;
+}
+function parseMentionSegments(content) {
+  if (!content) return [];
+  const segments = [];
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const fullMatch = match[0];
+    const atIndex = fullMatch.indexOf("@");
+    const prefix = atIndex > 0 ? fullMatch.slice(0, atIndex) : "";
+    const mentionToken = fullMatch.slice(atIndex);
+    const handle = match[1] ?? match[2] ?? match[3];
+    const matchStart = match.index + prefix.length;
+    if (matchStart > lastIndex) {
+      segments.push({
+        type: "text",
+        value: content.slice(lastIndex, matchStart)
+      });
+    }
+    segments.push({
+      type: "mention",
+      value: mentionToken,
+      handle
+    });
+    lastIndex = matchStart + mentionToken.length;
+  }
+  if (lastIndex < content.length) {
+    segments.push({
+      type: "text",
+      value: content.slice(lastIndex)
+    });
+  }
+  return segments;
+}
+function preprocessMarkdownMentions(content, optionsOrMentionables = []) {
+  if (!content || typeof content !== "string") return "";
+  const options = Array.isArray(optionsOrMentionables) ? { mentionables: optionsOrMentionables } : optionsOrMentionables;
+  const allMentionables = options.mentionables || [];
+  const defaultType = options.defaultType || "user";
+  const resolveMention = options.resolveMention;
+  const parts = content.split(MARKDOWN_MENTION_SPLIT_REGEX);
+  return parts.map((part) => {
+    if (!part) return "";
+    if (part.startsWith("```") || part.startsWith("~~~") || part.startsWith("`") || part.startsWith("](") || /^(?:https?|file|vscode|cursor|mailto):\/\//i.test(part) || /^<pre[\s>]/i.test(part) || /^<code[\s>]/i.test(part) || /^<[^>]+>$/i.test(part) || /^<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["']|data-mention=["'][^"']*["'])/i.test(
+      part
+    )) {
+      return part;
+    }
+    const regex = new RegExp(MENTION_REGEX.source, "g");
+    return part.replace(regex, (match, quotedHandle, escapedQuotedHandle, standardHandle) => {
+      const atIndex = match.indexOf("@");
+      const prefix = atIndex > 0 ? match.slice(0, atIndex) : "";
+      const rawHandle = (quotedHandle || escapedQuotedHandle || standardHandle || "").trim();
+      if (!rawHandle) return match;
+      const lowerHandle = rawHandle.toLowerCase();
+      const entity = allMentionables.find((e) => {
+        if (e.label?.toLowerCase() === lowerHandle) return true;
+        if (e.handle?.toLowerCase() === lowerHandle) return true;
+        if (e.name?.toLowerCase() === lowerHandle) return true;
+        if (e.id?.toLowerCase() === lowerHandle) return true;
+        if (e.type === "agent" && `agent${(e.handle || e.label || "").toLowerCase()}` === lowerHandle) return true;
+        if (e.aliases?.some(
+          (a) => a.toLowerCase() === lowerHandle || e.type === "agent" && `agent${a.toLowerCase()}` === lowerHandle
+        )) {
+          return true;
+        }
+        return false;
+      });
+      let id = entity?.id;
+      let label = entity?.label || entity?.handle || rawHandle;
+      let type = entity?.type;
+      let avatarUrl = entity?.avatarUrl;
+      let color = entity?.color || entity?.hexColor;
+      if (!entity) {
+        const customResolved = resolveMention?.(rawHandle);
+        if (customResolved) {
+          id = customResolved.id ?? id;
+          label = customResolved.label ?? customResolved.handle ?? label;
+          type = customResolved.type ?? type;
+          avatarUrl = customResolved.avatarUrl ?? avatarUrl;
+          color = customResolved.color ?? customResolved.hexColor ?? color;
+        } else {
+          const stripped = lowerHandle.replace(/^agent[\s\-_]*/i, "");
+          if (["supervisor", "coordinator", "planner", "validator", "executor"].includes(stripped)) {
+            type = "agent";
+            id = stripped;
+            label = stripped;
+          } else if (lowerHandle === "agents") {
+            type = "team";
+            id = "agents";
+            label = "agents";
+          } else {
+            type = defaultType;
+            id = rawHandle;
+            label = rawHandle;
+          }
+        }
+      }
+      const avatarAttr = avatarUrl ? ` data-avatar-url="${escapeHtml(avatarUrl)}"` : "";
+      const colorAttr = color ? ` data-color="${escapeHtml(color)}"` : "";
+      return `${prefix}<span class="pixerate-mention-node" data-type="mention" data-id="${escapeHtml(
+        id || label
+      )}" data-label="${escapeHtml(label)}" data-mention-suggestion-char="@" data-type-name="${escapeHtml(
+        type || defaultType
+      )}"${avatarAttr}${colorAttr}>@${escapeHtml(label)}</span>`;
+    });
+  }).join("");
+}
+
+// src/serializers/markdown.ts
+import MarkdownIt from "markdown-it";
+import taskLists from "markdown-it-task-lists";
+var md = new MarkdownIt({
+  html: true,
+  linkify: true,
+  breaks: true
+}).use(taskLists);
+var defaultValidateLink = md.validateLink;
+md.validateLink = (url) => {
+  if (url.startsWith("file://") || url.startsWith("vscode://") || url.startsWith("cursor://")) {
+    return true;
+  }
+  return defaultValidateLink.call(md, url);
+};
+var ALLOWED_HTML_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "blockquote",
+  "br",
+  "code",
+  "del",
+  "details",
+  "div",
+  "em",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "img",
+  "input",
+  "kbd",
+  "li",
+  "mark",
+  "ol",
+  "p",
+  "pre",
+  "s",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "u",
+  "ul"
+]);
+var ALLOWED_HTML_ATTRS = /* @__PURE__ */ new Set([
+  "alt",
+  "align",
+  "checked",
+  "class",
+  "colspan",
+  "disabled",
+  "height",
+  "href",
+  "rel",
+  "rowspan",
+  "src",
+  "start",
+  "target",
+  "title",
+  "type",
+  "width"
+]);
+var HTML_TAG_REGEX = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*\/?>/g;
+var HTML_ATTR_REGEX = /([^\s"'>\/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+function sanitizeTag(tagText, isClosing, rawTagName, rawAttrs, stripDisallowed) {
+  const tagName = rawTagName.toLowerCase();
+  const reject = () => stripDisallowed ? "" : escapeHtml(tagText);
+  if (!ALLOWED_HTML_TAGS.has(tagName)) return reject();
+  if (isClosing) return `</${tagName}>`;
+  if (tagName === "input" && !/\stype\s*=\s*["']?checkbox["']?[\s>/]/i.test(tagText)) {
+    return reject();
+  }
+  let attrs = "";
+  let attrMatch;
+  HTML_ATTR_REGEX.lastIndex = 0;
+  while ((attrMatch = HTML_ATTR_REGEX.exec(rawAttrs)) !== null) {
+    const name = attrMatch[1].toLowerCase();
+    if (!ALLOWED_HTML_ATTRS.has(name) && !/^data-[a-z0-9_.-]+$/.test(name)) {
+      continue;
+    }
+    const rawValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    if (rawValue === void 0) {
+      attrs += ` ${name}`;
+      continue;
+    }
+    const value = md.utils.unescapeAll(rawValue);
+    if ((name === "href" || name === "src") && // Browsers ignore control characters and whitespace inside schemes.
+    !md.validateLink(value.replace(/[\u0000-\u0020\u007f]/g, ""))) {
+      continue;
+    }
+    attrs += ` ${name}="${escapeHtml(value)}"`;
+  }
+  return `<${tagName}${attrs}>`;
+}
+function sanitizeHtml(html, options = {}) {
+  return sanitizeEmbeddedHtml(html, options.disallowedTags === "strip");
+}
+function sanitizeEmbeddedHtml(html, stripDisallowed = false) {
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  HTML_TAG_REGEX.lastIndex = 0;
+  while ((match = HTML_TAG_REGEX.exec(html)) !== null) {
+    result += html.slice(lastIndex, match.index).replace(/</g, "&lt;");
+    result += sanitizeTag(match[0], match[1], match[2], match[3], stripDisallowed);
+    lastIndex = match.index + match[0].length;
+  }
+  return result + html.slice(lastIndex).replace(/</g, "&lt;");
+}
+var defaultHtmlInline = md.renderer.rules.html_inline;
+var defaultHtmlBlock = md.renderer.rules.html_block;
+md.renderer.rules.html_inline = (tokens, idx, options, env, self) => env?.allowUnsafeHtml ? defaultHtmlInline(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+md.renderer.rules.html_block = (tokens, idx, options, env, self) => env?.allowUnsafeHtml ? defaultHtmlBlock(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+function preprocessMarkdownFileLinks(content) {
+  if (!content) return "";
+  return content.replace(
+    /\[([^\]]+)\]\(((?:file|vscode|cursor):\/\/[^)]+)\)/g,
+    (_match, rawLabel, href) => {
+      const trimmed = rawLabel.trim();
+      const codeMatch = trimmed.match(/^`([^`]+)`$/);
+      const labelContent = codeMatch ? `<code>${escapeHtml(codeMatch[1])}</code>` : escapeHtml(trimmed);
+      return `<a href="${escapeHtml(href)}" data-file-link="true" title="Click to copy file path">${labelContent}</a>`;
+    }
+  );
+}
+function markdownToTipTapHtml(markdown, options) {
+  if (!markdown) return "<p></p>";
+  let content = markdown;
+  if (options?.preprocessFileLinks) {
+    content = preprocessMarkdownFileLinks(content);
+  }
+  if (options?.preprocessMentions || options?.mentionables || options?.preprocessOptions) {
+    const mentionOpts = options.preprocessOptions || {
+      mentionables: options.mentionables
+    };
+    content = preprocessMarkdownMentions(content, mentionOpts);
+  }
+  return md.render(content, { allowUnsafeHtml: options?.allowUnsafeHtml });
+}
+function getEditorMarkdown(editor, options = {}) {
+  if (!editor) return "";
+  const markdown = editor.storage?.markdown;
+  if (typeof markdown?.getMarkdown === "function") {
+    const doc = editor.state?.doc;
+    if (doc && typeof markdown.serializer?.serialize === "function") {
+      const resolved = resolveTrackedChanges(doc, options.trackedChanges ?? "accepted");
+      if (resolved !== doc) return markdown.serializer.serialize(resolved);
+    }
+    return markdown.getMarkdown();
+  }
+  return getEditorText(editor, options);
+}
+
+export {
+  createReviewId,
+  CommentStore,
+  createCommentStore,
+  formatReviewTime,
+  INSERTION_MARK_NAME,
+  DELETION_MARK_NAME,
+  TRACK_CHANGES_SKIP_META,
+  TrackChangesStore,
+  trackChangesPluginKey,
+  TrackedInsertion,
+  TrackedDeletion,
+  getTrackedChanges,
+  getTrackedChangeAt,
+  isTrackChangesEnabled,
+  getTrackChangesStore,
+  resolveTrackedChanges,
+  TrackChanges,
+  MENTION_REGEX,
+  MARKDOWN_MENTION_SPLIT_REGEX,
+  stripMarkdownCode,
+  extractMentions,
+  parseMentionSegments,
+  preprocessMarkdownMentions,
+  escapeHtml,
+  plainTextToTipTapHtml,
+  plainTextToSlice,
+  htmlToPlainText,
+  getEditorText,
+  extractMentionsFromDoc,
+  sanitizeHtml,
+  preprocessMarkdownFileLinks,
+  markdownToTipTapHtml,
+  getEditorMarkdown
+};
+//# sourceMappingURL=chunk-3TYMNULT.js.map