@inkandswitch/patchwork-pkg-base 0.0.7 → 0.0.8

package/packages/comments-view/dist/assets/main-C8GVksuY.js

@@ -0,0 +1,2973 @@
+(function() {
+  "use strict";
+  try {
+    if (typeof document != "undefined") {
+      var elementStyle = document.createElement("style");
+      elementStyle.appendChild(document.createTextNode("@layer package {\n:root,\n:host,\n[theme] {\n  --comments-fg: var(--text-editor-line, var(--studio-line, black));\n  --comments-muted-fg: var(--studio-line-offset-50, #999);\n  --comments-bg: var(--text-editor-fill, var(--studio-fill, white));\n  --comments-border: var(--studio-fill-offset-20, #ccc);\n  --comments-hover-bg: var(--studio-fill-offset-10, #f5f5f5);\n  --comments-font: var(--studio-family-sans, system-ui, sans-serif);\n  --comments-accent: var(--studio-secondary, #33ccf8);\n}\n}\n\n/* The width:100% boxes below (panel, textarea) also carry padding and a\n   border, so without border-box they extend past their container and overflow\n   it. Scoped to the panel and the thread card so the injected stylesheet never\n   touches the host page (it may be injected into document.head, not a shadow\n   root). The card is covered on its own because a single thread renders\n   standalone too — e.g. in the editor's comment popover, with no panel around\n   it — and its draft textarea would otherwise spill out of the card. */\n.comments-panel,\n.comments-panel *,\n.comments-panel *::before,\n.comments-panel *::after,\n.comments-thread-card,\n.comments-thread-card *,\n.comments-thread-card *::before,\n.comments-thread-card *::after {\n  box-sizing: border-box;\n}\n\n.comments-panel {\n  height: 100%;\n  width: 100%;\n  overflow: auto;\n  display: flex;\n  flex-direction: column;\n  padding: 0.5rem;\n  gap: 0.5rem;\n  font-family: var(--comments-font);\n  color: var(--comments-fg);\n}\n\n.comments-panel-header {\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n  font-size: 0.75rem;\n  color: var(--comments-muted-fg);\n}\n\n.comments-panel-header-title {\n  font-weight: 500;\n}\n\n.comments-empty {\n  flex: 1;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  padding: 1.5rem 0.5rem;\n  text-align: center;\n  font-size: 0.875rem;\n  color: var(--comments-muted-fg);\n}\n\n.comments-thread {\n  display: flex;\n  flex-direction: column;\n  gap: 0.5rem;\n}\n\n/* The thread's card + actions are rendered by the `comment-thread` tool into\n   its <patchwork-view> host, so that host is the flex column that lays them\n   out (a custom element is `display: inline` by default). */\n.comments-thread > patchwork-view {\n  display: flex;\n  flex-direction: column;\n  gap: 0.5rem;\n}\n\n.comments-thread-card {\n  background: var(--comments-bg);\n  border: 1px solid var(--comments-border);\n  padding: 0.5rem;\n  display: flex;\n  flex-direction: column;\n  gap: 0.5rem;\n  cursor: pointer;\n  transition: box-shadow 0.15s ease;\n}\n\n.comments-thread-card--primary {\n  box-shadow:\n    0 10px 15px -3px rgb(0 0 0 / 0.1),\n    0 4px 6px -4px rgb(0 0 0 / 0.1);\n}\n\n.comments-thread-card--secondary {\n  box-shadow:\n    0 4px 6px -1px rgb(0 0 0 / 0.1),\n    0 2px 4px -2px rgb(0 0 0 / 0.1);\n}\n\n.comments-thread-card--inactive {\n  box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);\n}\n\n/* Resolved threads are hidden in the sidebar but shown when embedded. Keep\n   them clearly readable, just visibly \"settled\": muted fill, dashed border,\n   and slightly dimmed so they read as archived rather than active. */\n.comments-thread-card--resolved {\n  background: var(--comments-hover-bg);\n  border-style: dashed;\n  opacity: 0.75;\n}\n\n.comments-thread-resolved-label {\n  align-self: flex-start;\n  font-size: 0.6875rem;\n  font-weight: 500;\n  text-transform: uppercase;\n  letter-spacing: 0.03em;\n  padding: 0.0625rem 0.375rem;\n  border-radius: 0.625rem;\n  color: var(--comments-muted-fg);\n  border: 1px solid var(--comments-border);\n}\n\n.comments-thread-card-body {\n  display: flex;\n  flex-direction: column;\n  gap: 0.5rem;\n}\n\n.comments-thread-doc-level {\n  font-size: 0.6875rem;\n  text-transform: uppercase;\n  letter-spacing: 0.03em;\n  color: var(--comments-muted-fg);\n}\n\n.comments-thread-header {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n}\n\n.comments-thread-actions {\n  display: flex;\n  flex-direction: row;\n  gap: 0.5rem;\n  justify-content: flex-end;\n}\n\n.comment-card {\n  display: flex;\n  flex-direction: column;\n  gap: 0.5rem;\n}\n\n.comment-header {\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  align-items: center;\n}\n\n.comment-author {\n  display: flex;\n  flex-direction: row;\n  gap: 0.5rem;\n  align-items: center;\n}\n\n.comment-author-name {\n  font-size: 0.875rem;\n  font-weight: 500;\n  white-space: nowrap;\n  color: var(--comments-fg);\n}\n\n.comment-timestamp {\n  font-size: 0.75rem;\n  color: var(--comments-muted-fg);\n}\n\n.comment-content {\n  font-size: 1rem;\n  color: var(--comments-fg);\n  white-space: pre-wrap;\n  overflow-wrap: break-word;\n}\n\n/* The draft editor is a cute.txt (CodeMirror) instance; box it like the old\n   textarea. Its inner padding/font come from the injected cute.txt styles. */\n.comment-draft-editor {\n  height: 6rem;\n  min-height: 6rem;\n  border: 1px solid var(--comments-border);\n  border-radius: 0.5rem;\n  color: var(--comments-fg);\n  background: var(--comments-bg);\n  overflow: hidden;\n}\n\n.comment-draft-editor .cm-content {\n  box-sizing: border-box;\n  min-height: 100%;\n}\n\n.comment-draft-editor .cm-scroller {\n  height: 100%;\n}\n\n.comment-draft-editor:focus-within {\n  outline: 2px solid var(--comments-accent);\n  outline-offset: 1px;\n}\n\n.comment-btn {\n  padding: 0.25rem 0.5rem;\n  border-radius: 0.25rem;\n  font-family: inherit;\n  font-size: 0.875rem;\n  cursor: pointer;\n  border: none;\n  background: transparent;\n  color: var(--comments-fg);\n}\n\n.comment-btn:hover {\n  background: var(--comments-hover-bg);\n}"));
+      document.head.appendChild(elementStyle);
+    }
+  } catch (e) {
+    console.error("vite-plugin-css-injected-by-js", e);
+  }
+})();
+import { insert, createComponent, getOwner, effect, setAttribute, template, delegateEvents, className, memo, use, render } from "solid-js/web";
+import { onCleanup, createMemo, createContext, useContext, createResource, createEffect, createSignal, onMount, Show, For } from "solid-js";
+import { createStore, reconcile, produce } from "solid-js/store";
+import { applyPatches } from "@automerge/automerge/slim";
+import "@automerge/automerge-repo";
+import { c as createDocumentThread, a as createReply } from "./comments-D9lwpHOh.js";
+import { StateField, Prec, Annotation } from "@codemirror/state";
+import { EditorView, keymap, Decoration, WidgetType, ViewPlugin } from "@codemirror/view";
+import * as am from "@automerge/automerge";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var browser = { exports: {} };
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
+}
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = requireMs();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug2(...args) {
+        if (!debug2.enabled) {
+          return;
+        }
+        const self = debug2;
+        const curr = Number(/* @__PURE__ */ new Date());
+        const ms2 = curr - (prevTime || curr);
+        self.diff = ms2;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug2.namespace = namespace;
+      debug2.useColors = createDebug.useColors();
+      debug2.color = createDebug.selectColor(namespace);
+      debug2.extend = extend;
+      debug2.destroy = createDebug.destroy;
+      Object.defineProperty(debug2, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug2);
+      }
+      return debug2;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template2) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template2.length && (template2[templateIndex] === search[searchIndex] || template2[templateIndex] === "*")) {
+          if (template2[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template2.length && template2[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template2.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  common = setup;
+  return common;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function(module, exports) {
+    var define_process_env_default = {};
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = define_process_env_default.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = requireCommon()(exports);
+    const { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+var browserExports = requireBrowser();
+const debug = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+var log = debug("cabbages");
+function pojo(target) {
+  return typeof target == "object" && typeof target != null && Object.getPrototypeOf(target) == Object.prototype;
+}
+var BLOCK_MARKER = "";
+function apply(target, ...rest) {
+  if (rest.length == 0) {
+    log("empty patch");
+    return;
+  }
+  const [path, range, val] = rest;
+  let p = [...path];
+  while (true) {
+    let key = p.shift();
+    if (!p.length) {
+      const RANGE_ARRAY = Array.isArray(range);
+      if (pojo(target) && RANGE_ARRAY && typeof key == "undefined" && typeof range[0] == "string") {
+        delete target[range[0]];
+        return;
+      }
+      if (RANGE_ARRAY || typeof range == "number") {
+        if (typeof key == "undefined") {
+          throw new Error("cant treat top level as a seq");
+        }
+        key = key;
+        let [start, end] = Array.isArray(range) ? range : [range, range + 1];
+        const ZERO_LENGTH = Array.isArray(range) && range.length == 0;
+        if (!ZERO_LENGTH && (start == null || end == null)) {
+          throw new RangeError("it's all or nothing, no half measures");
+        }
+        const DELETE = typeof val == "undefined";
+        const INSERT = start === end && !DELETE;
+        const APPEND = ZERO_LENGTH && !DELETE;
+        const REPLACE = !INSERT && !DELETE && !APPEND;
+        if (typeof target[key] == "undefined") {
+          if (typeof target == "string") {
+            return;
+          } else if (typeof val == "string") {
+            target[key] = "";
+          } else {
+            target[key] = [];
+          }
+        }
+        let seq = target[key];
+        if (Array.isArray(seq)) {
+          if (APPEND) {
+            Array.isArray(val) ? seq.push(...val) : seq.push(val);
+            return;
+          }
+          if (INSERT || REPLACE) {
+            Array.isArray(val) ? seq.splice(start, end - start, ...val) : seq.splice(start, end - start, val);
+            return;
+          }
+          if (DELETE) {
+            seq.splice(start, end - start);
+            return;
+          }
+          throw new Error("i don't know what happened");
+        }
+        if (typeof seq == "string") {
+          if (APPEND) {
+            target[key] = seq + val;
+            return;
+          }
+          if (REPLACE || INSERT) {
+            target[key] = seq.slice(0, start) + (typeof val == "string" ? val : val.map(
+              (n) => typeof n == "string" ? n : BLOCK_MARKER
+            ).join("")) + seq.slice(end);
+            return;
+          }
+          if (DELETE) {
+            target[key] = seq.slice(0, start) + seq.slice(end);
+            return;
+          }
+          throw new Error("i don't know what happened");
+        }
+        if (pojo(seq) && RANGE_ARRAY && typeof range[0] == "string") {
+          delete seq[range[0]];
+          return;
+        }
+        throw new Error("not implemented");
+      }
+      if (typeof key == "undefined") {
+        if (typeof range != "string") {
+          throw new Error(`can't index top-level map with ${range}`);
+        }
+        if (typeof val == "undefined") {
+          delete target[range];
+        } else {
+          target[range] = val;
+        }
+        return;
+      }
+      if (typeof target[key] == "undefined") {
+        target[key] = {};
+      }
+      if (RANGE_ARRAY) {
+        let [a, b] = range;
+        if (a != null && b != null) {
+          if (typeof val == "undefined" && a != null && b != null) {
+            delete target[key][a || b];
+          } else {
+            target[key][a || b] = val;
+          }
+        }
+      } else {
+        if (typeof val == "undefined") {
+          delete target[key][range];
+        } else if (typeof target[key] == "string") {
+          return;
+        } else {
+          target[key][range] = val;
+        }
+      }
+      return;
+    }
+    if (typeof key == "undefined") {
+      throw new Error("cant treat top level as a seq");
+    }
+    key = key;
+    let nextkey = p[0];
+    if (typeof target[key] == "undefined") {
+      if (typeof nextkey == "string") {
+        target[key] = {};
+      } else if (typeof nextkey == "number") {
+        target[key] = [];
+      } else {
+        throw new Error(`can't go down this road ${target}.${key}.${nextkey}`);
+      }
+    }
+    target = target[key];
+  }
+}
+function get(obj, key) {
+  for (let p = 0; p < key.length; p++) {
+    obj = obj ? obj[key[p]] : void 0;
+  }
+  return obj;
+}
+function fromAutomerge(autopatch, payload) {
+  const path = autopatch.path.slice(0, -1);
+  const key = autopatch.path[autopatch.path.length - 1];
+  switch (autopatch.action) {
+    case "mark":
+    case "unmark":
+      log(
+        `skipping ${autopatch.action} because it doesn't affect material reality`
+      );
+      return [];
+    case "inc":
+      if (payload) {
+        return [path, key, get(payload.patchInfo.after, autopatch.path)];
+      } else {
+        throw new Error(
+          `can't apply ${autopatch.action} without payload argument`
+        );
+      }
+    case "conflict":
+      if (payload) {
+        return [path, key, get(payload.patchInfo.after, autopatch.path)];
+      } else {
+        throw new Error(
+          `can't apply ${autopatch.action} without payload argument`
+        );
+      }
+    case "del": {
+      return typeof key == "string" ? [path, key] : [path, [key, key + (autopatch.length || 1)]];
+    }
+    case "insert": {
+      return [path, [key, key], autopatch.values];
+    }
+    case "splice": {
+      return [path, [key, key], [autopatch.value]];
+    }
+    case "put": {
+      return [path, key, autopatch.value];
+    }
+  }
+}
+function autoproduce$1(payload) {
+  return (doc) => {
+    for (let patch of payload.patches) {
+      apply(doc, ...fromAutomerge(patch, payload));
+    }
+  };
+}
+const cache$1 = /* @__PURE__ */ new WeakMap();
+function makeDocumentProjection$1(handle) {
+  onCleanup(() => {
+    const item = cache$1.get(handle);
+    if (!item) return;
+    if (!item.refs--) {
+      item.cleanup();
+    }
+  });
+  if (cache$1.has(handle)) {
+    const item = cache$1.get(handle);
+    item.refs++;
+    return item.store;
+  }
+  const [doc, set] = createStore(handle.doc());
+  cache$1.set(handle, {
+    refs: 0,
+    store: doc,
+    cleanup() {
+      handle.off("change", patch);
+      handle.off("delete", ondelete);
+      cache$1.delete(handle);
+    }
+  });
+  function patch(payload) {
+    if (payload.scopeReplaced) {
+      set(reconcile(payload.doc ?? {}));
+      return;
+    }
+    set(produce(autoproduce$1(payload)));
+  }
+  function ondelete() {
+    set(reconcile({}));
+  }
+  handle.on("change", patch);
+  handle.on("delete", ondelete);
+  handle.whenReady().then(() => {
+    set(handle.doc());
+  });
+  return doc;
+}
+const access = (v) => typeof v === "function" && !v.length ? v() : v;
+function createDocumentProjection$1(handle) {
+  const projection = createMemo(
+    () => access(handle) && makeDocumentProjection$1(access(handle))
+  );
+  return projection;
+}
+const RepoContext = createContext(
+  null
+);
+function useDocHandle(url, options) {
+  const contextRepo = useContext(RepoContext);
+  if (!options?.repo && !contextRepo) {
+    throw new Error("use outside <RepoContext> requires options.repo");
+  }
+  const repo = options?.repo || contextRepo;
+  function getExistingHandle() {
+    if (options?.["~skipInitialValue"]) return void 0;
+    const unwrappedURL = access(url);
+    if (!unwrappedURL) return void 0;
+    const state = repo.findWithProgress(unwrappedURL).peek();
+    return state.state === "ready" ? state.handle : void 0;
+  }
+  const [handle, { mutate }] = createResource(
+    url,
+    (url2) => repo.findWithProgress(url2).whenReady(),
+    {
+      initialValue: getExistingHandle()
+    }
+  );
+  createEffect(() => {
+    if (!access(url)) {
+      mutate();
+    }
+  });
+  return handle;
+}
+function useDocument(url, options) {
+  const handle = useDocHandle(url, options);
+  return [createDocumentProjection$1(handle), handle];
+}
+function useRepo() {
+  const repo = useContext(RepoContext);
+  if (!repo) throw new Error("Please wrap me in a <RepoContext value={repo}>");
+  return repo;
+}
+const STYLE = `
+@layer cutetxt {
+.cutetxt-tool,
+.cutetxt-editor,
+.cutetxt-rendered,
+.cutetxt-autocomplete {
+  --cutetxt-bg: Canvas;
+  --cutetxt-fg: currentColor;
+  --cutetxt-transparent: transparent;
+  --cutetxt-link: var(--link, currentColor);
+  --cutetxt-code-bg: color-mix(in srgb, var(--cutetxt-fg) 10%, var(--cutetxt-transparent));
+  --cutetxt-spoiler-bg: currentColor;
+  --cutetxt-spoiler-revealed-bg: color-mix(in srgb, var(--cutetxt-fg) 12%, var(--cutetxt-transparent));
+  --cutetxt-embed-bg: var(--cutetxt-bg);
+  --cutetxt-embed-border: color-mix(in srgb, var(--cutetxt-fg) 18%, var(--cutetxt-transparent));
+  --cutetxt-embed-bar-bg: color-mix(in srgb, var(--cutetxt-fg) 5%, var(--cutetxt-bg));
+  --cutetxt-embed-bar-border: color-mix(in srgb, var(--cutetxt-fg) 12%, var(--cutetxt-transparent));
+  --cutetxt-embed-bar-fg: color-mix(in srgb, var(--cutetxt-fg) 72%, var(--cutetxt-transparent));
+  --cutetxt-embed-handle: color-mix(in srgb, var(--cutetxt-fg) 38%, var(--cutetxt-transparent));
+  --cutetxt-embed-handle-active: color-mix(in srgb, var(--cutetxt-fg) 62%, var(--cutetxt-transparent));
+  --cutetxt-control-bg: color-mix(in srgb, var(--cutetxt-bg) 85%, var(--cutetxt-fg) 4%);
+  --cutetxt-control-border: color-mix(in srgb, var(--cutetxt-fg) 20%, var(--cutetxt-transparent));
+  --cutetxt-control-fg: color-mix(in srgb, var(--cutetxt-fg) 70%, var(--cutetxt-transparent));
+  --cutetxt-menu-bg: var(--cutetxt-bg);
+  --cutetxt-menu-border: color-mix(in srgb, var(--cutetxt-fg) 15%, var(--cutetxt-transparent));
+  --cutetxt-menu-shadow: color-mix(in srgb, var(--cutetxt-fg) 20%, var(--cutetxt-transparent));
+  --cutetxt-hover-bg: color-mix(in srgb, var(--cutetxt-fg) 10%, var(--cutetxt-transparent));
+  --cutetxt-codeblock-bg: color-mix(in srgb, var(--cutetxt-fg) 8%, var(--cutetxt-transparent));
+  --cutetxt-think-border: color-mix(in srgb, var(--cutetxt-fg) 25%, var(--cutetxt-transparent));
+  --cutetxt-think-fg: color-mix(in srgb, var(--cutetxt-fg) 65%, var(--cutetxt-transparent));
+  --cutetxt-popup-shadow: color-mix(in srgb, var(--cutetxt-fg) 25%, var(--cutetxt-transparent));
+  --cutetxt-active-bg: color-mix(in srgb, var(--cutetxt-fg) 12%, var(--cutetxt-transparent));
+}
+.cutetxt-tool { display: block; height: 100%; }
+.cutetxt-editor { height: 100%; }
+
+.cutetxt-editor .cm-editor { height: 100%; }
+.cutetxt-editor .cm-content {
+  font: 15px/1.55 system-ui, sans-serif;
+  padding: 12px 14px;
+  caret-color: currentColor;
+}
+.cutetxt-editor .cm-editor.cm-focused { outline: none; }
+.cutetxt-editor .cm-scroller { font-family: inherit; }
+
+/* Marks rendered by tagName (strong/em/u/s) inherit browser defaults; these two
+   need classes. */
+.cutetxt-code {
+  font-family: ui-monospace, monospace;
+  font-size: 0.9em;
+  background: var(--cutetxt-code-bg);
+  padding: 0.1em 0.3em;
+  border-radius: 4px;
+}
+.cutetxt-spoiler {
+  background: var(--cutetxt-spoiler-bg);
+  border-radius: 3px;
+  transition: color 0.1s;
+  cursor: pointer;
+}
+.cutetxt-spoiler:not(.cutetxt-spoiler--revealed) {
+  color: transparent;
+}
+.cutetxt-spoiler--revealed { background: var(--cutetxt-spoiler-revealed-bg); }
+
+.cutetxt-underline-em { text-decoration: underline; font-style: italic; }
+.cutetxt-inverted { filter: invert(1); }
+.cutetxt-editor a, .cutetxt-rendered a { color: var(--cutetxt-link); }
+
+/* Block atoms: embeds, code fences, think blocks. */
+.cutetxt-block {
+  display: block;
+  margin: 6px 0;
+}
+.cutetxt-block { position: relative; }
+.cutetxt-block > patchwork-view,
+.cutetxt-block > img { display: block; max-width: 100%; }
+
+.cutetxt-embed {
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  width: min(100%, 640px);
+  min-width: 160px;
+  min-height: 120px;
+  max-width: 100%;
+  margin-right: 2px;
+  margin-bottom: 2px;
+  overflow: visible;
+  border: 1px solid var(--cutetxt-embed-border);
+  border-radius: 7px;
+  background: var(--cutetxt-embed-bg);
+}
+.cutetxt-embed-bar {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 27px;
+  padding: 3px 5px 3px 9px;
+  border-bottom: 1px solid var(--cutetxt-embed-bar-border);
+  background: var(--cutetxt-embed-bar-bg);
+  color: var(--cutetxt-embed-bar-fg);
+  font: 12px/1.3 system-ui, sans-serif;
+  user-select: none;
+  cursor: text;
+}
+.cutetxt-embed-title {
+  min-width: 0;
+  flex: 1 1 auto;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.cutetxt-embed-actions {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+  margin-left: auto;
+  padding-right: 7px;
+  flex: 0 0 auto;
+  min-width: max-content;
+}
+.cutetxt-embed-icon {
+  box-sizing: border-box;
+  min-width: 22px;
+  height: 22px;
+  padding: 0 6px;
+  border: 1px solid var(--cutetxt-control-border);
+  border-radius: 999px;
+  background: var(--cutetxt-control-bg);
+  color: var(--cutetxt-control-fg);
+  cursor: pointer;
+  font: 11px/1 system-ui, sans-serif;
+}
+.cutetxt-embed-icon:hover,
+.cutetxt-embed-icon:focus {
+  color: var(--cutetxt-fg);
+}
+.cutetxt-embed-delete {
+  position: relative;
+  right: -7px;
+  width: 22px;
+  min-width: 22px;
+  padding: 0;
+  border-radius: 999px;
+  font-weight: 600;
+}
+.cutetxt-embed-body {
+  min-height: 88px;
+  flex: 1 1 auto;
+  overflow: auto;
+  border-radius: 0 0 7px 7px;
+}
+.cutetxt-embed-body > patchwork-view,
+.cutetxt-embed-body > img {
+  display: block;
+  max-width: 100%;
+}
+.cutetxt-embed-resize {
+  position: absolute;
+  right: -5px;
+  bottom: -5px;
+  width: 16px;
+  height: 16px;
+  cursor: nwse-resize;
+  touch-action: none;
+}
+.cutetxt-embed-resize::before {
+  content: "";
+  position: absolute;
+  right: 3px;
+  bottom: 3px;
+  width: 9px;
+  height: 9px;
+  border-right: 3px solid var(--cutetxt-embed-handle);
+  border-bottom: 3px solid var(--cutetxt-embed-handle);
+  border-radius: 0 0 2px 0;
+}
+.cutetxt-embed:hover .cutetxt-embed-resize::before,
+.cutetxt-embed.is-resizing .cutetxt-embed-resize::before {
+  border-color: var(--cutetxt-embed-handle-active);
+}
+.cutetxt-embed.is-resizing {
+  user-select: none;
+}
+
+/* Tool-picker on embed widgets: a small "▾ tool" control + dropdown menu. */
+.cutetxt-embed-picker { position: relative; z-index: 2; flex: none; }
+.cutetxt-embed-tool {
+  font: 11px/1.4 system-ui, sans-serif;
+  padding: 2px 6px;
+  max-width: 88px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  border-radius: 5px;
+  border: 1px solid var(--cutetxt-control-border);
+  background: var(--cutetxt-control-bg);
+  color: var(--cutetxt-control-fg);
+  cursor: pointer;
+  opacity: 0.75;
+  transition: opacity 0.1s;
+}
+.cutetxt-embed:hover .cutetxt-embed-tool,
+.cutetxt-embed-tool:focus { opacity: 1; }
+.cutetxt-embed-menu {
+  position: absolute;
+  top: calc(100% + 3px);
+  right: 0;
+  min-width: 120px;
+  padding: 4px;
+  border-radius: 7px;
+  border: 1px solid var(--cutetxt-menu-border);
+  background: var(--cutetxt-menu-bg);
+  box-shadow: 0 4px 16px var(--cutetxt-menu-shadow);
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  font: 12px/1.4 system-ui, sans-serif;
+}
+.cutetxt-embed-menu-item {
+  text-align: left;
+  padding: 4px 8px;
+  border: none;
+  border-radius: 4px;
+  background: none;
+  color: inherit;
+  cursor: pointer;
+}
+.cutetxt-embed-menu-item:hover { background: var(--cutetxt-hover-bg); }
+.cutetxt-embed-menu-item.is-current { font-weight: 600; }
+
+.cutetxt-codeblock {
+  margin: 0;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: var(--cutetxt-codeblock-bg);
+  overflow-x: auto;
+  font: 13px/1.5 ui-monospace, monospace;
+}
+
+.cutetxt-think {
+  padding: 8px 12px;
+  border-left: 3px solid var(--cutetxt-think-border);
+  color: var(--cutetxt-think-fg);
+  font-style: italic;
+  white-space: pre-wrap;
+}
+
+/* Inline replaces: emoji, etc. */
+.cutetxt-replace { display: inline; }
+.cutetxt-emoji { font-style: normal; }
+
+/* Autocomplete popup (appended to <body>, positioned fixed at the caret). */
+.cutetxt-autocomplete {
+  position: fixed;
+  z-index: 30;
+  min-width: 150px;
+  max-height: 220px;
+  overflow-y: auto;
+  padding: 4px;
+  border-radius: 8px;
+  border: 1px solid var(--cutetxt-menu-border);
+  background: var(--cutetxt-menu-bg);
+  box-shadow: 0 6px 20px var(--cutetxt-popup-shadow);
+  font: 13px/1.4 system-ui, sans-serif;
+}
+.cutetxt-ac-item {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  padding: 4px 8px;
+  border-radius: 5px;
+  cursor: pointer;
+}
+.cutetxt-ac-item.is-active { background: var(--cutetxt-active-bg); }
+.cutetxt-ac-icon { width: 1.2em; height: 1.2em; object-fit: contain; text-align: center; flex: none; }
+.cutetxt-ac-desc { opacity: 0.7; }
+.cutetxt-ac-detail { margin-left: auto; opacity: 0.7; }
+}
+`;
+function autoproduce(payload) {
+  return (doc) => applyPatches(doc, payload.patches);
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function initial(handle) {
+  const template2 = {};
+  applyPatches(template2, handle.diff([], handle.heads()));
+  return template2;
+}
+function makeDocumentProjection(handle) {
+  onCleanup(() => {
+    const item = cache.get(handle);
+    if (!item) return;
+    if (!item.refs--) item.cleanup();
+  });
+  if (cache.has(handle)) {
+    const item = cache.get(handle);
+    item.refs++;
+    return item.store;
+  }
+  const [doc, set] = createStore(initial(handle));
+  cache.set(handle, {
+    refs: 0,
+    store: doc,
+    cleanup() {
+      handle.off("change", patch);
+      handle.off("delete", ondelete);
+      cache.delete(handle);
+    }
+  });
+  function patch(payload) {
+    if (payload.scopeReplaced) {
+      set(reconcile(payload.doc ?? {}));
+      return;
+    }
+    set(produce(autoproduce(payload)));
+  }
+  function ondelete() {
+    set(reconcile({}));
+  }
+  handle.on("change", patch);
+  handle.on("delete", ondelete);
+  return doc;
+}
+function createDocumentProjection(handle) {
+  return createMemo(() => {
+    const unwrappedHandle = typeof handle == "function" ? handle() : handle;
+    return unwrappedHandle && makeDocumentProjection(unwrappedHandle);
+  });
+}
+createContext(null);
+function subscribe$2(element, selector, listener) {
+  const view = element.closest("patchwork-view");
+  const dispatchEl = view ?? element;
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  const controller = new AbortController();
+  const { signal } = controller;
+  port.addEventListener("message", (event) => {
+    if (event.data?.type === "change")
+      listener(event.data.value);
+  }, { signal });
+  port.start();
+  const detail = {
+    selector,
+    port: channel.port1
+  };
+  dispatchEl.dispatchEvent(new CustomEvent("patchwork:subscribe", {
+    detail,
+    bubbles: true,
+    composed: true
+  }));
+  return () => {
+    if (signal.aborted)
+      return;
+    controller.abort();
+    port.postMessage({ type: "unsubscribe" });
+    port.close();
+  };
+}
+function resolveElement(source) {
+  return typeof source === "function" ? source() : source;
+}
+function subscribe$1(element, selector, initialValue) {
+  const [value, setValue] = createSignal(initialValue);
+  onMount(() => {
+    const target = resolveElement(element);
+    if (!target)
+      return;
+    const unsubscribe = subscribe$2(target, selector, setValue);
+    onCleanup(unsubscribe);
+  });
+  return value;
+}
+function subscribeDoc(element, selector) {
+  const [handle, setHandle] = createSignal(void 0);
+  onMount(() => {
+    const target = resolveElement(element);
+    if (!target)
+      return;
+    let canceled = false;
+    const unsubscribe = subscribe$2(target, selector, (url) => {
+      if (!url)
+        return;
+      const repo = "repo" in window ? window.repo : void 0;
+      if (!repo)
+        return;
+      void Promise.resolve(repo.find(url)).then((h) => {
+        if (canceled)
+          return;
+        setHandle(() => h);
+      });
+    });
+    onCleanup(() => {
+      canceled = true;
+      unsubscribe();
+    });
+  });
+  const doc = createDocumentProjection(handle);
+  return [doc, handle];
+}
+function subscribe(element, selector, listener) {
+  const view = element.closest("patchwork-view");
+  const dispatchEl = view ?? element;
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  const controller = new AbortController();
+  const { signal } = controller;
+  port.addEventListener("message", (event) => {
+    if (event.data?.type === "change")
+      listener(event.data.value);
+  }, { signal });
+  port.start();
+  const detail = {
+    selector,
+    port: channel.port1
+  };
+  dispatchEl.dispatchEvent(new CustomEvent("patchwork:subscribe", {
+    detail,
+    bubbles: true,
+    composed: true
+  }));
+  return () => {
+    if (signal.aborted)
+      return;
+    controller.abort();
+    port.postMessage({ type: "unsubscribe" });
+    port.close();
+  };
+}
+var _tmpl$$1 = /* @__PURE__ */ template(`<button class=comment-btn title="Comment on this document">Add comment`), _tmpl$2$1 = /* @__PURE__ */ template(`<div class=comments-panel><div class=comments-panel-header><span class=comments-panel-header-title>Comments`), _tmpl$3$1 = /* @__PURE__ */ template(`<div class=comments-empty>No comments yet`), _tmpl$4$1 = /* @__PURE__ */ template(`<div class=comments-thread><patchwork-view tool-id=comment-thread>`, true, false, false);
+function CommentsView(props) {
+  const repo = useRepo();
+  const selectedDocUrls = subscribe$1(props.element, {
+    type: "patchwork:selected-doc"
+  }, []);
+  const targetDocUrl = () => selectedDocUrls()[0];
+  const commentEntries = useScopedCommentEntries(props.element, targetDocUrl);
+  const [focusDoc, focusHandle] = subscribeDoc(props.element, {
+    type: "patchwork:focus"
+  });
+  const [, contactHandle] = subscribeDoc(props.element, {
+    type: "patchwork:contact"
+  });
+  const currentContactUrl = () => contactHandle()?.url;
+  const threadUrls = createMemo(() => {
+    const entries = commentEntries();
+    const threadUrls2 = /* @__PURE__ */ new Set();
+    for (const {
+      threadUrl
+    } of entries) {
+      threadUrls2.add(threadUrl);
+    }
+    return Array.from(threadUrls2);
+  });
+  const threadTargetUrlMap = createMemo(() => {
+    const entries = commentEntries();
+    const map = /* @__PURE__ */ new Map();
+    for (const {
+      targetUrl,
+      threadUrl
+    } of entries) {
+      const existing = map.get(threadUrl);
+      if (existing) {
+        if (!existing.includes(targetUrl)) existing.push(targetUrl);
+      } else {
+        map.set(threadUrl, [targetUrl]);
+      }
+    }
+    return map;
+  });
+  const selectedHandles = useResolvedHandles(() => Object.keys(focusDoc()?.selection ?? {}), repo);
+  const threadTargetHandleMap = useResolvedHandleMap(threadTargetUrlMap, repo);
+  const threadsWithVisibleTarget = useThreadsWithVisibleTarget(threadTargetUrlMap, repo);
+  const renderableThreadUrls = createMemo(() => threadUrls().filter((url) => threadsWithVisibleTarget().has(url)));
+  const docLevelThreadUrls = createMemo(() => {
+    const map = threadTargetUrlMap();
+    const set = /* @__PURE__ */ new Set();
+    for (const [threadUrl, targets] of map) {
+      if (targets.length > 0 && targets.every((t) => !t.includes("/") && !t.includes("#"))) {
+        set.add(threadUrl);
+      }
+    }
+    return set;
+  });
+  const displayedThreadUrls = createMemo(() => threadUrls().filter((url) => threadsWithVisibleTarget().has(url) || docLevelThreadUrls().has(url)));
+  const overlappingThreads = createMemo(() => renderableThreadUrls().filter((url) => threadOverlapsSelection(threadTargetHandleMap().get(url) ?? [], selectedHandles())));
+  const [pinnedThread, setPinnedThread] = createSignal();
+  const primaryThreadUrl = createMemo(() => {
+    const pinned = pinnedThread();
+    if (pinned && docLevelThreadUrls().has(pinned)) return pinned;
+    const overlaps = overlappingThreads();
+    if (overlaps.length === 0) return void 0;
+    if (pinned && overlaps.includes(pinned)) return pinned;
+    return overlaps[0];
+  });
+  const secondaryThreadUrls = createMemo(() => {
+    const p = primaryThreadUrl();
+    return new Set(overlappingThreads().filter((u) => u !== p));
+  });
+  createEffect(() => {
+    const handle = focusHandle();
+    if (!handle) return;
+    const p = primaryThreadUrl();
+    const urls = p ? threadTargetUrlMap().get(p) ?? [] : [];
+    const desired = {};
+    for (const u of urls) desired[u] = true;
+    handle.change((doc) => {
+      doc.highlight = desired;
+    });
+  });
+  const onSelectThread = (threadUrl, targetUrls) => {
+    const handle = focusHandle();
+    if (!handle) return;
+    const wasPrimary = primaryThreadUrl() === threadUrl;
+    setPinnedThread(wasPrimary ? void 0 : threadUrl);
+    const next = {};
+    if (!wasPrimary) for (const u of targetUrls) next[u] = true;
+    handle.change((doc) => {
+      doc.selection = next;
+    });
+  };
+  const onClickThreadCard = (e, threadUrl) => {
+    const target = e.target;
+    if (target?.closest("textarea, button, input, a, select, .cm-editor")) return;
+    onSelectThread(threadUrl, threadTargetUrlMap().get(threadUrl) ?? []);
+  };
+  const threadState = (threadUrl) => primaryThreadUrl() === threadUrl ? "primary" : secondaryThreadUrls().has(threadUrl) ? "secondary" : "inactive";
+  onCleanup(() => {
+    const handle = focusHandle();
+    if (!handle) return;
+    handle.change((doc) => {
+      doc.highlight = {};
+    });
+  });
+  const canAddComment = () => Boolean(targetDocUrl()) && Boolean(currentContactUrl());
+  const onAddComment = async () => {
+    const url = targetDocUrl();
+    const contactUrl = currentContactUrl();
+    if (!url || !contactUrl) return;
+    const handle = await repo.find(url);
+    createDocumentThread({
+      docHandle: handle,
+      contactUrl
+    });
+  };
+  return (() => {
+    var _el$ = _tmpl$2$1(), _el$2 = _el$.firstChild;
+    _el$2.firstChild;
+    insert(_el$2, createComponent(Show, {
+      get when() {
+        return canAddComment();
+      },
+      get children() {
+        var _el$4 = _tmpl$$1();
+        _el$4.$$click = onAddComment;
+        return _el$4;
+      }
+    }), null);
+    insert(_el$, createComponent(Show, {
+      get when() {
+        return displayedThreadUrls().length > 0;
+      },
+      get fallback() {
+        return _tmpl$3$1();
+      },
+      get children() {
+        return createComponent(For, {
+          get each() {
+            return displayedThreadUrls();
+          },
+          children: (threadUrl) => (() => {
+            var _el$6 = _tmpl$4$1(), _el$7 = _el$6.firstChild;
+            _el$6.$$click = (e) => onClickThreadCard(e, threadUrl);
+            _el$7.docUrl = threadUrl;
+            _el$7._$owner = getOwner();
+            effect(() => setAttribute(_el$7, "data-thread-state", threadState(threadUrl)));
+            return _el$6;
+          })()
+        });
+      }
+    }), null);
+    return _el$;
+  })();
+}
+function useScopedCommentEntries(element, docUrl) {
+  const [entries, setEntries] = createSignal([]);
+  createEffect(() => {
+    const url = docUrl();
+    setEntries([]);
+    if (!url) return;
+    const unsubscribe = subscribe(element, {
+      type: "patchwork:comments",
+      url
+    }, (value) => setEntries(value ?? []));
+    onCleanup(unsubscribe);
+  });
+  return entries;
+}
+function useResolvedHandles(urls, repo) {
+  const [handles, setHandles] = createSignal([]);
+  createEffect(() => {
+    const list = urls();
+    let cancelled = false;
+    Promise.all(list.map((u) => repo.find(u).catch(() => void 0))).then((resolved) => {
+      if (cancelled) return;
+      setHandles(resolved.filter((h) => Boolean(h)));
+    });
+    onCleanup(() => {
+      cancelled = true;
+    });
+  });
+  return handles;
+}
+function useResolvedHandleMap(map, repo) {
+  const [resolved, setResolved] = createSignal(/* @__PURE__ */ new Map());
+  createEffect(() => {
+    const m = map();
+    let cancelled = false;
+    void (async () => {
+      const out = /* @__PURE__ */ new Map();
+      for (const [key, urls] of m) {
+        const handles = await Promise.all(urls.map((u) => repo.find(u).catch(() => void 0)));
+        out.set(key, handles.filter((h) => Boolean(h)));
+      }
+      if (!cancelled) setResolved(out);
+    })();
+    onCleanup(() => {
+      cancelled = true;
+    });
+  });
+  return resolved;
+}
+function useThreadsWithVisibleTarget(map, repo) {
+  const [visible, setVisible] = createSignal(/* @__PURE__ */ new Set());
+  createEffect(() => {
+    const m = map();
+    let cancelled = false;
+    let resolved = /* @__PURE__ */ new Map();
+    const recompute = () => {
+      if (cancelled) return;
+      const next = /* @__PURE__ */ new Set();
+      for (const [threadUrl, handles] of resolved) {
+        if (handles.some(targetIsVisible)) next.add(threadUrl);
+      }
+      setVisible(next);
+    };
+    void (async () => {
+      const out = /* @__PURE__ */ new Map();
+      for (const [threadUrl, urls] of m) {
+        const handles = await Promise.all(urls.map((u) => repo.find(u).catch(() => void 0)));
+        out.set(threadUrl, handles.filter((h) => Boolean(h)));
+      }
+      if (cancelled) return;
+      resolved = out;
+      for (const h of flatHandles(resolved)) h.on("change", recompute);
+      recompute();
+    })();
+    onCleanup(() => {
+      cancelled = true;
+      for (const h of flatHandles(resolved)) h.off("change", recompute);
+    });
+  });
+  return visible;
+}
+function flatHandles(map) {
+  const out = [];
+  for (const handles of map.values()) out.push(...handles);
+  return out;
+}
+function targetIsVisible(handle) {
+  const positions = handle.rangePositions();
+  if (!positions) return false;
+  const [start, end] = positions;
+  return start !== end;
+}
+function threadOverlapsSelection(targets, selection) {
+  return targets.some((t) => selection.some((s) => s.overlaps(t)));
+}
+delegateEvents(["click"]);
+const relativeTime = (timestamp) => {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (seconds < 60) {
+    return "just now";
+  } else if (minutes < 60) {
+    return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+  } else if (hours < 24) {
+    return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  } else if (days < 7) {
+    return `${days} day${days === 1 ? "" : "s"} ago`;
+  } else if (weeks < 4) {
+    return `${weeks} week${weeks === 1 ? "" : "s"} ago`;
+  } else if (months < 12) {
+    return `${months} month${months === 1 ? "" : "s"} ago`;
+  } else {
+    return `${years} year${years === 1 ? "" : "s"} ago`;
+  }
+};
+function scanFlags(re) {
+  return "g" + (re.flags.includes("i") ? "i" : "");
+}
+function scanAtoms(text, specs, block, out) {
+  for (const [name, spec] of Object.entries(specs || {})) {
+    if (!spec.pattern)
+      continue;
+    const re = new RegExp(spec.pattern.source, scanFlags(spec.pattern));
+    let m;
+    while (m = re.exec(text)) {
+      if (!m[0]) {
+        re.lastIndex = m.index + 1;
+        continue;
+      }
+      out.push({
+        kind: "atom",
+        name,
+        spec,
+        block,
+        start: m.index,
+        end: m.index + m[0].length,
+        attrs: spec.parse ? spec.parse(m[0]) : {}
+      });
+    }
+  }
+}
+function findMarkupRanges(text, schema) {
+  const candidates = [];
+  for (const [name, spec] of Object.entries(schema.marks || {})) {
+    if (!spec.pattern)
+      continue;
+    const re = new RegExp(spec.pattern.source, scanFlags(spec.pattern));
+    let m;
+    while (m = re.exec(text)) {
+      const inner = m[1];
+      if (!inner) {
+        re.lastIndex = m.index + 1;
+        continue;
+      }
+      const start = m.index;
+      const openLen = m[0].indexOf(inner);
+      candidates.push({
+        kind: "mark",
+        name,
+        spec,
+        start,
+        innerStart: start + openLen,
+        innerEnd: start + openLen + inner.length,
+        end: start + m[0].length,
+        attrs: spec.parse ? spec.parse(m[0]) : void 0
+      });
+    }
+  }
+  scanAtoms(text, schema.blocks, true, candidates);
+  scanAtoms(text, schema.replaces, false, candidates);
+  candidates.sort((a, b) => a.start - b.start || b.end - b.start - (a.end - a.start));
+  const accepted = [];
+  let lastEnd = 0;
+  for (const c of candidates) {
+    if (c.start < lastEnd)
+      continue;
+    accepted.push(c);
+    lastEnd = c.end;
+  }
+  return accepted;
+}
+function parseMarkup(text, schema) {
+  const nodes = [];
+  let best = null;
+  const consider = (specs, kind2, block2) => {
+    for (const [, spec2] of Object.entries(specs || {})) {
+      if (!spec2.pattern)
+        continue;
+      const re = new RegExp(spec2.pattern.source, scanFlags(spec2.pattern).replace("g", ""));
+      const m2 = re.exec(text);
+      const ok = kind2 === "mark" ? m2 && m2[1] : m2 && m2[0];
+      if (ok && (best === null || m2.index < best.m.index))
+        best = { kind: kind2, spec: spec2, m: m2, block: block2 };
+    }
+  };
+  consider(schema.marks, "mark");
+  consider(schema.blocks, "atom", true);
+  consider(schema.replaces, "atom", false);
+  if (!best) {
+    if (text)
+      nodes.push({ text });
+    return nodes;
+  }
+  const { kind, spec, m, block } = best;
+  if (m.index > 0)
+    nodes.push({ text: text.slice(0, m.index) });
+  if (kind === "mark") {
+    const inner = m[1];
+    const leaf = spec.raw || inner.length >= m[0].length;
+    nodes.push({
+      mark: spec,
+      attrs: spec.parse ? spec.parse(m[0]) : void 0,
+      children: leaf ? [{ text: inner }] : parseMarkup(inner, schema)
+    });
+  } else {
+    nodes.push({ atom: spec, attrs: spec.parse ? spec.parse(m[0]) : {}, block });
+  }
+  for (const n of parseMarkup(text.slice(m.index + m[0].length), schema))
+    nodes.push(n);
+  return nodes;
+}
+const HTML_ESCAPE = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+const escapeHTML = (s) => String(s ?? "").replace(/[&<>]/g, (c) => HTML_ESCAPE[c]);
+const escapeAttr = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => HTML_ESCAPE[c]);
+function embedRangeForDOM(view, dom, schema) {
+  const embeds = Array.from(view.dom.querySelectorAll(".cutetxt-embed"));
+  const index = embeds.indexOf(dom);
+  if (index < 0)
+    return null;
+  return findMarkupRanges(view.state.doc.toString(), schema).filter((x) => x.kind === "atom" && x.name === "embed")[index];
+}
+function setEmbedAttrs(view, dom, schema, patch) {
+  const embed = schema.blocks && schema.blocks.embed;
+  if (!embed)
+    return;
+  const r = embedRangeForDOM(view, dom, schema);
+  if (!r)
+    return;
+  const nextAttrs = { ...r.attrs, ...patch };
+  if (Object.keys(patch).every((key) => String(r.attrs[key] || "") === String(nextAttrs[key] || "")))
+    return;
+  const token = embed.token(nextAttrs);
+  view.dispatch({ changes: { from: r.start, to: r.end, insert: token }, userEvent: "input" });
+}
+function editEmbedToken(view, dom, schema) {
+  const r = embedRangeForDOM(view, dom, schema);
+  if (!r)
+    return;
+  view.dispatch({ selection: { anchor: r.start }, scrollIntoView: true, userEvent: "select" });
+  view.focus();
+}
+function deleteEmbedToken(view, dom, schema) {
+  const r = embedRangeForDOM(view, dom, schema);
+  if (!r)
+    return;
+  const doc = view.state.doc;
+  let from = r.start;
+  let to = r.end;
+  if (to < doc.length && doc.sliceString(to, to + 1) === "\n")
+    to++;
+  else if (from > 0 && doc.sliceString(from - 1, from) === "\n")
+    from--;
+  view.dispatch({
+    changes: { from, to, insert: "" },
+    selection: { anchor: from },
+    userEvent: "delete"
+  });
+  view.focus();
+}
+function embedIconButton(label, title, onClick) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = "cutetxt-embed-icon";
+  button.classList.add("cutetxt-embed-delete");
+  button.textContent = label;
+  button.title = title;
+  button.setAttribute("aria-label", title);
+  button.addEventListener("mousedown", (event) => event.preventDefault());
+  button.addEventListener("click", (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    onClick();
+  });
+  return button;
+}
+function buildToolPicker(view, wrap, schema, picker, attrs) {
+  const holder = document.createElement("span");
+  holder.className = "cutetxt-embed-picker";
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = "cutetxt-embed-tool";
+  button.textContent = (attrs.toolId || "tool") + " ▾";
+  holder.append(button);
+  let menu = null;
+  const closeMenu = () => {
+    if (!menu)
+      return;
+    menu.remove();
+    menu = null;
+    document.removeEventListener("mousedown", onDocDown, true);
+  };
+  const onDocDown = (event) => {
+    if (!holder.contains(event.target))
+      closeMenu();
+  };
+  button.addEventListener("mousedown", (event) => event.preventDefault());
+  button.addEventListener("click", async (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (menu)
+      return closeMenu();
+    menu = document.createElement("div");
+    menu.className = "cutetxt-embed-menu";
+    menu.textContent = "…";
+    holder.append(menu);
+    document.addEventListener("mousedown", onDocDown, true);
+    let tools = [];
+    try {
+      tools = await picker(attrs.url) || [];
+    } catch {
+      tools = [];
+    }
+    if (!menu)
+      return;
+    menu.textContent = "";
+    if (!tools.length) {
+      menu.textContent = "no tools";
+      return;
+    }
+    for (const tool of tools) {
+      const item = document.createElement("button");
+      item.type = "button";
+      item.className = "cutetxt-embed-menu-item";
+      if (tool.id === attrs.toolId)
+        item.classList.add("is-current");
+      item.textContent = tool.name || tool.id;
+      item.addEventListener("mousedown", (ev) => ev.preventDefault());
+      item.addEventListener("click", (ev) => {
+        ev.preventDefault();
+        ev.stopPropagation();
+        closeMenu();
+        setEmbedAttrs(view, wrap, schema, { toolId: tool.id });
+      });
+      menu.append(item);
+    }
+  });
+  return holder;
+}
+class AtomWidget extends WidgetType {
+  spec;
+  attrs;
+  block;
+  name;
+  schema;
+  picker;
+  repo;
+  key;
+  cleanup;
+  constructor(spec, attrs, block, name, schema, picker, repo) {
+    super();
+    this.spec = spec;
+    this.attrs = attrs;
+    this.block = block;
+    this.name = name;
+    this.schema = schema;
+    this.picker = picker;
+    this.repo = repo;
+    const keyAttrs = name === "embed" ? { url: attrs.url, toolId: attrs.toolId } : attrs;
+    this.key = (block ? "b:" : "r:") + name + ":" + (spec.token ? spec.token(keyAttrs) : JSON.stringify(keyAttrs));
+  }
+  eq(other) {
+    return other.key === this.key;
+  }
+  updateDOM(dom, view, from) {
+    if (this.name !== "embed" || from.name !== "embed")
+      return false;
+    if (this.attrs.url !== from.attrs.url || this.attrs.toolId !== from.attrs.toolId)
+      return false;
+    this.cleanup = from.cleanup;
+    const body = dom.querySelector(".cutetxt-embed-body");
+    if (this.attrs.width)
+      dom.style.width = this.attrs.width + "px";
+    else
+      dom.style.removeProperty("width");
+    if (body instanceof HTMLElement) {
+      if (this.attrs.height)
+        body.style.height = this.attrs.height + "px";
+      else
+        body.style.removeProperty("height");
+    }
+    return true;
+  }
+  toDOM(view) {
+    const wrap = document.createElement(this.block ? "div" : "span");
+    wrap.className = this.block ? "cutetxt-block" : "cutetxt-replace";
+    wrap.contentEditable = "false";
+    const node = this.spec.toDOM(this.attrs);
+    if (this.name === "embed") {
+      const bar = document.createElement("div");
+      bar.className = "cutetxt-embed-bar";
+      bar.title = "Edit embed token";
+      bar.addEventListener("mousedown", (event) => {
+        if (event.target.closest("button, .cutetxt-embed-menu"))
+          return;
+        event.preventDefault();
+      });
+      bar.addEventListener("click", (event) => {
+        if (event.target.closest("button, .cutetxt-embed-menu"))
+          return;
+        event.preventDefault();
+        event.stopPropagation();
+        editEmbedToken(view, wrap, this.schema);
+      });
+      const title = document.createElement("span");
+      title.className = "cutetxt-embed-title";
+      title.textContent = this.attrs.toolId || "embed";
+      bar.append(title);
+      const actions = document.createElement("span");
+      actions.className = "cutetxt-embed-actions";
+      actions.append(embedIconButton("x", "Delete embed", () => deleteEmbedToken(view, wrap, this.schema)));
+      if (this.picker)
+        actions.prepend(buildToolPicker(view, wrap, this.schema, this.picker, this.attrs));
+      bar.append(actions);
+      const body = document.createElement("div");
+      body.className = "cutetxt-embed-body";
+      if (node instanceof Node)
+        body.append(node);
+      else if (typeof node === "string")
+        body.append(document.createTextNode(node));
+      const handle = document.createElement("div");
+      handle.className = "cutetxt-embed-resize";
+      handle.title = "Resize";
+      handle.setAttribute("role", "separator");
+      handle.setAttribute("aria-label", "Resize embed");
+      wrap.append(bar, body, handle);
+      this.setupTitle(title);
+      this.setupResize(view, wrap, body, handle, node);
+    } else {
+      if (node instanceof Node)
+        wrap.append(node);
+      else if (typeof node === "string")
+        wrap.append(document.createTextNode(node));
+    }
+    return wrap;
+  }
+  coordsAt(dom, _pos, side) {
+    const rect = dom.getBoundingClientRect();
+    const left = side > 0 ? rect.right : rect.left;
+    return { left, right: left, top: rect.top, bottom: rect.bottom };
+  }
+  setCleanup(fn) {
+    const prev = this.cleanup;
+    this.cleanup = prev ? () => {
+      prev();
+      fn();
+    } : fn;
+  }
+  setupTitle(title) {
+    const fallback = this.attrs.toolId || "embed";
+    const apply2 = (doc) => {
+      const patchwork = doc && doc["@patchwork"];
+      title.textContent = patchwork && patchwork.title || doc && (doc.title || doc.name) || fallback;
+    };
+    title.textContent = fallback;
+    if (!this.repo || !this.attrs.url)
+      return;
+    let handle = null;
+    let disposed = false;
+    const refresh = () => {
+      if (!disposed && handle)
+        apply2(handle.doc());
+    };
+    this.repo.find(this.attrs.url).then((h) => {
+      if (disposed)
+        return;
+      handle = h;
+      refresh();
+      handle.on?.("change", refresh);
+    }).catch(() => {
+    });
+    this.setCleanup(() => {
+      disposed = true;
+      handle?.off?.("change", refresh);
+    });
+  }
+  // Make the embed frame resizable. Width/height stored in the token describe the
+  // embedded tool viewport, not the frame chrome around it.
+  setupResize(view, wrap, body, handle, node) {
+    wrap.classList.add("cutetxt-embed");
+    if (this.attrs.width)
+      wrap.style.width = this.attrs.width + "px";
+    if (this.attrs.height)
+      body.style.height = this.attrs.height + "px";
+    if (node instanceof HTMLElement) {
+      node.style.width = "100%";
+      node.style.height = "100%";
+      node.style.display = "block";
+    }
+    let drag = null;
+    const onDown = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      handle.setPointerCapture?.(event.pointerId);
+      drag = {
+        id: event.pointerId,
+        x: event.clientX,
+        y: event.clientY,
+        width: wrap.getBoundingClientRect().width,
+        height: body.getBoundingClientRect().height,
+        moved: false
+      };
+      wrap.classList.add("is-resizing");
+    };
+    const onMove = (event) => {
+      if (!drag || event.pointerId !== drag.id)
+        return;
+      event.preventDefault();
+      const w = Math.max(160, Math.round(drag.width + event.clientX - drag.x));
+      const h = Math.max(88, Math.round(drag.height + event.clientY - drag.y));
+      drag.moved = drag.moved || w !== Math.round(drag.width) || h !== Math.round(drag.height);
+      wrap.style.width = w + "px";
+      body.style.height = h + "px";
+    };
+    const onUp = (event) => {
+      if (!drag || event.pointerId !== drag.id)
+        return;
+      handle.releasePointerCapture?.(event.pointerId);
+      wrap.classList.remove("is-resizing");
+      const moved = drag.moved;
+      drag = null;
+      if (!moved)
+        return;
+      const w = Math.round(body.clientWidth);
+      const h = Math.round(body.clientHeight);
+      if (w && h)
+        setEmbedAttrs(view, wrap, this.schema, { width: w, height: h });
+    };
+    const onCancel = (event) => {
+      if (!drag || event.pointerId !== drag.id)
+        return;
+      handle.releasePointerCapture?.(event.pointerId);
+      drag = null;
+      wrap.classList.remove("is-resizing");
+    };
+    handle.addEventListener("pointerdown", onDown);
+    handle.addEventListener("pointermove", onMove);
+    handle.addEventListener("pointerup", onUp);
+    handle.addEventListener("pointercancel", onCancel);
+    this.setCleanup(() => {
+      handle.removeEventListener("pointerdown", onDown);
+      handle.removeEventListener("pointermove", onMove);
+      handle.removeEventListener("pointerup", onUp);
+      handle.removeEventListener("pointercancel", onCancel);
+    });
+  }
+  destroy() {
+    if (this.cleanup)
+      this.cleanup();
+  }
+  ignoreEvent() {
+    return true;
+  }
+}
+function buildDecorations(state, schema, picker, repo) {
+  const text = state.doc.toString();
+  const sel = state.selection.main;
+  const decos = [];
+  for (const r of findMarkupRanges(text, schema)) {
+    const overlaps = sel.from < r.end && sel.to > r.start;
+    const atStart = r.kind === "atom" && sel.empty && sel.from === r.start;
+    const atEnd = r.kind === "atom" && sel.empty && sel.from === r.end;
+    if (overlaps || atStart || atEnd)
+      continue;
+    if (r.kind === "atom") {
+      decos.push(Decoration.replace({
+        widget: new AtomWidget(r.spec, r.attrs, r.block, r.name, schema, picker, repo),
+        block: r.block
+      }).range(r.start, r.end));
+      continue;
+    }
+    const [tagName, dom] = r.spec.toDOM(r.attrs);
+    let cls;
+    let attributes;
+    if (dom) {
+      const { class: c, ...rest } = dom;
+      cls = c;
+      if (Object.keys(rest).length)
+        attributes = rest;
+    }
+    if (r.innerStart > r.start)
+      decos.push(Decoration.replace({}).range(r.start, r.innerStart));
+    decos.push(Decoration.mark({ tagName, class: cls, attributes }).range(r.innerStart, r.innerEnd));
+    if (r.end > r.innerEnd)
+      decos.push(Decoration.replace({}).range(r.innerEnd, r.end));
+  }
+  return Decoration.set(decos, true);
+}
+function previewField(getSchema, getToolsForDoc, repo) {
+  return StateField.define({
+    create: (state) => buildDecorations(state, getSchema(), getToolsForDoc, repo),
+    update(value, tr) {
+      if (tr.docChanged || tr.selection)
+        return buildDecorations(tr.state, getSchema(), getToolsForDoc, repo);
+      return value.map(tr.changes);
+    },
+    provide: (f) => EditorView.decorations.from(f)
+  });
+}
+function wrapSelection(view, delim) {
+  const { from, to } = view.state.selection.main;
+  view.dispatch({
+    changes: [
+      { from, insert: delim },
+      { to, insert: delim }
+    ],
+    selection: { anchor: from + delim.length, head: to + delim.length },
+    userEvent: "input"
+  });
+}
+const MARK_KEYS = ["Mod-b", "Mod-i", "Mod-u"];
+function markKeymap(getSchema) {
+  return keymap.of(MARK_KEYS.map((k) => ({
+    key: k,
+    preventDefault: true,
+    run(view) {
+      const marks = (getSchema() || {}).marks || {};
+      for (const spec of Object.values(marks)) {
+        if (spec.key === k && spec.wrap) {
+          wrapSelection(view, spec.wrap);
+          return true;
+        }
+      }
+      return false;
+    }
+  })));
+}
+function embedToken(schema, attrs) {
+  const spec = schema.blocks && schema.blocks.embed;
+  return spec && spec.token ? spec.token(attrs) : "";
+}
+function insertText(view, text) {
+  const pos = view.state.selection.main.from;
+  view.dispatch({
+    changes: { from: pos, insert: text },
+    selection: { anchor: pos + text.length },
+    userEvent: "input"
+  });
+}
+function extensionForFile(file, mimeType) {
+  const fromName = file.name && file.name.includes(".") ? file.name.split(".").pop() : "";
+  return (fromName || (mimeType.split("/")[1] || "bin").split("+")[0] || "bin").toLowerCase();
+}
+async function createFileToken(schema, repo, file) {
+  if (!repo || !file)
+    return "";
+  const buffer = new Uint8Array(await file.arrayBuffer());
+  const mimeType = file.type || "application/octet-stream";
+  const extension = extensionForFile(file, mimeType);
+  const name = file.name || `file.${extension}`;
+  const fileHandle = await repo.create2({
+    content: buffer,
+    extension,
+    mimeType,
+    name,
+    "@patchwork": { type: "file" }
+  });
+  return embedToken(schema, { url: fileHandle.url, toolId: "file" });
+}
+async function insertFileBlob(view, schema, repo, file) {
+  const token = await createFileToken(schema, repo, file);
+  if (token)
+    insertText(view, token);
+}
+async function insertDroppedFiles(view, schema, repo, files, at) {
+  if (!repo || !files.length)
+    return false;
+  const tokens = [];
+  for (const file of files) {
+    const token = await createFileToken(schema, repo, file);
+    if (token)
+      tokens.push(token);
+  }
+  if (!tokens.length)
+    return false;
+  const insert2 = tokens.map((token) => token + "\n").join("");
+  view.dispatch({
+    changes: { from: at, insert: insert2 },
+    selection: { anchor: at + insert2.length },
+    userEvent: "input"
+  });
+  return true;
+}
+function docUrlFromDrop(dataTransfer) {
+  if (!dataTransfer)
+    return null;
+  const dnd = dataTransfer.getData("text/x-patchwork-dnd");
+  if (dnd) {
+    try {
+      const url = JSON.parse(dnd)?.items?.[0]?.url;
+      if (url)
+        return url;
+    } catch {
+    }
+  }
+  const urls = dataTransfer.getData("text/x-patchwork-urls");
+  if (urls) {
+    try {
+      const parsed = JSON.parse(urls);
+      if (Array.isArray(parsed) && parsed[0])
+        return parsed[0];
+    } catch {
+    }
+  }
+  const text = dataTransfer.getData("text/uri-list") || dataTransfer.getData("text/plain");
+  const match = (text || "").match(/automerge:[A-Za-z0-9]+/);
+  return match ? match[0] : null;
+}
+function dndHandlers(getSchema, repo) {
+  return EditorView.domEventHandlers({
+    paste(event, view) {
+      const items = event.clipboardData && event.clipboardData.items;
+      if (!items)
+        return false;
+      for (const item of items) {
+        if (item.kind === "file" && item.type.startsWith("image/")) {
+          event.preventDefault();
+          insertFileBlob(view, getSchema(), repo, item.getAsFile());
+          return true;
+        }
+      }
+      return false;
+    },
+    dragover(event) {
+      if (event.dataTransfer?.files && event.dataTransfer.files.length || docUrlFromDrop(event.dataTransfer)) {
+        event.preventDefault();
+        if (event.dataTransfer)
+          event.dataTransfer.dropEffect = "copy";
+        return true;
+      }
+      return false;
+    },
+    drop(event, view) {
+      const files = Array.from(event.dataTransfer?.files || []);
+      if (files.length) {
+        event.preventDefault();
+        const pos2 = view.posAtCoords({ x: event.clientX, y: event.clientY });
+        const at2 = pos2 == null ? view.state.selection.main.from : pos2;
+        insertDroppedFiles(view, getSchema(), repo, files, at2);
+        return true;
+      }
+      const url = docUrlFromDrop(event.dataTransfer);
+      if (!url)
+        return false;
+      event.preventDefault();
+      const pos = view.posAtCoords({ x: event.clientX, y: event.clientY });
+      const token = embedToken(getSchema(), { url });
+      if (!token)
+        return false;
+      const at = pos == null ? view.state.selection.main.from : pos;
+      const insert2 = token + "\n";
+      view.dispatch({
+        changes: { from: at, insert: insert2 },
+        selection: { anchor: at + insert2.length },
+        userEvent: "input"
+      });
+      return true;
+    }
+  });
+}
+function cutePreview(getSchema, opts = {}) {
+  const { repo, getToolsForDoc } = opts;
+  const exts = [previewField(getSchema, getToolsForDoc, repo), markKeymap(getSchema)];
+  if (repo)
+    exts.push(dndHandlers(getSchema, repo));
+  return exts;
+}
+const DEFAULTS = { className: "cutetxt-autocomplete", itemClass: "cutetxt-ac-item", max: 10 };
+function defaultRow(opt, active, cfg) {
+  const row = document.createElement("div");
+  row.className = cfg.itemClass + (active ? " is-active" : "");
+  if (opt.icon && opt.icon.kind === "image") {
+    const img = document.createElement("img");
+    img.className = "cutetxt-ac-icon";
+    img.src = opt.icon.src;
+    row.append(img);
+  } else if (opt.icon && opt.icon.kind === "emoji") {
+    const span = document.createElement("span");
+    span.className = "cutetxt-ac-icon";
+    span.textContent = opt.icon.char;
+    row.append(span);
+  }
+  const label = document.createElement("span");
+  label.className = "cutetxt-ac-label";
+  label.textContent = opt.label;
+  row.append(label);
+  if (opt.description != null) {
+    const d = document.createElement("span");
+    d.className = "cutetxt-ac-desc";
+    d.textContent = String(opt.description);
+    row.append(d);
+  }
+  if (opt.detail != null) {
+    const d = document.createElement("span");
+    d.className = "cutetxt-ac-detail";
+    d.textContent = String(opt.detail);
+    row.append(d);
+  }
+  return row;
+}
+function cuteAutocomplete(getSpecs, opts = {}) {
+  const cfg = { ...DEFAULTS, ...opts };
+  const normCache = /* @__PURE__ */ new WeakMap();
+  const norm = (spec) => {
+    let n = normCache.get(spec);
+    if (!n) {
+      n = { ...spec, trigger: new RegExp(spec.trigger.source, spec.trigger.flags.replace("g", "")) };
+      normCache.set(spec, n);
+    }
+    return n;
+  };
+  let popup = null;
+  let state = null;
+  let reqId = 0;
+  const close = () => {
+    state = null;
+    if (popup) {
+      popup.remove();
+      popup = null;
+    }
+  };
+  function render2(view) {
+    if (!state)
+      return close();
+    if (!popup) {
+      popup = document.createElement("div");
+      popup.className = cfg.className;
+      popup.contentEditable = "false";
+      document.body.appendChild(popup);
+    }
+    popup.replaceChildren();
+    state.options.forEach((opt, i) => {
+      const active = i === state.index;
+      const row = cfg.renderRow ? cfg.renderRow(opt, { index: i, active }) : defaultRow(opt, active, cfg);
+      row.addEventListener("mousedown", (event) => {
+        event.preventDefault();
+        state.index = i;
+        accept(view);
+      });
+      popup.append(row);
+    });
+    positionPopup(view);
+  }
+  function positionPopup(view) {
+    if (!popup || !state)
+      return;
+    const coords = view.coordsAtPos(state.from);
+    if (!coords)
+      return;
+    const margin = 6;
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const rect = popup.getBoundingClientRect();
+    let left = coords.left;
+    if (left + rect.width > vw - margin)
+      left = vw - rect.width - margin;
+    if (left < margin)
+      left = margin;
+    const below = coords.bottom + margin;
+    const above = coords.top - rect.height - margin;
+    const roomBelow = vh - coords.bottom;
+    const roomAbove = coords.top;
+    const top = below + rect.height > vh - margin && roomAbove > roomBelow ? Math.max(margin, above) : below;
+    popup.style.left = left + "px";
+    popup.style.top = top + "px";
+    const after = popup.getBoundingClientRect();
+    const dx = left - after.left;
+    const dy = top - after.top;
+    if (dx || dy) {
+      popup.style.left = left + dx + "px";
+      popup.style.top = top + dy + "px";
+    }
+  }
+  function accept(view) {
+    if (!state)
+      return false;
+    const opt = state.options[state.index];
+    if (!opt)
+      return false;
+    const head = view.state.selection.main.head;
+    let from = state.from;
+    let to = head;
+    if (opt.replace === "all") {
+      from = 0;
+      to = view.state.doc.length;
+    } else if (opt.replace === "line") {
+      const line = view.state.doc.lineAt(head);
+      from = line.from;
+      to = line.to;
+    }
+    view.dispatch({
+      changes: { from, to, insert: opt.insert },
+      selection: { anchor: from + opt.insert.length },
+      userEvent: "input.complete"
+    });
+    close();
+    return true;
+  }
+  function move(view, delta) {
+    if (!state)
+      return false;
+    state.index = (state.index + delta + state.options.length) % state.options.length;
+    render2(view);
+    return true;
+  }
+  async function refresh(view) {
+    const sel = view.state.selection.main;
+    if (!sel.empty || !view.hasFocus)
+      return close();
+    const line = view.state.doc.lineAt(sel.head);
+    const before = view.state.doc.sliceString(line.from, sel.head);
+    for (const raw of getSpecs()) {
+      const spec = norm(raw);
+      const m = spec.trigger.exec(before);
+      if (!m)
+        continue;
+      const from = sel.head - m[0].length;
+      const id = ++reqId;
+      let opts2;
+      try {
+        opts2 = await spec.options(m[1] ?? "", { view });
+      } catch {
+        opts2 = [];
+      }
+      if (id !== reqId)
+        return;
+      opts2 = (opts2 || []).slice(0, cfg.max);
+      if (!opts2.length)
+        return close();
+      const prev = state && state.options[state.index] && state.options[state.index].label;
+      const keep = opts2.findIndex((o) => o.label === prev);
+      state = { from, options: opts2, index: keep < 0 ? 0 : keep };
+      render2(view);
+      return;
+    }
+    close();
+  }
+  const listener = EditorView.updateListener.of((update) => {
+    if (update.docChanged || update.selectionSet || update.focusChanged)
+      refresh(update.view);
+  });
+  const cleanup = ViewPlugin.define(() => ({ destroy: close }));
+  const keys = Prec.highest(keymap.of([
+    { key: "ArrowDown", run: (view) => move(view, 1) },
+    { key: "ArrowUp", run: (view) => move(view, -1) },
+    { key: "Enter", run: (view) => accept(view) },
+    { key: "Tab", run: (view) => accept(view) },
+    {
+      key: "Escape",
+      run: () => {
+        if (!state)
+          return false;
+        close();
+        return true;
+      }
+    }
+  ]));
+  return [cleanup, listener, keys];
+}
+function getText(doc, path) {
+  let node = doc;
+  for (const key of path)
+    node = node == null ? node : node[key];
+  return typeof node === "string" ? node : "";
+}
+const remote = Annotation.define();
+function pushLocalEdits(handle, path, update) {
+  if (!update.docChanged)
+    return;
+  if (update.transactions.some((tr) => tr.annotation(remote)))
+    return;
+  const edits = [];
+  update.changes.iterChanges((fromA, toA, _fromB, _toB, inserted) => {
+    edits.push([fromA, toA - fromA, inserted.toString()]);
+  });
+  if (edits.length === 0)
+    return;
+  handle.change((doc) => {
+    for (let i = edits.length - 1; i >= 0; i--) {
+      const [from, del, ins] = edits[i];
+      am.splice(doc, path, from, del, ins);
+    }
+  });
+}
+function reconcileText(view, handle, path) {
+  const text = getText(handle.doc(), path);
+  const current = view.state.doc.toString();
+  if (text === current)
+    return;
+  let start = 0;
+  const min = Math.min(text.length, current.length);
+  while (start < min && text[start] === current[start])
+    start++;
+  let endText = text.length;
+  let endCur = current.length;
+  while (endText > start && endCur > start && text[endText - 1] === current[endCur - 1]) {
+    endText--;
+    endCur--;
+  }
+  view.dispatch({
+    changes: { from: start, to: endCur, insert: text.slice(start, endText) },
+    annotations: remote.of(true)
+  });
+}
+function createCuteEditor({ handle, path, schema, parent, repo, getToolsForDoc, autocompletes = [], editable = true }) {
+  let view;
+  const onChange = () => {
+    queueMicrotask(() => {
+      if (view)
+        reconcileText(view, handle, path);
+    });
+  };
+  handle.on("change", onChange);
+  const updateListener = EditorView.updateListener.of((update) => {
+    pushLocalEdits(handle, path, update);
+  });
+  const acExtensions = autocompletes.length ? cuteAutocomplete(() => autocompletes) : [];
+  view = new EditorView({
+    doc: getText(handle.doc(), path),
+    parent,
+    extensions: [
+      ...cutePreview(() => schema, { repo, getToolsForDoc }),
+      updateListener,
+      EditorView.lineWrapping,
+      EditorView.editable.of(editable),
+      ...acExtensions
+    ]
+  });
+  return {
+    view,
+    destroy() {
+      handle.off("change", onChange);
+      view.destroy();
+    }
+  };
+}
+function build(parent, nodes) {
+  for (const node of nodes) {
+    if (node.text != null) {
+      const parts = node.text.split("\n");
+      parts.forEach((part, i) => {
+        if (i > 0)
+          parent.append(document.createElement("br"));
+        if (part)
+          parent.append(document.createTextNode(part));
+      });
+    } else if (node.atom) {
+      const el = node.atom.toDOM(node.attrs);
+      const wrap = document.createElement(node.block ? "div" : "span");
+      wrap.className = node.block ? "cutetxt-block" : "cutetxt-replace";
+      if (el instanceof Node)
+        wrap.append(el);
+      else if (typeof el === "string")
+        wrap.append(document.createTextNode(el));
+      parent.append(wrap);
+    } else {
+      const [tagName, attrs] = node.mark.toDOM(node.attrs);
+      const el = document.createElement(tagName);
+      if (attrs)
+        for (const [key, value] of Object.entries(attrs))
+          el.setAttribute(key, value);
+      build(el, node.children);
+      parent.append(el);
+    }
+  }
+}
+function renderMarkup(text, schema) {
+  const container = document.createElement("div");
+  container.className = "cutetxt-rendered";
+  build(container, parseMarkup(typeof text === "string" ? text : "", schema));
+  return container;
+}
+function defineRichSchema({ marks = {}, blocks = {}, replaces = {} } = {}) {
+  return { marks, blocks, replaces };
+}
+const defaultMarks = {
+  strong: { pattern: /\*([^*\n]+?)\*/, toDOM: () => ["strong"], key: "Mod-b", wrap: "*" },
+  "underline-em": { pattern: /___([^_\n]+?)___/, toDOM: () => ["span", { class: "cutetxt-underline-em" }], wrap: "___" },
+  underline: { pattern: /__([^_\n]+?)__/, toDOM: () => ["u"], key: "Mod-u", wrap: "__" },
+  em: { pattern: new RegExp("(?<![_\\w])_([^_\\n]+?)_(?![_.\\w])"), toDOM: () => ["em"], key: "Mod-i", wrap: "_" },
+  strike: { pattern: /~~([^~\n]+?)~~/, toDOM: () => ["s"], wrap: "~~" },
+  spoiler: { pattern: /\|\|([^|\n]+?)\|\|/, toDOM: () => ["span", { class: "cutetxt-spoiler" }], wrap: "||" },
+  code: { pattern: /`([^`\n]+?)`/, toDOM: () => ["code", { class: "cutetxt-code" }], wrap: "`", raw: true },
+  sub: { pattern: /\._([^_\n]+?)_\./, toDOM: () => ["sub"] },
+  sup: { pattern: /\.\^([^^\n]+?)\^\./, toDOM: () => ["sup"] },
+  inverted: { pattern: /%%([^%\n]+?)%%/, toDOM: () => ["span", { class: "cutetxt-inverted" }], wrap: "%%" },
+  marquee: { pattern: /<>([^\n]+?)<>/, toDOM: () => ["marquee"], wrap: "<>" },
+  link: {
+    pattern: /(https?:\/\/[^\s<]+)/,
+    parse: (s) => ({ href: s }),
+    toDOM: ({ href }) => ["a", { href, target: "_blank", rel: "noopener noreferrer" }]
+  }
+};
+const CODE_FENCE = /```([a-zA-Z0-9]*)\n([\s\S]*?)```/;
+const THINK = /<think>([\s\S]*?)<\/think>/;
+const defaultBlocks = {
+  // An embed: a self-closing <patchwork-view .../> tag, rendered as the live element.
+  embed: {
+    pattern: /<patchwork-view\b[^>]*?\/>/,
+    parse(tag) {
+      const attr = (n) => tag.match(new RegExp(`\\b${n}="([^"]*)"`))?.[1] ?? tag.match(new RegExp(`\\b${n}='([^']*)'`))?.[1];
+      return { url: attr("doc-url"), toolId: attr("tool-id"), width: attr("width"), height: attr("height") };
+    },
+    token({ url, toolId, width, height }) {
+      return `<patchwork-view doc-url="${url}"` + (toolId ? ` tool-id="${toolId}"` : "") + (width ? ` width="${width}"` : "") + (height ? ` height="${height}"` : "") + `/>`;
+    },
+    toDOM({ url, toolId, width, height }) {
+      const el = document.createElement("patchwork-view");
+      if (url)
+        el.setAttribute("doc-url", url);
+      if (toolId)
+        el.setAttribute("tool-id", toolId);
+      if (width)
+        el.style.width = width + "px";
+      if (height)
+        el.style.height = height + "px";
+      return el;
+    },
+    toHTML({ url, toolId, width, height }) {
+      const style = (width ? `width:${escapeAttr(width)}px;` : "") + (height ? `height:${escapeAttr(height)}px;` : "");
+      const attrs = (url ? ` doc-url="${escapeAttr(url)}"` : "") + (toolId ? ` tool-id="${escapeAttr(toolId)}"` : "") + (style ? ` style="${escapeAttr(style)}"` : "");
+      return `<patchwork-view${attrs}></patchwork-view>`;
+    }
+  },
+  // A fenced code block: ```lang\n…\n```
+  codeblock: {
+    pattern: CODE_FENCE,
+    parse(s) {
+      const m = s.match(CODE_FENCE);
+      return { lang: m?.[1] || "", code: m?.[2] ?? "" };
+    },
+    toDOM({ lang, code }) {
+      const pre = document.createElement("pre");
+      pre.className = "cutetxt-codeblock";
+      const codeEl = document.createElement("code");
+      if (lang)
+        codeEl.className = "language-" + lang;
+      codeEl.textContent = code;
+      pre.append(codeEl);
+      return pre;
+    },
+    toHTML({ lang, code }) {
+      const cls = lang ? ` class="language-${escapeAttr(lang)}"` : "";
+      return `<pre class="cutetxt-codeblock"><code${cls}>${escapeHTML(code)}</code></pre>`;
+    }
+  },
+  // A <think>…</think> block.
+  think: {
+    pattern: THINK,
+    parse(s) {
+      return { text: s.match(THINK)?.[1] ?? "" };
+    },
+    toDOM({ text }) {
+      const div = document.createElement("div");
+      div.className = "cutetxt-think";
+      div.textContent = text;
+      return div;
+    },
+    toHTML({ text }) {
+      return `<div class="cutetxt-think">${escapeHTML(text)}</div>`;
+    }
+  }
+};
+const EMOJI = {
+  smile: "🙂",
+  grin: "😀",
+  joy: "😂",
+  heart: "❤️",
+  fire: "🔥",
+  tada: "🎉",
+  eyes: "👀",
+  "+1": "👍",
+  "-1": "👎",
+  rocket: "🚀",
+  sparkles: "✨",
+  thinking: "🤔"
+};
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+const EMOJI_RE = new RegExp(":(" + Object.keys(EMOJI).map(escapeRe).join("|") + "):");
+const defaultReplaces = {
+  emoji: {
+    pattern: EMOJI_RE,
+    parse(s) {
+      return { name: s.slice(1, -1) };
+    },
+    toDOM({ name }) {
+      const span = document.createElement("span");
+      span.className = "cutetxt-emoji";
+      span.textContent = EMOJI[name] ?? ":" + name + ":";
+      return span;
+    },
+    toHTML({ name }) {
+      return `<span class="cutetxt-emoji">${escapeHTML(EMOJI[name] ?? ":" + name + ":")}</span>`;
+    }
+  }
+};
+const defaultAutocompletes = {
+  emoji: {
+    // require ≥1 char after `:` so a bare `:` (or the trailing `:` of a just-
+    // inserted `:fire:`) doesn't reopen the popup.
+    trigger: /:([\w+-]+)$/,
+    options(query) {
+      const q = (query || "").toLowerCase();
+      return Object.keys(EMOJI).filter((name) => name.includes(q)).slice(0, 8).map((name) => ({ label: name, detail: EMOJI[name], insert: ":" + name + ":" }));
+    }
+  }
+};
+const defaultSchema = defineRichSchema({
+  marks: defaultMarks,
+  blocks: defaultBlocks,
+  replaces: defaultReplaces
+});
+const read = (v, fallback) => (typeof v === "function" ? v() : v) ?? fallback;
+function CuteText(props) {
+  const el = document.createElement("div");
+  el.className = "cutetxt-rendered";
+  createEffect(() => {
+    const rendered = renderMarkup(read(props.text, ""), read(props.schema, defaultSchema));
+    el.replaceChildren(...rendered.childNodes);
+  });
+  return el;
+}
+var _tmpl$ = /* @__PURE__ */ template(`<span class=comments-thread-resolved-label>Resolved`), _tmpl$2 = /* @__PURE__ */ template(`<span class=comments-thread-doc-level>On this document`), _tmpl$3 = /* @__PURE__ */ template(`<div><div class=comments-thread-card-body>`), _tmpl$4 = /* @__PURE__ */ template(`<button class=comment-btn>Cancel`), _tmpl$5 = /* @__PURE__ */ template(`<button class=comment-btn>Save`), _tmpl$6 = /* @__PURE__ */ template(`<div class=comments-thread-actions>`), _tmpl$7 = /* @__PURE__ */ template(`<button class=comment-btn title="Reopen comment">Reopen`), _tmpl$8 = /* @__PURE__ */ template(`<button class=comment-btn title="Resolve comment">Resolve`), _tmpl$9 = /* @__PURE__ */ template(`<button class=comment-btn title="Reply to comment">Reply`), _tmpl$0 = /* @__PURE__ */ template(`<span class=comment-timestamp>`), _tmpl$1 = /* @__PURE__ */ template(`<div class=comment-card><div class=comment-header><div class=comment-author><patchwork-view tool-id=contact-avatar></patchwork-view><span class=comment-author-name>`, true, false, false), _tmpl$10 = /* @__PURE__ */ template(`<div class=comment-content>`), _tmpl$11 = /* @__PURE__ */ template(`<div class="cutetxt-editor comment-draft-editor">`);
+function CommentThreadView(props) {
+  const [, contactHandle] = subscribeDoc(props.element, {
+    type: "patchwork:contact"
+  });
+  const currentContactUrl = () => contactHandle()?.url;
+  const [thread, setThread] = createSignal(props.handle.doc());
+  createEffect(() => {
+    const h = props.handle;
+    setThread(() => h.doc());
+    const onChange = () => setThread(() => h.doc());
+    h.on("change", onChange);
+    onCleanup(() => h.off("change", onChange));
+  });
+  const state = createElementAttribute(props.element, "data-thread-state", "primary");
+  const isPrimary = () => state() === "primary";
+  const stateClass = () => state() === "primary" ? "comments-thread-card--primary" : state() === "secondary" ? "comments-thread-card--secondary" : "comments-thread-card--inactive";
+  const isDocLevel = createMemo(() => {
+    const refs = thread()?.refs ?? [];
+    return refs.length > 0 && refs.every((ref) => !ref.includes("/") && !ref.includes("#"));
+  });
+  const isResolved = () => thread()?.isResolved ?? false;
+  const cardClass = () => `comments-thread-card ${stateClass()}${isResolved() ? " comments-thread-card--resolved" : ""}`;
+  const commentIds = createMemo((prev) => {
+    const t = thread();
+    if (!t) return [];
+    const next = [];
+    for (const c of t.comments) next.push(c.id);
+    if (prev && prev.length === next.length && next.every((id, i) => id === prev[i])) {
+      return prev;
+    }
+    return next;
+  }, []);
+  const draftComment = createMemo(() => {
+    const t = thread();
+    if (!t) return void 0;
+    const isDraft = (c) => c.draftContent !== void 0 || c.content === void 0;
+    const contactUrl = currentContactUrl();
+    return t.comments.find((c) => isDraft(c) && c.contactUrl === contactUrl) ?? t.comments.find(isDraft);
+  });
+  const draftCommentHandle = createMemo(() => {
+    const t = thread();
+    const d = draftComment();
+    if (!t || !d) return void 0;
+    return props.handle.sub("comments", {
+      id: d.id
+    });
+  });
+  const onResolveThread = () => {
+    props.handle.change((t) => {
+      t.isResolved = true;
+    });
+  };
+  const onReopenThread = () => {
+    props.handle.change((t) => {
+      t.isResolved = false;
+    });
+  };
+  const onReplyToComment = () => {
+    const contactUrl = currentContactUrl();
+    if (!contactUrl) return;
+    createReply({
+      threadHandle: props.handle,
+      content: "",
+      contactUrl
+    });
+  };
+  const onDeleteComment = (commentHandle) => {
+    commentHandle.remove();
+    if (props.handle.doc()?.comments.length === 0) {
+      props.handle.remove();
+    }
+  };
+  const onSaveDraft = () => {
+    const h = draftCommentHandle();
+    if (!h) return;
+    h.change((comment) => {
+      comment.content = comment.draftContent;
+      comment.timestamp = Date.now();
+      delete comment.draftContent;
+    });
+  };
+  const onCancelDraft = () => {
+    const h = draftCommentHandle();
+    if (!h) return;
+    const commentValue = h.doc();
+    if (commentValue?.content === void 0) {
+      onDeleteComment(h);
+      return;
+    }
+    h.change((comment) => {
+      delete comment.draftContent;
+    });
+  };
+  return createComponent(Show, {
+    get when() {
+      return thread();
+    },
+    get children() {
+      return [(() => {
+        var _el$ = _tmpl$3(), _el$2 = _el$.firstChild;
+        insert(_el$2, createComponent(Show, {
+          get when() {
+            return isResolved();
+          },
+          get children() {
+            return _tmpl$();
+          }
+        }), null);
+        insert(_el$2, createComponent(Show, {
+          get when() {
+            return isDocLevel();
+          },
+          get children() {
+            return _tmpl$2();
+          }
+        }), null);
+        insert(_el$2, createComponent(For, {
+          get each() {
+            return commentIds();
+          },
+          children: (commentId) => {
+            const commentHandle = createMemo(() => props.handle.sub("comments", {
+              id: commentId
+            }));
+            return createComponent(Show, {
+              get when() {
+                return commentHandle();
+              },
+              children: (handle) => createComponent(CommentView, {
+                get commentHandle() {
+                  return handle();
+                },
+                get currentContactUrl() {
+                  return currentContactUrl();
+                },
+                get repo() {
+                  return props.repo;
+                }
+              })
+            });
+          }
+        }), null);
+        effect(() => className(_el$, cardClass()));
+        return _el$;
+      })(), createComponent(Show, {
+        get when() {
+          return draftComment() || isResolved() || isPrimary();
+        },
+        get children() {
+          var _el$5 = _tmpl$6();
+          insert(_el$5, createComponent(Show, {
+            get when() {
+              return draftComment();
+            },
+            get fallback() {
+              return createComponent(Show, {
+                get when() {
+                  return isResolved();
+                },
+                get fallback() {
+                  return [(() => {
+                    var _el$9 = _tmpl$8();
+                    _el$9.$$click = onResolveThread;
+                    return _el$9;
+                  })(), (() => {
+                    var _el$0 = _tmpl$9();
+                    _el$0.$$click = onReplyToComment;
+                    return _el$0;
+                  })()];
+                },
+                get children() {
+                  var _el$8 = _tmpl$7();
+                  _el$8.$$click = onReopenThread;
+                  return _el$8;
+                }
+              });
+            },
+            get children() {
+              return [(() => {
+                var _el$6 = _tmpl$4();
+                _el$6.$$click = onCancelDraft;
+                return _el$6;
+              })(), (() => {
+                var _el$7 = _tmpl$5();
+                _el$7.$$click = onSaveDraft;
+                return _el$7;
+              })()];
+            }
+          }));
+          return _el$5;
+        }
+      })];
+    }
+  });
+}
+function CommentView(props) {
+  const [comment, setComment] = createSignal(void 0);
+  createEffect(() => {
+    const h = props.commentHandle;
+    setComment(() => h.doc());
+    const onChange = () => setComment(() => h.doc());
+    h.on("change", onChange);
+    onCleanup(() => h.off("change", onChange));
+  });
+  const contactUrl = () => comment()?.contactUrl;
+  const [contact] = useDocument(contactUrl, {
+    repo: props.repo
+  });
+  const isDraft = () => {
+    const c = comment();
+    if (!c) return false;
+    return c.draftContent !== void 0 || c.content === void 0;
+  };
+  const shouldRender = () => {
+    const c = comment();
+    if (!c) return false;
+    if (isDraft() && c.contactUrl !== props.currentContactUrl) return false;
+    return true;
+  };
+  const contactName = () => {
+    const ct = contact();
+    return ct?.type === "registered" ? ct.name : "Anonymous";
+  };
+  return createComponent(Show, {
+    get when() {
+      return memo(() => !!shouldRender())() && comment();
+    },
+    get children() {
+      var _el$1 = _tmpl$1(), _el$10 = _el$1.firstChild, _el$11 = _el$10.firstChild, _el$12 = _el$11.firstChild, _el$13 = _el$12.nextSibling;
+      _el$12._$owner = getOwner();
+      insert(_el$13, contactName);
+      insert(_el$10, createComponent(Show, {
+        get when() {
+          return memo(() => !!!isDraft())() && comment().timestamp;
+        },
+        get children() {
+          var _el$14 = _tmpl$0();
+          insert(_el$14, () => relativeTime(comment().timestamp));
+          return _el$14;
+        }
+      }), null);
+      insert(_el$1, createComponent(Show, {
+        get when() {
+          return isDraft();
+        },
+        get fallback() {
+          return (() => {
+            var _el$15 = _tmpl$10();
+            insert(_el$15, createComponent(CuteText, {
+              text: () => comment()?.content ?? ""
+            }));
+            return _el$15;
+          })();
+        },
+        get children() {
+          return createComponent(CuteDraftEditor, {
+            get commentHandle() {
+              return props.commentHandle;
+            },
+            get repo() {
+              return props.repo;
+            }
+          });
+        }
+      }), null);
+      effect((_p$) => {
+        var _v$ = props.commentHandle.url, _v$2 = comment().contactUrl;
+        _v$ !== _p$.e && setAttribute(_el$1, "data-id", _p$.e = _v$);
+        _v$2 !== _p$.t && (_el$12.docUrl = _p$.t = _v$2);
+        return _p$;
+      }, {
+        e: void 0,
+        t: void 0
+      });
+      return _el$1;
+    }
+  });
+}
+function CuteDraftEditor(props) {
+  let parent;
+  onMount(() => {
+    const handle = props.commentHandle;
+    if (typeof handle.doc()?.draftContent !== "string") {
+      handle.change((c) => {
+        if (typeof c.draftContent !== "string") c.draftContent = "";
+      });
+    }
+    const editor = createCuteEditor({
+      handle,
+      path: ["draftContent"],
+      schema: defaultSchema,
+      // `defaultAutocompletes` is a map keyed by id; the editor wants the specs
+      // as a flat array (e.g. the built-in emoji `:` completer).
+      autocompletes: Object.values(defaultAutocompletes),
+      parent,
+      repo: props.repo
+    });
+    editor.view.focus();
+    const onKeyDown = (event) => {
+      if (!(event.metaKey || event.ctrlKey) || event.code !== "Space") return;
+      event.preventDefault();
+      event.stopPropagation();
+      const draft = handle.doc()?.draftContent ?? "";
+      if (!draft.trim()) return;
+      handle.change((c) => {
+        c.content = c.draftContent;
+        c.timestamp = Date.now();
+        delete c.draftContent;
+      });
+    };
+    parent.addEventListener("keydown", onKeyDown, true);
+    onCleanup(() => {
+      parent.removeEventListener("keydown", onKeyDown, true);
+      editor.destroy();
+    });
+  });
+  return (() => {
+    var _el$16 = _tmpl$11();
+    var _ref$ = parent;
+    typeof _ref$ === "function" ? use(_ref$, _el$16) : parent = _el$16;
+    return _el$16;
+  })();
+}
+function createElementAttribute(element, name, fallback) {
+  const read2 = () => element.getAttribute(name) ?? fallback;
+  const [value, setValue] = createSignal(read2());
+  onMount(() => {
+    const observer = new MutationObserver(() => setValue(read2()));
+    observer.observe(element, {
+      attributes: true,
+      attributeFilter: [name]
+    });
+    setValue(read2());
+    onCleanup(() => observer.disconnect());
+  });
+  return value;
+}
+delegateEvents(["click"]);
+function ensureCuteStyle() {
+  const id = "cute-txt-style";
+  if (typeof document === "undefined" || document.getElementById(id)) return;
+  const style = document.createElement("style");
+  style.id = id;
+  style.textContent = STYLE;
+  document.head.append(style);
+}
+ensureCuteStyle();
+const renderCommentsView = (_handle, element) => {
+  return render(() => createComponent(RepoContext.Provider, {
+    get value() {
+      return element.repo;
+    },
+    get children() {
+      return createComponent(CommentsView, {
+        element
+      });
+    }
+  }), element);
+};
+const renderCommentThread = (handle, element) => {
+  return render(() => createComponent(RepoContext.Provider, {
+    get value() {
+      return element.repo;
+    },
+    get children() {
+      return createComponent(CommentThreadView, {
+        handle,
+        element,
+        get repo() {
+          return element.repo;
+        }
+      });
+    }
+  }), element);
+};
+export {
+  renderCommentThread,
+  renderCommentsView
+};
+//# sourceMappingURL=main-C8GVksuY.js.map