@paramms/chat-widget 1.6.2 → 1.6.3

package/dist/chatlist2.js

@@ -0,0 +1,1417 @@
+var Ue = Object.defineProperty;
+var ve = (n, e, t) => e in n ? Ue(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => ve(n, typeof e != "symbol" ? e + "" : e, t);
+function de(n, e) {
+  var d;
+  const t = n.trim().replace(/\/+$/, ""), i = (d = t.match(/^(https|http|wss|ws):\/\//)) == null ? void 0 : d[1], s = i ? i === "https" || i === "wss" : !0, r = (i ? t.slice(i.length + 3) : t).replace(/\/ws$/, ""), o = e ? e.trim().replace(/\/+$/, "") : `${s ? "https" : "http"}://${r}`;
+  return { wsUrl: `${s ? "wss" : "ws"}://${r}/ws`, httpBase: o };
+}
+function Se(n) {
+  return de(n).httpBase;
+}
+function be(n, e, t, i) {
+  const s = `beforeSeq=${t}&limit=${i}`;
+  return [
+    `${n}/conversations/${e}/messages?${s}`,
+    `${n}/conversations/${e}/history?${s}`
+  ];
+}
+async function ae(n, e, t, i, s = 20) {
+  let r, o = !1;
+  for (const h of be(n, e, i, s))
+    try {
+      const d = await fetch(h, { headers: { authorization: `Bearer ${t}` } });
+      if (o = !0, !d.ok) continue;
+      const U = await d.json();
+      return { messages: U.messages ?? [], hasMore: U.hasMore ?? !1 };
+    } catch (d) {
+      r = d;
+    }
+  return o ? console.error(`[chat-widget] history request to ${n} was rejected for conversation ${e}.`) : console.error(
+    `[chat-widget] could not load history from ${n} — the request never reached the server. This is almost always CORS: add this site's origin to the chatroom's allowed origins (dashboard → chatroom → allowed origins) or to the server's CORS_ORIGINS.`,
+    r
+  ), null;
+}
+async function yt(n, e, t, i, s, r) {
+  const o = r ? r.replace(/\/+$/, "") : Se(n), h = await ae(o, t, e, Number.MAX_SAFE_INTEGER);
+  if (!h || (h.messages.length ? (i.apply({ type: "sync", conversationId: t, messages: h.messages }), i.apply({ type: "history", conversationId: t, messages: [], hasMore: h.hasMore }), s.render(i)) : i.apply({ type: "history", conversationId: t, messages: [], hasMore: !1 }), !h.hasMore)) return;
+  let d = !1;
+  const U = async () => {
+    if (d || !i.hasMoreHistory) return;
+    d = !0;
+    const I = i.messages()[0];
+    if (!I) {
+      d = !1;
+      return;
+    }
+    const v = await ae(o, t, e, I.seq);
+    v && (i.apply({ type: "history", conversationId: t, messages: v.messages, hasMore: v.hasMore }), s.render(i)), d = !1;
+  }, b = s.getScrollEl();
+  if (!b) return;
+  let x = !1;
+  setTimeout(() => {
+    x = !0;
+  }, 300);
+  const g = () => {
+    x && b.scrollTop < 80 && i.hasMoreHistory && !d && U();
+  };
+  b.addEventListener("scroll", g, { passive: !0 }), s.setScrollCleanup(() => b.removeEventListener("scroll", g));
+}
+const Ee = {
+  accent: "#6c5ce7",
+  accent2: "#4c6fff",
+  bg: "#f4f3fb",
+  card: "#fff",
+  tint: "#eeecfb",
+  line: "#e6e2f5",
+  ink: "#221d3a",
+  mut: "#8f8aa8",
+  onaccent: "#fff",
+  rowhover: "#e7e3f8",
+  shadow: "0 12px 32px rgba(108,92,231,.14)"
+}, Be = {
+  accent: "#a99cf2",
+  accent2: "#6f8cff",
+  bg: "#221d3a",
+  card: "#2b2550",
+  tint: "#2f2853",
+  line: "#3a3363",
+  ink: "#eceafc",
+  mut: "#9b93c9",
+  onaccent: "#221d3a",
+  rowhover: "#39325e",
+  shadow: "0 12px 32px rgba(0,0,0,.4)"
+}, Ie = "'Nunito',-apple-system,BlinkMacSystemFont,'Segoe UI',system-ui,sans-serif";
+function fe(n, e) {
+  return Object.entries(e).map(([t, i]) => `--${n}-${t}:${i};`).join(" ");
+}
+function ke(n) {
+  return `${fe(n, Ee)} --${n}-fb:${Ie}; --${n}-fh:'Baloo 2',var(--${n}-fb);`;
+}
+function ce(n) {
+  return fe(n, Be);
+}
+const Te = `
+.ocl { ${ke("ocl")}
+  display:flex; flex-direction:column; height:100%; background:var(--ocl-bg);
+  font-family:var(--ocl-fb); color:var(--ocl-ink); overflow:hidden; }
+@media (prefers-color-scheme: dark) { .ocl[data-theme="auto"] { ${ce("ocl")} } }
+.ocl[data-theme="dark"] { ${ce("ocl")} }
+.ocl-head { display:flex; align-items:center; padding:16px 16px 10px; background:var(--ocl-bg); }
+.ocl-title { flex:1; display:flex; align-items:center; font-family:var(--ocl-fh); font-weight:700; font-size:18px; color:var(--ocl-ink); }
+.ocl-retry { margin-top:14px; border:none; background:var(--ocl-accent); color:var(--ocl-onaccent); border-radius:20px; padding:8px 20px; font:inherit; font-size:13px; font-weight:600; cursor:pointer; }
+.ocl-search-wrap { padding:4px 12px 8px; background:var(--ocl-bg); }
+.ocl-search { width:100%; box-sizing:border-box; border:none; background:var(--ocl-tint); border-radius:20px; padding:9px 14px; font:inherit; font-size:14px; outline:none; }
+.ocl-body { flex:1; overflow-y:auto; }
+.ocl-section { padding:10px 18px 4px; font-family:var(--ocl-fh); font-size:11px; font-weight:600; color:var(--ocl-mut); text-transform:uppercase; letter-spacing:.5px; background:transparent; }
+.ocl-empty { padding:40px 20px; text-align:center; color:var(--ocl-mut); font-size:14px; }
+.ocl-row { display:flex; align-items:center; gap:12px; padding:10px 12px; margin:6px 12px; background:var(--ocl-tint); border:none; width:calc(100% - 24px); box-sizing:border-box; border-radius:16px; text-align:left; cursor:pointer; transition:background .12s; }
+.ocl-row:hover { background:var(--ocl-rowhover); }
+.ocl-row.unread { background:var(--ocl-rowhover); }
+.ocl-av { width:40px; height:40px; border-radius:50%; background:var(--ocl-accent); color:var(--ocl-onaccent); font-family:var(--ocl-fh); font-size:15px; font-weight:600; display:flex; align-items:center; justify-content:center; flex:none; }
+.ocl-info { flex:1; min-width:0; }
+.ocl-name { font-family:var(--ocl-fh); font-size:14px; font-weight:600; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; margin-bottom:2px; }
+.ocl-row.unread .ocl-name { font-weight:700; }
+.ocl-preview { font-size:11.5px; color:var(--ocl-mut); white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
+.ocl-row.unread .ocl-preview { color:var(--ocl-ink); }
+.ocl-right { display:flex; flex-direction:column; align-items:flex-end; gap:4px; flex:none; }
+.ocl-time { font-size:10px; color:var(--ocl-mut); }
+.ocl-row.unread .ocl-time { color:var(--ocl-accent); font-weight:600; }
+.ocl-badge { background:var(--ocl-accent); color:var(--ocl-onaccent); border-radius:999px; font-size:11px; font-weight:700; min-width:20px; height:20px; padding:0 5px; display:flex; align-items:center; justify-content:center; }
+.ocl-status { font-size:10px; font-weight:600; padding:2px 8px; border-radius:20px; white-space:nowrap; }
+.ocl-status.open { background:#dff3e6; color:#2f8a52; }
+.ocl-status.waiting { background:var(--ocl-tint); color:var(--ocl-accent); border:1px solid var(--ocl-accent); }
+.ocl-status.done { background:#eee; color:#777; }
+.ocl[data-theme="dark"] .ocl-status.done { background:#39325e; color:#b3abd6; }
+@media (prefers-color-scheme: dark) { .ocl[data-theme="auto"] .ocl-status.done { background:#39325e; color:#b3abd6; } }
+.ocl-spinner { padding:24px; text-align:center; color:var(--ocl-mut); font-size:13px; }
+.ocl-compose { border:none; background:var(--ocl-accent); color:var(--ocl-onaccent); width:32px; height:32px; border-radius:50%; font-size:18px; line-height:1; cursor:pointer; box-shadow:var(--ocl-shadow); }
+.ocl-compose:hover { filter:brightness(1.08); }
+/* When the HOST overlays a ✕ (ChatApp's onClose / embed's inbox stack), it is
+   absolutely positioned at top-right and used to land straight on top of the ✎
+   compose button. Reserve the space instead of stacking them. */
+.ocl-has-close .ocl-head { padding-right:52px; }
+.ocl-start { margin-top:12px; border:none; background:var(--ocl-accent); color:var(--ocl-onaccent); border-radius:20px; padding:8px 18px; font:inherit; font-size:13px; font-weight:600; cursor:pointer; }
+/* Compact sizing keyed on the LIST'S OWN width (ResizeObserver toggles
+ * .ocl-compact below 400px) — covers phones and narrow desktop embeds alike.
+ * Search must be ≥16px in compact or iOS zooms the page on focus. */
+.ocl-compact .ocl-row { padding:13px 14px; }
+.ocl-compact .ocl-search { font-size:16px; }
+.ocl-compact .ocl-compose { width:36px; height:36px; }
+.ocl-row:focus-visible, .ocl button:focus-visible, .ocl input:focus-visible { outline:2px solid var(--ocl-accent); outline-offset:2px; border-radius:12px; }
+`, _ = "oc_uid";
+function Ae(n) {
+  try {
+    const e = document.cookie.match(new RegExp(`(?:^|; )${n}=([^;]*)`));
+    return e ? decodeURIComponent(e[1]) : null;
+  } catch {
+    return null;
+  }
+}
+function $e(n, e) {
+  try {
+    const i = location.protocol === "https:" ? "; Secure" : "";
+    document.cookie = `${n}=${encodeURIComponent(e)}; Max-Age=31536000; Path=/; SameSite=Lax${i}`;
+  } catch {
+  }
+}
+function ze() {
+  return `g_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function Ce() {
+  let n = null;
+  try {
+    n = localStorage.getItem(_);
+  } catch {
+  }
+  n || (n = Ae(_));
+  const e = n ?? ze();
+  try {
+    localStorage.setItem(_, e);
+  } catch {
+  }
+  return $e(_, e), e;
+}
+function Le(n) {
+  const e = n.length;
+  let t = 0, i = 0;
+  for (; i < e; ) {
+    let s = n.charCodeAt(i++);
+    if (s & 4294967168)
+      if (!(s & 4294965248))
+        t += 2;
+      else {
+        if (s >= 55296 && s <= 56319 && i < e) {
+          const r = n.charCodeAt(i);
+          (r & 64512) === 56320 && (++i, s = ((s & 1023) << 10) + (r & 1023) + 65536);
+        }
+        s & 4294901760 ? t += 4 : t += 3;
+      }
+    else {
+      t++;
+      continue;
+    }
+  }
+  return t;
+}
+function Me(n, e, t) {
+  const i = n.length;
+  let s = t, r = 0;
+  for (; r < i; ) {
+    let o = n.charCodeAt(r++);
+    if (o & 4294967168)
+      if (!(o & 4294965248))
+        e[s++] = o >> 6 & 31 | 192;
+      else {
+        if (o >= 55296 && o <= 56319 && r < i) {
+          const h = n.charCodeAt(r);
+          (h & 64512) === 56320 && (++r, o = ((o & 1023) << 10) + (h & 1023) + 65536);
+        }
+        o & 4294901760 ? (e[s++] = o >> 18 & 7 | 240, e[s++] = o >> 12 & 63 | 128, e[s++] = o >> 6 & 63 | 128) : (e[s++] = o >> 12 & 15 | 224, e[s++] = o >> 6 & 63 | 128);
+      }
+    else {
+      e[s++] = o;
+      continue;
+    }
+    e[s++] = o & 63 | 128;
+  }
+}
+const De = new TextEncoder(), _e = 50;
+function Re(n, e, t) {
+  De.encodeInto(n, e.subarray(t));
+}
+function Fe(n, e, t) {
+  n.length > _e ? Re(n, e, t) : Me(n, e, t);
+}
+const Pe = 4096;
+function ue(n, e, t) {
+  let i = e;
+  const s = i + t, r = [];
+  let o = "";
+  for (; i < s; ) {
+    const h = n[i++];
+    if (!(h & 128))
+      r.push(h);
+    else if ((h & 224) === 192) {
+      const d = n[i++] & 63;
+      r.push((h & 31) << 6 | d);
+    } else if ((h & 240) === 224) {
+      const d = n[i++] & 63, U = n[i++] & 63;
+      r.push((h & 31) << 12 | d << 6 | U);
+    } else if ((h & 248) === 240) {
+      const d = n[i++] & 63, U = n[i++] & 63, b = n[i++] & 63;
+      let x = (h & 7) << 18 | d << 12 | U << 6 | b;
+      x > 65535 && (x -= 65536, r.push(x >>> 10 & 1023 | 55296), x = 56320 | x & 1023), r.push(x);
+    } else
+      r.push(h);
+    r.length >= Pe && (o += String.fromCharCode(...r), r.length = 0);
+  }
+  return r.length > 0 && (o += String.fromCharCode(...r)), o;
+}
+const Ne = new TextDecoder(), He = 200;
+function Ke(n, e, t) {
+  const i = n.subarray(e, e + t);
+  return Ne.decode(i);
+}
+function We(n, e, t) {
+  return t > He ? Ke(n, e, t) : ue(n, e, t);
+}
+class R {
+  constructor(e, t) {
+    a(this, "type");
+    a(this, "data");
+    this.type = e, this.data = t;
+  }
+}
+class y extends Error {
+  constructor(e) {
+    super(e);
+    const t = Object.create(y.prototype);
+    Object.setPrototypeOf(this, t), Object.defineProperty(this, "name", {
+      configurable: !0,
+      enumerable: !1,
+      value: y.name
+    });
+  }
+}
+const z = 4294967295;
+function Oe(n, e, t) {
+  const i = t / 4294967296, s = t;
+  n.setUint32(e, i), n.setUint32(e + 4, s);
+}
+function xe(n, e, t) {
+  const i = Math.floor(t / 4294967296), s = t;
+  n.setUint32(e, i), n.setUint32(e + 4, s);
+}
+function pe(n, e) {
+  const t = n.getInt32(e), i = n.getUint32(e + 4);
+  return t * 4294967296 + i;
+}
+function Ve(n, e) {
+  const t = n.getUint32(e), i = n.getUint32(e + 4);
+  return t * 4294967296 + i;
+}
+const Ye = -1, qe = 4294967296 - 1, Xe = 17179869184 - 1;
+function Ge({ sec: n, nsec: e }) {
+  if (n >= 0 && e >= 0 && n <= Xe)
+    if (e === 0 && n <= qe) {
+      const t = new Uint8Array(4);
+      return new DataView(t.buffer).setUint32(0, n), t;
+    } else {
+      const t = n / 4294967296, i = n & 4294967295, s = new Uint8Array(8), r = new DataView(s.buffer);
+      return r.setUint32(0, e << 2 | t & 3), r.setUint32(4, i), s;
+    }
+  else {
+    const t = new Uint8Array(12), i = new DataView(t.buffer);
+    return i.setUint32(0, e), xe(i, 4, n), t;
+  }
+}
+function Je(n) {
+  const e = n.getTime(), t = Math.floor(e / 1e3), i = (e - t * 1e3) * 1e6, s = Math.floor(i / 1e9);
+  return {
+    sec: t + s,
+    nsec: i - s * 1e9
+  };
+}
+function Ze(n) {
+  if (n instanceof Date) {
+    const e = Je(n);
+    return Ge(e);
+  } else
+    return null;
+}
+function Qe(n) {
+  const e = new DataView(n.buffer, n.byteOffset, n.byteLength);
+  switch (n.byteLength) {
+    case 4:
+      return { sec: e.getUint32(0), nsec: 0 };
+    case 8: {
+      const t = e.getUint32(0), i = e.getUint32(4), s = (t & 3) * 4294967296 + i, r = t >>> 2;
+      return { sec: s, nsec: r };
+    }
+    case 12: {
+      const t = pe(e, 4), i = e.getUint32(0);
+      return { sec: t, nsec: i };
+    }
+    default:
+      throw new y(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${n.length}`);
+  }
+}
+function je(n) {
+  const e = Qe(n);
+  return new Date(e.sec * 1e3 + e.nsec / 1e6);
+}
+const et = {
+  type: Ye,
+  encode: Ze,
+  decode: je
+}, P = class P {
+  constructor() {
+    // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+    // this will make type errors a lot more clear
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    a(this, "__brand");
+    // built-in extensions
+    a(this, "builtInEncoders", []);
+    a(this, "builtInDecoders", []);
+    // custom extensions
+    a(this, "encoders", []);
+    a(this, "decoders", []);
+    this.register(et);
+  }
+  register({ type: e, encode: t, decode: i }) {
+    if (e >= 0)
+      this.encoders[e] = t, this.decoders[e] = i;
+    else {
+      const s = -1 - e;
+      this.builtInEncoders[s] = t, this.builtInDecoders[s] = i;
+    }
+  }
+  tryToEncode(e, t) {
+    for (let i = 0; i < this.builtInEncoders.length; i++) {
+      const s = this.builtInEncoders[i];
+      if (s != null) {
+        const r = s(e, t);
+        if (r != null) {
+          const o = -1 - i;
+          return new R(o, r);
+        }
+      }
+    }
+    for (let i = 0; i < this.encoders.length; i++) {
+      const s = this.encoders[i];
+      if (s != null) {
+        const r = s(e, t);
+        if (r != null) {
+          const o = i;
+          return new R(o, r);
+        }
+      }
+    }
+    return e instanceof R ? e : null;
+  }
+  decode(e, t, i) {
+    const s = t < 0 ? this.builtInDecoders[-1 - t] : this.decoders[t];
+    return s ? s(e, t, i) : new R(t, e);
+  }
+};
+a(P, "defaultCodec", new P());
+let F = P;
+function tt(n) {
+  return n instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && n instanceof SharedArrayBuffer;
+}
+function W(n) {
+  return n instanceof Uint8Array ? n : ArrayBuffer.isView(n) ? new Uint8Array(n.buffer, n.byteOffset, n.byteLength) : tt(n) ? new Uint8Array(n) : Uint8Array.from(n);
+}
+const it = 100, st = 2048;
+class V {
+  constructor(e) {
+    a(this, "extensionCodec");
+    a(this, "context");
+    a(this, "useBigInt64");
+    a(this, "maxDepth");
+    a(this, "initialBufferSize");
+    a(this, "sortKeys");
+    a(this, "forceFloat32");
+    a(this, "ignoreUndefined");
+    a(this, "forceIntegerToFloat");
+    a(this, "pos");
+    a(this, "view");
+    a(this, "bytes");
+    a(this, "entered", !1);
+    this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? F.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.maxDepth = (e == null ? void 0 : e.maxDepth) ?? it, this.initialBufferSize = (e == null ? void 0 : e.initialBufferSize) ?? st, this.sortKeys = (e == null ? void 0 : e.sortKeys) ?? !1, this.forceFloat32 = (e == null ? void 0 : e.forceFloat32) ?? !1, this.ignoreUndefined = (e == null ? void 0 : e.ignoreUndefined) ?? !1, this.forceIntegerToFloat = (e == null ? void 0 : e.forceIntegerToFloat) ?? !1, this.pos = 0, this.view = new DataView(new ArrayBuffer(this.initialBufferSize)), this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new V({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
+  }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(e) {
+    if (this.entered)
+      return this.clone().encodeSharedRef(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.subarray(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
+  encode(e) {
+    if (this.entered)
+      return this.clone().encode(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.slice(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doEncode(e, t) {
+    if (t > this.maxDepth)
+      throw new Error(`Too deep objects in depth ${t}`);
+    e == null ? this.encodeNil() : typeof e == "boolean" ? this.encodeBoolean(e) : typeof e == "number" ? this.forceIntegerToFloat ? this.encodeNumberAsFloat(e) : this.encodeNumber(e) : typeof e == "string" ? this.encodeString(e) : this.useBigInt64 && typeof e == "bigint" ? this.encodeBigInt64(e) : this.encodeObject(e, t);
+  }
+  ensureBufferSizeToWrite(e) {
+    const t = this.pos + e;
+    this.view.byteLength < t && this.resizeBuffer(t * 2);
+  }
+  resizeBuffer(e) {
+    const t = new ArrayBuffer(e), i = new Uint8Array(t), s = new DataView(t);
+    i.set(this.bytes), this.view = s, this.bytes = i;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(e) {
+    e === !1 ? this.writeU8(194) : this.writeU8(195);
+  }
+  encodeNumber(e) {
+    !this.forceIntegerToFloat && Number.isSafeInteger(e) ? e >= 0 ? e < 128 ? this.writeU8(e) : e < 256 ? (this.writeU8(204), this.writeU8(e)) : e < 65536 ? (this.writeU8(205), this.writeU16(e)) : e < 4294967296 ? (this.writeU8(206), this.writeU32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(207), this.writeU64(e)) : e >= -32 ? this.writeU8(224 | e + 32) : e >= -128 ? (this.writeU8(208), this.writeI8(e)) : e >= -32768 ? (this.writeU8(209), this.writeI16(e)) : e >= -2147483648 ? (this.writeU8(210), this.writeI32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(211), this.writeI64(e)) : this.encodeNumberAsFloat(e);
+  }
+  encodeNumberAsFloat(e) {
+    this.forceFloat32 ? (this.writeU8(202), this.writeF32(e)) : (this.writeU8(203), this.writeF64(e));
+  }
+  encodeBigInt64(e) {
+    e >= BigInt(0) ? (this.writeU8(207), this.writeBigUint64(e)) : (this.writeU8(211), this.writeBigInt64(e));
+  }
+  writeStringHeader(e) {
+    if (e < 32)
+      this.writeU8(160 + e);
+    else if (e < 256)
+      this.writeU8(217), this.writeU8(e);
+    else if (e < 65536)
+      this.writeU8(218), this.writeU16(e);
+    else if (e < 4294967296)
+      this.writeU8(219), this.writeU32(e);
+    else
+      throw new Error(`Too long string: ${e} bytes in UTF-8`);
+  }
+  encodeString(e) {
+    const i = Le(e);
+    this.ensureBufferSizeToWrite(5 + i), this.writeStringHeader(i), Fe(e, this.bytes, this.pos), this.pos += i;
+  }
+  encodeObject(e, t) {
+    const i = this.extensionCodec.tryToEncode(e, this.context);
+    if (i != null)
+      this.encodeExtension(i);
+    else if (Array.isArray(e))
+      this.encodeArray(e, t);
+    else if (ArrayBuffer.isView(e))
+      this.encodeBinary(e);
+    else if (typeof e == "object")
+      this.encodeMap(e, t);
+    else
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(e)}`);
+  }
+  encodeBinary(e) {
+    const t = e.byteLength;
+    if (t < 256)
+      this.writeU8(196), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(197), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(198), this.writeU32(t);
+    else
+      throw new Error(`Too large binary: ${t}`);
+    const i = W(e);
+    this.writeU8a(i);
+  }
+  encodeArray(e, t) {
+    const i = e.length;
+    if (i < 16)
+      this.writeU8(144 + i);
+    else if (i < 65536)
+      this.writeU8(220), this.writeU16(i);
+    else if (i < 4294967296)
+      this.writeU8(221), this.writeU32(i);
+    else
+      throw new Error(`Too large array: ${i}`);
+    for (const s of e)
+      this.doEncode(s, t + 1);
+  }
+  countWithoutUndefined(e, t) {
+    let i = 0;
+    for (const s of t)
+      e[s] !== void 0 && i++;
+    return i;
+  }
+  encodeMap(e, t) {
+    const i = Object.keys(e);
+    this.sortKeys && i.sort();
+    const s = this.ignoreUndefined ? this.countWithoutUndefined(e, i) : i.length;
+    if (s < 16)
+      this.writeU8(128 + s);
+    else if (s < 65536)
+      this.writeU8(222), this.writeU16(s);
+    else if (s < 4294967296)
+      this.writeU8(223), this.writeU32(s);
+    else
+      throw new Error(`Too large map object: ${s}`);
+    for (const r of i) {
+      const o = e[r];
+      this.ignoreUndefined && o === void 0 || (this.encodeString(r), this.doEncode(o, t + 1));
+    }
+  }
+  encodeExtension(e) {
+    if (typeof e.data == "function") {
+      const i = e.data(this.pos + 6), s = i.length;
+      if (s >= 4294967296)
+        throw new Error(`Too large extension object: ${s}`);
+      this.writeU8(201), this.writeU32(s), this.writeI8(e.type), this.writeU8a(i);
+      return;
+    }
+    const t = e.data.length;
+    if (t === 1)
+      this.writeU8(212);
+    else if (t === 2)
+      this.writeU8(213);
+    else if (t === 4)
+      this.writeU8(214);
+    else if (t === 8)
+      this.writeU8(215);
+    else if (t === 16)
+      this.writeU8(216);
+    else if (t < 256)
+      this.writeU8(199), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(200), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(201), this.writeU32(t);
+    else
+      throw new Error(`Too large extension object: ${t}`);
+    this.writeI8(e.type), this.writeU8a(e.data);
+  }
+  writeU8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setUint8(this.pos, e), this.pos++;
+  }
+  writeU8a(e) {
+    const t = e.length;
+    this.ensureBufferSizeToWrite(t), this.bytes.set(e, this.pos), this.pos += t;
+  }
+  writeI8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setInt8(this.pos, e), this.pos++;
+  }
+  writeU16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setUint16(this.pos, e), this.pos += 2;
+  }
+  writeI16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setInt16(this.pos, e), this.pos += 2;
+  }
+  writeU32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setUint32(this.pos, e), this.pos += 4;
+  }
+  writeI32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setInt32(this.pos, e), this.pos += 4;
+  }
+  writeF32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setFloat32(this.pos, e), this.pos += 4;
+  }
+  writeF64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setFloat64(this.pos, e), this.pos += 8;
+  }
+  writeU64(e) {
+    this.ensureBufferSizeToWrite(8), Oe(this.view, this.pos, e), this.pos += 8;
+  }
+  writeI64(e) {
+    this.ensureBufferSizeToWrite(8), xe(this.view, this.pos, e), this.pos += 8;
+  }
+  writeBigUint64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigUint64(this.pos, e), this.pos += 8;
+  }
+  writeBigInt64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigInt64(this.pos, e), this.pos += 8;
+  }
+}
+function nt(n, e) {
+  return new V(e).encodeSharedRef(n);
+}
+function K(n) {
+  return `${n < 0 ? "-" : ""}0x${Math.abs(n).toString(16).padStart(2, "0")}`;
+}
+const rt = 16, ot = 16;
+class at {
+  constructor(e = rt, t = ot) {
+    a(this, "hit", 0);
+    a(this, "miss", 0);
+    a(this, "caches");
+    a(this, "maxKeyLength");
+    a(this, "maxLengthPerKey");
+    this.maxKeyLength = e, this.maxLengthPerKey = t, this.caches = [];
+    for (let i = 0; i < this.maxKeyLength; i++)
+      this.caches.push([]);
+  }
+  canBeCached(e) {
+    return e > 0 && e <= this.maxKeyLength;
+  }
+  find(e, t, i) {
+    const s = this.caches[i - 1];
+    e: for (const r of s) {
+      const o = r.bytes;
+      for (let h = 0; h < i; h++)
+        if (o[h] !== e[t + h])
+          continue e;
+      return r.str;
+    }
+    return null;
+  }
+  store(e, t) {
+    const i = this.caches[e.length - 1], s = { bytes: e, str: t };
+    i.length >= this.maxLengthPerKey ? i[Math.random() * i.length | 0] = s : i.push(s);
+  }
+  decode(e, t, i) {
+    const s = this.find(e, t, i);
+    if (s != null)
+      return this.hit++, s;
+    this.miss++;
+    const r = ue(e, t, i), o = Uint8Array.prototype.slice.call(e, t, t + i);
+    return this.store(o, r), r;
+  }
+}
+const O = "array", L = "map_key", ge = "map_value", ct = (n) => {
+  if (typeof n == "string" || typeof n == "number")
+    return n;
+  throw new y("The type of key must be string or number but " + typeof n);
+};
+class ht {
+  constructor() {
+    a(this, "stack", []);
+    a(this, "stackHeadPosition", -1);
+  }
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = O, t.position = 0, t.size = e, t.array = new Array(e);
+  }
+  pushMapState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = L, t.readCount = 0, t.size = e, t.map = {};
+  }
+  getUninitializedStateFromPool() {
+    if (this.stackHeadPosition++, this.stackHeadPosition === this.stack.length) {
+      const e = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(e);
+    }
+    return this.stack[this.stackHeadPosition];
+  }
+  release(e) {
+    if (this.stack[this.stackHeadPosition] !== e)
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    if (e.type === O) {
+      const i = e;
+      i.size = 0, i.array = void 0, i.position = 0, i.type = void 0;
+    }
+    if (e.type === L || e.type === ge) {
+      const i = e;
+      i.size = 0, i.map = void 0, i.readCount = 0, i.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0, this.stackHeadPosition = -1;
+  }
+}
+const C = -1, Y = new DataView(new ArrayBuffer(0)), lt = new Uint8Array(Y.buffer);
+try {
+  Y.getInt8(0);
+} catch (n) {
+  if (!(n instanceof RangeError))
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+}
+const he = new RangeError("Insufficient data"), dt = new at();
+class q {
+  constructor(e) {
+    a(this, "extensionCodec");
+    a(this, "context");
+    a(this, "useBigInt64");
+    a(this, "rawStrings");
+    a(this, "maxStrLength");
+    a(this, "maxBinLength");
+    a(this, "maxArrayLength");
+    a(this, "maxMapLength");
+    a(this, "maxExtLength");
+    a(this, "keyDecoder");
+    a(this, "mapKeyConverter");
+    a(this, "totalPos", 0);
+    a(this, "pos", 0);
+    a(this, "view", Y);
+    a(this, "bytes", lt);
+    a(this, "headByte", C);
+    a(this, "stack", new ht());
+    a(this, "entered", !1);
+    this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? F.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.rawStrings = (e == null ? void 0 : e.rawStrings) ?? !1, this.maxStrLength = (e == null ? void 0 : e.maxStrLength) ?? z, this.maxBinLength = (e == null ? void 0 : e.maxBinLength) ?? z, this.maxArrayLength = (e == null ? void 0 : e.maxArrayLength) ?? z, this.maxMapLength = (e == null ? void 0 : e.maxMapLength) ?? z, this.maxExtLength = (e == null ? void 0 : e.maxExtLength) ?? z, this.keyDecoder = (e == null ? void 0 : e.keyDecoder) !== void 0 ? e.keyDecoder : dt, this.mapKeyConverter = (e == null ? void 0 : e.mapKeyConverter) ?? ct;
+  }
+  clone() {
+    return new q({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0, this.headByte = C, this.stack.reset();
+  }
+  setBuffer(e) {
+    const t = W(e);
+    this.bytes = t, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength), this.pos = 0;
+  }
+  appendBuffer(e) {
+    if (this.headByte === C && !this.hasRemaining(1))
+      this.setBuffer(e);
+    else {
+      const t = this.bytes.subarray(this.pos), i = W(e), s = new Uint8Array(t.length + i.length);
+      s.set(t), s.set(i, t.length), this.setBuffer(s);
+    }
+  }
+  hasRemaining(e) {
+    return this.view.byteLength - this.pos >= e;
+  }
+  createExtraByteError(e) {
+    const { view: t, pos: i } = this;
+    return new RangeError(`Extra ${t.byteLength - i} of ${t.byteLength} byte(s) found at buffer[${e}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(e) {
+    if (this.entered)
+      return this.clone().decode(e);
+    try {
+      this.entered = !0, this.reinitializeState(), this.setBuffer(e);
+      const t = this.doDecodeSync();
+      if (this.hasRemaining(1))
+        throw this.createExtraByteError(this.pos);
+      return t;
+    } finally {
+      this.entered = !1;
+    }
+  }
+  *decodeMulti(e) {
+    if (this.entered) {
+      yield* this.clone().decodeMulti(e);
+      return;
+    }
+    try {
+      for (this.entered = !0, this.reinitializeState(), this.setBuffer(e); this.hasRemaining(1); )
+        yield this.doDecodeSync();
+    } finally {
+      this.entered = !1;
+    }
+  }
+  async decodeAsync(e) {
+    if (this.entered)
+      return this.clone().decodeAsync(e);
+    try {
+      this.entered = !0;
+      let t = !1, i;
+      for await (const h of e) {
+        if (t)
+          throw this.entered = !1, this.createExtraByteError(this.totalPos);
+        this.appendBuffer(h);
+        try {
+          i = this.doDecodeSync(), t = !0;
+        } catch (d) {
+          if (!(d instanceof RangeError))
+            throw d;
+        }
+        this.totalPos += this.pos;
+      }
+      if (t) {
+        if (this.hasRemaining(1))
+          throw this.createExtraByteError(this.totalPos);
+        return i;
+      }
+      const { headByte: s, pos: r, totalPos: o } = this;
+      throw new RangeError(`Insufficient data in parsing ${K(s)} at ${o} (${r} in the current buffer)`);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  decodeArrayStream(e) {
+    return this.decodeMultiAsync(e, !0);
+  }
+  decodeStream(e) {
+    return this.decodeMultiAsync(e, !1);
+  }
+  async *decodeMultiAsync(e, t) {
+    if (this.entered) {
+      yield* this.clone().decodeMultiAsync(e, t);
+      return;
+    }
+    try {
+      this.entered = !0;
+      let i = t, s = -1;
+      for await (const r of e) {
+        if (t && s === 0)
+          throw this.createExtraByteError(this.totalPos);
+        this.appendBuffer(r), i && (s = this.readArraySize(), i = !1, this.complete());
+        try {
+          for (; yield this.doDecodeSync(), --s !== 0; )
+            ;
+        } catch (o) {
+          if (!(o instanceof RangeError))
+            throw o;
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doDecodeSync() {
+    e: for (; ; ) {
+      const e = this.readHeadByte();
+      let t;
+      if (e >= 224)
+        t = e - 256;
+      else if (e < 192)
+        if (e < 128)
+          t = e;
+        else if (e < 144) {
+          const s = e - 128;
+          if (s !== 0) {
+            this.pushMapState(s), this.complete();
+            continue e;
+          } else
+            t = {};
+        } else if (e < 160) {
+          const s = e - 144;
+          if (s !== 0) {
+            this.pushArrayState(s), this.complete();
+            continue e;
+          } else
+            t = [];
+        } else {
+          const s = e - 160;
+          t = this.decodeString(s, 0);
+        }
+      else if (e === 192)
+        t = null;
+      else if (e === 194)
+        t = !1;
+      else if (e === 195)
+        t = !0;
+      else if (e === 202)
+        t = this.readF32();
+      else if (e === 203)
+        t = this.readF64();
+      else if (e === 204)
+        t = this.readU8();
+      else if (e === 205)
+        t = this.readU16();
+      else if (e === 206)
+        t = this.readU32();
+      else if (e === 207)
+        this.useBigInt64 ? t = this.readU64AsBigInt() : t = this.readU64();
+      else if (e === 208)
+        t = this.readI8();
+      else if (e === 209)
+        t = this.readI16();
+      else if (e === 210)
+        t = this.readI32();
+      else if (e === 211)
+        this.useBigInt64 ? t = this.readI64AsBigInt() : t = this.readI64();
+      else if (e === 217) {
+        const s = this.lookU8();
+        t = this.decodeString(s, 1);
+      } else if (e === 218) {
+        const s = this.lookU16();
+        t = this.decodeString(s, 2);
+      } else if (e === 219) {
+        const s = this.lookU32();
+        t = this.decodeString(s, 4);
+      } else if (e === 220) {
+        const s = this.readU16();
+        if (s !== 0) {
+          this.pushArrayState(s), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 221) {
+        const s = this.readU32();
+        if (s !== 0) {
+          this.pushArrayState(s), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 222) {
+        const s = this.readU16();
+        if (s !== 0) {
+          this.pushMapState(s), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 223) {
+        const s = this.readU32();
+        if (s !== 0) {
+          this.pushMapState(s), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 196) {
+        const s = this.lookU8();
+        t = this.decodeBinary(s, 1);
+      } else if (e === 197) {
+        const s = this.lookU16();
+        t = this.decodeBinary(s, 2);
+      } else if (e === 198) {
+        const s = this.lookU32();
+        t = this.decodeBinary(s, 4);
+      } else if (e === 212)
+        t = this.decodeExtension(1, 0);
+      else if (e === 213)
+        t = this.decodeExtension(2, 0);
+      else if (e === 214)
+        t = this.decodeExtension(4, 0);
+      else if (e === 215)
+        t = this.decodeExtension(8, 0);
+      else if (e === 216)
+        t = this.decodeExtension(16, 0);
+      else if (e === 199) {
+        const s = this.lookU8();
+        t = this.decodeExtension(s, 1);
+      } else if (e === 200) {
+        const s = this.lookU16();
+        t = this.decodeExtension(s, 2);
+      } else if (e === 201) {
+        const s = this.lookU32();
+        t = this.decodeExtension(s, 4);
+      } else
+        throw new y(`Unrecognized type byte: ${K(e)}`);
+      this.complete();
+      const i = this.stack;
+      for (; i.length > 0; ) {
+        const s = i.top();
+        if (s.type === O)
+          if (s.array[s.position] = t, s.position++, s.position === s.size)
+            t = s.array, i.release(s);
+          else
+            continue e;
+        else if (s.type === L) {
+          if (t === "__proto__")
+            throw new y("The key __proto__ is not allowed");
+          s.key = this.mapKeyConverter(t), s.type = ge;
+          continue e;
+        } else if (s.map[s.key] = t, s.readCount++, s.readCount === s.size)
+          t = s.map, i.release(s);
+        else {
+          s.key = null, s.type = L;
+          continue e;
+        }
+      }
+      return t;
+    }
+  }
+  readHeadByte() {
+    return this.headByte === C && (this.headByte = this.readU8()), this.headByte;
+  }
+  complete() {
+    this.headByte = C;
+  }
+  readArraySize() {
+    const e = this.readHeadByte();
+    switch (e) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (e < 160)
+          return e - 144;
+        throw new y(`Unrecognized array type byte: ${K(e)}`);
+      }
+    }
+  }
+  pushMapState(e) {
+    if (e > this.maxMapLength)
+      throw new y(`Max length exceeded: map length (${e}) > maxMapLengthLength (${this.maxMapLength})`);
+    this.stack.pushMapState(e);
+  }
+  pushArrayState(e) {
+    if (e > this.maxArrayLength)
+      throw new y(`Max length exceeded: array length (${e}) > maxArrayLength (${this.maxArrayLength})`);
+    this.stack.pushArrayState(e);
+  }
+  decodeString(e, t) {
+    return !this.rawStrings || this.stateIsMapKey() ? this.decodeUtf8String(e, t) : this.decodeBinary(e, t);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(e, t) {
+    var r;
+    if (e > this.maxStrLength)
+      throw new y(`Max length exceeded: UTF-8 byte length (${e}) > maxStrLength (${this.maxStrLength})`);
+    if (this.bytes.byteLength < this.pos + t + e)
+      throw he;
+    const i = this.pos + t;
+    let s;
+    return this.stateIsMapKey() && ((r = this.keyDecoder) != null && r.canBeCached(e)) ? s = this.keyDecoder.decode(this.bytes, i, e) : s = We(this.bytes, i, e), this.pos += t + e, s;
+  }
+  stateIsMapKey() {
+    return this.stack.length > 0 ? this.stack.top().type === L : !1;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(e, t) {
+    if (e > this.maxBinLength)
+      throw new y(`Max length exceeded: bin length (${e}) > maxBinLength (${this.maxBinLength})`);
+    if (!this.hasRemaining(e + t))
+      throw he;
+    const i = this.pos + t, s = this.bytes.subarray(i, i + e);
+    return this.pos += t + e, s;
+  }
+  decodeExtension(e, t) {
+    if (e > this.maxExtLength)
+      throw new y(`Max length exceeded: ext length (${e}) > maxExtLength (${this.maxExtLength})`);
+    const i = this.view.getInt8(this.pos + t), s = this.decodeBinary(
+      e,
+      t + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(s, i, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const e = this.view.getUint8(this.pos);
+    return this.pos++, e;
+  }
+  readI8() {
+    const e = this.view.getInt8(this.pos);
+    return this.pos++, e;
+  }
+  readU16() {
+    const e = this.view.getUint16(this.pos);
+    return this.pos += 2, e;
+  }
+  readI16() {
+    const e = this.view.getInt16(this.pos);
+    return this.pos += 2, e;
+  }
+  readU32() {
+    const e = this.view.getUint32(this.pos);
+    return this.pos += 4, e;
+  }
+  readI32() {
+    const e = this.view.getInt32(this.pos);
+    return this.pos += 4, e;
+  }
+  readU64() {
+    const e = Ve(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readI64() {
+    const e = pe(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readU64AsBigInt() {
+    const e = this.view.getBigUint64(this.pos);
+    return this.pos += 8, e;
+  }
+  readI64AsBigInt() {
+    const e = this.view.getBigInt64(this.pos);
+    return this.pos += 8, e;
+  }
+  readF32() {
+    const e = this.view.getFloat32(this.pos);
+    return this.pos += 4, e;
+  }
+  readF64() {
+    const e = this.view.getFloat64(this.pos);
+    return this.pos += 8, e;
+  }
+}
+function ft(n, e) {
+  return new q(e).decode(n);
+}
+const ut = /* @__PURE__ */ new Set([
+  "auth",
+  "open",
+  "send",
+  "sync",
+  "history",
+  "read",
+  "typing",
+  "react",
+  "edit",
+  "delete",
+  "invoke",
+  "pubkey",
+  "ping",
+  "uploadPrekeys",
+  "fetchPrekey",
+  "assign",
+  "tag",
+  "note",
+  "agent_status",
+  "subscribe_inbox",
+  "unsubscribe_inbox"
+]);
+function mt(n) {
+  return ut.has(n.type);
+}
+function le(n) {
+  return nt(n);
+}
+function xt(n) {
+  let e;
+  try {
+    e = ft(n);
+  } catch {
+    return null;
+  }
+  return typeof e != "object" || e === null || typeof e.type != "string" ? null : e;
+}
+function pt(n) {
+  switch (n) {
+    case "open":
+      return { label: "Open", cls: "open" };
+    case "awaiting_staff":
+      return { label: "Waiting on you", cls: "waiting" };
+    case "resolved":
+      return { label: "Resolved", cls: "done" };
+    case "closed":
+      return { label: "Closed", cls: "done" };
+    default:
+      return null;
+  }
+}
+function gt(n) {
+  const e = Math.floor((Date.now() - n) / 1e3);
+  if (e < 60) return "just now";
+  if (e < 3600) return `${Math.floor(e / 60)}m`;
+  if (e < 86400) return `${Math.floor(e / 3600)}h`;
+  const t = Math.floor(e / 86400);
+  if (t <= 7) return `${t}d`;
+  try {
+    return new Date(n).toLocaleDateString(void 0, { month: "short", day: "numeric" });
+  } catch {
+    return `${t}d`;
+  }
+}
+function l(n, e, t) {
+  const i = document.createElement(n);
+  return e && (i.className = e), t !== void 0 && (i.textContent = t), i;
+}
+function Ut(n) {
+  const e = n.token ?? n.userId ?? Ce(), { httpBase: t, wsUrl: i } = de(n.url, n.apiUrl), s = n.i18n ?? {}, r = n.accent ?? "#6c5ce7";
+  if (!document.getElementById("ocl-styles")) {
+    const c = document.createElement("style");
+    c.id = "ocl-styles", c.textContent = Te, document.head.append(c);
+  }
+  if (n.webfont !== !1 && typeof document < "u" && !document.getElementById("ocw-webfont")) {
+    const c = document.createElement("link");
+    c.id = "ocw-webfont", c.rel = "stylesheet", c.href = "https://fonts.googleapis.com/css2?family=Baloo+2:wght@500;600;700&family=Nunito:wght@400;500;600;700&display=swap", document.head.append(c);
+  }
+  const o = l("div", "ocl");
+  o.style.setProperty("--ocl-accent", r), o.dataset.theme = n.theme ?? "light", n.reserveCloseSpace && o.classList.add("ocl-has-close");
+  const h = l("div", "ocl-head"), d = s.title ?? "Your conversations", U = l("span", "ocl-title", d);
+  if (U.setAttribute("aria-label", d), h.append(U), n.onNewChat) {
+    const c = l("button", "ocl-compose", "✎");
+    c.title = s.newChat ?? "New conversation", c.addEventListener("click", () => n.onNewChat()), h.append(c);
+  }
+  const b = l("div", "ocl-search-wrap"), x = l("input", "ocl-search");
+  x.placeholder = s.search ?? "🔍  Search", x.type = "search", b.append(x);
+  const g = l("div", "ocl-body");
+  g.append(l("div", "ocl-spinner", "Loading…")), o.append(h, b, g), n.el.replaceChildren(o);
+  const I = (c) => {
+    o.classList.toggle("ocl-compact", c > 0 && c < 400);
+  };
+  I(o.clientWidth);
+  let v = null;
+  if (typeof ResizeObserver < "u" && (v = new ResizeObserver((c) => {
+    var u;
+    return I(((u = c[0]) == null ? void 0 : u.contentRect.width) ?? o.clientWidth);
+  }), v.observe(o)), !n.profileId && !n.tenantId) throw new Error("[relay chatlist] provide profileId or tenantId");
+  let X;
+  const G = `ocl_seen_${n.profileId ?? `t_${n.tenantId}`}_${(n.userId ?? e).slice(-8)}`;
+  let k = {};
+  try {
+    k = JSON.parse(localStorage.getItem(G) ?? "{}");
+  } catch {
+  }
+  const we = () => {
+    try {
+      localStorage.setItem(G, JSON.stringify(k));
+    } catch {
+    }
+  };
+  let J = [], B = !1;
+  const ye = async () => {
+    const c = n.profileId ? `profileId=${encodeURIComponent(n.profileId)}${n.scope === "tenant" ? "&scope=tenant" : ""}` : `tenantId=${encodeURIComponent(n.tenantId)}`, u = `${t}/conversations/mine?${c}`, w = { authorization: `Bearer ${e}` };
+    let S;
+    try {
+      S = await fetch(u, { headers: w });
+    } catch {
+      S = await fetch(u, { headers: w });
+    }
+    if (!S.ok) return [];
+    const m = await S.json();
+    return m.defaultProfileId && (X = m.defaultProfileId), (m.conversations ?? []).sort((E, f) => f.updatedAt - E.updatedAt);
+  }, Z = (c, u) => {
+    if (B) return;
+    const w = u ? c.filter(
+      (f) => Q(f).toLowerCase().includes(u) || (f.lastMessage ?? "").toLowerCase().includes(u)
+    ) : c;
+    if (g.replaceChildren(), !w.length) {
+      const f = l("div", "ocl-empty", u ? "No results." : s.empty ?? "No conversations yet.");
+      if (!u && n.onNewChat) {
+        f.append(l("br"));
+        const D = l("button", "ocl-start", s.newChat ?? "Start a conversation");
+        D.addEventListener("click", () => n.onNewChat()), f.append(D);
+      }
+      g.append(f);
+      return;
+    }
+    const S = (f) => (f.lastSeq ?? 0) > (k[f.id] ?? 0), m = w.filter(S), E = w.filter((f) => !S(f));
+    if (m.length) {
+      g.append(l("div", "ocl-section", `${s.unread ?? "Unread"} (${m.length})`));
+      for (const f of m) g.append(j(f, S(f)));
+    }
+    if (E.length) {
+      g.append(l("div", "ocl-section", m.length ? s.all ?? "All conversations" : ""));
+      for (const f of E) g.append(j(f, !1));
+    }
+  }, Q = (c) => c.subjectTitle ?? (c.kind === "direct" ? c.peerId ?? "Direct message" : "General enquiry"), j = (c, u) => {
+    var re;
+    const w = Q(c), S = (((re = w.match(new RegExp("\\p{L}", "u"))) == null ? void 0 : re[0]) ?? w.trim()[0] ?? "?").toUpperCase(), m = c.lastSeq ?? 0, E = u ? Math.max(1, m - (k[c.id] ?? 0)) : 0, f = l("button", `ocl-row${u ? " unread" : ""}`), D = l("div", "ocl-av", S);
+    f.append(D);
+    const N = l("div", "ocl-info");
+    N.append(l("div", "ocl-name", w));
+    const me = {
+      open: "Open",
+      awaiting_staff: "Waiting for reply…",
+      resolved: "Resolved ✓",
+      closed: "Closed"
+    };
+    N.append(l("div", "ocl-preview", c.lastMessage ?? me[c.state] ?? c.state)), f.append(N);
+    const $ = l("div", "ocl-right");
+    $.append(l("div", "ocl-time", gt(c.updatedAt)));
+    const H = pt(c.state);
+    return H && $.append(l("div", `ocl-status ${H.cls}`, H.label)), E > 0 && $.append(l("div", "ocl-badge", String(E > 99 ? "99+" : E))), f.append($), f.addEventListener("click", () => {
+      var oe;
+      m > 0 && (k[c.id] = m, we()), f.classList.remove("unread"), (oe = $.querySelector(".ocl-badge")) == null || oe.remove(), n.onSelect(c);
+    }), f;
+  }, M = () => {
+    B || ye().then((c) => {
+      B || (J = c, Z(c, x.value.trim().toLowerCase()));
+    }).catch((c) => {
+      if (B) return;
+      console.error(`[chat-widget] failed to load conversations from ${t}/conversations/mine — check the apiUrl/CORS config.`, c);
+      const u = l("div", "ocl-empty", s.error ?? "Could not load conversations.");
+      u.append(l("br"));
+      const w = l("button", "ocl-retry", s.retry ?? "Retry");
+      w.addEventListener("click", () => {
+        g.replaceChildren(l("div", "ocl-spinner", "Loading…")), M();
+      }), u.append(w), g.replaceChildren(u);
+    });
+  };
+  x.addEventListener("input", () => Z(J, x.value.trim().toLowerCase())), M();
+  let p = null, T, A, ee = 0, te = !1;
+  const ie = () => {
+    A || (A = setTimeout(() => {
+      A = void 0, M();
+    }, 300));
+  }, se = () => {
+    if (!B) {
+      try {
+        p = new WebSocket(i);
+      } catch {
+        ne();
+        return;
+      }
+      p.binaryType = "arraybuffer", p.onopen = () => {
+        ee = 0, p.send(le({ type: "auth", token: e })), p.send(le({ type: "subscribe_inbox" })), te && ie(), te = !0;
+      }, p.onmessage = (c) => {
+        const u = xt(new Uint8Array(c.data));
+        u && u.type === "inbox_event" && ie();
+      }, p.onclose = () => {
+        p = null, ne();
+      }, p.onerror = () => {
+        try {
+          p == null || p.close();
+        } catch {
+        }
+      };
+    }
+  }, ne = () => {
+    if (B || T) return;
+    const c = Math.min(15e3, 500 * 2 ** ee++) + Math.random() * 250;
+    T = setTimeout(() => {
+      T = void 0, se();
+    }, c);
+  };
+  return se(), {
+    refresh: M,
+    close() {
+      B = !0, T && clearTimeout(T), A && clearTimeout(A), v == null || v.disconnect(), v = null;
+      try {
+        p == null || p.close();
+      } catch {
+      }
+      p = null, n.el.replaceChildren();
+    },
+    defaultProfileId() {
+      return n.profileId ?? X;
+    }
+  };
+}
+export {
+  yt as a,
+  ce as b,
+  xt as d,
+  le as e,
+  Se as h,
+  mt as i,
+  ke as l,
+  Ut as m,
+  Ce as p,
+  de as r
+};
+//# sourceMappingURL=chatlist2.js.map