@blocknote/core 0.42.3 → 0.44.0

package/dist/comments.js

@@ -1,13 +1,325 @@
-var p = Object.defineProperty;
-var A = (d, r, e) => r in d ? p(d, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : d[r] = e;
-var n = (d, r, e) => A(d, typeof r != "symbol" ? r + "" : r, e);
-import * as u from "yjs";
-import { v4 as I } from "uuid";
-class v {
+var x = Object.defineProperty;
+var Y = (r, d, e) => d in r ? x(r, d, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[d] = e;
+var c = (r, d, e) => Y(r, typeof d != "symbol" ? d + "" : d, e);
+import { PluginKey as $, Plugin as k } from "prosemirror-state";
+import { DecorationSet as C, Decoration as z } from "prosemirror-view";
+import { ySyncPluginKey as B, getRelativeSelection as q } from "y-prosemirror";
+import { c as L, a as N } from "./BlockNoteExtension-C2X7LW-V.js";
+import { S } from "./ShowSelection-Dz-NEase.js";
+import { Mark as O, mergeAttributes as _ } from "@tiptap/core";
+import { E as H } from "./EventEmitter-CjSwpTbz.js";
+import * as g from "yjs";
+import { v4 as D } from "uuid";
+const M = O.create({
+  name: "comment",
+  excludes: "",
+  inclusive: !1,
+  keepOnSplit: !0,
+  addAttributes() {
+    return {
+      // orphans are marks that currently don't have an active thread. It could be
+      // that users have resolved the thread. Resolved threads by default are not shown in the document,
+      // but we need to keep the mark (positioning) data so we can still "revive" it when the thread is unresolved
+      // or we enter a "comments" view that includes resolved threads.
+      orphan: {
+        parseHTML: (r) => !!r.getAttribute("data-orphan"),
+        renderHTML: (r) => r.orphan ? {
+          "data-orphan": "true"
+        } : {},
+        default: !1
+      },
+      threadId: {
+        parseHTML: (r) => r.getAttribute("data-bn-thread-id"),
+        renderHTML: (r) => ({
+          "data-bn-thread-id": r.threadId
+        }),
+        default: ""
+      }
+    };
+  },
+  renderHTML({ HTMLAttributes: r }) {
+    return [
+      "span",
+      _(r, {
+        class: "bn-thread-mark"
+      })
+    ];
+  },
+  parseHTML() {
+    return [{ tag: "span.bn-thread-mark" }];
+  },
+  extendMarkSchema(r) {
+    return r.name === "comment" ? {
+      blocknoteIgnore: !0
+    } : {};
+  }
+});
+class F extends H {
+  constructor(e) {
+    super();
+    c(this, "userCache", /* @__PURE__ */ new Map());
+    // avoid duplicate loads
+    c(this, "loadingUsers", /* @__PURE__ */ new Set());
+    this.resolveUsers = e;
+  }
+  /**
+   * Load information about users based on an array of user ids.
+   */
+  async loadUsers(e) {
+    const t = e.filter(
+      (a) => !this.userCache.has(a) && !this.loadingUsers.has(a)
+    );
+    if (t.length !== 0) {
+      for (const a of t)
+        this.loadingUsers.add(a);
+      try {
+        const a = await this.resolveUsers(t);
+        for (const s of a)
+          this.userCache.set(s.id, s);
+        this.emit("update", this.userCache);
+      } finally {
+        for (const a of t)
+          this.loadingUsers.delete(a);
+      }
+    }
+  }
+  /**
+   * Retrieve information about a user based on their id, if cached.
+   *
+   * The user will have to be loaded via `loadUsers` first
+   */
+  getUser(e) {
+    return this.userCache.get(e);
+  }
+  /**
+   * Subscribe to changes in the user store.
+   *
+   * @param cb - The callback to call when the user store changes.
+   * @returns A function to unsubscribe from the user store.
+   */
+  subscribe(e) {
+    return this.on("update", e);
+  }
+}
+const w = new $("blocknote-comments");
+function K(r, d) {
+  const e = /* @__PURE__ */ new Map();
+  return r.descendants((t, a) => {
+    t.marks.forEach((s) => {
+      if (s.type.name === d) {
+        const o = s.attrs.threadId;
+        if (!o)
+          return;
+        const m = a, n = m + t.nodeSize, i = e.get(o) ?? {
+          from: 1 / 0,
+          to: 0
+        };
+        e.set(o, {
+          from: Math.min(m, i.from),
+          to: Math.max(n, i.to)
+        });
+      }
+    });
+  }), e;
+}
+const ne = L(
+  ({
+    editor: r,
+    options: { schema: d, threadStore: e, resolveUsers: t }
+  }) => {
+    if (!t)
+      throw new Error(
+        "resolveUsers is required to be defined when using comments"
+      );
+    if (!e)
+      throw new Error(
+        "threadStore is required to be defined when using comments"
+      );
+    const a = M.name, s = new F(t), o = N(
+      {
+        pendingComment: !1,
+        selectedThreadId: void 0,
+        threadPositions: /* @__PURE__ */ new Map()
+      },
+      {
+        onUpdate() {
+          o.state.selectedThreadId !== o.prevState.selectedThreadId && r.transact((n) => n.setMeta(w, !0));
+        }
+      }
+    ), m = (n) => {
+      r.transact((i) => {
+        i.doc.descendants((u, l) => {
+          u.marks.forEach((h) => {
+            if (h.type.name === a) {
+              const T = h.type, f = h.attrs.threadId, A = n.get(f), v = !!(!A || A.resolved || A.deletedAt);
+              if (v !== h.attrs.orphan) {
+                const E = Math.max(l, 0), b = Math.min(
+                  l + u.nodeSize,
+                  i.doc.content.size - 1,
+                  i.doc.content.size - 1
+                );
+                i.removeMark(E, b, h), i.addMark(
+                  E,
+                  b,
+                  T.create({
+                    ...h.attrs,
+                    orphan: v
+                  })
+                ), v && o.state.selectedThreadId === f && o.setState((P) => ({
+                  ...P,
+                  selectedThreadId: void 0
+                }));
+              }
+            }
+          });
+        });
+      });
+    };
+    return {
+      key: "comments",
+      store: o,
+      prosemirrorPlugins: [
+        new k({
+          key: w,
+          state: {
+            init() {
+              return {
+                decorations: C.empty
+              };
+            },
+            apply(n, i) {
+              const u = n.getMeta(w);
+              if (!n.docChanged && !u)
+                return i;
+              const l = n.docChanged ? K(n.doc, a) : o.state.threadPositions;
+              (l.size > 0 || o.state.threadPositions.size > 0) && o.setState((T) => ({
+                ...T,
+                threadPositions: l
+              }));
+              const h = [];
+              if (o.state.selectedThreadId) {
+                const T = l.get(
+                  o.state.selectedThreadId
+                );
+                T && h.push(
+                  z.inline(
+                    T.from,
+                    T.to,
+                    {
+                      class: "bn-thread-mark-selected"
+                    }
+                  )
+                );
+              }
+              return {
+                decorations: C.create(n.doc, h)
+              };
+            }
+          },
+          props: {
+            decorations(n) {
+              var i;
+              return ((i = w.getState(n)) == null ? void 0 : i.decorations) ?? C.empty;
+            },
+            handleClick: (n, i, u) => {
+              if (u.button !== 0)
+                return;
+              const l = n.state.doc.nodeAt(i);
+              if (!l) {
+                o.setState((f) => ({
+                  ...f,
+                  selectedThreadId: void 0
+                }));
+                return;
+              }
+              const h = l.marks.find(
+                (f) => f.type.name === a && f.attrs.orphan !== !0
+              ), T = h == null ? void 0 : h.attrs.threadId;
+              T !== o.state.selectedThreadId && o.setState((f) => ({
+                ...f,
+                selectedThreadId: T
+              }));
+            }
+          }
+        })
+      ],
+      threadStore: e,
+      mount() {
+        const n = e.subscribe(m);
+        m(e.getThreads());
+        const i = r.onSelectionChange(() => {
+          o.state.pendingComment && o.setState((u) => ({
+            ...u,
+            pendingComment: !1
+          }));
+        });
+        return () => {
+          n(), i();
+        };
+      },
+      selectThread(n, i = !0) {
+        var u, l;
+        if (o.state.selectedThreadId !== n && (o.setState((h) => ({
+          ...h,
+          pendingComment: !1,
+          selectedThreadId: n
+        })), n && i)) {
+          const h = o.state.threadPositions.get(n);
+          if (!h)
+            return;
+          (l = (u = r.prosemirrorView) == null ? void 0 : u.domAtPos(h.from).node) == null || l.scrollIntoView({
+            behavior: "smooth",
+            block: "center"
+          });
+        }
+      },
+      startPendingComment() {
+        var n;
+        o.setState((i) => ({
+          ...i,
+          selectedThreadId: void 0,
+          pendingComment: !0
+        })), (n = r.getExtension(S)) == null || n.showSelection(!0);
+      },
+      stopPendingComment() {
+        var n;
+        o.setState((i) => ({
+          ...i,
+          selectedThreadId: void 0,
+          pendingComment: !1
+        })), (n = r.getExtension(S)) == null || n.showSelection(!1);
+      },
+      async createThread(n) {
+        const i = await e.createThread(n);
+        if (e.addThreadToDocument) {
+          const u = r.prosemirrorView, l = u.state.selection, h = B.getState(u.state), T = {
+            prosemirror: {
+              head: l.head,
+              anchor: l.anchor
+            },
+            yjs: h ? q(h.binding, u.state) : void 0
+          };
+          await e.addThreadToDocument({
+            threadId: i.id,
+            selection: T
+          });
+        } else
+          r._tiptapEditor.commands.setMark(a, {
+            orphan: !1,
+            threadId: i.id
+          });
+      },
+      userStore: s,
+      commentEditorSchema: d,
+      tiptapExtensions: [M]
+    };
+  }
+);
+class V {
 }
-class b extends v {
-  constructor(r, e) {
-    super(), this.userId = r, this.role = e;
+class oe extends V {
+  constructor(d, e) {
+    super(), this.userId = d, this.role = e;
   }
   /**
    * Auth: should be possible by anyone with comment access
@@ -18,37 +330,37 @@ class b extends v {
   /**
    * Auth: should be possible by anyone with comment access
    */
-  canAddComment(r) {
+  canAddComment(d) {
     return !0;
   }
   /**
    * Auth: should only be possible by the comment author
    */
-  canUpdateComment(r) {
-    return r.userId === this.userId;
+  canUpdateComment(d) {
+    return d.userId === this.userId;
   }
   /**
    * Auth: should be possible by the comment author OR an editor of the document
    */
-  canDeleteComment(r) {
-    return r.userId === this.userId || this.role === "editor";
+  canDeleteComment(d) {
+    return d.userId === this.userId || this.role === "editor";
   }
   /**
    * Auth: should only be possible by an editor of the document
    */
-  canDeleteThread(r) {
+  canDeleteThread(d) {
     return this.role === "editor";
   }
   /**
    * Auth: should be possible by anyone with comment access
    */
-  canResolveThread(r) {
+  canResolveThread(d) {
     return !0;
   }
   /**
    * Auth: should be possible by anyone with comment access
    */
-  canUnresolveThread(r) {
+  canUnresolveThread(d) {
     return !0;
   }
   /**
@@ -56,8 +368,8 @@ class b extends v {
    *
    * Note: will also check if the user has already reacted with the same emoji. TBD: is that a nice design or should this responsibility be outside of auth?
    */
-  canAddReaction(r, e) {
-    return e ? !r.reactions.some(
+  canAddReaction(d, e) {
+    return e ? !d.reactions.some(
       (t) => t.emoji === e && t.userIds.includes(this.userId)
     ) : !0;
   }
@@ -66,23 +378,23 @@ class b extends v {
    *
    * Note: will also check if the user has already reacted with the same emoji. TBD: is that a nice design or should this responsibility be outside of auth?
    */
-  canDeleteReaction(r, e) {
-    return e ? r.reactions.some(
+  canDeleteReaction(d, e) {
+    return e ? d.reactions.some(
       (t) => t.emoji === e && t.userIds.includes(this.userId)
     ) : !0;
   }
 }
-class w {
-  constructor(r) {
-    n(this, "auth");
-    this.auth = r;
+class R {
+  constructor(d) {
+    c(this, "auth");
+    this.auth = d;
   }
 }
-class j extends w {
+class ie extends R {
   constructor(e, t, a) {
     super(a);
     // TipTapThreadStore does not support addThreadToDocument
-    n(this, "addThreadToDocument");
+    c(this, "addThreadToDocument");
     this.userId = e, this.provider = t;
   }
   /**
@@ -137,16 +449,16 @@ class j extends w {
   tiptapCommentToCommentData(e) {
     var a, s, o;
     const t = [];
-    for (const h of ((a = e.data) == null ? void 0 : a.reactions) || []) {
-      const m = t.find(
-        (i) => i.emoji === h.emoji
+    for (const m of ((a = e.data) == null ? void 0 : a.reactions) || []) {
+      const n = t.find(
+        (i) => i.emoji === m.emoji
       );
-      m ? (m.userIds.push(h.userId), m.createdAt = new Date(
-        Math.min(m.createdAt.getTime(), h.createdAt)
+      n ? (n.userIds.push(m.userId), n.createdAt = new Date(
+        Math.min(n.createdAt.getTime(), m.createdAt)
       )) : t.push({
-        emoji: h.emoji,
-        createdAt: new Date(h.createdAt),
-        userIds: [h.userId]
+        emoji: m.emoji,
+        createdAt: new Date(m.createdAt),
+        userIds: [m.userId]
       });
     }
     return {
@@ -273,29 +585,29 @@ class j extends w {
     };
   }
 }
-function g(d) {
-  const r = new u.Map();
-  if (r.set("id", d.id), r.set("userId", d.userId), r.set("createdAt", d.createdAt.getTime()), r.set("updatedAt", d.updatedAt.getTime()), d.deletedAt ? (r.set("deletedAt", d.deletedAt.getTime()), r.set("body", void 0)) : r.set("body", d.body), d.reactions.length > 0)
+function U(r) {
+  const d = new g.Map();
+  if (d.set("id", r.id), d.set("userId", r.userId), d.set("createdAt", r.createdAt.getTime()), d.set("updatedAt", r.updatedAt.getTime()), r.deletedAt ? (d.set("deletedAt", r.deletedAt.getTime()), d.set("body", void 0)) : d.set("body", r.body), r.reactions.length > 0)
     throw new Error("Reactions should be empty in commentToYMap");
-  return r.set("reactionsByUser", new u.Map()), r.set("metadata", d.metadata), r;
+  return d.set("reactionsByUser", new g.Map()), d.set("metadata", r.metadata), d;
 }
-function y(d) {
+function G(r) {
   var t;
-  const r = new u.Map();
-  r.set("id", d.id), r.set("createdAt", d.createdAt.getTime()), r.set("updatedAt", d.updatedAt.getTime());
-  const e = new u.Array();
-  return e.push(d.comments.map((a) => g(a))), r.set("comments", e), r.set("resolved", d.resolved), r.set("resolvedUpdatedAt", (t = d.resolvedUpdatedAt) == null ? void 0 : t.getTime()), r.set("resolvedBy", d.resolvedBy), r.set("metadata", d.metadata), r;
+  const d = new g.Map();
+  d.set("id", r.id), d.set("createdAt", r.createdAt.getTime()), d.set("updatedAt", r.updatedAt.getTime());
+  const e = new g.Array();
+  return e.push(r.comments.map((a) => U(a))), d.set("comments", e), d.set("resolved", r.resolved), d.set("resolvedUpdatedAt", (t = r.resolvedUpdatedAt) == null ? void 0 : t.getTime()), d.set("resolvedBy", r.resolvedBy), d.set("metadata", r.metadata), d;
 }
-function C(d) {
+function J(r) {
   return {
-    emoji: d.get("emoji"),
-    createdAt: new Date(d.get("createdAt")),
-    userId: d.get("userId")
+    emoji: r.get("emoji"),
+    createdAt: new Date(r.get("createdAt")),
+    userId: r.get("userId")
   };
 }
-function D(d) {
-  return [...d.values()].map(
-    (e) => C(e)
+function Q(r) {
+  return [...r.values()].map(
+    (e) => J(e)
   ).reduce(
     (e, t) => {
       const a = e.find((s) => s.emoji === t.emoji);
@@ -313,64 +625,64 @@ function D(d) {
     []
   );
 }
-function T(d) {
+function I(r) {
   return {
     type: "comment",
-    id: d.get("id"),
-    userId: d.get("userId"),
-    createdAt: new Date(d.get("createdAt")),
-    updatedAt: new Date(d.get("updatedAt")),
-    deletedAt: d.get("deletedAt") ? new Date(d.get("deletedAt")) : void 0,
-    reactions: D(d.get("reactionsByUser")),
-    metadata: d.get("metadata"),
-    body: d.get("body")
+    id: r.get("id"),
+    userId: r.get("userId"),
+    createdAt: new Date(r.get("createdAt")),
+    updatedAt: new Date(r.get("updatedAt")),
+    deletedAt: r.get("deletedAt") ? new Date(r.get("deletedAt")) : void 0,
+    reactions: Q(r.get("reactionsByUser")),
+    metadata: r.get("metadata"),
+    body: r.get("body")
   };
 }
-function c(d) {
+function p(r) {
   return {
     type: "thread",
-    id: d.get("id"),
-    createdAt: new Date(d.get("createdAt")),
-    updatedAt: new Date(d.get("updatedAt")),
-    comments: (d.get("comments") || []).map(
-      (r) => T(r)
+    id: r.get("id"),
+    createdAt: new Date(r.get("createdAt")),
+    updatedAt: new Date(r.get("updatedAt")),
+    comments: (r.get("comments") || []).map(
+      (d) => I(d)
     ),
-    resolved: d.get("resolved"),
-    resolvedUpdatedAt: new Date(d.get("resolvedUpdatedAt")),
-    resolvedBy: d.get("resolvedBy"),
-    metadata: d.get("metadata")
+    resolved: r.get("resolved"),
+    resolvedUpdatedAt: new Date(r.get("resolvedUpdatedAt")),
+    resolvedBy: r.get("resolvedBy"),
+    metadata: r.get("metadata")
   };
 }
-class f extends w {
-  constructor(r, e) {
-    super(e), this.threadsYMap = r;
+class j extends R {
+  constructor(d, e) {
+    super(e), this.threadsYMap = d;
   }
   // TODO: async / reactive interface?
-  getThread(r) {
-    const e = this.threadsYMap.get(r);
+  getThread(d) {
+    const e = this.threadsYMap.get(d);
     if (!e)
       throw new Error("Thread not found");
-    return c(e);
+    return p(e);
   }
   getThreads() {
-    const r = /* @__PURE__ */ new Map();
+    const d = /* @__PURE__ */ new Map();
     return this.threadsYMap.forEach((e, t) => {
-      e instanceof u.Map && r.set(t, c(e));
-    }), r;
+      e instanceof g.Map && d.set(t, p(e));
+    }), d;
   }
-  subscribe(r) {
+  subscribe(d) {
     const e = () => {
-      r(this.getThreads());
+      d(this.getThreads());
     };
     return this.threadsYMap.observeDeep(e), () => {
       this.threadsYMap.unobserveDeep(e);
     };
   }
 }
-class Y extends f {
+class ce extends j {
   constructor(e, t, a, s) {
     super(a, s);
-    n(this, "doRequest", async (e, t, a) => {
+    c(this, "doRequest", async (e, t, a) => {
       const s = await fetch(`${this.BASE_URL}${e}`, {
         method: t,
         body: JSON.stringify(a),
@@ -383,30 +695,30 @@ class Y extends f {
         throw new Error(`Failed to ${t} ${e}: ${s.statusText}`);
       return s.json();
     });
-    n(this, "addThreadToDocument", async (e) => {
+    c(this, "addThreadToDocument", async (e) => {
       const { threadId: t, ...a } = e;
       return this.doRequest(`/${t}/addToDocument`, "POST", a);
     });
-    n(this, "createThread", async (e) => this.doRequest("", "POST", e));
-    n(this, "addComment", (e) => {
+    c(this, "createThread", async (e) => this.doRequest("", "POST", e));
+    c(this, "addComment", (e) => {
       const { threadId: t, ...a } = e;
       return this.doRequest(`/${t}/comments`, "POST", a);
     });
-    n(this, "updateComment", (e) => {
+    c(this, "updateComment", (e) => {
       const { threadId: t, commentId: a, ...s } = e;
       return this.doRequest(`/${t}/comments/${a}`, "PUT", s);
     });
-    n(this, "deleteComment", (e) => {
+    c(this, "deleteComment", (e) => {
       const { threadId: t, commentId: a, ...s } = e;
       return this.doRequest(
         `/${t}/comments/${a}?soft=${!!s.softDelete}`,
         "DELETE"
       );
     });
-    n(this, "deleteThread", (e) => this.doRequest(`/${e.threadId}`, "DELETE"));
-    n(this, "resolveThread", (e) => this.doRequest(`/${e.threadId}/resolve`, "POST"));
-    n(this, "unresolveThread", (e) => this.doRequest(`/${e.threadId}/unresolve`, "POST"));
-    n(this, "addReaction", (e) => {
+    c(this, "deleteThread", (e) => this.doRequest(`/${e.threadId}`, "DELETE"));
+    c(this, "resolveThread", (e) => this.doRequest(`/${e.threadId}/resolve`, "POST"));
+    c(this, "unresolveThread", (e) => this.doRequest(`/${e.threadId}/unresolve`, "POST"));
+    c(this, "addReaction", (e) => {
       const { threadId: t, commentId: a, ...s } = e;
       return this.doRequest(
         `/${t}/comments/${a}/reactions`,
@@ -414,24 +726,24 @@ class Y extends f {
         s
       );
     });
-    n(this, "deleteReaction", (e) => this.doRequest(
+    c(this, "deleteReaction", (e) => this.doRequest(
       `/${e.threadId}/comments/${e.commentId}/reactions/${e.emoji}`,
       "DELETE"
     ));
     this.BASE_URL = e, this.headers = t;
   }
 }
-class $ extends f {
+class he extends j {
   constructor(e, t, a) {
     super(t, a);
-    n(this, "transact", (e) => async (t) => this.threadsYMap.doc.transact(() => e(t)));
-    n(this, "createThread", this.transact(
+    c(this, "transact", (e) => async (t) => this.threadsYMap.doc.transact(() => e(t)));
+    c(this, "createThread", this.transact(
       (e) => {
         if (!this.auth.canCreateThread())
           throw new Error("Not authorized");
         const t = /* @__PURE__ */ new Date(), a = {
           type: "comment",
-          id: I(),
+          id: D(),
           userId: this.userId,
           createdAt: t,
           updatedAt: t,
@@ -440,28 +752,28 @@ class $ extends f {
           body: e.initialComment.body
         }, s = {
           type: "thread",
-          id: I(),
+          id: D(),
           createdAt: t,
           updatedAt: t,
           comments: [a],
           resolved: !1,
           metadata: e.metadata
         };
-        return this.threadsYMap.set(s.id, y(s)), s;
+        return this.threadsYMap.set(s.id, G(s)), s;
       }
     ));
     // YjsThreadStore does not support addThreadToDocument
-    n(this, "addThreadToDocument");
-    n(this, "addComment", this.transact(
+    c(this, "addThreadToDocument");
+    c(this, "addComment", this.transact(
       (e) => {
         const t = this.threadsYMap.get(e.threadId);
         if (!t)
           throw new Error("Thread not found");
-        if (!this.auth.canAddComment(c(t)))
+        if (!this.auth.canAddComment(p(t)))
           throw new Error("Not authorized");
         const a = /* @__PURE__ */ new Date(), s = {
           type: "comment",
-          id: I(),
+          id: D(),
           userId: this.userId,
           createdAt: a,
           updatedAt: a,
@@ -471,103 +783,103 @@ class $ extends f {
           body: e.comment.body
         };
         return t.get("comments").push([
-          g(s)
+          U(s)
         ]), t.set("updatedAt", (/* @__PURE__ */ new Date()).getTime()), s;
       }
     ));
-    n(this, "updateComment", this.transact(
+    c(this, "updateComment", this.transact(
       (e) => {
         const t = this.threadsYMap.get(e.threadId);
         if (!t)
           throw new Error("Thread not found");
-        const a = l(
+        const a = y(
           t.get("comments"),
           (o) => o.get("id") === e.commentId
         );
         if (a === -1)
           throw new Error("Comment not found");
         const s = t.get("comments").get(a);
-        if (!this.auth.canUpdateComment(T(s)))
+        if (!this.auth.canUpdateComment(I(s)))
           throw new Error("Not authorized");
         s.set("body", e.comment.body), s.set("updatedAt", (/* @__PURE__ */ new Date()).getTime()), s.set("metadata", e.comment.metadata);
       }
     ));
-    n(this, "deleteComment", this.transact(
+    c(this, "deleteComment", this.transact(
       (e) => {
         const t = this.threadsYMap.get(e.threadId);
         if (!t)
           throw new Error("Thread not found");
-        const a = l(
+        const a = y(
           t.get("comments"),
           (o) => o.get("id") === e.commentId
         );
         if (a === -1)
           throw new Error("Comment not found");
         const s = t.get("comments").get(a);
-        if (!this.auth.canDeleteComment(T(s)))
+        if (!this.auth.canDeleteComment(I(s)))
           throw new Error("Not authorized");
         if (s.get("deletedAt"))
           throw new Error("Comment already deleted");
         e.softDelete ? (s.set("deletedAt", (/* @__PURE__ */ new Date()).getTime()), s.set("body", void 0)) : t.get("comments").delete(a), t.get("comments").toArray().every((o) => o.get("deletedAt")) && (e.softDelete ? t.set("deletedAt", (/* @__PURE__ */ new Date()).getTime()) : this.threadsYMap.delete(e.threadId)), t.set("updatedAt", (/* @__PURE__ */ new Date()).getTime());
       }
     ));
-    n(this, "deleteThread", this.transact((e) => {
+    c(this, "deleteThread", this.transact((e) => {
       if (!this.auth.canDeleteThread(
-        c(this.threadsYMap.get(e.threadId))
+        p(this.threadsYMap.get(e.threadId))
       ))
         throw new Error("Not authorized");
       this.threadsYMap.delete(e.threadId);
     }));
-    n(this, "resolveThread", this.transact((e) => {
+    c(this, "resolveThread", this.transact((e) => {
       const t = this.threadsYMap.get(e.threadId);
       if (!t)
         throw new Error("Thread not found");
-      if (!this.auth.canResolveThread(c(t)))
+      if (!this.auth.canResolveThread(p(t)))
         throw new Error("Not authorized");
       t.set("resolved", !0), t.set("resolvedUpdatedAt", (/* @__PURE__ */ new Date()).getTime()), t.set("resolvedBy", this.userId);
     }));
-    n(this, "unresolveThread", this.transact((e) => {
+    c(this, "unresolveThread", this.transact((e) => {
       const t = this.threadsYMap.get(e.threadId);
       if (!t)
         throw new Error("Thread not found");
-      if (!this.auth.canUnresolveThread(c(t)))
+      if (!this.auth.canUnresolveThread(p(t)))
         throw new Error("Not authorized");
       t.set("resolved", !1), t.set("resolvedUpdatedAt", (/* @__PURE__ */ new Date()).getTime());
     }));
-    n(this, "addReaction", this.transact(
+    c(this, "addReaction", this.transact(
       (e) => {
         const t = this.threadsYMap.get(e.threadId);
         if (!t)
           throw new Error("Thread not found");
-        const a = l(
+        const a = y(
           t.get("comments"),
           (i) => i.get("id") === e.commentId
         );
         if (a === -1)
           throw new Error("Comment not found");
         const s = t.get("comments").get(a);
-        if (!this.auth.canAddReaction(T(s), e.emoji))
+        if (!this.auth.canAddReaction(I(s), e.emoji))
           throw new Error("Not authorized");
-        const o = /* @__PURE__ */ new Date(), h = `${this.userId}-${e.emoji}`, m = s.get("reactionsByUser");
-        if (!m.has(h)) {
-          const i = new u.Map();
-          i.set("emoji", e.emoji), i.set("createdAt", o.getTime()), i.set("userId", this.userId), m.set(h, i);
+        const o = /* @__PURE__ */ new Date(), m = `${this.userId}-${e.emoji}`, n = s.get("reactionsByUser");
+        if (!n.has(m)) {
+          const i = new g.Map();
+          i.set("emoji", e.emoji), i.set("createdAt", o.getTime()), i.set("userId", this.userId), n.set(m, i);
         }
       }
     ));
-    n(this, "deleteReaction", this.transact(
+    c(this, "deleteReaction", this.transact(
       (e) => {
         const t = this.threadsYMap.get(e.threadId);
         if (!t)
           throw new Error("Thread not found");
-        const a = l(
+        const a = y(
           t.get("comments"),
-          (m) => m.get("id") === e.commentId
+          (n) => n.get("id") === e.commentId
         );
         if (a === -1)
           throw new Error("Comment not found");
         const s = t.get("comments").get(a);
-        if (!this.auth.canDeleteReaction(T(s), e.emoji))
+        if (!this.auth.canDeleteReaction(I(s), e.emoji))
           throw new Error("Not authorized");
         const o = `${this.userId}-${e.emoji}`;
         s.get("reactionsByUser").delete(o);
@@ -576,19 +888,21 @@ class $ extends f {
     this.userId = e;
   }
 }
-function l(d, r) {
-  for (let e = 0; e < d.length; e++)
-    if (r(d.get(e)))
+function y(r, d) {
+  for (let e = 0; e < r.length; e++)
+    if (d(r.get(e)))
       return e;
   return -1;
 }
 export {
-  b as DefaultThreadStoreAuth,
-  Y as RESTYjsThreadStore,
-  w as ThreadStore,
-  v as ThreadStoreAuth,
-  j as TiptapThreadStore,
-  $ as YjsThreadStore,
-  f as YjsThreadStoreBase
+  M as CommentMark,
+  ne as CommentsExtension,
+  oe as DefaultThreadStoreAuth,
+  ce as RESTYjsThreadStore,
+  R as ThreadStore,
+  V as ThreadStoreAuth,
+  ie as TiptapThreadStore,
+  he as YjsThreadStore,
+  j as YjsThreadStoreBase
 };
 //# sourceMappingURL=comments.js.map