g-comments 0.0.0-stage → 0.1.0

package/dist/chunk-6E3M3PQN.js

@@ -0,0 +1,3056 @@
+// src/constants.ts
+var PACKAGE_NAME = "g-comments";
+var AUTH_MESSAGE_TYPE = "g-comments:auth";
+var REDIRECT_CODE_PARAM = "gc_code";
+var REDIRECT_NONCE_PARAM = "gc_nonce";
+var STORAGE_PREFIX = "gc";
+var COUNTS_BATCH_SIZE = 50;
+var REFETCH_BATCH_SIZE = 50;
+var CLIENT_ID_FORMAT = /^[\w-]{8,64}$/;
+
+// src/errors.ts
+var SERVER_TYPES = /* @__PURE__ */ new Set([
+  "invalid_key",
+  "not_logged_in",
+  "invalid_access",
+  "invalid_parameters",
+  "not_found",
+  "rate_limit",
+  "thread_conflict",
+  "page_not_allowed",
+  "invalid_url",
+  "no_category",
+  "thread_not_created",
+  "invalid_grant",
+  "user_not_allowed",
+  "submission_rejected",
+  "not_a_root_comment",
+  "pin_limit_reached"
+]);
+var TYPE_BY_STATUS = {
+  400: "invalid_parameters",
+  401: "invalid_key",
+  403: "invalid_access",
+  404: "not_found",
+  409: "thread_conflict",
+  422: "invalid_parameters",
+  429: "rate_limit"
+};
+var CommentsError = class extends Error {
+  name = "CommentsError";
+  type;
+  /** HTTP status, or 0 when no response was received. */
+  status;
+  /** Human-readable messages from the server, safe to show inline. */
+  errors;
+  extras;
+  /** Seconds until a rate-limited action may be retried. */
+  waitSeconds;
+  /** Developer-facing explanation of the probable cause (setup problems). */
+  hint;
+  /** The raw `error_type` from the server, if it sent one. */
+  serverType;
+  constructor(type, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.type = type;
+    this.status = options.status ?? 0;
+    this.errors = options.errors ?? (message ? [message] : []);
+    this.extras = options.extras;
+    this.waitSeconds = options.waitSeconds;
+    this.hint = options.hint;
+    this.serverType = options.serverType;
+  }
+};
+function isCommentsError(error) {
+  return error instanceof CommentsError;
+}
+function errorFromResponse(status, body, headers) {
+  const serverType = typeof body?.error_type === "string" ? body.error_type : void 0;
+  const type = serverType && SERVER_TYPES.has(serverType) ? serverType : TYPE_BY_STATUS[status] ?? "unknown";
+  const errors = Array.isArray(body?.errors) ? body.errors.filter((e) => typeof e === "string") : [];
+  const extras = body?.extras && typeof body.extras === "object" ? body.extras : void 0;
+  return new CommentsError(type, errors[0] ?? `Request failed with status ${status}`, {
+    status,
+    errors,
+    extras,
+    serverType,
+    waitSeconds: type === "rate_limit" ? waitSecondsFrom(extras, headers) : void 0
+  });
+}
+function waitSecondsFrom(extras, headers) {
+  return seconds(extras?.wait_seconds) ?? seconds(headers?.get("Retry-After"));
+}
+function seconds(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && value >= 0 ? value : void 0;
+  }
+  if (typeof value === "string" && /^\s*\d+(\.\d+)?\s*$/.test(value)) {
+    return Number(value);
+  }
+  return void 0;
+}
+function unreachableError(forum, origin, cause) {
+  const from = origin ? `this page's origin (${origin})` : "this page's origin";
+  const hint = [
+    `${PACKAGE_NAME} could not reach ${forum}. Probable causes:`,
+    `- ${from} is not allowed: add the host under Admin \u2192 Customize \u2192 Embedding on the forum, or to the discourse_comments_allowed_origins setting;`,
+    "- the forum is behind HTTP basic auth, which rejects CORS preflight (OPTIONS) requests: let OPTIONS through without credentials;",
+    "- the discourse-comments plugin is disabled (discourse_comments_enabled);",
+    "- the forum URL is wrong or the forum is offline."
+  ].join("\n");
+  return new CommentsError("unreachable", `Could not reach ${forum}`, {
+    status: 0,
+    errors: [],
+    hint,
+    cause
+  });
+}
+
+// src/core/storage.ts
+function memoryStorage() {
+  const items = /* @__PURE__ */ new Map();
+  return {
+    durable: false,
+    getItem: (key) => items.get(key) ?? null,
+    setItem: (key, value) => void items.set(key, value),
+    removeItem: (key) => void items.delete(key)
+  };
+}
+function signInStorage(storage) {
+  if (storage.durable !== false) {
+    return storage;
+  }
+  try {
+    const session = globalThis.sessionStorage;
+    if (session) {
+      const probe = "gc:probe";
+      session.setItem(probe, probe);
+      const readable = session.getItem(probe) === probe;
+      session.removeItem(probe);
+      if (readable) {
+        return session;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function browserStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    if (storage) {
+      const probe = "gc:probe";
+      storage.setItem(probe, probe);
+      storage.removeItem(probe);
+      return { storage, isLocalStorage: true };
+    }
+  } catch {
+  }
+  return { storage: memoryStorage(), isLocalStorage: false };
+}
+function isLocalStorage(storage) {
+  try {
+    return storage === globalThis.localStorage;
+  } catch {
+    return false;
+  }
+}
+function readJson(storage, key) {
+  try {
+    const raw = storage.getItem(key);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function writeJson(storage, key, value) {
+  try {
+    storage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+function removeItem(storage, key) {
+  try {
+    storage.removeItem(key);
+  } catch {
+  }
+}
+
+// src/core/env.ts
+function getWindow() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+function getDocument() {
+  return typeof document === "undefined" ? void 0 : document;
+}
+function pageOrigin() {
+  return getWindow()?.location.origin;
+}
+function defaultPageUrl() {
+  const canonical = getDocument()?.querySelector('link[rel="canonical"]');
+  if (canonical?.href) {
+    return canonical.href;
+  }
+  return getWindow()?.location.href;
+}
+function defaultPageTitle() {
+  return getDocument()?.title || void 0;
+}
+function currentUrlWithoutHash() {
+  const location = getWindow()?.location;
+  if (!location) {
+    return void 0;
+  }
+  return location.href.split("#")[0];
+}
+function isDocumentHidden() {
+  return getDocument()?.hidden === true;
+}
+function onVisibilityChange(listener) {
+  const doc = getDocument();
+  if (!doc) {
+    return () => {
+    };
+  }
+  doc.addEventListener("visibilitychange", listener);
+  return () => doc.removeEventListener("visibilitychange", listener);
+}
+
+// src/core/counts.ts
+function encodeRef(ref) {
+  if ("topicId" in ref) {
+    return `t:${ref.topicId}`;
+  }
+  if ("identifier" in ref) {
+    const host = ref.host ?? getWindow()?.location.host;
+    if (!host) {
+      throw new TypeError("A count ref with an identifier needs a host outside the browser");
+    }
+    return `id:${host}/${ref.identifier}`;
+  }
+  return `url:${ref.url}`;
+}
+var MAX_QUERY_LENGTH = 4e3;
+var CountsBatcher = class {
+  #http;
+  #waiters = [];
+  #scheduled = false;
+  constructor(http) {
+    this.#http = http;
+  }
+  request(refs) {
+    const keys = refs.map(encodeRef);
+    if (keys.length === 0) {
+      return Promise.resolve({});
+    }
+    return new Promise((resolve, reject) => {
+      this.#waiters.push({ keys, resolve, reject });
+      if (!this.#scheduled) {
+        this.#scheduled = true;
+        setTimeout(() => void this.#flush(), 0);
+      }
+    });
+  }
+  async #flush() {
+    const waiters = this.#waiters;
+    this.#waiters = [];
+    this.#scheduled = false;
+    const unique = [...new Set(waiters.flatMap((w) => w.keys))];
+    const batches = [];
+    let current = [];
+    let length = 0;
+    for (const key of unique) {
+      const cost = encodeURIComponent(key).length + "&refs[]=".length;
+      if (current.length > 0 && (current.length >= COUNTS_BATCH_SIZE || length + cost > MAX_QUERY_LENGTH)) {
+        batches.push(current);
+        current = [];
+        length = 0;
+      }
+      current.push(key);
+      length += cost;
+    }
+    if (current.length > 0) {
+      batches.push(current);
+    }
+    const results = /* @__PURE__ */ new Map();
+    const failures = /* @__PURE__ */ new Map();
+    await Promise.all(
+      batches.map(async (batch) => {
+        try {
+          const response = await this.#http.request("GET", "/counts", {
+            query: { refs: batch },
+            anonymous: true
+          });
+          for (const key of batch) {
+            results.set(key, Number(response.counts?.[key] ?? 0));
+          }
+        } catch (error) {
+          for (const key of batch) {
+            failures.set(key, error);
+          }
+        }
+      })
+    );
+    for (const waiter of waiters) {
+      const failed = waiter.keys.find((key) => failures.has(key));
+      if (failed !== void 0) {
+        waiter.reject(failures.get(failed));
+        continue;
+      }
+      const counts = {};
+      for (const key of waiter.keys) {
+        counts[key] = results.get(key) ?? 0;
+      }
+      waiter.resolve(counts);
+    }
+  }
+};
+
+// src/types.ts
+function isVirtualThread(thread) {
+  return thread.topic_id === null;
+}
+
+// src/core/composer.ts
+var TYPING_WINDOW_MS = 100;
+function createComposerTimer(now = Date.now) {
+  let openedAt = null;
+  let typingMs = 0;
+  let lastTypingAt = -Infinity;
+  const measure = () => ({
+    typingDurationMsecs: typingMs,
+    composerOpenDurationMsecs: openedAt === null ? 0 : Math.max(0, now() - openedAt)
+  });
+  return {
+    get started() {
+      return openedAt !== null;
+    },
+    start() {
+      openedAt ??= now();
+    },
+    typing() {
+      openedAt ??= now();
+      const at = now();
+      if (at - lastTypingAt >= TYPING_WINDOW_MS) {
+        typingMs += TYPING_WINDOW_MS;
+        lastTypingAt = at;
+      }
+    },
+    measure,
+    stop() {
+      const timing = measure();
+      openedAt = null;
+      typingMs = 0;
+      lastTypingAt = -Infinity;
+      return timing;
+    }
+  };
+}
+
+// src/core/emitter.ts
+var Emitter = class {
+  #listeners = /* @__PURE__ */ new Set();
+  get size() {
+    return this.#listeners.size;
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  emit(value) {
+    for (const listener of [...this.#listeners]) {
+      try {
+        listener(value);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+  clear() {
+    this.#listeners.clear();
+  }
+};
+
+// src/core/http.ts
+function normalizeForum(forum) {
+  let url;
+  try {
+    url = new URL(forum);
+  } catch {
+    throw new TypeError(`${PACKAGE_NAME}: "forum" must be an absolute URL, got "${forum}"`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new TypeError(`${PACKAGE_NAME}: "forum" must be an http(s) URL, got "${forum}"`);
+  }
+  return { origin: url.origin, base: url.origin + url.pathname.replace(/\/+$/, "") };
+}
+function buildQuery(query) {
+  if (!query) {
+    return "";
+  }
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        parts.push(`${encodeURIComponent(key)}[]=${encodeURIComponent(String(item))}`);
+      }
+    } else {
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return parts.join("&");
+}
+function threadPath(threadId) {
+  return `/threads/${encodeURIComponent(threadId).replace(/%3A/gi, ":")}`;
+}
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+var Http = class {
+  forum;
+  #options;
+  #fetch;
+  constructor(options) {
+    this.forum = options.forum;
+    this.#options = options;
+    this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  get fetch() {
+    return this.#fetch;
+  }
+  url(path, query) {
+    const qs = buildQuery(query);
+    const url = `${this.forum.base}/comments${path}`;
+    return qs ? `${url}?${qs}` : url;
+  }
+  async request(method, path, options = {}) {
+    const headers = {
+      Accept: "application/json",
+      ...this.#options.headers
+    };
+    const language = acceptLanguage(this.#options.locale);
+    if (language) {
+      headers["Accept-Language"] = language;
+    }
+    let body;
+    if (options.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.json);
+    } else if (options.form) {
+      body = options.form;
+    }
+    const credentials = options.anonymous ? null : options.credentials ?? this.#options.credentials();
+    if (credentials) {
+      headers["User-Api-Key"] = credentials.key;
+      headers["User-Api-Client-Id"] = credentials.clientId;
+    }
+    const url = this.url(path, options.query);
+    const lifetime = options.detached ? void 0 : this.#options.lifetime;
+    if (lifetime?.aborted) {
+      throw new DOMException("The comments client was disposed", "AbortError");
+    }
+    const signal = combineSignals(options.signal, lifetime);
+    this.#options.log(method, url);
+    let response;
+    try {
+      response = await this.#fetch(url, {
+        method,
+        headers,
+        body,
+        credentials: "omit",
+        mode: "cors",
+        signal
+      });
+    } catch (error2) {
+      if (signal?.aborted || isAbortError(error2)) {
+        throw error2;
+      }
+      throw unreachableError(this.forum.base, pageOrigin(), error2);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    const data = parseJson(text);
+    if (response.ok) {
+      if (data === void 0) {
+        throw new CommentsError("unknown", "The forum returned a non-JSON response", {
+          status: response.status
+        });
+      }
+      return data;
+    }
+    const errorBody = isObject(data) ? data : null;
+    const error = errorFromResponse(response.status, errorBody, response.headers);
+    if (response.status === 401 && error.serverType === "invalid_key" && credentials && errorBody?.degraded !== true) {
+      this.#options.onInvalidKey(credentials.key);
+    }
+    throw error;
+  }
+};
+function acceptLanguage(locale) {
+  const value = locale?.replace(/_/g, "-");
+  return value && /^[0-9A-Za-z *,\-.;=]+$/.test(value) ? value : void 0;
+}
+function combineSignals(a, b) {
+  if (!a || !b) {
+    return a ?? b;
+  }
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([a, b]);
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  if (a.aborted || b.aborted) {
+    abort();
+  }
+  a.addEventListener("abort", abort, { once: true });
+  b.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
+function parseJson(text) {
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/pkce.ts
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function randomToken(bytes) {
+  const buffer = new Uint8Array(bytes);
+  globalThis.crypto.getRandomValues(buffer);
+  return base64url(buffer);
+}
+async function codeChallenge(verifier) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("Signing in requires a secure context (https or localhost).");
+  }
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return base64url(new Uint8Array(digest));
+}
+
+// src/core/auth.ts
+var PENDING_TTL_MS = 15 * 6e4;
+var POPUP_NAME = "gc-auth";
+var POPUP_WIDTH = 520;
+var POPUP_HEIGHT = 680;
+var CLOSED_CHECK_MS = 500;
+var CLOSED_GRACE_MS = 1e3;
+var AuthController = class {
+  clientId;
+  #options;
+  #keys;
+  #stored;
+  #state;
+  #emitter = new Emitter();
+  #attempt = null;
+  #redirect = null;
+  #stopSync = null;
+  /** Bumped on sign-out and dispose; an exchange started earlier must not sign anyone in. */
+  #generation = 0;
+  constructor(options) {
+    this.#options = options;
+    const prefix = `${STORAGE_PREFIX}:${options.forum.base}`;
+    this.#keys = {
+      auth: `${prefix}:auth`,
+      clientId: `${prefix}:client_id`,
+      pending: `${prefix}:pending`
+    };
+    this.clientId = this.#resolveClientId(options.clientId);
+    this.#stored = this.#readStored();
+    this.#state = Object.freeze({
+      status: this.#stored ? "signed-in" : "anonymous",
+      user: this.#stored?.user ?? null,
+      degraded: false,
+      error: null
+    });
+    const win = getWindow();
+    if (options.syncAcrossTabs && win) {
+      win.addEventListener("storage", this.#onStorage);
+      this.#stopSync = () => win.removeEventListener("storage", this.#onStorage);
+    }
+  }
+  get status() {
+    return this.#state.status;
+  }
+  get user() {
+    return this.#state.user;
+  }
+  get providers() {
+    return this.#options.providers();
+  }
+  state() {
+    return this.#state;
+  }
+  onChange(listener) {
+    return this.#emitter.on(listener);
+  }
+  /** Headers for the current key; the client id is the one that minted it. */
+  credentials() {
+    return this.#stored ? { key: this.#stored.key, clientId: this.#stored.client_id } : null;
+  }
+  signIn(options = {}) {
+    if (this.#attempt) {
+      const popup2 = this.#attempt.popup;
+      if (popup2 && !popup2.closed) {
+        popup2.focus();
+        return this.#attempt.promise;
+      }
+      this.#attempt.cancel(new CommentsError("cancelled", "Sign-in was restarted"));
+    }
+    const win = getWindow();
+    if (!win) {
+      return Promise.reject(new CommentsError("unknown", "Signing in needs a browser window"));
+    }
+    const previous = this.#readPending();
+    const nonce = previous?.nonce ?? randomToken(16);
+    const verifier = previous?.verifier ?? randomToken(32);
+    const opened = (options.mode ?? "popup") === "popup" ? openPopup(win) : null;
+    const popup = opened && !opened.closed ? opened : null;
+    let popupNavigated = false;
+    let cancelledWith = null;
+    let rejectCancelled = () => {
+    };
+    const cancelled = new Promise((_, reject) => {
+      rejectCancelled = reject;
+    });
+    cancelled.catch(() => {
+    });
+    let stopPopup = () => {
+    };
+    const writePending = (mode) => this.#options.pendingStorage && writeJson(this.#options.pendingStorage, this.#keys.pending, {
+      nonce,
+      verifier,
+      mode,
+      created_at: previous?.created_at ?? Date.now()
+    });
+    const run = async () => {
+      const challenge = await codeChallenge(verifier);
+      if (cancelledWith) {
+        throw cancelledWith;
+      }
+      const url = this.#startUrl(nonce, challenge, options.provider);
+      if (popup) {
+        if (popup.closed) {
+          throw new CommentsError("cancelled", "The sign-in window was closed");
+        }
+        writePending("popup");
+        popupNavigated = navigatePopup(popup, url);
+      }
+      if (!popupNavigated) {
+        if (!this.#options.pendingStorage) {
+          throw new CommentsError(
+            "storage_unavailable",
+            "Signing in needs a popup or browser storage, and this page has neither. Allow popups for this site, or enable site data (localStorage/sessionStorage)."
+          );
+        }
+        writePending("redirect");
+        this.#options.log("popup unavailable, redirecting");
+        win.addEventListener("pageshow", this.#onPageShow);
+        (this.#options.navigate ?? ((target) => win.location.assign(target)))(url);
+        return null;
+      }
+      const outcome = await this.#waitForPopup(win, popup, nonce, (stop) => {
+        stopPopup = stop;
+      });
+      if (outcome.kind === "user") {
+        return outcome.user;
+      }
+      return this.#exchange(outcome.code, verifier, nonce, () => cancelledWith);
+    };
+    this.#set({ status: "signing-in", error: null });
+    const attempt = {
+      popup,
+      cancel: (error) => {
+        cancelledWith = error;
+        stopPopup();
+        rejectCancelled(error);
+      },
+      promise: Promise.race([run(), cancelled]).then(
+        (user) => {
+          if (this.#attempt === attempt) {
+            this.#attempt = null;
+          }
+          return user;
+        },
+        (error) => {
+          const failure = toCommentsError(error);
+          if (popup && !popupNavigated && !popup.closed) {
+            popup.close();
+          }
+          if (this.#attempt !== attempt) {
+            throw failure;
+          }
+          this.#attempt = null;
+          if (failure.type !== "cancelled") {
+            this.#removePending();
+          }
+          this.#set({ status: this.#stored ? "signed-in" : "anonymous", error: failure });
+          throw failure;
+        }
+      )
+    };
+    this.#attempt = attempt;
+    return attempt.promise;
+  }
+  cancelSignIn() {
+    this.#attempt?.cancel(new CommentsError("cancelled", "Sign-in was cancelled"));
+  }
+  async signOut() {
+    this.#generation++;
+    this.cancelSignIn();
+    this.#removePending();
+    if (this.#stored) {
+      try {
+        await this.#options.http.request("POST", "/auth/revoke");
+      } catch (error) {
+        this.#options.log("revoke failed", error);
+      }
+    }
+    this.#clearStored();
+    this.#set({ status: "anonymous", user: null, degraded: false, error: null });
+  }
+  handleRedirect() {
+    if (!this.#redirect) {
+      this.#redirect = this.#consumeRedirect();
+      this.#redirect.catch(() => {
+      });
+    }
+    return this.#redirect;
+  }
+  /** Called by the HTTP layer on 401 `invalid_key` for the key it sent. */
+  invalidate(sentKey) {
+    if (!this.#stored || this.#stored.key !== sentKey) {
+      return;
+    }
+    const latest = this.#readStored();
+    if (latest && latest.key !== sentKey) {
+      this.#stored = latest;
+      this.#set({ status: "signed-in", user: latest.user, error: null });
+      return;
+    }
+    this.#clearStored();
+    this.#set({
+      status: this.#attempt ? "signing-in" : "anonymous",
+      user: null,
+      degraded: false,
+      error: new CommentsError("invalid_key", "Your session has expired. Please sign in again.", {
+        status: 401
+      })
+    });
+  }
+  /** Folds `/comments/config` into the auth state. */
+  applyConfig(config) {
+    if (this.#stored && config.current_user) {
+      this.#stored = { ...this.#stored, user: config.current_user };
+      writeJson(this.#options.storage, this.#keys.auth, this.#stored);
+    }
+    this.#set({ degraded: config.degraded === true, user: this.#stored?.user ?? null });
+  }
+  dispose() {
+    this.#generation++;
+    this.cancelSignIn();
+    getWindow()?.removeEventListener("pageshow", this.#onPageShow);
+    this.#stopSync?.();
+    this.#stopSync = null;
+    this.#emitter.clear();
+  }
+  async #consumeRedirect() {
+    const win = getWindow();
+    const hash = win?.location.hash ?? "";
+    if (!win || !hash.includes(`${REDIRECT_CODE_PARAM}=`)) {
+      return null;
+    }
+    const params = new URLSearchParams(hash.slice(1));
+    const code = params.get(REDIRECT_CODE_PARAM);
+    const nonce = params.get(REDIRECT_NONCE_PARAM);
+    const pending = this.#readPending();
+    if (!code || !nonce || !pending || pending.nonce !== nonce) {
+      return null;
+    }
+    win.history.replaceState(win.history.state, "", win.location.pathname + win.location.search);
+    this.#set({ status: "signing-in", error: null });
+    try {
+      const user = await this.#exchange(code, pending.verifier, nonce);
+      if (pending.mode === "popup") {
+        win.close();
+      }
+      return user;
+    } catch (error) {
+      const failure = toCommentsError(error);
+      if (failure.type !== "cancelled") {
+        this.#removePending();
+      }
+      this.#set({ status: this.#stored ? "signed-in" : "anonymous", error: failure });
+      throw failure;
+    }
+  }
+  async #exchange(code, verifier, nonce, cancelled = () => null) {
+    const generation = this.#generation;
+    const tracked = this.#readPending()?.nonce === nonce;
+    const response = await this.#options.http.request("POST", "/auth/exchange", {
+      json: { code, client_id: this.clientId, code_verifier: verifier },
+      anonymous: true,
+      detached: true
+    });
+    const cancellation = cancelled() ?? (generation !== this.#generation ? new CommentsError("cancelled", "Signed out while signing in") : null) ?? // Sign-out in another tab removes the shared pending entry.
+    (tracked && this.#readPending()?.nonce !== nonce ? new CommentsError("cancelled", "The sign-in was abandoned") : null);
+    if (cancellation) {
+      this.#options.http.request("POST", "/auth/revoke", {
+        credentials: { key: response.key, clientId: response.client_id || this.clientId },
+        detached: true
+      }).catch(() => {
+      });
+      throw cancellation;
+    }
+    const stored = {
+      key: response.key,
+      client_id: response.client_id || this.clientId,
+      expires_at: response.expires_at ?? null,
+      user: response.user
+    };
+    this.#stored = stored;
+    writeJson(this.#options.storage, this.#keys.auth, stored);
+    this.#removePending();
+    this.#set({ status: "signed-in", user: stored.user, degraded: false, error: null });
+    return stored.user;
+  }
+  #waitForPopup(win, popup, nonce, registerStop) {
+    return new Promise((resolve, reject) => {
+      let closedSince = null;
+      const onMessage = (event) => {
+        if (event.origin !== this.#options.forum.origin || event.source !== popup) {
+          return;
+        }
+        const data = event.data;
+        if (!data || typeof data !== "object" || data.type !== AUTH_MESSAGE_TYPE || data.nonce !== nonce || typeof data.code !== "string") {
+          return;
+        }
+        stop();
+        resolve({ kind: "code", code: data.code });
+      };
+      const onStorage = (event) => {
+        if (event.key !== this.#keys.auth || !event.newValue) {
+          return;
+        }
+        const stored = this.#readStored();
+        if (stored) {
+          stop();
+          resolve({ kind: "user", user: stored.user });
+        }
+      };
+      const checkClosed = setInterval(() => {
+        if (!popup.closed || !getDocument()?.hasFocus()) {
+          closedSince = null;
+          return;
+        }
+        closedSince ??= Date.now();
+        if (Date.now() - closedSince >= CLOSED_GRACE_MS) {
+          stop();
+          reject(new CommentsError("cancelled", "The sign-in window was closed"));
+        }
+      }, CLOSED_CHECK_MS);
+      const timeout = setTimeout(() => {
+        stop();
+        reject(new CommentsError("cancelled", "Sign-in timed out"));
+      }, PENDING_TTL_MS);
+      const stop = () => {
+        win.removeEventListener("message", onMessage);
+        win.removeEventListener("storage", onStorage);
+        clearInterval(checkClosed);
+        clearTimeout(timeout);
+      };
+      win.addEventListener("message", onMessage);
+      if (this.#options.syncAcrossTabs) {
+        win.addEventListener("storage", onStorage);
+      }
+      registerStop(stop);
+    });
+  }
+  #startUrl(nonce, challenge, provider) {
+    const query = buildQuery({
+      origin: getWindow()?.location.origin,
+      client_id: this.clientId,
+      nonce,
+      code_challenge: challenge,
+      return_to: currentUrlWithoutHash(),
+      provider
+    });
+    return `${this.#options.forum.base}/comments/auth/start?${query}`;
+  }
+  #onPageShow = (event) => {
+    if (!event.persisted) {
+      return;
+    }
+    getWindow()?.removeEventListener("pageshow", this.#onPageShow);
+    if (!this.#attempt && this.#state.status === "signing-in") {
+      this.#set({ status: this.#stored ? "signed-in" : "anonymous" });
+    }
+  };
+  #removePending() {
+    if (this.#options.pendingStorage) {
+      removeItem(this.#options.pendingStorage, this.#keys.pending);
+    }
+  }
+  #readPending() {
+    const storage = this.#options.pendingStorage;
+    const pending = storage ? readJson(storage, this.#keys.pending) : null;
+    if (!pending || typeof pending.nonce !== "string" || typeof pending.verifier !== "string" || typeof pending.created_at !== "number" || Date.now() - pending.created_at > PENDING_TTL_MS) {
+      return null;
+    }
+    return pending;
+  }
+  #onStorage = (event) => {
+    if (event.key !== null && event.key !== this.#keys.auth) {
+      return;
+    }
+    const stored = this.#readStored();
+    if (stored?.key === this.#stored?.key) {
+      return;
+    }
+    this.#stored = stored;
+    this.#set({
+      status: stored ? "signed-in" : this.#attempt ? "signing-in" : "anonymous",
+      user: stored?.user ?? null,
+      degraded: false,
+      error: null
+    });
+  };
+  #resolveClientId(explicit) {
+    if (explicit !== void 0) {
+      if (!CLIENT_ID_FORMAT.test(explicit)) {
+        throw new TypeError(`${PACKAGE_NAME}: "clientId" must match ${CLIENT_ID_FORMAT}`);
+      }
+      return explicit;
+    }
+    const { storage } = this.#options;
+    let stored = null;
+    try {
+      stored = storage.getItem(this.#keys.clientId);
+    } catch {
+      stored = null;
+    }
+    if (stored && CLIENT_ID_FORMAT.test(stored)) {
+      return stored;
+    }
+    const generated = randomToken(24);
+    try {
+      storage.setItem(this.#keys.clientId, generated);
+    } catch {
+    }
+    return generated;
+  }
+  #readStored() {
+    const stored = readJson(this.#options.storage, this.#keys.auth);
+    if (!stored || typeof stored.key !== "string" || typeof stored.client_id !== "string" || !stored.user || typeof stored.user !== "object") {
+      return null;
+    }
+    if (stored.expires_at && Date.parse(stored.expires_at) <= Date.now()) {
+      removeItem(this.#options.storage, this.#keys.auth);
+      return null;
+    }
+    return stored;
+  }
+  #clearStored() {
+    this.#stored = null;
+    removeItem(this.#options.storage, this.#keys.auth);
+  }
+  #set(patch) {
+    const next = { ...this.#state, ...patch };
+    if (next.status === this.#state.status && next.degraded === this.#state.degraded && next.error === this.#state.error && sameUser(next.user, this.#state.user)) {
+      return;
+    }
+    this.#state = Object.freeze(next);
+    this.#emitter.emit(this.#state);
+  }
+};
+function openPopup(win) {
+  const left = Math.round(win.screenX + Math.max(0, (win.outerWidth - POPUP_WIDTH) / 2));
+  const top = Math.round(win.screenY + Math.max(0, (win.outerHeight - POPUP_HEIGHT) / 2));
+  try {
+    return win.open(
+      "",
+      POPUP_NAME,
+      `popup=yes,width=${POPUP_WIDTH},height=${POPUP_HEIGHT},left=${left},top=${top}`
+    );
+  } catch {
+    return null;
+  }
+}
+function navigatePopup(popup, url) {
+  try {
+    popup.location.replace(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sameUser(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function toCommentsError(error) {
+  if (isCommentsError(error)) {
+    return error;
+  }
+  return new CommentsError("unknown", error instanceof Error ? error.message : String(error), {
+    cause: error
+  });
+}
+
+// src/core/log.ts
+function createLogger(debug) {
+  if (!debug) {
+    return () => {
+    };
+  }
+  return (...args) => console.debug(`[${PACKAGE_NAME}]`, ...args);
+}
+
+// src/core/realtime.ts
+var STATUS_CHANNEL = "/__status";
+var CHUNK_SEPARATOR = "\r\n|\r\n";
+var ESCAPED_SEPARATOR = /\r\n\|\|\r\n/g;
+var QUICK_RESPONSE_MS = 1e3;
+var SHORT_POLL_INTERVAL_MS = 15e3;
+var MIN_BACKOFF_MS = 5e3;
+var MAX_BACKOFF_MS = 6e4;
+function retryDelay(failures) {
+  const ceiling = Math.min(MIN_BACKOFF_MS * 2 ** (failures - 1), MAX_BACKOFF_MS);
+  return ceiling / 2 + Math.random() * (ceiling / 2);
+}
+var MessageBusPoller = class {
+  clientId = randomToken(16);
+  #options;
+  #channels = /* @__PURE__ */ new Map();
+  #statusEmitter = new Emitter();
+  #status = "idle";
+  #controller = null;
+  #wake = null;
+  #running = false;
+  #stopped = false;
+  #failures = 0;
+  #seq = 0;
+  constructor(options) {
+    this.#options = options;
+  }
+  get status() {
+    return this.#status;
+  }
+  get url() {
+    return `${this.#options.base}/message-bus/${this.clientId}/poll`;
+  }
+  subscribe(channel, lastId, listener) {
+    let subscribers = this.#channels.get(channel);
+    const before = subscribers ? cursorOf(subscribers) : void 0;
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Map();
+      this.#channels.set(channel, subscribers);
+    }
+    subscribers.set(listener, lastId);
+    if (before === void 0 || lastId < before) {
+      this.#restart();
+    }
+    return {
+      channel,
+      advanceTo: (id) => {
+        const current = this.#channels.get(channel);
+        const cursor = current?.get(listener);
+        if (current && cursor !== void 0 && id > cursor) {
+          current.set(listener, id);
+        }
+      },
+      unsubscribe: () => {
+        const current = this.#channels.get(channel);
+        if (!current?.delete(listener)) {
+          return;
+        }
+        if (current.size === 0) {
+          this.#channels.delete(channel);
+          this.#restart();
+        }
+      }
+    };
+  }
+  onStatus(listener) {
+    return this.#statusEmitter.on(listener);
+  }
+  /** The position the poll asks a channel from (the oldest subscriber cursor). */
+  cursor(channel) {
+    const subscribers = this.#channels.get(channel);
+    return subscribers ? cursorOf(subscribers) : void 0;
+  }
+  stop() {
+    this.#stopped = true;
+    this.#channels.clear();
+    this.#controller?.abort();
+    this.#wake?.();
+    this.#setStatus("idle");
+  }
+  #restart() {
+    if (this.#stopped) {
+      return;
+    }
+    this.#controller?.abort();
+    this.#wake?.();
+    if (this.#channels.size === 0) {
+      this.#setStatus("idle");
+      return;
+    }
+    if (!this.#running) {
+      void this.#loop();
+    }
+  }
+  async #loop() {
+    this.#running = true;
+    try {
+      while (!this.#stopped && this.#channels.size > 0) {
+        if (this.#status === "idle") {
+          this.#setStatus("connecting");
+        }
+        const controller = new AbortController();
+        this.#controller = controller;
+        const startedAt = Date.now();
+        let received = 0;
+        try {
+          const response = await this.#options.fetch(this.url, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: this.#body(),
+            credentials: "omit",
+            mode: "cors",
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            throw new Error(`MessageBus poll failed with status ${response.status}`);
+          }
+          await readMessageBusResponse(response, (messages) => {
+            received += messages.length;
+            this.#deliver(messages);
+          });
+        } catch (error) {
+          if (controller.signal.aborted) {
+            continue;
+          }
+          this.#failures++;
+          this.#options.log("message-bus poll failed", error);
+          if (this.#failures >= (this.#options.failureThreshold ?? 2)) {
+            this.#setStatus("failed");
+          }
+          await this.#sleep(retryDelay(this.#failures));
+          continue;
+        } finally {
+          if (this.#controller === controller) {
+            this.#controller = null;
+          }
+        }
+        this.#failures = 0;
+        this.#setStatus("connected");
+        if (received === 0 && Date.now() - startedAt < QUICK_RESPONSE_MS) {
+          await this.#sleep(SHORT_POLL_INTERVAL_MS);
+        }
+      }
+    } finally {
+      this.#running = false;
+    }
+  }
+  #body() {
+    const parts = [];
+    for (const [channel, subscribers] of this.#channels) {
+      parts.push(`${encodeURIComponent(channel).replace(/%2F/gi, "/")}=${cursorOf(subscribers)}`);
+    }
+    parts.push(`__seq=${++this.#seq}`);
+    return parts.join("&");
+  }
+  #deliver(messages) {
+    for (const raw of messages) {
+      if (!raw || typeof raw !== "object") {
+        continue;
+      }
+      const message = raw;
+      if (message.channel === STATUS_CHANNEL) {
+        const positions = message.data ?? {};
+        for (const [channel, id] of Object.entries(positions)) {
+          const subscribers2 = this.#channels.get(channel);
+          if (subscribers2 && typeof id === "number") {
+            this.#applyStatus(subscribers2, id);
+          }
+        }
+        continue;
+      }
+      const subscribers = this.#channels.get(message.channel);
+      if (!subscribers || typeof message.message_id !== "number") {
+        continue;
+      }
+      for (const [listener, cursor] of [...subscribers]) {
+        if (cursor >= 0 && message.message_id <= cursor) {
+          continue;
+        }
+        subscribers.set(listener, message.message_id);
+        notify(listener, { kind: "message", data: message.data, message });
+      }
+    }
+  }
+  #applyStatus(subscribers, id) {
+    for (const [listener, cursor] of [...subscribers]) {
+      subscribers.set(listener, id);
+      if (cursor === -1 || id === cursor) {
+        continue;
+      }
+      if (id > cursor) {
+        notify(listener, { kind: "bump", lastId: id });
+      } else if (cursor >= 0) {
+        notify(listener, { kind: "gap", lastId: id });
+      }
+    }
+  }
+  #sleep(ms) {
+    return new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        if (this.#wake === done) {
+          this.#wake = null;
+        }
+        resolve();
+      };
+      const timer = setTimeout(done, ms);
+      this.#wake = done;
+    });
+  }
+  #setStatus(status) {
+    if (status !== this.#status) {
+      this.#status = status;
+      this.#statusEmitter.emit(status);
+    }
+  }
+};
+function cursorOf(subscribers) {
+  return Math.min(...subscribers.values());
+}
+function notify(listener, event) {
+  try {
+    listener(event);
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function readMessageBusResponse(response, onBatch) {
+  let buffer = "";
+  const emit = (chunk) => {
+    const text = chunk.replace(ESCAPED_SEPARATOR, CHUNK_SEPARATOR).trim();
+    if (!text) {
+      return;
+    }
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      onBatch(parsed);
+    }
+  };
+  const drain = (final) => {
+    let index;
+    while ((index = buffer.indexOf(CHUNK_SEPARATOR)) !== -1) {
+      const chunk = buffer.slice(0, index);
+      buffer = buffer.slice(index + CHUNK_SEPARATOR.length);
+      emit(chunk);
+    }
+    if (final) {
+      emit(buffer);
+      buffer = "";
+    }
+  };
+  const reader = response.body?.getReader();
+  if (!reader) {
+    buffer = await response.text();
+    drain(true);
+    return;
+  }
+  const decoder = new TextDecoder();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    drain(false);
+  }
+  buffer += decoder.decode();
+  drain(true);
+}
+var IntervalRefresher = class {
+  #task;
+  #baseMs;
+  #maxMs;
+  #intervalMs;
+  #timer;
+  #inFlight = null;
+  #active = false;
+  #lastRunAt = 0;
+  #stopListening = null;
+  constructor(task, options = {}) {
+    this.#task = task;
+    this.#baseMs = options.baseMs ?? 3e4;
+    this.#maxMs = options.maxMs ?? 12e4;
+    this.#intervalMs = this.#baseMs;
+  }
+  get active() {
+    return this.#active;
+  }
+  get intervalMs() {
+    return this.#intervalMs;
+  }
+  start() {
+    if (this.#active) {
+      return;
+    }
+    this.#active = true;
+    this.#intervalMs = this.#baseMs;
+    this.#lastRunAt = Date.now();
+    this.#stopListening = onVisibilityChange(this.#onVisibilityChange);
+    this.#schedule();
+  }
+  stop() {
+    this.#active = false;
+    clearTimeout(this.#timer);
+    this.#stopListening?.();
+    this.#stopListening = null;
+  }
+  runNow() {
+    if (!this.#inFlight) {
+      this.#inFlight = this.#run().finally(() => {
+        this.#inFlight = null;
+        this.#schedule();
+      });
+    }
+    return this.#inFlight;
+  }
+  async #run() {
+    clearTimeout(this.#timer);
+    let changed = false;
+    try {
+      changed = await this.#task();
+    } catch {
+      changed = false;
+    }
+    this.#lastRunAt = Date.now();
+    this.#intervalMs = changed ? this.#baseMs : Math.min(this.#intervalMs * 2, this.#maxMs);
+  }
+  #schedule() {
+    clearTimeout(this.#timer);
+    if (!this.#active || this.#inFlight || isDocumentHidden()) {
+      return;
+    }
+    this.#timer = setTimeout(() => void this.runNow(), this.#intervalMs);
+  }
+  #onVisibilityChange = () => {
+    if (!this.#active) {
+      return;
+    }
+    if (isDocumentHidden()) {
+      clearTimeout(this.#timer);
+    } else if (Date.now() - this.#lastRunAt >= this.#intervalMs) {
+      void this.runNow();
+    } else {
+      this.#schedule();
+    }
+  };
+};
+
+// src/core/tree.ts
+function findComment(roots, id) {
+  return find(roots, (c) => c.id === id, 0, []);
+}
+function findByNumber(roots, number) {
+  return find(roots, (c) => c.number === number, 0, []);
+}
+function find(nodes, match, depth, path) {
+  for (const node of nodes) {
+    const nodePath = [...path, node.id];
+    if (match(node)) {
+      return { node, depth, path: nodePath };
+    }
+    if (node.children.length > 0) {
+      const found = find(node.children, match, depth + 1, nodePath);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+function updateComment(roots, id, update) {
+  return mapNode(roots, id, update) ?? roots;
+}
+function mapNode(nodes, id, update) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.id === id) {
+      const next = update(node);
+      if (next === node) {
+        return null;
+      }
+      const copy = nodes.slice();
+      copy[i] = next;
+      return copy;
+    }
+    if (node.children.length > 0) {
+      const children = mapNode(node.children, id, update);
+      if (children) {
+        const copy = nodes.slice();
+        copy[i] = { ...node, children };
+        return copy;
+      }
+    }
+  }
+  return null;
+}
+function mergeComment(local, incoming) {
+  const children = mergeChildren(local.children, incoming.children);
+  const stale = Date.parse(incoming.updated_at) < Date.parse(local.updated_at);
+  if (stale || sameFields(local, incoming)) {
+    return children === local.children ? local : { ...local, children };
+  }
+  return { ...incoming, children };
+}
+function mergeChildren(local, incoming) {
+  if (incoming.length === 0) {
+    return local;
+  }
+  const localById = new Map(local.map((c) => [c.id, c]));
+  const merged = incoming.map((c) => {
+    const existing = localById.get(c.id);
+    return existing ? mergeComment(existing, c) : c;
+  });
+  const seen = new Set(incoming.map((c) => c.id));
+  for (const c of local) {
+    if (!seen.has(c.id)) {
+      merged.push(c);
+    }
+  }
+  const unchanged = merged.length === local.length && merged.every((c, i) => c === local[i]);
+  return unchanged ? local : merged;
+}
+function sameFields(a, b) {
+  for (const key of Object.keys(b)) {
+    if (key === "children") {
+      continue;
+    }
+    const left = a[key];
+    const right = b[key];
+    if (left === right) {
+      continue;
+    }
+    if (typeof left !== "object" || typeof right !== "object" || JSON.stringify(left) !== JSON.stringify(right)) {
+      return false;
+    }
+  }
+  return true;
+}
+function patchComment(roots, incoming) {
+  return updateComment(roots, incoming.id, (local) => mergeComment(local, incoming));
+}
+function tombstone(comment) {
+  if (comment.deleted && comment.html === "" && comment.author === null) {
+    return comment;
+  }
+  return {
+    ...comment,
+    deleted: true,
+    html: "",
+    author: null,
+    likes: { ...comment.likes, can_like: false },
+    can: { ...comment.can, edit: false, delete: false, flag: false }
+  };
+}
+function tombstoneComment(roots, id) {
+  return updateComment(roots, id, tombstone);
+}
+function insertRoot(roots, comment, position) {
+  if (findComment(roots, comment.id)) {
+    return patchComment(roots, comment);
+  }
+  if (position === "end") {
+    return [...roots, comment];
+  }
+  let index = 0;
+  while (index < roots.length && roots[index].pinned) {
+    index++;
+  }
+  return [...roots.slice(0, index), comment, ...roots.slice(index)];
+}
+function insertReply(roots, parentId, comment, position, { bumpCounts }) {
+  if (findComment(roots, comment.id)) {
+    return patchComment(roots, comment);
+  }
+  const location = findComment(roots, parentId);
+  if (!location) {
+    return null;
+  }
+  const ancestors = new Set(location.path);
+  return mapPath(roots, ancestors, (node) => {
+    const isParent = node.id === parentId;
+    const children = isParent ? position === "start" ? [comment, ...node.children] : [...node.children, comment] : node.children;
+    if (!bumpCounts) {
+      return { ...node, children };
+    }
+    return {
+      ...node,
+      children,
+      direct_reply_count: isParent ? node.direct_reply_count + 1 : node.direct_reply_count,
+      total_descendant_count: node.total_descendant_count + 1
+    };
+  });
+}
+function mapPath(nodes, ids, update) {
+  return nodes.map((node) => {
+    if (!ids.has(node.id)) {
+      return node;
+    }
+    const children = node.children.some((c) => ids.has(c.id)) ? mapPath(node.children, ids, update) : node.children;
+    return update(children === node.children ? node : { ...node, children });
+  });
+}
+function mergeSiblings(local, incoming, tree) {
+  const byId = new Map(incoming.map((c) => [c.id, c]));
+  let changed = false;
+  const merged = local.map((c) => {
+    const next = byId.get(c.id);
+    if (!next) {
+      return c;
+    }
+    const result = mergeComment(c, next);
+    changed ||= result !== c;
+    return result;
+  });
+  const localIds = new Set(local.map((c) => c.id));
+  const fresh = incoming.filter((c) => !localIds.has(c.id) && !findComment(tree, c.id));
+  if (!changed && fresh.length === 0) {
+    return local;
+  }
+  return [...merged, ...fresh];
+}
+function collectIds(roots) {
+  const ids = [];
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (!node.deleted) {
+        ids.push(node.id);
+      }
+      walk(node.children);
+    }
+  };
+  walk(roots);
+  return ids;
+}
+function maxNumber(roots) {
+  let max = 0;
+  for (const node of roots) {
+    max = Math.max(max, node.number, maxNumber(node.children));
+  }
+  return max;
+}
+function applyPins(roots, pinnedIds) {
+  const pinned = new Set(pinnedIds);
+  const flagged = roots.map(
+    (c) => c.pinned === pinned.has(c.id) ? c : { ...c, pinned: pinned.has(c.id) }
+  );
+  const order = new Map(pinnedIds.map((id, index) => [id, index]));
+  const featured = flagged.filter((c) => c.pinned).sort((a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0));
+  return [...featured, ...flagged.filter((c) => !c.pinned)];
+}
+function rootPosition(sort) {
+  return sort === "oldest" ? "end" : "start";
+}
+function replyPosition(sort) {
+  return sort === "newest" ? "start" : "end";
+}
+
+// src/core/thread.ts
+var MAX_REFETCH_RETRIES = 4;
+var MAX_RESOLVE_RETRIES = 5;
+var RECONCILE_BATCHES_PER_RUN = 4;
+var MAX_GAP_PAGES = 5;
+var CommentThread = class {
+  composer = createComposerTimer();
+  #deps;
+  #state;
+  #events = new Emitter();
+  /** Live-arrived roots, oldest first, not yet shown. */
+  #incoming = [];
+  #incomingIdentity = 0;
+  /** Bumped by every reload; page and branch responses from an older one are dropped. */
+  #generation = 0;
+  #loadController = null;
+  #journal = [];
+  /** Local event counter (see `Ticket`). */
+  #seq = 0;
+  /** Event seq at which each comment was seen deleted; older responses cannot revive it. */
+  #deletedAt = /* @__PURE__ */ new Map();
+  #likes = /* @__PURE__ */ new Map();
+  #realtimeKey = null;
+  #subscription = null;
+  #stopStatus = null;
+  #refresher;
+  /** Highest top-level post number known to exist; `null` until known exactly. */
+  #baseline = null;
+  #reconcileOffset = 0;
+  #refetch = /* @__PURE__ */ new Map();
+  #refetchScheduled = false;
+  #refetchChain = Promise.resolve();
+  #refetchAttempts = 0;
+  #refetchTimer;
+  #resolving = null;
+  #resolveAttempts = 0;
+  #resolveTimer;
+  #disposed = false;
+  constructor(thread, deps, sort) {
+    this.#deps = deps;
+    this.#state = Object.freeze({
+      thread,
+      virtual: isVirtualThread(thread),
+      comments: [],
+      sort: sort ?? thread.sort,
+      status: "idle",
+      error: null,
+      page: 0,
+      hasMore: false,
+      loadingMore: false,
+      pendingNew: 0,
+      branches: {},
+      awaitingApproval: [],
+      connection: "off"
+    });
+    this.#refresher = new IntervalRefresher(() => this.#refreshOnce());
+  }
+  get id() {
+    return this.#state.thread.id;
+  }
+  snapshot() {
+    return this.#state;
+  }
+  subscribe(listener) {
+    return this.#events.on(listener);
+  }
+  async load() {
+    if (this.#disposed) {
+      return;
+    }
+    const thread = this.#state.thread;
+    if (isVirtualThread(thread)) {
+      if (this.#state.status === "ready") {
+        await this.#reresolve();
+        if (!this.#state.virtual) {
+          return;
+        }
+      }
+      this.#set({ status: "ready", comments: [], hasMore: false, page: 0 });
+      this.#ensureRealtime();
+      return;
+    }
+    const generation = ++this.#generation;
+    this.#loadController?.abort();
+    const controller = new AbortController();
+    this.#loadController = controller;
+    this.#journal = [];
+    const ticket = this.#ticket();
+    const sort = this.#state.sort;
+    this.#set({ status: "loading", error: null });
+    try {
+      let baseline = null;
+      if (thread.realtime === "poll" && sort !== "newest") {
+        baseline = await this.#readBaseline(thread.id, controller.signal);
+      }
+      const response = await this.#deps.http.request("GET", threadPath(thread.id), {
+        query: { sort, page: 0 },
+        signal: controller.signal
+      });
+      if (generation !== this.#generation || !this.#current(ticket)) {
+        return;
+      }
+      const comments = response.comments.map((c) => this.#sanitize(c, ticket));
+      const effectiveSort = response.sort ?? sort;
+      const exact = effectiveSort === "newest" || !response.has_more;
+      this.#baseline = baseline !== null ? Math.max(baseline, maxNumber(comments)) : exact ? maxNumber(comments) : null;
+      this.#incoming = this.#incomingIdentity === ticket.identity ? this.#incoming.filter((c) => !findComment(comments, c.id)) : [];
+      this.#set({
+        thread: response.thread,
+        comments,
+        sort: effectiveSort,
+        page: response.page ?? 0,
+        hasMore: response.has_more,
+        loadingMore: false,
+        branches: {},
+        pendingNew: this.#incoming.length,
+        status: "ready",
+        error: null
+      });
+      this.#subscription?.advanceTo(response.thread.message_bus_last_id);
+      this.#loadController = null;
+      this.#replayJournal();
+      this.#ensureRealtime();
+    } catch (error) {
+      if (generation !== this.#generation || isAbortError(error)) {
+        return;
+      }
+      this.#journal = [];
+      const failure = toCommentsError2(error);
+      this.#set({ status: "error", error: failure });
+      throw failure;
+    } finally {
+      if (this.#loadController === controller) {
+        this.#loadController = null;
+      }
+    }
+  }
+  async loadMore() {
+    const state = this.#state;
+    if (state.virtual || !state.hasMore || state.loadingMore || state.status !== "ready") {
+      return;
+    }
+    const generation = this.#generation;
+    const ticket = this.#ticket();
+    this.#set({ loadingMore: true });
+    try {
+      const response = await this.#deps.http.request(
+        "GET",
+        threadPath(state.thread.id),
+        { query: { sort: state.sort, page: state.page + 1 } }
+      );
+      if (generation !== this.#generation || !this.#current(ticket)) {
+        return;
+      }
+      const page = response.comments.map((c) => this.#sanitize(c, ticket));
+      let comments = this.#state.comments;
+      const fresh = [];
+      for (const comment of page) {
+        if (findComment(comments, comment.id)) {
+          comments = patchComment(comments, comment);
+        } else {
+          fresh.push(comment);
+        }
+      }
+      const ids = new Set(page.map((c) => c.id));
+      this.#incoming = this.#incoming.filter((c) => !ids.has(c.id));
+      this.#set({
+        comments: fresh.length > 0 ? [...comments, ...fresh] : comments,
+        page: response.page ?? state.page + 1,
+        hasMore: response.has_more,
+        loadingMore: false,
+        pendingNew: this.#incoming.length
+      });
+    } catch (error) {
+      if (generation === this.#generation) {
+        this.#set({ loadingMore: false });
+      }
+      throw toCommentsError2(error);
+    }
+  }
+  async loadReplies(commentId) {
+    const location = findComment(this.#state.comments, commentId);
+    if (!location) {
+      throw notInThread(commentId);
+    }
+    const branch = this.#state.branches[commentId];
+    if (branch?.loading) {
+      return;
+    }
+    const page = (branch?.page ?? -1) + 1;
+    const generation = this.#generation;
+    const ticket = this.#ticket();
+    this.#setBranch(commentId, {
+      page: branch?.page ?? -1,
+      loading: true,
+      hasMore: branch?.hasMore ?? true
+    });
+    try {
+      const response = await this.#deps.http.request(
+        "GET",
+        `${threadPath(this.id)}/children/${location.node.number}`,
+        { query: { sort: this.#state.sort, page, depth: location.depth + 1 } }
+      );
+      if (generation !== this.#generation || !this.#current(ticket)) {
+        return;
+      }
+      const children = response.comments.map((c) => this.#sanitize(c, ticket));
+      const tree = this.#state.comments;
+      let comments = updateComment(tree, commentId, (node) => {
+        const merged = mergeSiblings(node.children, children, tree);
+        return merged === node.children ? node : { ...node, children: merged };
+      });
+      for (const child of children) {
+        const elsewhere = findComment(comments, child.id);
+        if (elsewhere && elsewhere.path.at(-2) !== commentId) {
+          comments = patchComment(comments, child);
+        }
+      }
+      this.#set({ comments });
+      this.#setBranch(commentId, {
+        page: response.page ?? page,
+        loading: false,
+        hasMore: response.has_more
+      });
+    } catch (error) {
+      if (generation === this.#generation) {
+        this.#setBranch(commentId, {
+          page: branch?.page ?? -1,
+          loading: false,
+          hasMore: branch?.hasMore ?? true
+        });
+      }
+      throw toCommentsError2(error);
+    }
+  }
+  async setSort(sort) {
+    if (sort === this.#state.sort && this.#state.status === "ready") {
+      return;
+    }
+    this.#set({ sort });
+    await this.load();
+  }
+  async post(options) {
+    const timer = options.composer ?? this.composer;
+    const measured = timer.measure();
+    const thread = this.#state.thread;
+    const json = {
+      raw: options.body,
+      reply_to_id: options.replyTo,
+      typing_duration_msecs: options.typingDurationMsecs ?? measured.typingDurationMsecs,
+      composer_open_duration_msecs: options.composerOpenDurationMsecs ?? measured.composerOpenDurationMsecs
+    };
+    if (isVirtualThread(thread)) {
+      const { url, title, identifier } = this.#deps.page;
+      json.page = { url, title, identifier };
+    }
+    const ticket = this.#ticket();
+    const response = await this.#deps.http.request(
+      "POST",
+      `${threadPath(thread.id)}/comments`,
+      { json }
+    );
+    timer.stop();
+    const current = this.#current(ticket);
+    if ("pending" in response) {
+      if (current) {
+        this.#set({ awaitingApproval: [...this.#state.awaitingApproval, response.pending] });
+        this.#events.emit({ type: "comment.pending", pending: response.pending });
+      }
+      return { type: "pending", pending: response.pending };
+    }
+    const { comment } = response;
+    if (!current) {
+      return { type: "created", comment };
+    }
+    const wasVirtual = this.#state.virtual;
+    if (wasVirtual) {
+      this.#adopt(response.thread);
+    } else {
+      this.#mergeThreadMeta(response.thread);
+    }
+    this.#insertOwn(comment, options.replyTo, ticket);
+    this.#events.emit({ type: "comment.posted", comment });
+    if (wasVirtual && response.thread.count > 1) {
+      void this.load().catch(() => {
+      });
+    }
+    return { type: "created", comment };
+  }
+  async edit(commentId, body) {
+    const ticket = this.#ticket();
+    const response = await this.#deps.http.request(
+      "PATCH",
+      this.#commentPath(commentId),
+      { json: { raw: body } }
+    );
+    if (this.#current(ticket)) {
+      this.#applyComments([response.comment], ticket, () => false);
+      this.#events.emit({ type: "comment.edited", comment: response.comment });
+    }
+    return response.comment;
+  }
+  async remove(commentId) {
+    const ticket = this.#ticket();
+    await this.#deps.http.request("DELETE", this.#commentPath(commentId));
+    if (!this.#current(ticket)) {
+      return;
+    }
+    this.#markDeleted(commentId);
+    const after = this.#ticket();
+    try {
+      const current = (await this.#fetchByIds([commentId])).comments[0];
+      if (current) {
+        this.#applyComments([current], after, () => false);
+      }
+    } catch {
+    }
+    this.#events.emit({ type: "comment.removed", id: commentId });
+  }
+  like(commentId) {
+    return this.#toggleLike(commentId, true);
+  }
+  unlike(commentId) {
+    return this.#toggleLike(commentId, false);
+  }
+  async flag(commentId, options) {
+    await this.#deps.http.request("POST", `${this.#commentPath(commentId)}/flag`, {
+      json: { flag_type: options.type, message: options.message }
+    });
+  }
+  async pin(commentId) {
+    await this.#setPin(commentId, "PUT");
+  }
+  async unpin(commentId) {
+    await this.#setPin(commentId, "DELETE");
+  }
+  async raw(commentId) {
+    const ticket = this.#ticket();
+    const response = await this.#deps.http.request(
+      "GET",
+      `${this.#commentPath(commentId)}/raw`
+    );
+    this.#assertCurrent(ticket);
+    return response.raw;
+  }
+  showPending() {
+    if (this.#incoming.length === 0) {
+      return;
+    }
+    let comments = this.#state.comments;
+    const position = rootPosition(this.#state.sort);
+    for (const comment of this.#incoming) {
+      comments = insertRoot(comments, comment, position);
+    }
+    this.#incoming = [];
+    this.#set({ comments, pendingNew: 0 });
+  }
+  async context(commentId) {
+    const ticket = this.#ticket();
+    let number = findComment(this.#state.comments, commentId)?.node.number;
+    if (number === void 0) {
+      number = (await this.#fetchByIds([commentId])).comments[0]?.number;
+      this.#assertCurrent(ticket);
+    }
+    if (number === void 0) {
+      throw notInThread(commentId);
+    }
+    const response = await this.#deps.http.request(
+      "GET",
+      `${threadPath(this.id)}/context/${number}`,
+      { query: { sort: this.#state.sort } }
+    );
+    this.#assertCurrent(ticket);
+    const ancestors = response.ancestors.map((c) => this.#sanitize(c, ticket));
+    const target = this.#sanitize(response.comment, ticket);
+    const chain = [...ancestors, target];
+    let comments = this.#state.comments;
+    const [top, ...rest] = chain;
+    if (top && !findComment(comments, top.id)) {
+      comments = insertRoot(comments, top, "start");
+    }
+    let parentId = top?.id;
+    for (const node of rest) {
+      if (parentId !== void 0 && !findComment(comments, node.id)) {
+        comments = insertReply(comments, parentId, node, "start", { bumpCounts: false }) ?? comments;
+      }
+      parentId = node.id;
+    }
+    this.#incoming = this.#incoming.filter((c) => !chain.some((n) => n.id === c.id));
+    this.#set({ comments, pendingNew: this.#incoming.length });
+    return {
+      ancestors,
+      ancestorsTruncated: response.ancestors_truncated,
+      comment: target
+    };
+  }
+  dispose() {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
+    this.#generation++;
+    this.#loadController?.abort();
+    clearTimeout(this.#refetchTimer);
+    clearTimeout(this.#resolveTimer);
+    this.#stopRealtime();
+    this.#events.clear();
+    this.#deps.onDispose();
+  }
+  // Realtime
+  #realtimeKeyFor(thread) {
+    return isVirtualThread(thread) ? `pending:${thread.pending_channel}` : `${thread.realtime}:${thread.topic_id}`;
+  }
+  /** (Re)connects whenever the thread, its channel or its realtime mode changes. */
+  #ensureRealtime() {
+    const thread = this.#state.thread;
+    const key = this.#realtimeKeyFor(thread);
+    if (this.#disposed || this.#realtimeKey === key) {
+      return;
+    }
+    this.#stopRealtime();
+    this.#realtimeKey = key;
+    const { realtime } = this.#deps;
+    if (isVirtualThread(thread)) {
+      this.#subscription = realtime.subscribe(thread.pending_channel, -2, () => {
+        void this.#reresolve();
+      });
+    } else if (thread.realtime === "live") {
+      this.#subscription = realtime.subscribe(
+        `/topic/${thread.topic_id}`,
+        thread.message_bus_last_id,
+        (event) => this.#onTopicEvent(event)
+      );
+    } else {
+      this.#startFallback(false);
+      return;
+    }
+    this.#stopStatus = realtime.onStatus((status) => this.#onTransportStatus(status));
+    this.#onTransportStatus(realtime.status);
+  }
+  /** Interval refreshes; `immediate` also runs one now (catching up after a failure). */
+  #startFallback(immediate) {
+    this.#set({ connection: "interval" });
+    if (this.#refresher.active) {
+      return;
+    }
+    this.#refresher.start();
+    if (immediate) {
+      void this.#refresher.runNow();
+    }
+  }
+  #stopRealtime() {
+    this.#subscription?.unsubscribe();
+    this.#subscription = null;
+    this.#stopStatus?.();
+    this.#stopStatus = null;
+    this.#refresher.stop();
+    this.#realtimeKey = null;
+    this.#set({ connection: "off" });
+  }
+  #onTransportStatus(status) {
+    if (status === "failed") {
+      this.#startFallback(true);
+      return;
+    }
+    const recovering = this.#refresher.active;
+    this.#refresher.stop();
+    this.#set({ connection: "live" });
+    if (recovering && status === "connected") {
+      void this.#refresher.runNow();
+    }
+  }
+  #onTopicEvent(event) {
+    if (event.kind === "gap") {
+      void this.#refresher.runNow();
+      return;
+    }
+    if (event.kind !== "message") {
+      return;
+    }
+    const message = event.data;
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    const id = typeof message.id === "number" ? message.id : null;
+    switch (message.type) {
+      case "created":
+        if (id !== null) {
+          this.#queueRefetch(id, true);
+        }
+        break;
+      case "recovered":
+        if (id !== null) {
+          this.#deletedAt.delete(id);
+          this.#event();
+          this.#queueRefetch(id, true);
+        }
+        break;
+      case "revised":
+      case "rebaked":
+      case "liked":
+      case "unliked":
+        if (id !== null && this.#knows(id)) {
+          this.#queueRefetch(id, false);
+        }
+        break;
+      case "deleted":
+      case "destroyed":
+        if (id !== null) {
+          this.#markDeleted(id);
+        }
+        break;
+      case "stats":
+        if (typeof message.posts_count === "number" && !isVirtualThread(this.#state.thread)) {
+          const count = Math.max(message.posts_count - 1, 0);
+          if (count !== this.#state.thread.count) {
+            this.#set({ thread: { ...this.#state.thread, count } });
+          }
+        }
+        break;
+    }
+  }
+  #knows(id) {
+    return findComment(this.#state.comments, id) !== null || findComment(this.#incoming, id) !== null;
+  }
+  #queueRefetch(id, allowInsert) {
+    this.#refetch.set(id, (this.#refetch.get(id) ?? false) || allowInsert);
+    if (this.#refetchTimer === void 0) {
+      this.#scheduleRefetch();
+    }
+  }
+  #scheduleRefetch() {
+    if (this.#refetchScheduled) {
+      return;
+    }
+    this.#refetchScheduled = true;
+    queueMicrotask(() => {
+      this.#refetchChain = this.#refetchChain.then(() => this.#flushRefetch());
+    });
+  }
+  async #flushRefetch() {
+    const pending = new Map(this.#refetch);
+    this.#refetch.clear();
+    this.#refetchScheduled = false;
+    if (this.#disposed || isVirtualThread(this.#state.thread) || pending.size === 0) {
+      return;
+    }
+    const ticket = this.#ticket();
+    const ids = [...pending.keys()];
+    for (let i = 0; i < ids.length; i += REFETCH_BATCH_SIZE) {
+      try {
+        const response = await this.#fetchByIds(ids.slice(i, i + REFETCH_BATCH_SIZE));
+        if (!this.#current(ticket)) {
+          return;
+        }
+        this.#refetchAttempts = 0;
+        this.#mergeThreadMeta(response.thread);
+        this.#applyComments(response.comments, ticket, (c) => pending.get(c.id) === true);
+      } catch (error) {
+        if (this.#disposed || isAbortError(error)) {
+          return;
+        }
+        this.#deps.log("refetch failed", error);
+        for (const id of ids.slice(i)) {
+          this.#refetch.set(id, (this.#refetch.get(id) ?? false) || pending.get(id) === true);
+        }
+        this.#retryRefetch(error);
+        return;
+      }
+    }
+  }
+  /** Retries failed hydration with backoff (honouring rate limits), then reconciles. */
+  #retryRefetch(error) {
+    this.#refetchAttempts++;
+    if (this.#refetchAttempts > MAX_REFETCH_RETRIES) {
+      this.#refetchAttempts = 0;
+      this.#refetch.clear();
+      void this.#refresher.runNow();
+      return;
+    }
+    const waitSeconds = isCommentsError(error) ? error.waitSeconds : void 0;
+    const delay = waitSeconds !== void 0 ? waitSeconds * 1e3 : Math.min(1e3 * 2 ** this.#refetchAttempts, 3e4);
+    clearTimeout(this.#refetchTimer);
+    this.#refetchTimer = setTimeout(() => {
+      this.#refetchTimer = void 0;
+      this.#scheduleRefetch();
+    }, delay);
+  }
+  /**
+   * One fallback refresh; resolves `true` when anything changed. Discovers new
+   * top-level comments by post number (whatever the display sort), then
+   * re-reads the loaded ones so edits, likes and deletions show up.
+   */
+  async #refreshOnce() {
+    const thread = this.#state.thread;
+    if (isVirtualThread(thread)) {
+      await this.#reresolve();
+      return !this.#state.virtual;
+    }
+    const ticket = this.#ticket();
+    const generation = this.#generation;
+    const stale = () => generation !== this.#generation || !this.#current(ticket);
+    const countBefore = thread.count;
+    let changed = false;
+    if (this.#baseline === null) {
+      const baseline = await this.#readBaseline(thread.id);
+      if (stale()) {
+        return false;
+      }
+      this.#baseline = Math.max(baseline, maxNumber(this.#state.comments), maxNumber(this.#incoming));
+      changed = true;
+    } else {
+      const baseline = this.#baseline;
+      let highest = baseline;
+      const found = [];
+      for (let page = 0; page < MAX_GAP_PAGES; page++) {
+        const response = await this.#deps.http.request("GET", threadPath(thread.id), {
+          query: { sort: "newest", page }
+        });
+        if (stale()) {
+          return false;
+        }
+        this.#mergeThreadMeta(response.thread);
+        found.push(...response.comments);
+        highest = Math.max(highest, maxNumber(response.comments));
+        if (!response.has_more || response.comments.some((c) => c.number <= baseline)) {
+          break;
+        }
+      }
+      this.#baseline = highest;
+      changed = this.#applyComments(found, ticket, (c) => c.number > baseline);
+    }
+    changed = await this.#reconcileLoaded(ticket, stale) || changed;
+    return changed || this.#state.thread.count !== countBefore;
+  }
+  /** Re-reads a rotating window of loaded comments; missing ones are gone for this reader. */
+  async #reconcileLoaded(ticket, stale) {
+    const ids = collectIds(this.#state.comments);
+    if (ids.length === 0) {
+      return false;
+    }
+    const start = this.#reconcileOffset % ids.length;
+    const window2 = [...ids.slice(start), ...ids.slice(0, start)].slice(
+      0,
+      REFETCH_BATCH_SIZE * RECONCILE_BATCHES_PER_RUN
+    );
+    this.#reconcileOffset = start + window2.length;
+    let changed = false;
+    for (let i = 0; i < window2.length; i += REFETCH_BATCH_SIZE) {
+      const batch = window2.slice(i, i + REFETCH_BATCH_SIZE);
+      const response = await this.#fetchByIds(batch);
+      if (stale()) {
+        return changed;
+      }
+      this.#mergeThreadMeta(response.thread);
+      changed = this.#applyComments(response.comments, ticket, () => false) || changed;
+      const returned = new Set(response.comments.map((c) => c.id));
+      for (const id of batch) {
+        if (!returned.has(id) && findComment(this.#state.comments, id)?.node.deleted === false) {
+          this.#markDeleted(id);
+          changed = true;
+        }
+      }
+    }
+    return changed;
+  }
+  async #readBaseline(threadId, signal) {
+    const response = await this.#deps.http.request("GET", threadPath(threadId), {
+      query: { sort: "newest", page: 0 },
+      signal
+    });
+    return maxNumber(response.comments);
+  }
+  /**
+   * Re-resolves a virtual thread (did its topic appear? did permissions
+   * change?). Failures surface on `snapshot().error` and retry with backoff,
+   * then on the slow interval until the topic exists or the handle is disposed.
+   */
+  #reresolve() {
+    this.#resolving ??= (async () => {
+      const ticket = this.#ticket();
+      try {
+        const thread = await this.#deps.resolve();
+        if (this.#disposed || !this.#state.virtual) {
+          return;
+        }
+        if (!this.#current(ticket)) {
+          queueMicrotask(() => void this.#reresolve());
+          return;
+        }
+        this.#resolveAttempts = 0;
+        clearTimeout(this.#resolveTimer);
+        if (isVirtualThread(thread)) {
+          this.#set({ thread: sameJson(thread, this.#state.thread) ? this.#state.thread : thread, error: null });
+          this.#ensureRealtime();
+          return;
+        }
+        this.#adopt(thread);
+        await this.load();
+      } catch (error) {
+        if (this.#disposed || isAbortError(error)) {
+          return;
+        }
+        this.#deps.log("re-resolving the thread failed", error);
+        this.#set({ error: toCommentsError2(error) });
+        this.#scheduleResolveRetry();
+      } finally {
+        this.#resolving = null;
+      }
+    })();
+    return this.#resolving;
+  }
+  #scheduleResolveRetry() {
+    this.#resolveAttempts++;
+    clearTimeout(this.#resolveTimer);
+    if (this.#resolveAttempts > MAX_RESOLVE_RETRIES) {
+      this.#resolveAttempts = 0;
+      this.#startFallback(false);
+      return;
+    }
+    this.#resolveTimer = setTimeout(
+      () => void this.#reresolve(),
+      Math.min(2e3 * 2 ** (this.#resolveAttempts - 1), 3e4)
+    );
+  }
+  /** Switches a virtual thread to its newly created topic. */
+  #adopt(thread) {
+    clearTimeout(this.#resolveTimer);
+    this.#resolveAttempts = 0;
+    this.#set({ thread, virtual: false, status: "ready", error: null });
+    this.#ensureRealtime();
+    this.#events.emit({ type: "thread.created", thread });
+  }
+  // Applying server data
+  #ticket() {
+    return { seq: this.#seq, identity: this.#deps.identity() };
+  }
+  #event() {
+    return ++this.#seq;
+  }
+  /** The response belongs to this handle's current reader. */
+  #current(ticket) {
+    return !this.#disposed && ticket.identity === this.#deps.identity();
+  }
+  #assertCurrent(ticket) {
+    if (!this.#current(ticket)) {
+      throw new CommentsError("cancelled", "The reader changed while this request was running");
+    }
+  }
+  /**
+   * Adjusts a server comment (recursively) for what happened locally after the
+   * request started: deletions win, and a like in flight keeps showing the
+   * reader's latest intent.
+   */
+  #sanitize(comment, ticket) {
+    let node = comment;
+    const deletedAt = this.#deletedAt.get(node.id);
+    if (deletedAt !== void 0 && deletedAt > ticket.seq && !node.deleted) {
+      node = tombstone(node);
+    }
+    if (this.#likes.has(node.id)) {
+      const shown = findComment(this.#state.comments, node.id)?.node.likes;
+      if (shown && !sameJson(shown, node.likes)) {
+        node = { ...node, likes: shown };
+      }
+    }
+    if (node.children.length > 0) {
+      const children = node.children.map((child) => this.#sanitize(child, ticket));
+      if (children.some((child, index) => child !== node.children[index])) {
+        node = { ...node, children };
+      }
+    }
+    return node;
+  }
+  /** Folds server comments in: patch known ones, place insertable new ones. */
+  #applyComments(comments, ticket, insertable) {
+    if (!this.#current(ticket) || comments.length === 0) {
+      return false;
+    }
+    const sanitized = comments.map((c) => this.#sanitize(c, ticket));
+    this.#record({
+      kind: "comments",
+      comments: sanitized,
+      insertable: new Set(sanitized.filter(insertable).map((c) => c.id)),
+      ticket
+    });
+    let tree = this.#state.comments;
+    let incoming = this.#incoming;
+    const received = [];
+    const me = this.#deps.currentUserId();
+    const sort = this.#state.sort;
+    for (const comment of sanitized) {
+      if (findComment(tree, comment.id)) {
+        tree = patchComment(tree, comment);
+        continue;
+      }
+      if (findComment(incoming, comment.id)) {
+        incoming = patchComment(incoming, comment);
+        continue;
+      }
+      if (!insertable(comment) || this.#deletedAt.has(comment.id)) {
+        continue;
+      }
+      const parentNumber = comment.reply_to?.number;
+      if (parentNumber === void 0) {
+        if (me !== null && comment.author?.id === me) {
+          tree = insertRoot(tree, comment, rootPosition(sort));
+          received.push({ comment, buffered: false });
+        } else {
+          incoming = [...incoming, comment];
+          received.push({ comment, buffered: true });
+        }
+        continue;
+      }
+      const position = replyPosition(sort);
+      const parentInTree = findByNumber(tree, parentNumber);
+      if (parentInTree) {
+        tree = insertReply(tree, parentInTree.node.id, comment, position, { bumpCounts: true }) ?? tree;
+        received.push({ comment, buffered: false });
+        continue;
+      }
+      const parentInIncoming = findByNumber(incoming, parentNumber);
+      if (parentInIncoming) {
+        incoming = insertReply(incoming, parentInIncoming.node.id, comment, position, {
+          bumpCounts: true
+        }) ?? incoming;
+      }
+    }
+    const changed = tree !== this.#state.comments || incoming !== this.#incoming;
+    if (incoming !== this.#incoming) {
+      this.#incomingIdentity = ticket.identity;
+    }
+    this.#incoming = incoming;
+    this.#set({ comments: tree, pendingNew: incoming.length });
+    for (const entry of received) {
+      this.#events.emit({ type: "comment.received", ...entry });
+    }
+    return changed;
+  }
+  /** Records a deletion (barrier for older responses) and tombstones it everywhere. */
+  #markDeleted(id) {
+    this.#deletedAt.set(id, this.#event());
+    this.#record({ kind: "tombstone", id });
+    this.#applyTombstone(id);
+  }
+  #applyTombstone(id) {
+    this.#incoming = tombstoneComment(
+      this.#incoming.filter((c) => c.id !== id),
+      id
+    );
+    this.#set({
+      comments: tombstoneComment(this.#state.comments, id),
+      pendingNew: this.#incoming.length
+    });
+  }
+  #record(entry) {
+    if (this.#loadController) {
+      this.#journal.push(entry);
+    }
+  }
+  /** Re-applies facts that the just-loaded snapshot may predate. */
+  #replayJournal() {
+    const journal = this.#journal;
+    this.#journal = [];
+    for (const entry of journal) {
+      if (entry.kind === "tombstone") {
+        this.#applyTombstone(entry.id);
+      } else if (entry.kind === "pins") {
+        if (entry.identity === this.#deps.identity()) {
+          this.#applyPins(entry.ids);
+        }
+      } else {
+        this.#applyComments(entry.comments, entry.ticket, (c) => entry.insertable.has(c.id));
+      }
+    }
+  }
+  // Helpers
+  #insertOwn(comment, replyTo, ticket) {
+    this.#record({ kind: "comments", comments: [comment], insertable: /* @__PURE__ */ new Set([comment.id]), ticket });
+    const sort = this.#state.sort;
+    let comments = this.#state.comments;
+    if (replyTo !== void 0) {
+      comments = insertReply(comments, replyTo, comment, replyPosition(sort), { bumpCounts: true }) ?? comments;
+    } else {
+      comments = insertRoot(comments, comment, rootPosition(sort));
+    }
+    this.#incoming = this.#incoming.filter((c) => c.id !== comment.id);
+    this.#set({ comments, pendingNew: this.#incoming.length });
+  }
+  /**
+   * Likes are optimistic. Requests for one comment are sent in order and only
+   * the latest intent's outcome (or rollback) touches what is shown.
+   */
+  async #toggleLike(commentId, liked) {
+    const node = findComment(this.#state.comments, commentId)?.node;
+    if (!node) {
+      throw notInThread(commentId);
+    }
+    const ticket = this.#ticket();
+    const seq = this.#event();
+    const intent = this.#likes.get(commentId) ?? {
+      seq,
+      confirmed: node.likes,
+      chain: Promise.resolve()
+    };
+    intent.seq = seq;
+    this.#likes.set(commentId, intent);
+    if (node.likes.liked !== liked) {
+      this.#set({
+        comments: updateComment(this.#state.comments, commentId, (c) => ({
+          ...c,
+          likes: { ...c.likes, liked, count: Math.max(0, c.likes.count + (liked ? 1 : -1)) }
+        }))
+      });
+    }
+    const request = intent.chain.catch(() => {
+    }).then(
+      () => this.#deps.http.request(
+        liked ? "PUT" : "DELETE",
+        `${this.#commentPath(commentId)}/like`
+      )
+    );
+    intent.chain = request;
+    try {
+      const response = await request;
+      if (!this.#current(ticket)) {
+        return response.comment;
+      }
+      intent.confirmed = response.comment.likes;
+      if (intent.seq === seq) {
+        this.#likes.delete(commentId);
+      }
+      this.#applyComments([response.comment], ticket, () => false);
+      return response.comment;
+    } catch (error) {
+      if (this.#current(ticket) && intent.seq === seq) {
+        this.#likes.delete(commentId);
+        this.#set({
+          comments: updateComment(
+            this.#state.comments,
+            commentId,
+            (c) => sameJson(c.likes, intent.confirmed) ? c : { ...c, likes: intent.confirmed }
+          )
+        });
+      }
+      throw toCommentsError2(error);
+    }
+  }
+  async #setPin(commentId, method) {
+    const ticket = this.#ticket();
+    const response = await this.#deps.http.request(
+      method,
+      `${this.#commentPath(commentId)}/pin`
+    );
+    if (this.#current(ticket)) {
+      this.#record({ kind: "pins", ids: response.pinned_ids, identity: ticket.identity });
+      this.#applyPins(response.pinned_ids);
+    }
+  }
+  #applyPins(pinnedIds) {
+    const thread = this.#state.thread;
+    if (isVirtualThread(thread)) {
+      return;
+    }
+    this.#set({
+      thread: sameJson(thread.pinned_ids, pinnedIds) ? thread : { ...thread, pinned_ids: pinnedIds },
+      comments: applyPins(this.#state.comments, pinnedIds)
+    });
+  }
+  #mergeThreadMeta(thread) {
+    const current = this.#state.thread;
+    if (isVirtualThread(current) || current.id !== thread.id) {
+      return;
+    }
+    const next = { ...thread, sort: current.sort, message_bus_last_id: current.message_bus_last_id };
+    if (!sameJson(next, current)) {
+      this.#set({ thread: next });
+      if (this.#realtimeKey !== null && next.realtime !== current.realtime) {
+        this.#ensureRealtime();
+      }
+    }
+  }
+  #fetchByIds(ids) {
+    return this.#deps.http.request("GET", threadPath(this.id), {
+      query: { ids, sort: this.#state.sort }
+    });
+  }
+  #commentPath(commentId) {
+    return `${threadPath(this.id)}/comments/${commentId}`;
+  }
+  #setBranch(commentId, branch) {
+    this.#set({ branches: { ...this.#state.branches, [commentId]: branch } });
+  }
+  #set(patch) {
+    let changed = false;
+    for (const key of Object.keys(patch)) {
+      if (patch[key] !== this.#state[key]) {
+        changed = true;
+        break;
+      }
+    }
+    if (!changed || this.#disposed) {
+      return;
+    }
+    this.#state = Object.freeze({ ...this.#state, ...patch });
+    this.#events.emit({ type: "change", snapshot: this.#state });
+  }
+};
+function sameJson(a, b) {
+  return a === b || JSON.stringify(a) === JSON.stringify(b);
+}
+function notInThread(commentId) {
+  return new CommentsError("not_found", `Comment ${commentId} is not loaded in this thread`, {
+    status: 404
+  });
+}
+function toCommentsError2(error) {
+  if (isCommentsError(error)) {
+    return error;
+  }
+  return new CommentsError("unknown", error instanceof Error ? error.message : String(error), {
+    cause: error
+  });
+}
+
+// src/core/client.ts
+var DEGRADED_RECHECK_MS = 6e4;
+var MAX_DEGRADED_RECHECK_MS = 10 * 6e4;
+var MAX_DEGRADED_CHECKS = 6;
+function createClient(options) {
+  return createClientWithInternals(options, {});
+}
+function createClientWithInternals(options, internals) {
+  const forum = normalizeForum(options.forum);
+  const log = createLogger(options.debug);
+  const { storage, syncAcrossTabs } = options.storage ? { storage: options.storage, syncAcrossTabs: isLocalStorage(options.storage) } : (() => {
+    const resolved = browserStorage();
+    return { storage: resolved.storage, syncAcrossTabs: resolved.isLocalStorage };
+  })();
+  let latestConfig = null;
+  let configPromise = null;
+  const threads = /* @__PURE__ */ new Set();
+  const lifetime = new AbortController();
+  const disposedError = () => new CommentsError("cancelled", "The comments client was disposed");
+  let auth;
+  const http = new Http({
+    forum,
+    fetch: options.fetch,
+    headers: options.headers,
+    locale: options.locale,
+    credentials: () => auth.credentials(),
+    onInvalidKey: (key) => auth.invalidate(key),
+    log,
+    lifetime: lifetime.signal
+  });
+  auth = new AuthController({
+    http,
+    forum,
+    storage,
+    pendingStorage: signInStorage(storage),
+    syncAcrossTabs,
+    clientId: options.clientId,
+    log,
+    providers: () => latestConfig?.auth_providers ?? [],
+    navigate: internals.navigate
+  });
+  const realtime = internals.realtime ?? new MessageBusPoller({ base: forum.base, fetch: http.fetch, log });
+  const batcher = new CountsBatcher(http);
+  let configGeneration = 0;
+  let degradedRecheck;
+  let degradedChecks = 0;
+  function config() {
+    if (lifetime.signal.aborted) {
+      return Promise.reject(disposedError());
+    }
+    if (!configPromise) {
+      const generation = configGeneration;
+      configPromise = http.request("GET", "/config").then(
+        (loaded) => {
+          if (lifetime.signal.aborted) {
+            throw disposedError();
+          }
+          if (generation !== configGeneration) {
+            return config();
+          }
+          latestConfig = loaded;
+          auth.applyConfig(loaded);
+          clearTimeout(degradedRecheck);
+          if (loaded.degraded) {
+            scheduleDegradedRecheck();
+          } else {
+            degradedChecks = 0;
+          }
+          return loaded;
+        },
+        (error) => {
+          if (generation === configGeneration) {
+            configPromise = null;
+          }
+          throw error;
+        }
+      );
+    }
+    return configPromise;
+  }
+  function scheduleDegradedRecheck() {
+    if (lifetime.signal.aborted || degradedChecks >= MAX_DEGRADED_CHECKS) {
+      return;
+    }
+    const delay = Math.min(DEGRADED_RECHECK_MS * 2 ** degradedChecks, MAX_DEGRADED_RECHECK_MS);
+    degradedChecks++;
+    clearTimeout(degradedRecheck);
+    degradedRecheck = setTimeout(() => {
+      configPromise = null;
+      config().catch(() => scheduleDegradedRecheck());
+    }, delay);
+  }
+  let lastUserId = auth.user?.id ?? null;
+  let identity = 0;
+  const stopAuthListener = auth.onChange((state) => {
+    if (state.status === "signing-in") {
+      return;
+    }
+    const userId = state.status === "signed-in" ? state.user?.id ?? null : null;
+    if (userId === lastUserId) {
+      return;
+    }
+    lastUserId = userId;
+    identity++;
+    const hadConfig = configPromise !== null;
+    configGeneration++;
+    configPromise = null;
+    if (hadConfig) {
+      void config().catch(() => {
+      });
+    }
+    for (const thread of threads) {
+      void thread.load().catch(() => {
+      });
+    }
+  });
+  async function open(openOptions = {}) {
+    if (lifetime.signal.aborted) {
+      throw disposedError();
+    }
+    const url = openOptions.url ?? defaultPageUrl();
+    if (!url) {
+      throw new CommentsError("invalid_url", "No page URL: pass `url` outside the browser");
+    }
+    const page = {
+      url,
+      title: openOptions.title ?? defaultPageTitle(),
+      identifier: openOptions.identifier
+    };
+    const resolve = async () => (await http.request("POST", "/threads", { json: page })).thread;
+    const thread = await resolve();
+    if (lifetime.signal.aborted) {
+      throw disposedError();
+    }
+    const handle = new CommentThread(
+      thread,
+      {
+        http,
+        realtime,
+        currentUserId: () => auth.user?.id ?? null,
+        identity: () => identity,
+        page,
+        resolve,
+        log,
+        onDispose: () => threads.delete(handle)
+      },
+      openOptions.sort
+    );
+    threads.add(handle);
+    await handle.load().catch(() => {
+    });
+    return handle;
+  }
+  async function upload(threadId, file, uploadOptions = {}) {
+    const form = new FormData();
+    const name = uploadOptions.filename ?? file.name ?? "upload";
+    form.append("file", file, name);
+    if (uploadOptions.pasted) {
+      form.append("pasted", "true");
+    }
+    return http.request("POST", `${threadPath(threadId)}/attachments`, { form });
+  }
+  const client = {
+    forum: forum.base,
+    forumOrigin: forum.origin,
+    locale: options.locale,
+    auth,
+    threads: { open },
+    attachments: { upload },
+    config,
+    counts: (refs) => batcher.request(refs),
+    count: async (ref) => (await batcher.request([ref]))[encodeRef(ref)] ?? 0,
+    preview: async (body) => (await http.request("POST", "/preview", { json: { raw: body } })).html,
+    mentions: async (query, threadId) => (await http.request("GET", "/mentions", {
+      query: { q: query, thread: threadId }
+    })).users,
+    dispose() {
+      if (lifetime.signal.aborted) {
+        return;
+      }
+      lifetime.abort();
+      for (const thread of [...threads]) {
+        thread.dispose();
+      }
+      realtime.stop();
+      clearTimeout(degradedRecheck);
+      stopAuthListener();
+      auth.dispose();
+    }
+  };
+  if (getWindow()) {
+    void auth.handleRedirect();
+  }
+  return client;
+}
+
+// src/core/registry.ts
+function createClientRegistry(create = createClient) {
+  const clients = /* @__PURE__ */ new Map();
+  return {
+    acquire(options) {
+      const key = normalizeForum(options.forum).base;
+      let client = clients.get(key);
+      if (!client) {
+        client = create(options);
+        clients.set(key, client);
+      }
+      return client;
+    },
+    get(forum) {
+      return clients.get(normalizeForum(forum).base);
+    },
+    clear(forum) {
+      const keys = forum === void 0 ? [...clients.keys()] : [normalizeForum(forum).base];
+      for (const key of keys) {
+        clients.get(key)?.dispose();
+        clients.delete(key);
+      }
+    }
+  };
+}
+var clientRegistry = createClientRegistry();
+
+// src/messages.ts
+var en = {
+  signIn: "Sign in",
+  signInWith: "Continue with {provider}",
+  signOut: "Sign out",
+  signingIn: "Finish signing in in the window that opened.",
+  signInCancel: "Cancel",
+  sessionExpired: "Your session expired. Sign in again to comment.",
+  joinConversation: "Join the conversation",
+  joinConversationBody: "Sign in with your {forum} account to comment.",
+  composerPlaceholder: "Add a comment\u2026",
+  post: "Post",
+  posting: "Posting\u2026",
+  reply: "Reply",
+  replyingTo: "Replying to @{username}",
+  cancel: "Cancel",
+  save: "Save",
+  edit: "Edit",
+  edited: "Edited",
+  delete: "Delete",
+  deleteConfirm: "Delete this comment?",
+  deleted: "This comment was deleted.",
+  hidden: "This comment was hidden after reports from the community.",
+  like: "Like",
+  unlike: "Remove like",
+  likeCount: { zero: "No likes", one: "{count} like", other: "{count} likes" },
+  report: "Report",
+  reportTitle: "Why are you reporting this comment?",
+  "report.off_topic": "Off-topic",
+  "report.inappropriate": "Inappropriate",
+  "report.spam": "Spam",
+  "report.illegal": "Illegal",
+  "report.notify_moderators": "Something else",
+  reportMessagePlaceholder: "Tell the moderators more (optional)",
+  reportSent: "Thanks, the moderators will take a look.",
+  pin: "Feature",
+  unpin: "Unfeature",
+  pinned: "Featured",
+  pending: "Your comment was submitted and is awaiting approval.",
+  loadMore: "Load more comments",
+  loadReplies: { one: "View {count} reply", other: "View {count} replies" },
+  continueThread: "Continue this thread",
+  newComments: { one: "{count} new comment", other: "{count} new comments" },
+  commentCount: { zero: "No comments yet", one: "{count} comment", other: "{count} comments" },
+  sortBy: "Sort by",
+  "sort.best": "Best",
+  "sort.hot": "Hot",
+  "sort.newest": "Newest",
+  "sort.oldest": "Oldest",
+  closed: "Comments are closed.",
+  readOnly: "Comments are read-only right now.",
+  guidelines: "Community guidelines",
+  preview: "Preview",
+  write: "Write",
+  unavailable: "Comments are unavailable right now.",
+  retry: "Try again",
+  rateLimited: {
+    one: "You're doing that too often. Try again in {count} second.",
+    other: "You're doing that too often. Try again in {count} seconds."
+  },
+  genericError: "Something went wrong. Please try again.",
+  copyLink: "Copy link",
+  linkCopied: "Link copied",
+  viewOnForum: "View on {forum}",
+  staff: "Staff",
+  upload: "Attach image",
+  uploading: "Uploading\u2026",
+  comments: "Comments",
+  signedInAs: "Signed in as {username}",
+  loadMoreReplies: { one: "View {count} more reply", other: "View {count} more replies" },
+  backToAll: "Back to all comments",
+  ancestorsTruncated: "Some earlier replies are not shown.",
+  moreActions: "More actions",
+  commentBy: "Comment by {name}",
+  deletedComment: "Deleted comment",
+  repliesTo: "Replies to {name}",
+  replyPlaceholder: "Write a reply\u2026",
+  editing: "Editing your comment",
+  tooShort: "Comments need at least {min} characters.",
+  tooLong: "Comments can have at most {max} characters.",
+  formatting: "Formatting",
+  bold: "Bold",
+  italic: "Italic",
+  insertLink: "Insert link",
+  code: "Code",
+  quote: "Quote",
+  mentionSuggestions: "Mention suggestions",
+  previewEmpty: "Nothing to preview yet.",
+  loading: "Loading\u2026",
+  cannotComment: "You can't comment on this page.",
+  reportMessageRequired: "Tell the moderators what's wrong",
+  close: "Close"
+};
+var ptBR = {
+  signIn: "Entrar",
+  signInWith: "Continuar com {provider}",
+  signOut: "Sair",
+  signingIn: "Conclua o login na janela que foi aberta.",
+  signInCancel: "Cancelar",
+  sessionExpired: "Sua sess\xE3o expirou. Entre novamente para comentar.",
+  joinConversation: "Participe da conversa",
+  joinConversationBody: "Entre com sua conta de {forum} para comentar.",
+  composerPlaceholder: "Escreva um coment\xE1rio\u2026",
+  post: "Publicar",
+  posting: "Publicando\u2026",
+  reply: "Responder",
+  replyingTo: "Respondendo a @{username}",
+  cancel: "Cancelar",
+  save: "Salvar",
+  edit: "Editar",
+  edited: "Editado",
+  delete: "Excluir",
+  deleteConfirm: "Excluir este coment\xE1rio?",
+  deleted: "Este coment\xE1rio foi exclu\xEDdo.",
+  hidden: "Este coment\xE1rio foi ocultado ap\xF3s den\xFAncias da comunidade.",
+  like: "Curtir",
+  unlike: "Descurtir",
+  likeCount: { zero: "Nenhuma curtida", one: "{count} curtida", other: "{count} curtidas" },
+  report: "Denunciar",
+  reportTitle: "Por que voc\xEA est\xE1 denunciando este coment\xE1rio?",
+  "report.off_topic": "Fora do assunto",
+  "report.inappropriate": "Inapropriado",
+  "report.spam": "Spam",
+  "report.illegal": "Ilegal",
+  "report.notify_moderators": "Outro motivo",
+  reportMessagePlaceholder: "Conte mais aos moderadores (opcional)",
+  reportSent: "Obrigado, os moderadores v\xE3o analisar.",
+  pin: "Destacar",
+  unpin: "Remover destaque",
+  pinned: "Em destaque",
+  pending: "Seu coment\xE1rio foi enviado e aguarda aprova\xE7\xE3o.",
+  loadMore: "Carregar mais coment\xE1rios",
+  loadReplies: { one: "Ver {count} resposta", other: "Ver {count} respostas" },
+  continueThread: "Continuar esta conversa",
+  newComments: { one: "{count} novo coment\xE1rio", other: "{count} novos coment\xE1rios" },
+  commentCount: {
+    zero: "Nenhum coment\xE1rio ainda",
+    one: "{count} coment\xE1rio",
+    other: "{count} coment\xE1rios"
+  },
+  sortBy: "Ordenar por",
+  "sort.best": "Melhores",
+  "sort.hot": "Em alta",
+  "sort.newest": "Mais recentes",
+  "sort.oldest": "Mais antigos",
+  closed: "Os coment\xE1rios est\xE3o encerrados.",
+  readOnly: "Os coment\xE1rios est\xE3o somente leitura no momento.",
+  guidelines: "Diretrizes da comunidade",
+  preview: "Pr\xE9-visualizar",
+  write: "Escrever",
+  unavailable: "Os coment\xE1rios est\xE3o indispon\xEDveis no momento.",
+  retry: "Tentar novamente",
+  rateLimited: {
+    one: "Voc\xEA est\xE1 fazendo isso com muita frequ\xEAncia. Tente novamente em {count} segundo.",
+    other: "Voc\xEA est\xE1 fazendo isso com muita frequ\xEAncia. Tente novamente em {count} segundos."
+  },
+  genericError: "Algo deu errado. Tente novamente.",
+  copyLink: "Copiar link",
+  linkCopied: "Link copiado",
+  viewOnForum: "Ver em {forum}",
+  staff: "Equipe",
+  upload: "Anexar imagem",
+  uploading: "Enviando\u2026",
+  comments: "Coment\xE1rios",
+  signedInAs: "Conectado como {username}",
+  loadMoreReplies: { one: "Ver mais {count} resposta", other: "Ver mais {count} respostas" },
+  backToAll: "Voltar para todos os coment\xE1rios",
+  ancestorsTruncated: "Algumas respostas anteriores n\xE3o s\xE3o exibidas.",
+  moreActions: "Mais a\xE7\xF5es",
+  commentBy: "Coment\xE1rio de {name}",
+  deletedComment: "Coment\xE1rio exclu\xEDdo",
+  repliesTo: "Respostas a {name}",
+  replyPlaceholder: "Escreva uma resposta\u2026",
+  editing: "Editando seu coment\xE1rio",
+  tooShort: "Coment\xE1rios precisam ter pelo menos {min} caracteres.",
+  tooLong: "Coment\xE1rios podem ter no m\xE1ximo {max} caracteres.",
+  formatting: "Formata\xE7\xE3o",
+  bold: "Negrito",
+  italic: "It\xE1lico",
+  insertLink: "Inserir link",
+  code: "C\xF3digo",
+  quote: "Cita\xE7\xE3o",
+  mentionSuggestions: "Sugest\xF5es de men\xE7\xE3o",
+  previewEmpty: "Nada para pr\xE9-visualizar ainda.",
+  loading: "Carregando\u2026",
+  cannotComment: "Voc\xEA n\xE3o pode comentar nesta p\xE1gina.",
+  reportMessageRequired: "Conte aos moderadores o que h\xE1 de errado",
+  close: "Fechar"
+};
+var locales = { en, "pt-BR": ptBR };
+function resolveLocale(locale) {
+  return locale?.toLowerCase().startsWith("pt") ? "pt-BR" : "en";
+}
+function createTranslator(locale, overrides = {}) {
+  const resolved = resolveLocale(locale);
+  const table = { ...locales[resolved], ...overrides };
+  const rules = new Intl.PluralRules(resolved);
+  return (key, vars) => {
+    const value = table[key];
+    let template;
+    if (typeof value === "string") {
+      template = value;
+    } else {
+      const count = Number(vars?.count ?? 0);
+      const category = rules.select(count);
+      template = (count === 0 ? value.zero : void 0) ?? value[category] ?? value.other;
+    }
+    return template.replace(
+      /\{(\w+)\}/g,
+      (match, name) => vars && name in vars ? String(vars[name]) : match
+    );
+  };
+}
+
+export { CommentsError, PACKAGE_NAME, STORAGE_PREFIX, clientRegistry, createClient, createClientRegistry, createComposerTimer, createTranslator, currentUrlWithoutHash, defaultPageUrl, en, encodeRef, findComment, isCommentsError, isVirtualThread, locales, memoryStorage, normalizeForum, ptBR, resolveLocale };
+//# sourceMappingURL=chunk-6E3M3PQN.js.map
+//# sourceMappingURL=chunk-6E3M3PQN.js.map