quoin-editor 0.4.1 → 1.0.0

package/dist/comments.cjs

@@ -0,0 +1,993 @@
+'use client';"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+var _chunkGLLXHMH2cjs = require('./chunk-GLLXHMH2.cjs');
+
+
+var _chunkWXMYDXPNcjs = require('./chunk-WXMYDXPN.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2VDK27IFcjs = require('./chunk-2VDK27IF.cjs');
+
+
+
+
+var _chunkGTTPVJSDcjs = require('./chunk-GTTPVJSD.cjs');
+require('./chunk-OMOBMXD5.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPZ4GT5JOcjs = require('./chunk-PZ4GT5JO.cjs');
+require('./chunk-2QCRZ7OL.cjs');
+
+
+
+
+
+
+var _chunkND5XJVK2cjs = require('./chunk-ND5XJVK2.cjs');
+
+// src/extensions/comments/comments-extension.tsx
+var _lucidereact = require('lucide-react');
+
+// src/extensions/comments/comment-anchors.ts
+var idsOf = (node) => _nullishCoalesce(_optionalChain([node, 'optionalAccess', _2 => _2.marks, 'access', _3 => _3.flatMap, 'call', _4 => _4((mark) => mark.type === "comment" && _optionalChain([mark, 'access', _5 => _5.attrs, 'optionalAccess', _6 => _6.id]) ? [mark.attrs.id] : [])]), () => ( []));
+function addRegion(anchors, block, region, inline2) {
+  let position = 0;
+  for (const node of inline2) {
+    const from = position;
+    position += _chunkND5XJVK2cjs.nodeLength.call(void 0, node);
+    for (const id of idsOf(node)) {
+      const ranges = _nullishCoalesce(anchors.get(id), () => ( []));
+      const last = ranges[ranges.length - 1];
+      const continues = _optionalChain([last, 'optionalAccess', _7 => _7.block]) === block && last.region === region && last.to === from;
+      if (continues) ranges[ranges.length - 1] = { ...last, to: position };
+      else ranges.push({ block, region, from, to: position });
+      anchors.set(id, ranges);
+    }
+  }
+}
+var read = /* @__PURE__ */ new WeakMap();
+function commentAnchors(doc) {
+  let anchors = read.get(doc);
+  if (anchors === void 0) {
+    const found = /* @__PURE__ */ new Map();
+    for (const block of doc.blocks) {
+      for (const [region, inline2] of Object.entries(block.regions)) addRegion(found, block.id, region, inline2);
+    }
+    anchors = found;
+    read.set(doc, anchors);
+  }
+  return anchors;
+}
+var atomLabel = (node) => node.kind === "atom" ? _nullishCoalesce(node.attrs.label, () => ( "")) : "";
+function anchorText(doc, ranges) {
+  return ranges.map(({ block, region, from, to }) => {
+    const inline2 = _nullishCoalesce(_optionalChain([_chunkND5XJVK2cjs.blockById.call(void 0, doc, block), 'optionalAccess', _8 => _8.regions, 'access', _9 => _9[region]]), () => ( []));
+    return _chunkND5XJVK2cjs.inlineText.call(void 0, _chunkND5XJVK2cjs.sliceInline.call(void 0, inline2, from, to), atomLabel);
+  }).join(" ");
+}
+function commentIdsAt(doc, { block, region, offset }) {
+  const inline2 = _nullishCoalesce(_optionalChain([_chunkND5XJVK2cjs.blockById.call(void 0, doc, block), 'optionalAccess', _10 => _10.regions, 'access', _11 => _11[region]]), () => ( []));
+  const ids = /* @__PURE__ */ new Set();
+  let position = 0;
+  for (const node of inline2) {
+    const end = position + _chunkND5XJVK2cjs.nodeLength.call(void 0, node);
+    if (position <= offset && offset <= end && end > position) idsOf(node).forEach((id) => ids.add(id));
+    position = end;
+  }
+  return [...ids].sort();
+}
+function threadRemoval(state, id) {
+  const tr = new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setOrigin("command");
+  for (const { block, region, from, to } of _nullishCoalesce(commentAnchors(state.doc).get(id), () => ( []))) {
+    tr.step(_chunkPZ4GT5JOcjs.removeMarkStep.call(void 0, block, region, from, to, { type: "comment", attrs: { id } }));
+  }
+  return tr;
+}
+
+// src/extensions/comments/pending-ranges.ts
+function mapPendingRanges(tr, ranges, state) {
+  return ranges.flatMap((range) => {
+    const from = tr.mapPos({ block: range.block, region: range.region, offset: range.from }, 1);
+    const to = tr.mapPos({ block: range.block, region: range.region, offset: range.to }, -1);
+    const { index } = state.doc;
+    if (!index.has(from.block) || !index.has(to.block) || _chunkPZ4GT5JOcjs.comparePos.call(void 0, state.doc, from, to) >= 0) return [];
+    return _chunkPZ4GT5JOcjs.markRanges.call(void 0, { ...state, selection: _chunkPZ4GT5JOcjs.textSelection.call(void 0, from, to) });
+  });
+}
+
+// src/extensions/comments/comments-plugin.ts
+var isEnded = (ended, id, current) => ended.some((thread) => thread.id === id && thread.seen === current);
+var commentsKey = _chunkPZ4GT5JOcjs.createPluginKey.call(void 0, "comments");
+var COMMENTS = "comments";
+var IDLE = { pending: [], active: null, open: null, ended: [] };
+function act(value, action) {
+  switch (action.type) {
+    case "pending":
+      return { ...value, pending: [...value.pending, action.pending] };
+    case "settled": {
+      const pending = value.pending.filter(({ key }) => key !== action.key);
+      if (action.open === void 0) return { ...value, pending };
+      return { ...value, pending, active: _nullishCoalesce(action.open.ids[0], () => ( null)), open: action.open };
+    }
+    case "activate":
+      return value.active === action.id ? value : { ...value, active: action.id };
+    case "open":
+      return { ...value, active: action.open.ids.length === 1 ? action.open.ids[0] : value.active, open: action.open };
+    case "close":
+      return value.open === null ? value : { ...value, active: null, open: null };
+    case "forget": {
+      const active = value.active === action.id ? null : value.active;
+      const open = _optionalChain([value, 'access', _12 => _12.open, 'optionalAccess', _13 => _13.ids, 'access', _14 => _14.includes, 'call', _15 => _15(action.id)]) ? null : value.open;
+      const ended = [...value.ended.filter(({ id }) => id !== action.id), { id: action.id, seen: action.seen }];
+      return { ...value, active, open, ended };
+    }
+  }
+}
+function afterEdit(tr, value, state) {
+  if (!tr.docChanged || value.pending.length === 0) return value;
+  const pending = value.pending.map((anchor) => ({ ...anchor, ranges: mapPendingRanges(tr, anchor.ranges, state) }));
+  return { ...value, pending };
+}
+function afterMove(tr, value, state) {
+  const { open } = value;
+  if (open === null || open.focus || !tr.selectionSet || _chunkPZ4GT5JOcjs.foreignOrigins.includes(tr.origin)) return value;
+  const anchors = commentAnchors(state.doc);
+  return open.ids.some((id) => anchors.has(id)) ? value : { ...value, active: null, open: null };
+}
+var commentsPlugin = {
+  key: commentsKey,
+  init: () => IDLE,
+  apply(tr, value, _oldState, newState) {
+    const edited = afterMove(tr, afterEdit(tr, value, newState), newState);
+    const action = tr.getMeta(COMMENTS);
+    return action === void 0 ? edited : act(edited, action);
+  }
+};
+
+// src/extensions/comments/comment-create.ts
+var nextKey = 0;
+var hasCommentableText = (state) => _optionalChain([state, 'access', _16 => _16.selection, 'optionalAccess', _17 => _17.kind]) === "text" && _chunkPZ4GT5JOcjs.markRanges.call(void 0, state).length > 0;
+var requestComment = (state, dispatch) => {
+  const { selection } = state;
+  if (_optionalChain([selection, 'optionalAccess', _18 => _18.kind]) !== "text" || _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, commentsKey).pending.length > 0) return false;
+  const ranges = _chunkPZ4GT5JOcjs.markRanges.call(void 0, state);
+  if (ranges.length === 0) return false;
+  if (dispatch === void 0) return true;
+  const pending = { key: ++nextKey, ranges, selection };
+  const action = { type: "pending", pending };
+  dispatch(new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setMeta(COMMENTS, action).setMeta("addToHistory", false));
+  return true;
+};
+function settledTransaction(editor, key, id) {
+  const pending = _chunkPZ4GT5JOcjs.getPluginState.call(void 0, editor.state, commentsKey).pending.find((anchor) => anchor.key === key);
+  const tr = editor.createTransaction().setOrigin("command");
+  const ranges = id === null ? [] : _nullishCoalesce(_optionalChain([pending, 'optionalAccess', _19 => _19.ranges]), () => ( []));
+  for (const { block, region, from, to } of ranges) {
+    tr.step(_chunkPZ4GT5JOcjs.addMarkStep.call(void 0, block, region, from, to, { type: "comment", attrs: { id } }));
+  }
+  const untouched = pending !== void 0 && _chunkPZ4GT5JOcjs.sameSelection.call(void 0, editor.state.selection, pending.selection);
+  const open = id !== null && ranges.length > 0 && untouched ? { ids: [id], focus: true } : void 0;
+  const action = { type: "settled", key, open };
+  return tr.setMeta(COMMENTS, action);
+}
+function create(editor, pending, onCreate, link) {
+  const input = { anchorText: anchorText(editor.state.doc, pending.ranges), blockId: pending.ranges[0].block };
+  const settle = (id, error) => {
+    if (link.mounts === 0) return;
+    const tr = settledTransaction(editor, pending.key, id);
+    editor.dispatch(tr);
+    if (id === null) link.report(_chunk2VDK27IFcjs.toError.call(void 0, error));
+    else if (!tr.docChanged) link.report(new Error(`Comment thread ${id} has no text: it was deleted meanwhile`));
+  };
+  new Promise((resolve) => resolve(onCreate(input))).then(
+    (id) => typeof id === "string" && id !== "" ? settle(id) : settle(null, new Error("onCreate gave no thread id")),
+    (error) => settle(null, error)
+  );
+}
+function watchCreates(editor, onCreate, link) {
+  return editor.subscribe((_, tr) => {
+    const action = _optionalChain([tr, 'optionalAccess', _20 => _20.getMeta, 'call', _21 => _21(COMMENTS)]);
+    if (_optionalChain([action, 'optionalAccess', _22 => _22.type]) === "pending") create(editor, action.pending, onCreate, link);
+  });
+}
+
+// src/extensions/comments/comment-open.ts
+function openIds(state, threads, ids) {
+  const { ended } = _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, commentsKey);
+  return ids.filter((id) => {
+    const thread = threads.find(id);
+    return _optionalChain([thread, 'optionalAccess', _23 => _23.resolved]) === false && !isEnded(ended, id, thread);
+  });
+}
+function commentsTransaction(state, action) {
+  return new (0, _chunkPZ4GT5JOcjs.Transaction)(state).setMeta(COMMENTS, action).setMeta("addToHistory", false);
+}
+function commentCommand(threads) {
+  return (state, dispatch) => {
+    if (requestComment(state, dispatch)) return true;
+    const { selection } = state;
+    if (_optionalChain([selection, 'optionalAccess', _24 => _24.kind]) !== "text" || !_chunkPZ4GT5JOcjs.isCollapsed.call(void 0, selection)) return false;
+    const ids = openIds(state, threads, commentIdsAt(state.doc, selection.head));
+    if (ids.length === 0) return false;
+    _optionalChain([dispatch, 'optionalCall', _25 => _25(commentsTransaction(state, { type: "open", open: { ids, focus: true } }))]);
+    return true;
+  };
+}
+
+// src/extensions/comments/comments-labels.ts
+var DATE = new Intl.DateTimeFormat("en", { dateStyle: "medium", timeStyle: "short" });
+function englishDate(createdAt) {
+  const date = new Date(createdAt);
+  return Number.isNaN(date.getTime()) ? createdAt : DATE.format(date);
+}
+var englishCommentsLabels = {
+  comment: "Comment",
+  comments: "Comments",
+  showComments: (count) => `Comments (${count})`,
+  thread: (anchorText2) => `Comment on "${anchorText2}"`,
+  threadsHere: "Comments on this text",
+  textRemoved: "Text removed",
+  addComment: "Add a comment",
+  reply: "Reply",
+  send: "Send",
+  resolve: "Resolve",
+  delete: "Delete",
+  close: "Close",
+  commentCount: (count) => `${count} ${count === 1 ? "comment" : "comments"}`,
+  postedAt: englishDate
+};
+function resolveCommentsLabels(overrides) {
+  const given = Object.entries(_nullishCoalesce(overrides, () => ( {}))).filter(([, value]) => value !== void 0);
+  return given.length === 0 ? englishCommentsLabels : { ...englishCommentsLabels, ...Object.fromEntries(given) };
+}
+
+// src/extensions/comments/comments-link.ts
+var links = /* @__PURE__ */ new WeakMap();
+function linkOf(editor) {
+  let link = links.get(editor);
+  if (link === void 0) {
+    link = { mounts: 0, report: (error) => console.error(error), stopWatching: null };
+    links.set(editor, link);
+  }
+  return link;
+}
+
+// src/extensions/comments/CommentsOverlay.tsx
+var _react = require('react');
+
+// src/extensions/comments/CommentMarkers.tsx
+
+
+// src/extensions/comments/rail-layout.ts
+function stackTops(items, gap) {
+  let next = 0;
+  return items.map(({ top, height }) => {
+    const placed = Math.max(_nullishCoalesce(top, () => ( next)), next);
+    next = placed + height + gap;
+    return placed;
+  });
+}
+
+// src/extensions/comments/use-block-aligned.ts
+function topOf(controller, root, block) {
+  const shell = block === "" ? void 0 : controller.blockElement(block);
+  if (shell === void 0) return null;
+  return shell.getBoundingClientRect().top - root.getBoundingClientRect().top - root.clientTop + root.scrollTop;
+}
+var HEIGHT = "--quoin-comments-height";
+function place(controller, box, gap) {
+  const root = box.parentElement;
+  if (root === null) return;
+  const items = Array.from(box.querySelectorAll("[data-rail-item]"));
+  const tops = stackTops(
+    items.map((item) => ({ top: topOf(controller, root, _nullishCoalesce(item.dataset.block, () => ( ""))), height: item.offsetHeight })),
+    gap
+  );
+  items.forEach((item, i) => item.style.transform = `translateY(${tops[i]}px)`);
+  const bottom = Math.max(0, ...items.map((item, i) => tops[i] + item.offsetHeight));
+  root.style.setProperty(HEIGHT, `${bottom}px`);
+}
+function useBlockAligned(controller, box, gap, key) {
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const element = box.current;
+    const view = _optionalChain([element, 'optionalAccess', _26 => _26.ownerDocument, 'access', _27 => _27.defaultView]);
+    if (!element || !view) return void 0;
+    const update = () => place(controller, element, gap);
+    update();
+    let frame = 0;
+    const later = () => {
+      view.cancelAnimationFrame(frame);
+      frame = view.requestAnimationFrame(update);
+    };
+    const unsubscribe = controller.editor.subscribe(later);
+    const observer = new ResizeObserver(later);
+    if (element.parentElement) observer.observe(element.parentElement);
+    element.querySelectorAll("[data-rail-item]").forEach((item) => observer.observe(item));
+    return () => {
+      view.cancelAnimationFrame(frame);
+      unsubscribe();
+      observer.disconnect();
+      _optionalChain([element, 'access', _28 => _28.parentElement, 'optionalAccess', _29 => _29.style, 'access', _30 => _30.removeProperty, 'call', _31 => _31(HEIGHT)]);
+    };
+  }, [controller, box, gap, key]);
+}
+
+// src/extensions/comments/CommentMarkers.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var GAP = 4;
+function groupsOf(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const { thread, ranges } of entries) {
+    const block = _nullishCoalesce(_optionalChain([ranges, 'access', _32 => _32[0], 'optionalAccess', _33 => _33.block]), () => ( ""));
+    groups.set(block, [..._nullishCoalesce(groups.get(block), () => ( [])), thread.id]);
+  }
+  const removed = groups.get("");
+  groups.delete("");
+  return [...groups, ...removed ? [["", removed]] : []].map(([block, ids]) => ({ block, ids }));
+}
+function CommentMarkers({ env, box, entries, onOpen }) {
+  const groups = groupsOf(entries);
+  useBlockAligned(env.controller, box, GAP, groups.map(({ block, ids }) => `${block}:${ids}`).join(" "));
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ref: box, className: "quoin-comments-markers", children: groups.map(({ block, ids }) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "button",
+    {
+      type: "button",
+      "data-rail-item": "",
+      "data-block": block,
+      "aria-label": env.labels.showComments(ids.length),
+      className: _chunk2VDK27IFcjs.cn.call(void 0, "quoin-comments-marker", _chunk2VDK27IFcjs.FOCUS_RING),
+      onClick: (event) => onOpen(ids[0], event.currentTarget),
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.MessageSquare, { "aria-hidden": "true" }),
+        ids.length
+      ]
+    },
+    block
+  )) });
+}
+
+// src/extensions/comments/ThreadCard.tsx
+
+
+// src/extensions/comments/ThreadView.tsx
+
+
+// src/extensions/comments/comment-actions.ts
+async function called(link, call) {
+  try {
+    await call();
+    return true;
+  } catch (error) {
+    link.report(_chunk2VDK27IFcjs.toError.call(void 0, error));
+    return false;
+  }
+}
+async function endThread(editor, link, call, id, threads) {
+  if (!await called(link, () => call(id)) || link.mounts === 0) return false;
+  const action = { type: "forget", id, seen: _optionalChain([threads, 'optionalAccess', _34 => _34.find, 'call', _35 => _35(id)]) };
+  editor.dispatch(threadRemoval(editor.state, id).setMeta(COMMENTS, action));
+  return true;
+}
+function sendReply(link, call, id, body) {
+  return called(link, () => call(id, body));
+}
+
+// src/extensions/comments/CommentAvatar.tsx
+
+
+var initials = (name) => name.trim().split(/\s+/).slice(0, 2).map((word) => _nullishCoalesce(_optionalChain([Array, 'access', _36 => _36.from, 'call', _37 => _37(word), 'access', _38 => _38[0], 'optionalAccess', _39 => _39.toUpperCase, 'call', _40 => _40()]), () => ( ""))).join("");
+function CommentAvatar({ author }) {
+  const picture = _chunkGLLXHMH2cjs.webAddress.call(void 0, author.avatarUrl);
+  const [failed, setFailed] = _react.useState.call(void 0, null);
+  if (picture !== null && picture !== failed) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "img",
+      {
+        src: picture,
+        alt: "",
+        loading: "lazy",
+        referrerPolicy: "no-referrer",
+        draggable: false,
+        className: "size-6 shrink-0 rounded-full object-cover",
+        onError: () => setFailed(picture)
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { "aria-hidden": "true", className: "quoin-comments-initials", children: initials(author.name) });
+}
+
+// src/extensions/comments/CommentItem.tsx
+
+function CommentItem({ comment, labels }) {
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "li", { className: "flex gap-2", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentAvatar, { author: comment.author }),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "min-w-0 flex-1", children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { className: "flex flex-wrap items-baseline gap-x-2 text-sm", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "font-medium", children: comment.author.name }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "time", { dateTime: comment.createdAt, className: "text-xs text-muted-foreground", children: labels.postedAt(comment.createdAt) })
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "quoin-comments-body text-sm", children: comment.body })
+    ] })
+  ] });
+}
+
+// src/extensions/comments/ReplyBox.tsx
+
+
+
+var REPLY_FIELD = "data-comments-field";
+function ReplyBox({ env, threadId, first }) {
+  const { controller, host, labels, link } = env;
+  const [body, setBody] = _react.useState.call(void 0, "");
+  const [sending, setSending] = _react.useState.call(void 0, false);
+  const alive = _react.useRef.call(void 0, true);
+  _react.useEffect.call(void 0, () => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+    };
+  }, []);
+  const label = first ? labels.addComment : labels.reply;
+  const text = body.trim();
+  const send = async () => {
+    if (text === "" || sending) return;
+    setSending(true);
+    const sent = await sendReply(link, host.onReply, threadId, text);
+    if (!alive.current) return;
+    setSending(false);
+    if (sent) setBody("");
+  };
+  const onSubmit = (event) => {
+    event.preventDefault();
+    void send();
+  };
+  const onKeyDown = (event) => {
+    if (event.nativeEvent.isComposing || event.key !== "Enter") return;
+    if (controller.isMac ? !event.metaKey : !event.ctrlKey) return;
+    event.preventDefault();
+    void send();
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "form", { className: "flex items-start gap-2", onSubmit, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentAvatar, { author: host.currentUser }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "textarea",
+      {
+        ...{ [REPLY_FIELD]: "" },
+        "aria-label": label,
+        placeholder: label,
+        rows: 2,
+        value: body,
+        onChange: (event) => setBody(event.target.value),
+        onKeyDown,
+        className: "quoin-comments-field"
+      }
+    ),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _chunk2VDK27IFcjs.Button,
+      {
+        type: "submit",
+        variant: "ghost",
+        size: "icon-sm",
+        "aria-label": labels.send,
+        "aria-disabled": text === "" || sending || void 0,
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.SendHorizontal, {})
+      }
+    )
+  ] });
+}
+
+// src/extensions/comments/ThreadView.tsx
+
+function ThreadView({ env, id, thread, onEnded }) {
+  const { controller, host, labels, link } = env;
+  const readOnly = _chunkGTTPVJSDcjs.useReadOnly.call(void 0, controller);
+  const [busy, setBusy] = _react.useState.call(void 0, false);
+  const alive = _react.useRef.call(void 0, true);
+  const root = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+    };
+  }, []);
+  const comments = _nullishCoalesce(_optionalChain([thread, 'optionalAccess', _41 => _41.comments]), () => ( []));
+  const end = async (call) => {
+    if (busy) return;
+    setBusy(true);
+    const ended = await endThread(controller.editor, link, call, id, host.threads);
+    if (alive.current) setBusy(false);
+    const active = document.activeElement;
+    const stayed = active === null || active === document.body || _optionalChain([root, 'access', _42 => _42.current, 'optionalAccess', _43 => _43.contains, 'call', _44 => _44(active)]) === true;
+    if (ended && stayed) onEnded();
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { ref: root, className: "flex flex-col gap-3", children: [
+    comments.length > 0 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "ol", { className: "flex flex-col gap-3", children: comments.map((comment) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentItem, { comment, labels }, comment.id)) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ReplyBox, { env, threadId: id, first: comments.length === 0 }),
+    !readOnly && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex justify-end gap-1", children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _chunk2VDK27IFcjs.Button,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "xs",
+          "aria-disabled": busy || void 0,
+          onClick: () => void end(host.onResolve),
+          children: labels.resolve
+        }
+      ),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _chunk2VDK27IFcjs.Button,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "xs",
+          "aria-disabled": busy || void 0,
+          onClick: () => void end(host.onDelete),
+          children: labels.delete
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/extensions/comments/ThreadCard.tsx
+
+function ThreadCard({ env, entry, active, expanded, onToggle }) {
+  const { labels, controller } = env;
+  const { thread, anchorText: anchorText2, ranges } = entry;
+  const header = _react.useRef.call(void 0, null);
+  const [first] = thread.comments;
+  const removed = ranges.length === 0;
+  const backToHeader = () => {
+    if (_optionalChain([header, 'access', _45 => _45.current, 'optionalAccess', _46 => _46.isConnected])) header.current.focus();
+    else controller.focus();
+  };
+  const onKeyDown = (event) => {
+    if (event.key !== "Escape" || !expanded) return;
+    event.preventDefault();
+    event.stopPropagation();
+    onToggle(null);
+    _optionalChain([header, 'access', _47 => _47.current, 'optionalAccess', _48 => _48.focus, 'call', _49 => _49()]);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "quoin-comments-card", "data-active": active || void 0, onKeyDown, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      "button",
+      {
+        ref: header,
+        type: "button",
+        "aria-expanded": expanded,
+        className: _chunk2VDK27IFcjs.cn.call(void 0, "flex w-full flex-col items-start gap-1 rounded-sm text-start", _chunk2VDK27IFcjs.FOCUS_RING),
+        onClick: () => onToggle(expanded ? null : thread.id),
+        children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: removed ? "text-xs text-muted-foreground italic" : "quoin-comments-quote", children: removed ? labels.textRemoved : anchorText2 }),
+          first !== void 0 && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "line-clamp-2 text-sm", children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "font-medium", children: first.author.name }),
+            " ",
+            first.body
+          ] }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-xs text-muted-foreground", children: labels.commentCount(thread.comments.length) })
+        ]
+      }
+    ),
+    expanded && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "mt-3", role: "group", "aria-label": removed ? labels.textRemoved : labels.thread(anchorText2), children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadView, { env, id: thread.id, thread, onEnded: backToHeader }) })
+  ] });
+}
+
+// src/extensions/comments/CommentsRail.tsx
+
+var GAP2 = 8;
+var layoutKey = (entries, value) => `${value.active} ${value.open !== null} ${entries.map(({ thread, ranges }) => `${thread.id}:${_optionalChain([ranges, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.block])}`)}`;
+function CommentsRail({ env, box, entries, value, onToggle }) {
+  useBlockAligned(env.controller, box, GAP2, layoutKey(entries, value));
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ref: box, className: "quoin-comments-rail", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "ul", { "aria-label": env.labels.comments, children: entries.map((entry) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "li", { "data-rail-item": "", "data-block": _nullishCoalesce(_optionalChain([entry, 'access', _52 => _52.ranges, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.block]), () => ( "")), children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    ThreadCard,
+    {
+      env,
+      entry,
+      active: value.active === entry.thread.id,
+      expanded: value.active === entry.thread.id && value.open === null,
+      onToggle
+    }
+  ) }, entry.thread.id)) }) });
+}
+
+// src/extensions/comments/CommentsSheet.tsx
+var _reactdialog = require('@radix-ui/react-dialog'); var DialogPrimitive = _interopRequireWildcard(_reactdialog);
+
+
+
+function CommentsSheet({ env, entries, value, onToggle, onClose, returnFocus }) {
+  const { labels } = env;
+  const content = _react.useRef.call(void 0, null);
+  const outside = _react.useRef.call(void 0, false);
+  const focusOpened = (event) => {
+    const opened = _optionalChain([content, 'access', _55 => _55.current, 'optionalAccess', _56 => _56.querySelector, 'call', _57 => _57('[aria-expanded="true"]')]);
+    if (!opened) return;
+    event.preventDefault();
+    opened.focus();
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    DialogPrimitive.Root,
+    {
+      open: true,
+      modal: false,
+      onOpenChange: (open) => {
+        if (!open) onClose();
+      },
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Portal, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+        DialogPrimitive.Content,
+        {
+          ref: content,
+          "aria-describedby": void 0,
+          className: "quoin quoin-comments-sheet",
+          onOpenAutoFocus: focusOpened,
+          onInteractOutside: () => {
+            outside.current = true;
+          },
+          onCloseAutoFocus: (event) => {
+            event.preventDefault();
+            if (!outside.current) returnFocus();
+          },
+          children: [
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center justify-between gap-2", children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Title, { className: "text-sm font-semibold", children: labels.comments }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Close, { asChild: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.Button, { type: "button", variant: "ghost", size: "icon-sm", "aria-label": labels.close, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.XIcon, {}) }) })
+            ] }),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "ul", { "aria-label": labels.comments, className: "flex flex-col gap-2", children: entries.map((entry) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "li", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              ThreadCard,
+              {
+                env,
+                entry,
+                active: value.active === entry.thread.id,
+                expanded: value.active === entry.thread.id,
+                onToggle
+              }
+            ) }, entry.thread.id)) })
+          ]
+        }
+      ) })
+    }
+  );
+}
+
+// src/extensions/comments/rail-entries.ts
+var NONE = [];
+function railEntries(doc, threads, ended = []) {
+  const anchors = commentAnchors(doc);
+  const entries = threads.filter((thread) => !thread.resolved && !isEnded(ended, thread.id, thread)).map((thread) => {
+    const ranges = _nullishCoalesce(anchors.get(thread.id), () => ( NONE));
+    return { thread, ranges, anchorText: anchorText(doc, ranges) };
+  });
+  const place2 = ({ ranges: [first] }) => first === void 0 ? [Infinity, 0] : [_chunkND5XJVK2cjs.indexOfBlock.call(void 0, doc, first.block), first.from];
+  return entries.map((entry, order) => ({ entry, order, at: place2(entry) })).sort((a, b) => a.at[0] - b.at[0] || a.at[1] - b.at[1] || a.order - b.order).map(({ entry }) => entry);
+}
+
+// src/extensions/comments/ThreadPopover.tsx
+
+
+// src/extensions/comments/ThreadChooser.tsx
+
+function ThreadChooser({ env, choices, onChoose }) {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "ul", { "aria-label": env.labels.threadsHere, className: "flex flex-col gap-1", children: choices.map(({ id, anchorText: anchorText2, preview }) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "li", { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "button",
+    {
+      type: "button",
+      className: "quoin-comments-choice",
+      onClick: () => onChoose(id),
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "quoin-comments-quote", children: anchorText2 }),
+        preview && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "line-clamp-1 text-sm", children: preview })
+      ]
+    }
+  ) }, id)) });
+}
+
+// src/extensions/comments/ThreadPopover.tsx
+
+var docOf = (state) => state.doc;
+function focusIsOurs(controller, content) {
+  const active = _nullishCoalesce(_optionalChain([content, 'optionalAccess', _58 => _58.ownerDocument, 'access', _59 => _59.activeElement]), () => ( null));
+  return active === null || active === active.ownerDocument.body || _chunkWXMYDXPNcjs.ownsNode.call(void 0, controller, active);
+}
+function ThreadPopover({ env, open, threads, onChoose, onClose }) {
+  const { controller, labels } = env;
+  const doc = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, docOf);
+  const anchors = commentAnchors(doc);
+  const { ids } = open;
+  const first = ids.map((id) => _optionalChain([anchors, 'access', _60 => _60.get, 'call', _61 => _61(id), 'optionalAccess', _62 => _62[0]])).find(Boolean);
+  const latest = _react.useRef.call(void 0, first);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    if (first) latest.current = first;
+  });
+  const anchor = _react.useMemo.call(void 0, 
+    () => ({
+      current: _chunk2VDK27IFcjs.virtualAnchor.call(void 0, 
+        () => latest.current ? _chunk2VDK27IFcjs.rangeRect.call(void 0, controller, latest.current) : null,
+        () => latest.current && controller.registry.get(latest.current.block, latest.current.region)
+      )
+    }),
+    [controller]
+  );
+  const content = _react.useRef.call(void 0, null);
+  const focusField = () => {
+    const target = _optionalChain([content, 'access', _63 => _63.current, 'optionalAccess', _64 => _64.querySelector, 'call', _65 => _65(`[${REPLY_FIELD}], button`)]);
+    if (focusIsOurs(controller, content.current) && !_optionalChain([content, 'access', _66 => _66.current, 'optionalAccess', _67 => _67.contains, 'call', _68 => _68(content.current.ownerDocument.activeElement)])) {
+      _optionalChain([target, 'optionalAccess', _69 => _69.focus, 'call', _70 => _70()]);
+    }
+  };
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    if (open.focus) focusField();
+  }, [open]);
+  if (first === void 0 && latest.current === void 0) return null;
+  const textOf = (id) => anchorText(doc, _nullishCoalesce(anchors.get(id), () => ( []))) || labels.textRemoved;
+  const single = ids.length === 1;
+  const gone = single && !anchors.has(ids[0]);
+  const backToText = () => controller.focus();
+  const focusInside = (event) => {
+    event.preventDefault();
+    if (open.focus) focusField();
+  };
+  const onEscape = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    const inside = _nullishCoalesce(_optionalChain([content, 'access', _71 => _71.current, 'optionalAccess', _72 => _72.contains, 'call', _73 => _73(content.current.ownerDocument.activeElement)]), () => ( false));
+    onClose();
+    if (inside) backToText();
+  };
+  const choices = ids.map((id) => ({ id, anchorText: textOf(id), preview: _nullishCoalesce(_optionalChain([threads, 'access', _74 => _74.find, 'call', _75 => _75(id), 'optionalAccess', _76 => _76.comments, 'access', _77 => _77[0], 'optionalAccess', _78 => _78.body]), () => ( "")) }));
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _chunk2VDK27IFcjs.Popover,
+    {
+      open: true,
+      modal: false,
+      onOpenChange: (next) => {
+        if (!next) onClose();
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunk2VDK27IFcjs.PopoverAnchor, { virtualRef: anchor }),
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _chunk2VDK27IFcjs.PopoverContent,
+          {
+            ref: content,
+            "aria-label": gone ? labels.textRemoved : single ? labels.thread(textOf(ids[0])) : labels.threadsHere,
+            side: "bottom",
+            align: "start",
+            className: "w-80 p-3",
+            onOpenAutoFocus: focusInside,
+            onCloseAutoFocus: (event) => event.preventDefault(),
+            onEscapeKeyDown: onEscape,
+            children: [
+              gone && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "mb-2 text-xs text-muted-foreground italic", children: labels.textRemoved }),
+              single ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadView, { env, id: ids[0], thread: threads.find(ids[0]), onEnded: backToText }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThreadChooser, { env, choices, onChoose })
+            ]
+          },
+          ids.join(" ")
+        )
+      ]
+    }
+  );
+}
+
+// src/extensions/comments/use-anchor-clicks.ts
+
+function idsUnder(root, target) {
+  const ids = [];
+  let element = target instanceof Element ? target.closest("[data-comment]") : null;
+  while (element !== null && root.contains(element)) {
+    const id = element.getAttribute("data-comment");
+    if (id) ids.push(id);
+    element = _nullishCoalesce(_optionalChain([element, 'access', _79 => _79.parentElement, 'optionalAccess', _80 => _80.closest, 'call', _81 => _81("[data-comment]")]), () => ( null));
+  }
+  return ids;
+}
+function useAnchorClicks(controller, threads) {
+  _react.useEffect.call(void 0, () => {
+    const onClick = (event) => {
+      const root = controller.root;
+      if (root === null || event.defaultPrevented || !_optionalChain([root, 'access', _82 => _82.ownerDocument, 'access', _83 => _83.getSelection, 'call', _84 => _84(), 'optionalAccess', _85 => _85.isCollapsed])) return;
+      const { editor } = controller;
+      const ids = openIds(editor.state, threads, idsUnder(root, event.target));
+      if (ids.length === 0) return;
+      editor.dispatch(commentsTransaction(editor.state, { type: "open", open: { ids, focus: false } }));
+    };
+    document.addEventListener("click", onClick);
+    return () => document.removeEventListener("click", onClick);
+  }, [controller, threads]);
+}
+
+// src/extensions/comments/use-canvas-wide.ts
+
+var WIDE_CANVAS = 800;
+function useCanvasWide(box) {
+  const [wide, setWide] = _react.useState.call(void 0, false);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    const canvas = _optionalChain([box, 'access', _86 => _86.current, 'optionalAccess', _87 => _87.parentElement]);
+    if (!canvas) return void 0;
+    const measure = () => setWide(canvas.offsetWidth >= WIDE_CANVAS);
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(canvas);
+    return () => observer.disconnect();
+  }, [box]);
+  return wide;
+}
+
+// src/extensions/comments/use-threads.ts
+
+function useThreads(threads) {
+  return _react.useSyncExternalStore.call(void 0, threads.subscribe, threads.get, threads.get);
+}
+
+// src/extensions/comments/CommentsOverlay.tsx
+
+var commentsOf = (state) => _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, commentsKey);
+var docOf2 = (state) => state.doc;
+function CommentsOverlay({ controller, host, labels }) {
+  const { onError } = _chunk2VDK27IFcjs.useQuoin.call(void 0, );
+  const link = linkOf(controller.editor);
+  _chunkGTTPVJSDcjs.useIsomorphicLayoutEffect.call(void 0, () => {
+    link.report = onError;
+  }, [link, onError]);
+  useAnchorClicks(controller, host.threads);
+  const threads = useThreads(host.threads);
+  const value = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, commentsOf);
+  const doc = _chunkGTTPVJSDcjs.useEditorState.call(void 0, controller, docOf2);
+  const entries = _react.useMemo.call(void 0, () => railEntries(doc, threads, value.ended), [doc, threads, value.ended]);
+  const box = _react.useRef.call(void 0, null);
+  const wide = useCanvasWide(box);
+  const [sheet, setSheet] = _react.useState.call(void 0, false);
+  const opener = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    if (wide) setSheet(false);
+  }, [wide]);
+  const env = _react.useMemo.call(void 0, () => ({ controller, host, labels, link }), [controller, host, labels, link]);
+  const act2 = _react.useCallback.call(void 0, 
+    (action) => controller.editor.dispatch(commentsTransaction(controller.editor.state, action)),
+    [controller]
+  );
+  const toggle = _react.useCallback.call(void 0, (id) => act2({ type: "activate", id }), [act2]);
+  const openSheet = (id, marker) => {
+    opener.current = marker;
+    toggle(id);
+    setSheet(true);
+  };
+  const returnFocus = () => {
+    if (_optionalChain([opener, 'access', _88 => _88.current, 'optionalAccess', _89 => _89.isConnected])) opener.current.focus();
+    else controller.focus();
+  };
+  const closeSheet = () => {
+    setSheet(false);
+    toggle(null);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+    wide ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentsRail, { env, box, entries, value, onToggle: toggle }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentMarkers, { env, box, entries, onOpen: openSheet }),
+    !wide && sheet && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      CommentsSheet,
+      {
+        env,
+        entries,
+        value,
+        onToggle: toggle,
+        onClose: closeSheet,
+        returnFocus
+      }
+    ),
+    value.open && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      ThreadPopover,
+      {
+        env,
+        open: value.open,
+        threads: host.threads,
+        onChoose: (id) => act2({ type: "open", open: { ids: [id], focus: true } }),
+        onClose: () => act2({ type: "close" })
+      }
+    )
+  ] });
+}
+
+// src/extensions/comments/comments-decorations.ts
+var PENDING = { class: "quoin-comment-pending" };
+var ACTIVE = { class: "quoin-comment-active" };
+var inline = (ranges, attrs) => ranges.map((range) => ({ kind: "inline", ...range, attrs }));
+var drawn = /* @__PURE__ */ new WeakMap();
+function commentsDecorations(state) {
+  const value = _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, commentsKey);
+  const last = drawn.get(value);
+  if (_optionalChain([last, 'optionalAccess', _90 => _90.doc]) === state.doc) return last.decorations;
+  const active = value.active === null ? [] : _nullishCoalesce(commentAnchors(state.doc).get(value.active), () => ( []));
+  const decorations = [...value.pending.flatMap(({ ranges }) => inline(ranges, PENDING)), ...inline(active, ACTIVE)];
+  drawn.set(value, { doc: state.doc, decorations });
+  return decorations;
+}
+
+// src/extensions/comments/comments-extension.tsx
+
+var commentItem = (labels) => ({
+  id: "comment",
+  title: labels.comment,
+  icon: _lucidereact.MessageSquarePlus,
+  shortcut: "Mod-Alt-m",
+  available: (state) => hasCommentableText(state) && _chunkPZ4GT5JOcjs.getPluginState.call(void 0, state, commentsKey).pending.length === 0,
+  // Focus goes back to the text first: the button leaves the toolbar while the thread is being asked for.
+  run: (controller) => {
+    controller.focus();
+    controller.run(requestComment);
+  }
+});
+function commentsExtension(options) {
+  const { labels: overrides, ...host } = options;
+  const labels = resolveCommentsLabels(overrides);
+  function Overlay({ controller }) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CommentsOverlay, { controller, host, labels });
+  }
+  const ui = { bubbleItems: [commentItem(labels)], overlays: [Overlay] };
+  return _chunkPZ4GT5JOcjs.defineExtension.call(void 0, {
+    name: "comments",
+    plugins: [commentsPlugin],
+    decorations: commentsDecorations,
+    keymap: { "Mod-Alt-m": commentCommand(host.threads) },
+    // One watcher per editor however many views mount it at once, so the host is asked once per thread.
+    onMount(editor) {
+      const link = linkOf(editor);
+      if (link.mounts++ === 0) link.stopWatching = watchCreates(editor, host.onCreate, link);
+      return () => {
+        if (--link.mounts > 0) return;
+        _optionalChain([link, 'access', _91 => _91.stopWatching, 'optionalCall', _92 => _92()]);
+        link.stopWatching = null;
+      };
+    },
+    ui
+  });
+}
+
+// src/extensions/comments/comment-threads.ts
+var NO_THREADS = [];
+function createCommentThreads(initial = NO_THREADS) {
+  let threads = initial;
+  let byId = null;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => threads,
+    set(next) {
+      if (next === threads) return;
+      threads = next;
+      byId = null;
+      for (const listener of [...listeners]) listener();
+    },
+    find(id) {
+      byId ??= new Map(threads.map((thread) => [thread.id, thread]));
+      return byId.get(id);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+
+
+
+exports.commentsExtension = commentsExtension; exports.createCommentThreads = createCommentThreads; exports.englishCommentsLabels = englishCommentsLabels;
+//# sourceMappingURL=comments.cjs.map