@paramms/chat-widget 1.0.30 → 1.0.32

package/dist/e2e.js

@@ -0,0 +1,1608 @@
+var O = Object.defineProperty;
+var q = (n, e, t) => e in n ? O(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var r = (n, e, t) => q(n, typeof e != "symbol" ? e + "" : e, t);
+const V = (n) => n, Ve = (n) => n, Xe = (n) => n, We = (n) => n, Ye = (n) => n, Je = (n) => n, Ge = (n) => n, Ze = (n) => n, Qe = V("anonymous");
+function X(n) {
+  const e = n.length;
+  let t = 0, s = 0;
+  for (; s < e; ) {
+    let i = n.charCodeAt(s++);
+    if (i & 4294967168)
+      if (!(i & 4294965248))
+        t += 2;
+      else {
+        if (i >= 55296 && i <= 56319 && s < e) {
+          const a = n.charCodeAt(s);
+          (a & 64512) === 56320 && (++s, i = ((i & 1023) << 10) + (a & 1023) + 65536);
+        }
+        i & 4294901760 ? t += 4 : t += 3;
+      }
+    else {
+      t++;
+      continue;
+    }
+  }
+  return t;
+}
+function W(n, e, t) {
+  const s = n.length;
+  let i = t, a = 0;
+  for (; a < s; ) {
+    let o = n.charCodeAt(a++);
+    if (o & 4294967168)
+      if (!(o & 4294965248))
+        e[i++] = o >> 6 & 31 | 192;
+      else {
+        if (o >= 55296 && o <= 56319 && a < s) {
+          const h = n.charCodeAt(a);
+          (h & 64512) === 56320 && (++a, o = ((o & 1023) << 10) + (h & 1023) + 65536);
+        }
+        o & 4294901760 ? (e[i++] = o >> 18 & 7 | 240, e[i++] = o >> 12 & 63 | 128, e[i++] = o >> 6 & 63 | 128) : (e[i++] = o >> 12 & 15 | 224, e[i++] = o >> 6 & 63 | 128);
+      }
+    else {
+      e[i++] = o;
+      continue;
+    }
+    e[i++] = o & 63 | 128;
+  }
+}
+const Y = new TextEncoder(), J = 50;
+function G(n, e, t) {
+  Y.encodeInto(n, e.subarray(t));
+}
+function Z(n, e, t) {
+  n.length > J ? G(n, e, t) : W(n, e, t);
+}
+const Q = 4096;
+function z(n, e, t) {
+  let s = e;
+  const i = s + t, a = [];
+  let o = "";
+  for (; s < i; ) {
+    const h = n[s++];
+    if (!(h & 128))
+      a.push(h);
+    else if ((h & 224) === 192) {
+      const d = n[s++] & 63;
+      a.push((h & 31) << 6 | d);
+    } else if ((h & 240) === 224) {
+      const d = n[s++] & 63, f = n[s++] & 63;
+      a.push((h & 31) << 12 | d << 6 | f);
+    } else if ((h & 248) === 240) {
+      const d = n[s++] & 63, f = n[s++] & 63, x = n[s++] & 63;
+      let u = (h & 7) << 18 | d << 12 | f << 6 | x;
+      u > 65535 && (u -= 65536, a.push(u >>> 10 & 1023 | 55296), u = 56320 | u & 1023), a.push(u);
+    } else
+      a.push(h);
+    a.length >= Q && (o += String.fromCharCode(...a), a.length = 0);
+  }
+  return a.length > 0 && (o += String.fromCharCode(...a)), o;
+}
+const j = new TextDecoder(), ee = 200;
+function te(n, e, t) {
+  const s = n.subarray(e, e + t);
+  return j.decode(s);
+}
+function se(n, e, t) {
+  return t > ee ? te(n, e, t) : z(n, e, t);
+}
+class I {
+  constructor(e, t) {
+    r(this, "type");
+    r(this, "data");
+    this.type = e, this.data = t;
+  }
+}
+class l extends Error {
+  constructor(e) {
+    super(e);
+    const t = Object.create(l.prototype);
+    Object.setPrototypeOf(this, t), Object.defineProperty(this, "name", {
+      configurable: !0,
+      enumerable: !1,
+      value: l.name
+    });
+  }
+}
+const p = 4294967295;
+function ie(n, e, t) {
+  const s = t / 4294967296, i = t;
+  n.setUint32(e, s), n.setUint32(e + 4, i);
+}
+function H(n, e, t) {
+  const s = Math.floor(t / 4294967296), i = t;
+  n.setUint32(e, s), n.setUint32(e + 4, i);
+}
+function F(n, e) {
+  const t = n.getInt32(e), s = n.getUint32(e + 4);
+  return t * 4294967296 + s;
+}
+function ne(n, e) {
+  const t = n.getUint32(e), s = n.getUint32(e + 4);
+  return t * 4294967296 + s;
+}
+const re = -1, ae = 4294967296 - 1, oe = 17179869184 - 1;
+function he({ sec: n, nsec: e }) {
+  if (n >= 0 && e >= 0 && n <= oe)
+    if (e === 0 && n <= ae) {
+      const t = new Uint8Array(4);
+      return new DataView(t.buffer).setUint32(0, n), t;
+    } else {
+      const t = n / 4294967296, s = n & 4294967295, i = new Uint8Array(8), a = new DataView(i.buffer);
+      return a.setUint32(0, e << 2 | t & 3), a.setUint32(4, s), i;
+    }
+  else {
+    const t = new Uint8Array(12), s = new DataView(t.buffer);
+    return s.setUint32(0, e), H(s, 4, n), t;
+  }
+}
+function ce(n) {
+  const e = n.getTime(), t = Math.floor(e / 1e3), s = (e - t * 1e3) * 1e6, i = Math.floor(s / 1e9);
+  return {
+    sec: t + i,
+    nsec: s - i * 1e9
+  };
+}
+function de(n) {
+  if (n instanceof Date) {
+    const e = ce(n);
+    return he(e);
+  } else
+    return null;
+}
+function le(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), s = e.getUint32(4), i = (t & 3) * 4294967296 + s, a = t >>> 2;
+      return { sec: i, nsec: a };
+    }
+    case 12: {
+      const t = F(e, 4), s = e.getUint32(0);
+      return { sec: t, nsec: s };
+    }
+    default:
+      throw new l(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${n.length}`);
+  }
+}
+function ue(n) {
+  const e = le(n);
+  return new Date(e.sec * 1e3 + e.nsec / 1e6);
+}
+const fe = {
+  type: re,
+  encode: de,
+  decode: ue
+}, k = class k {
+  constructor() {
+    // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+    // this will make type errors a lot more clear
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    r(this, "__brand");
+    // built-in extensions
+    r(this, "builtInEncoders", []);
+    r(this, "builtInDecoders", []);
+    // custom extensions
+    r(this, "encoders", []);
+    r(this, "decoders", []);
+    this.register(fe);
+  }
+  register({ type: e, encode: t, decode: s }) {
+    if (e >= 0)
+      this.encoders[e] = t, this.decoders[e] = s;
+    else {
+      const i = -1 - e;
+      this.builtInEncoders[i] = t, this.builtInDecoders[i] = s;
+    }
+  }
+  tryToEncode(e, t) {
+    for (let s = 0; s < this.builtInEncoders.length; s++) {
+      const i = this.builtInEncoders[s];
+      if (i != null) {
+        const a = i(e, t);
+        if (a != null) {
+          const o = -1 - s;
+          return new I(o, a);
+        }
+      }
+    }
+    for (let s = 0; s < this.encoders.length; s++) {
+      const i = this.encoders[s];
+      if (i != null) {
+        const a = i(e, t);
+        if (a != null) {
+          const o = s;
+          return new I(o, a);
+        }
+      }
+    }
+    return e instanceof I ? e : null;
+  }
+  decode(e, t, s) {
+    const i = t < 0 ? this.builtInDecoders[-1 - t] : this.decoders[t];
+    return i ? i(e, t, s) : new I(t, e);
+  }
+};
+r(k, "defaultCodec", new k());
+let v = k;
+function ye(n) {
+  return n instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && n instanceof SharedArrayBuffer;
+}
+function B(n) {
+  return n instanceof Uint8Array ? n : ArrayBuffer.isView(n) ? new Uint8Array(n.buffer, n.byteOffset, n.byteLength) : ye(n) ? new Uint8Array(n) : Uint8Array.from(n);
+}
+const we = 100, xe = 2048;
+class P {
+  constructor(e) {
+    r(this, "extensionCodec");
+    r(this, "context");
+    r(this, "useBigInt64");
+    r(this, "maxDepth");
+    r(this, "initialBufferSize");
+    r(this, "sortKeys");
+    r(this, "forceFloat32");
+    r(this, "ignoreUndefined");
+    r(this, "forceIntegerToFloat");
+    r(this, "pos");
+    r(this, "view");
+    r(this, "bytes");
+    r(this, "entered", !1);
+    this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? v.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) ?? we, this.initialBufferSize = (e == null ? void 0 : e.initialBufferSize) ?? xe, 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 P({
+      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), s = new Uint8Array(t), i = new DataView(t);
+    s.set(this.bytes), this.view = i, this.bytes = s;
+  }
+  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 s = X(e);
+    this.ensureBufferSizeToWrite(5 + s), this.writeStringHeader(s), Z(e, this.bytes, this.pos), this.pos += s;
+  }
+  encodeObject(e, t) {
+    const s = this.extensionCodec.tryToEncode(e, this.context);
+    if (s != null)
+      this.encodeExtension(s);
+    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 s = B(e);
+    this.writeU8a(s);
+  }
+  encodeArray(e, t) {
+    const s = e.length;
+    if (s < 16)
+      this.writeU8(144 + s);
+    else if (s < 65536)
+      this.writeU8(220), this.writeU16(s);
+    else if (s < 4294967296)
+      this.writeU8(221), this.writeU32(s);
+    else
+      throw new Error(`Too large array: ${s}`);
+    for (const i of e)
+      this.doEncode(i, t + 1);
+  }
+  countWithoutUndefined(e, t) {
+    let s = 0;
+    for (const i of t)
+      e[i] !== void 0 && s++;
+    return s;
+  }
+  encodeMap(e, t) {
+    const s = Object.keys(e);
+    this.sortKeys && s.sort();
+    const i = this.ignoreUndefined ? this.countWithoutUndefined(e, s) : s.length;
+    if (i < 16)
+      this.writeU8(128 + i);
+    else if (i < 65536)
+      this.writeU8(222), this.writeU16(i);
+    else if (i < 4294967296)
+      this.writeU8(223), this.writeU32(i);
+    else
+      throw new Error(`Too large map object: ${i}`);
+    for (const a of s) {
+      const o = e[a];
+      this.ignoreUndefined && o === void 0 || (this.encodeString(a), this.doEncode(o, t + 1));
+    }
+  }
+  encodeExtension(e) {
+    if (typeof e.data == "function") {
+      const s = e.data(this.pos + 6), i = s.length;
+      if (i >= 4294967296)
+        throw new Error(`Too large extension object: ${i}`);
+      this.writeU8(201), this.writeU32(i), this.writeI8(e.type), this.writeU8a(s);
+      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), ie(this.view, this.pos, e), this.pos += 8;
+  }
+  writeI64(e) {
+    this.ensureBufferSizeToWrite(8), H(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 ge(n, e) {
+  return new P(e).encodeSharedRef(n);
+}
+function E(n) {
+  return `${n < 0 ? "-" : ""}0x${Math.abs(n).toString(16).padStart(2, "0")}`;
+}
+const pe = 16, me = 16;
+class Se {
+  constructor(e = pe, t = me) {
+    r(this, "hit", 0);
+    r(this, "miss", 0);
+    r(this, "caches");
+    r(this, "maxKeyLength");
+    r(this, "maxLengthPerKey");
+    this.maxKeyLength = e, this.maxLengthPerKey = t, this.caches = [];
+    for (let s = 0; s < this.maxKeyLength; s++)
+      this.caches.push([]);
+  }
+  canBeCached(e) {
+    return e > 0 && e <= this.maxKeyLength;
+  }
+  find(e, t, s) {
+    const i = this.caches[s - 1];
+    e: for (const a of i) {
+      const o = a.bytes;
+      for (let h = 0; h < s; h++)
+        if (o[h] !== e[t + h])
+          continue e;
+      return a.str;
+    }
+    return null;
+  }
+  store(e, t) {
+    const s = this.caches[e.length - 1], i = { bytes: e, str: t };
+    s.length >= this.maxLengthPerKey ? s[Math.random() * s.length | 0] = i : s.push(i);
+  }
+  decode(e, t, s) {
+    const i = this.find(e, t, s);
+    if (i != null)
+      return this.hit++, i;
+    this.miss++;
+    const a = z(e, t, s), o = Uint8Array.prototype.slice.call(e, t, t + s);
+    return this.store(o, a), a;
+  }
+}
+const b = "array", S = "map_key", R = "map_value", Ue = (n) => {
+  if (typeof n == "string" || typeof n == "number")
+    return n;
+  throw new l("The type of key must be string or number but " + typeof n);
+};
+class Ie {
+  constructor() {
+    r(this, "stack", []);
+    r(this, "stackHeadPosition", -1);
+  }
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = b, t.position = 0, t.size = e, t.array = new Array(e);
+  }
+  pushMapState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = S, 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 === b) {
+      const s = e;
+      s.size = 0, s.array = void 0, s.position = 0, s.type = void 0;
+    }
+    if (e.type === S || e.type === R) {
+      const s = e;
+      s.size = 0, s.map = void 0, s.readCount = 0, s.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0, this.stackHeadPosition = -1;
+  }
+}
+const m = -1, T = new DataView(new ArrayBuffer(0)), ve = new Uint8Array(T.buffer);
+try {
+  T.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 D = new RangeError("Insufficient data"), Ke = new Se();
+class C {
+  constructor(e) {
+    r(this, "extensionCodec");
+    r(this, "context");
+    r(this, "useBigInt64");
+    r(this, "rawStrings");
+    r(this, "maxStrLength");
+    r(this, "maxBinLength");
+    r(this, "maxArrayLength");
+    r(this, "maxMapLength");
+    r(this, "maxExtLength");
+    r(this, "keyDecoder");
+    r(this, "mapKeyConverter");
+    r(this, "totalPos", 0);
+    r(this, "pos", 0);
+    r(this, "view", T);
+    r(this, "bytes", ve);
+    r(this, "headByte", m);
+    r(this, "stack", new Ie());
+    r(this, "entered", !1);
+    this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? v.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) ?? p, this.maxBinLength = (e == null ? void 0 : e.maxBinLength) ?? p, this.maxArrayLength = (e == null ? void 0 : e.maxArrayLength) ?? p, this.maxMapLength = (e == null ? void 0 : e.maxMapLength) ?? p, this.maxExtLength = (e == null ? void 0 : e.maxExtLength) ?? p, this.keyDecoder = (e == null ? void 0 : e.keyDecoder) !== void 0 ? e.keyDecoder : Ke, this.mapKeyConverter = (e == null ? void 0 : e.mapKeyConverter) ?? Ue;
+  }
+  clone() {
+    return new C({
+      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 = m, this.stack.reset();
+  }
+  setBuffer(e) {
+    const t = B(e);
+    this.bytes = t, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength), this.pos = 0;
+  }
+  appendBuffer(e) {
+    if (this.headByte === m && !this.hasRemaining(1))
+      this.setBuffer(e);
+    else {
+      const t = this.bytes.subarray(this.pos), s = B(e), i = new Uint8Array(t.length + s.length);
+      i.set(t), i.set(s, t.length), this.setBuffer(i);
+    }
+  }
+  hasRemaining(e) {
+    return this.view.byteLength - this.pos >= e;
+  }
+  createExtraByteError(e) {
+    const { view: t, pos: s } = this;
+    return new RangeError(`Extra ${t.byteLength - s} 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, s;
+      for await (const h of e) {
+        if (t)
+          throw this.entered = !1, this.createExtraByteError(this.totalPos);
+        this.appendBuffer(h);
+        try {
+          s = 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 s;
+      }
+      const { headByte: i, pos: a, totalPos: o } = this;
+      throw new RangeError(`Insufficient data in parsing ${E(i)} at ${o} (${a} 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 s = t, i = -1;
+      for await (const a of e) {
+        if (t && i === 0)
+          throw this.createExtraByteError(this.totalPos);
+        this.appendBuffer(a), s && (i = this.readArraySize(), s = !1, this.complete());
+        try {
+          for (; yield this.doDecodeSync(), --i !== 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 i = e - 128;
+          if (i !== 0) {
+            this.pushMapState(i), this.complete();
+            continue e;
+          } else
+            t = {};
+        } else if (e < 160) {
+          const i = e - 144;
+          if (i !== 0) {
+            this.pushArrayState(i), this.complete();
+            continue e;
+          } else
+            t = [];
+        } else {
+          const i = e - 160;
+          t = this.decodeString(i, 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 i = this.lookU8();
+        t = this.decodeString(i, 1);
+      } else if (e === 218) {
+        const i = this.lookU16();
+        t = this.decodeString(i, 2);
+      } else if (e === 219) {
+        const i = this.lookU32();
+        t = this.decodeString(i, 4);
+      } else if (e === 220) {
+        const i = this.readU16();
+        if (i !== 0) {
+          this.pushArrayState(i), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 221) {
+        const i = this.readU32();
+        if (i !== 0) {
+          this.pushArrayState(i), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 222) {
+        const i = this.readU16();
+        if (i !== 0) {
+          this.pushMapState(i), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 223) {
+        const i = this.readU32();
+        if (i !== 0) {
+          this.pushMapState(i), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 196) {
+        const i = this.lookU8();
+        t = this.decodeBinary(i, 1);
+      } else if (e === 197) {
+        const i = this.lookU16();
+        t = this.decodeBinary(i, 2);
+      } else if (e === 198) {
+        const i = this.lookU32();
+        t = this.decodeBinary(i, 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 i = this.lookU8();
+        t = this.decodeExtension(i, 1);
+      } else if (e === 200) {
+        const i = this.lookU16();
+        t = this.decodeExtension(i, 2);
+      } else if (e === 201) {
+        const i = this.lookU32();
+        t = this.decodeExtension(i, 4);
+      } else
+        throw new l(`Unrecognized type byte: ${E(e)}`);
+      this.complete();
+      const s = this.stack;
+      for (; s.length > 0; ) {
+        const i = s.top();
+        if (i.type === b)
+          if (i.array[i.position] = t, i.position++, i.position === i.size)
+            t = i.array, s.release(i);
+          else
+            continue e;
+        else if (i.type === S) {
+          if (t === "__proto__")
+            throw new l("The key __proto__ is not allowed");
+          i.key = this.mapKeyConverter(t), i.type = R;
+          continue e;
+        } else if (i.map[i.key] = t, i.readCount++, i.readCount === i.size)
+          t = i.map, s.release(i);
+        else {
+          i.key = null, i.type = S;
+          continue e;
+        }
+      }
+      return t;
+    }
+  }
+  readHeadByte() {
+    return this.headByte === m && (this.headByte = this.readU8()), this.headByte;
+  }
+  complete() {
+    this.headByte = m;
+  }
+  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 l(`Unrecognized array type byte: ${E(e)}`);
+      }
+    }
+  }
+  pushMapState(e) {
+    if (e > this.maxMapLength)
+      throw new l(`Max length exceeded: map length (${e}) > maxMapLengthLength (${this.maxMapLength})`);
+    this.stack.pushMapState(e);
+  }
+  pushArrayState(e) {
+    if (e > this.maxArrayLength)
+      throw new l(`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 a;
+    if (e > this.maxStrLength)
+      throw new l(`Max length exceeded: UTF-8 byte length (${e}) > maxStrLength (${this.maxStrLength})`);
+    if (this.bytes.byteLength < this.pos + t + e)
+      throw D;
+    const s = this.pos + t;
+    let i;
+    return this.stateIsMapKey() && ((a = this.keyDecoder) != null && a.canBeCached(e)) ? i = this.keyDecoder.decode(this.bytes, s, e) : i = se(this.bytes, s, e), this.pos += t + e, i;
+  }
+  stateIsMapKey() {
+    return this.stack.length > 0 ? this.stack.top().type === S : !1;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(e, t) {
+    if (e > this.maxBinLength)
+      throw new l(`Max length exceeded: bin length (${e}) > maxBinLength (${this.maxBinLength})`);
+    if (!this.hasRemaining(e + t))
+      throw D;
+    const s = this.pos + t, i = this.bytes.subarray(s, s + e);
+    return this.pos += t + e, i;
+  }
+  decodeExtension(e, t) {
+    if (e > this.maxExtLength)
+      throw new l(`Max length exceeded: ext length (${e}) > maxExtLength (${this.maxExtLength})`);
+    const s = this.view.getInt8(this.pos + t), i = this.decodeBinary(
+      e,
+      t + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(i, s, 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 = ne(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readI64() {
+    const e = F(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 ke(n, e) {
+  return new C(e).decode(n);
+}
+const Ee = /* @__PURE__ */ new Set([
+  "auth",
+  "open",
+  "send",
+  "sync",
+  "history",
+  "read",
+  "typing",
+  "react",
+  "edit",
+  "delete",
+  "invoke",
+  "pubkey",
+  "ping",
+  "annotate",
+  "annotate_clear",
+  "uploadPrekeys",
+  "fetchPrekey",
+  "assign",
+  "tag",
+  "note",
+  "agent_status",
+  "subscribe_inbox",
+  "unsubscribe_inbox"
+]);
+function Be(n) {
+  return Ee.has(n.type);
+}
+function be(n) {
+  return ge(n);
+}
+function Ae(n) {
+  let e;
+  try {
+    e = ke(n);
+  } catch {
+    return null;
+  }
+  return typeof e != "object" || e === null || typeof e.type != "string" ? null : e;
+}
+class je {
+  constructor(e) {
+    r(this, "socket", null);
+    r(this, "state", "idle");
+    r(this, "authed", !1);
+    r(this, "everAuthed", !1);
+    r(this, "attempt", 0);
+    r(this, "outbox", []);
+    r(this, "stopped", !1);
+    r(this, "timer", null);
+    r(this, "refreshing", !1);
+    this.opts = e;
+  }
+  connect() {
+    var s, i;
+    if (this.state === "connecting" || this.state === "open") return;
+    this.stopped = !1, this.state = "connecting", this.authed = !1, (i = (s = this.opts).onStatusChange) == null || i.call(s, this.attempt > 0 ? "reconnecting" : "connecting");
+    const t = (this.opts.socketFactory ?? Ce)(this.opts.url);
+    t.binaryType = "arraybuffer", this.socket = t, t.onopen = () => {
+      this.raw({ type: "auth", token: this.opts.token });
+    }, t.onmessage = (a) => {
+      const o = Ae(new Uint8Array(a.data));
+      !o || Be(o) || this.handle(o);
+    }, t.onclose = () => this.onClosed(), t.onerror = () => {
+      try {
+        t.close();
+      } catch {
+      }
+    };
+  }
+  /** Queue a frame; sent immediately if open, else flushed on (re)connect.
+   *  The outbox is bounded so a prolonged outage can't grow memory without limit
+   *  — oldest queued frames are dropped past the cap. */
+  send(e) {
+    if (this.state === "open" && this.authed) {
+      this.raw(e);
+      return;
+    }
+    const t = this.opts.maxOutbox ?? 1e3;
+    this.outbox.length >= t && (this.outbox = this.outbox.slice(this.outbox.length - (t >> 1))), this.outbox.push(e);
+  }
+  close() {
+    var e;
+    this.stopped = !0, this.timer && clearTimeout(this.timer), this.state = "closed";
+    try {
+      (e = this.socket) == null || e.close();
+    } catch {
+    }
+  }
+  handle(e) {
+    var t, s, i, a;
+    if (e.type === "authed" && (this.attempt = 0, this.state = "open", this.authed = !0, this.everAuthed = !0, (s = (t = this.opts).onStatusChange) == null || s.call(t, "open"), this.raw(this.opts.open), this.flush()), e.type === "opened" && this.raw({ type: "sync", conversationId: e.conversation.id, sinceSeq: this.opts.getCursor() }), e.type === "error" && Pe.has(e.code)) {
+      if (e.code === "UNAUTHORIZED" && this.opts.refreshToken && !this.refreshing) {
+        this.refreshing = !0, (a = (i = this.opts).onStatusChange) == null || a.call(i, "reconnecting", "Renewing session…"), this.opts.refreshToken().then((o) => {
+          var h;
+          if (this.refreshing = !1, !o) {
+            this.fatal(e);
+            return;
+          }
+          this.opts.token = o;
+          try {
+            (h = this.socket) == null || h.close();
+          } catch {
+          }
+        }).catch(() => {
+          this.refreshing = !1, this.fatal(e);
+        });
+        return;
+      }
+      this.fatal(e);
+      return;
+    }
+    this.opts.onFrame(e);
+  }
+  fatal(e) {
+    var t, s, i;
+    this.stopped = !0;
+    try {
+      (t = this.socket) == null || t.close();
+    } catch {
+    }
+    this.state = "closed", (i = (s = this.opts).onStatusChange) == null || i.call(s, "error", Te(e.code)), this.opts.onFrame(e);
+  }
+  flush() {
+    const e = this.outbox;
+    this.outbox = [];
+    for (const t of e) this.raw(t);
+  }
+  raw(e) {
+    var t;
+    try {
+      (t = this.socket) == null || t.send(be(e));
+    } catch {
+      this.outbox.push(e);
+    }
+  }
+  onClosed() {
+    var i, a;
+    if (this.authed = !1, this.socket = null, this.stopped) {
+      this.state = "closed";
+      return;
+    }
+    this.state = "idle";
+    const e = this.opts.backoffBaseMs ?? 500, t = this.opts.backoffMaxMs ?? 15e3, s = Math.min(t, e * 2 ** this.attempt) * (0.5 + Math.random() * 0.5);
+    this.attempt++, this.attempt >= 3 && !this.everAuthed && ((a = (i = this.opts).onStatusChange) == null || a.call(i, "reconnecting", "Can't reach chat — retrying…")), this.timer = setTimeout(() => this.connect(), s);
+  }
+}
+const Pe = /* @__PURE__ */ new Set(["UNAUTHORIZED"]);
+function Te(n) {
+  switch (n) {
+    case "UNAUTHORIZED":
+      return "Chat unavailable — sign-in/token was rejected";
+    default:
+      return "Chat unavailable";
+  }
+}
+function Ce(n) {
+  return new WebSocket(n);
+}
+class et {
+  constructor(e) {
+    r(this, "conversationId");
+    r(this, "state", "");
+    r(this, "version", 0);
+    r(this, "hasMoreHistory", !1);
+    r(this, "lastReadByOthers", 0);
+    r(this, "assignedAgentId");
+    r(this, "accent");
+    r(this, "subject");
+    r(this, "name");
+    r(this, "e2e", !1);
+    r(this, "offline", !1);
+    r(this, "offlineMessage", "");
+    r(this, "whiteLabel", !1);
+    r(this, "typing", /* @__PURE__ */ new Set());
+    r(this, "online", /* @__PURE__ */ new Set());
+    /** Co-browsing: shared whiteboard strokes for this conversation. */
+    r(this, "annotations", []);
+    /** Bumped on any annotation change so the renderer can cheaply detect updates. */
+    r(this, "annotationVersion", 0);
+    /** Live sentiment of the guest's latest message (agent-side only). */
+    r(this, "sentiment");
+    r(this, "sentimentScore");
+    r(this, "actions", []);
+    r(this, "byId", /* @__PURE__ */ new Map());
+    r(this, "keyByClient", /* @__PURE__ */ new Map());
+    r(this, "_maxSeq", 0);
+    r(this, "_sorted", null);
+    this.me = e;
+  }
+  messages() {
+    return this._sorted || (this._sorted = [...this.byId.values()].sort((e, t) => {
+      const s = e.status === "pending", i = t.status === "pending";
+      return s !== i ? s ? 1 : -1 : s && i ? e.ts - t.ts : e.seq - t.seq;
+    })), this._sorted;
+  }
+  visibleActions() {
+    return this.actions.filter((e) => !e.availableInStates || e.availableInStates.includes(this.state));
+  }
+  highestSeq() {
+    return this._maxSeq;
+  }
+  addOptimistic(e, t) {
+    const s = {
+      id: e,
+      conversationId: this.conversationId,
+      seq: 0,
+      senderId: this.me,
+      senderRole: "guest",
+      content: t,
+      ts: Date.now(),
+      clientMsgId: e,
+      status: "pending"
+    };
+    return this.byId.set(e, s), this.keyByClient.set(e, e), this._sorted = null, s;
+  }
+  apply(e) {
+    var t;
+    switch (e.type) {
+      case "opened":
+        this.conversationId = e.conversation.id, this.state = e.conversation.state, e.subject && (this.subject = e.subject), e.annotations && (this.annotations = e.annotations, this.annotationVersion++);
+        return;
+      case "manifest":
+        this.actions = e.actions, this.version = e.version, e.name && (this.name = e.name), (t = e.theme) != null && t.accent && (this.accent = e.theme.accent), e.e2e && (this.e2e = !0), e.offline && (this.offline = !0), e.offlineMessage && (this.offlineMessage = e.offlineMessage), e.whiteLabel && (this.whiteLabel = !0);
+        return;
+      case "message":
+        this.upsert({ ...e.message });
+        return;
+      case "ack": {
+        const s = this.keyByClient.get(e.clientMsgId), i = s ? this.byId.get(s) : void 0;
+        if (i && s) {
+          this.byId.delete(s);
+          const a = { ...i, id: e.messageId, seq: e.seq, ts: e.ts, status: "sent" };
+          this.byId.set(e.messageId, a), this.keyByClient.set(e.clientMsgId, e.messageId), e.seq > this._maxSeq && (this._maxSeq = e.seq);
+        }
+        this._sorted = null;
+        return;
+      }
+      case "delivered":
+        this.markOwnStatus(e.seq, "delivered");
+        return;
+      case "read":
+        e.by !== this.me && (this.lastReadByOthers = Math.max(this.lastReadByOthers, e.seq), this.markOwnStatus(e.seq, "read"));
+        return;
+      case "sync":
+        for (const s of e.messages) this.upsert({ ...s });
+        return;
+      case "history":
+        for (const s of e.messages) this.upsert({ ...s });
+        this.hasMoreHistory = e.hasMore;
+        return;
+      case "typing":
+        e.userId !== this.me && (e.isTyping ? this.typing.add(e.userId) : this.typing.delete(e.userId));
+        return;
+      case "reaction": {
+        const s = this.byId.get(e.messageId);
+        if (!s) return;
+        const i = { ...s.reactions ?? {} }, a = (i[e.emoji] ?? []).filter((o) => o !== e.by);
+        e.removed || a.push(e.by), a.length ? i[e.emoji] = a : delete i[e.emoji], this.byId.set(e.messageId, { ...s, reactions: i }), this._sorted = null;
+        return;
+      }
+      case "edited": {
+        const s = this.byId.get(e.messageId);
+        s && (this.byId.set(e.messageId, { ...s, content: e.content, editedAt: e.editedAt }), this._sorted = null);
+        return;
+      }
+      case "deleted": {
+        const s = this.byId.get(e.messageId);
+        s && (this.byId.set(e.messageId, { ...s, deletedAt: e.ts }), this._sorted = null);
+        return;
+      }
+      case "state":
+        this.state = e.state;
+        return;
+      case "assigned":
+        this.assignedAgentId = e.agentId ?? void 0;
+        return;
+      case "presence":
+        e.status === "online" ? this.online.add(e.userId) : this.online.delete(e.userId);
+        return;
+      case "subjectState":
+      case "invoked":
+      case "authed":
+      case "error":
+      case "pong":
+        return;
+      case "annotation":
+        this.annotations = [...this.annotations, e.stroke], this.annotationVersion++;
+        return;
+      case "annotation_clear":
+        this.annotations = [], this.annotationVersion++;
+        return;
+      case "sentiment":
+        this.sentiment = e.label, this.sentimentScore = e.score;
+        return;
+      default:
+        return;
+    }
+  }
+  upsert(e) {
+    const t = this.byId.get(e.id);
+    this.byId.set(e.id, t ? { ...t, ...e } : e), e.seq > this._maxSeq && (this._maxSeq = e.seq), this._sorted = null;
+  }
+  markOwnStatus(e, t) {
+    const s = M(t);
+    let i = !1;
+    for (const [a, o] of this.byId)
+      o.senderId !== this.me || o.seq <= 0 || o.seq > e || M(o.status) >= s || (this.byId.set(a, { ...o, status: t }), i = !0);
+    i && (this._sorted = null);
+  }
+}
+function M(n) {
+  switch (n) {
+    case "read":
+      return 3;
+    case "delivered":
+      return 2;
+    case "sent":
+      return 1;
+    default:
+      return 0;
+  }
+}
+const _ = 200, De = 7 * 864e5;
+class tt {
+  constructor(e) {
+    r(this, "key");
+    this.key = `ocw_outbox_${e}`;
+  }
+  /** All pending items, oldest first, with stale (>7d) entries dropped. */
+  load() {
+    try {
+      const e = localStorage.getItem(this.key);
+      if (!e) return [];
+      const t = JSON.parse(e), s = Date.now() - De, i = t.filter((a) => a.ts >= s);
+      return i.length !== t.length && this.save(i), i;
+    } catch {
+      return [];
+    }
+  }
+  add(e) {
+    try {
+      const t = this.load();
+      t.push(e), this.save(t.length > _ ? t.slice(t.length - _) : t);
+    } catch {
+    }
+  }
+  /** Remove an item once it's been acknowledged by the server. */
+  remove(e) {
+    try {
+      const t = this.load().filter((s) => s.clientMsgId !== e);
+      this.save(t);
+    } catch {
+    }
+  }
+  save(e) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(e));
+    } catch {
+    }
+  }
+}
+const c = () => globalThis.crypto.subtle;
+function K(n) {
+  const e = n instanceof Uint8Array ? n : new Uint8Array(n);
+  let t = "";
+  for (const s of e) t += String.fromCharCode(s);
+  return btoa(t);
+}
+function A(n) {
+  const e = atob(n), t = new ArrayBuffer(e.length), s = new Uint8Array(t);
+  for (let i = 0; i < e.length; i++) s[i] = e.charCodeAt(i);
+  return s;
+}
+async function U() {
+  const n = await c().generateKey({ name: "ECDH", namedCurve: "P-256" }, !0, ["deriveKey", "deriveBits"]);
+  return { publicKey: n.publicKey, privateKey: n.privateKey };
+}
+async function w(n) {
+  return K(await c().exportKey("raw", n));
+}
+async function g(n) {
+  return c().importKey("raw", A(n), { name: "ECDH", namedCurve: "P-256" }, !1, []);
+}
+async function Me(n, e) {
+  const t = await g(e);
+  return c().deriveKey(
+    { name: "ECDH", public: t },
+    n,
+    { name: "AES-GCM", length: 256 },
+    !1,
+    ["encrypt", "decrypt"]
+  );
+}
+async function _e(n, e) {
+  const t = globalThis.crypto.getRandomValues(new Uint8Array(12)), s = new TextEncoder().encode(e), i = await c().encrypt({ name: "AES-GCM", iv: t }, n, s);
+  return { ct: K(i), iv: K(t) };
+}
+async function Le(n, e, t) {
+  const s = await c().decrypt({ name: "AES-GCM", iv: A(t) }, n, A(e));
+  return new TextDecoder().decode(s);
+}
+async function ze(n) {
+  var t, s;
+  try {
+    const i = (t = globalThis.localStorage) == null ? void 0 : t.getItem(n);
+    if (i) {
+      const { pub: a, priv: o } = JSON.parse(i), h = await c().importKey("jwk", a, { name: "ECDH", namedCurve: "P-256" }, !0, []), d = await c().importKey("jwk", o, { name: "ECDH", namedCurve: "P-256" }, !0, ["deriveKey", "deriveBits"]);
+      return { publicKey: h, privateKey: d };
+    }
+  } catch {
+  }
+  const e = await U();
+  try {
+    const i = await c().exportKey("jwk", e.publicKey), a = await c().exportKey("jwk", e.privateKey);
+    (s = globalThis.localStorage) == null || s.setItem(n, JSON.stringify({ pub: i, priv: a }));
+  } catch {
+  }
+  return e;
+}
+async function He(n, e) {
+  const t = await c().exportKey("raw", e), s = await c().sign({ name: "ECDSA", hash: "SHA-256" }, n, t);
+  return K(s);
+}
+async function Fe() {
+  const n = await U(), e = await c().generateKey({ name: "ECDSA", namedCurve: "P-256" }, !0, ["sign", "verify"]);
+  return {
+    ecdhKP: n,
+    ecdsaKP: { publicKey: e.publicKey, privateKey: e.privateKey },
+    publicKeyB64: await w(n.publicKey),
+    sigPublicKeyB64: await w(e.publicKey)
+  };
+}
+async function L(n) {
+  var t, s;
+  try {
+    const i = (t = globalThis.localStorage) == null ? void 0 : t.getItem(`${n}-identity`);
+    if (i) {
+      const a = JSON.parse(i), o = await c().importKey("jwk", a.ecdhPub, { name: "ECDH", namedCurve: "P-256" }, !0, []), h = await c().importKey("jwk", a.ecdhPriv, { name: "ECDH", namedCurve: "P-256" }, !0, ["deriveKey", "deriveBits"]), d = await c().importKey("jwk", a.ecdsaPub, { name: "ECDSA", namedCurve: "P-256" }, !0, ["verify"]), f = await c().importKey("jwk", a.ecdsaPriv, { name: "ECDSA", namedCurve: "P-256" }, !0, ["sign"]);
+      return {
+        ecdhKP: { publicKey: o, privateKey: h },
+        ecdsaKP: { publicKey: d, privateKey: f },
+        publicKeyB64: await w(o),
+        sigPublicKeyB64: await w(d)
+      };
+    }
+  } catch {
+  }
+  const e = await Fe();
+  try {
+    const i = await c().exportKey("jwk", e.ecdhKP.publicKey), a = await c().exportKey("jwk", e.ecdhKP.privateKey), o = await c().exportKey("jwk", e.ecdsaKP.publicKey), h = await c().exportKey("jwk", e.ecdsaKP.privateKey);
+    (s = globalThis.localStorage) == null || s.setItem(`${n}-identity`, JSON.stringify({ ecdhPub: i, ecdhPriv: a, ecdsaPub: o, ecdsaPriv: h }));
+  } catch {
+  }
+  return e;
+}
+async function Re(n, e) {
+  const t = await U(), s = await w(t.publicKey), i = await g(e.identityKey), a = await g(e.signedPrekey), o = e.oneTimePrekey ? await g(e.oneTimePrekey) : null, h = await y(n.privateKey, a), d = await y(t.privateKey, i), f = await y(t.privateKey, a), x = o ? await y(t.privateKey, o) : null, u = $(h, d, f, ...x ? [x] : []);
+  return { sharedKey: await N(u), ephemeralPublicKey: s };
+}
+async function $e(n, e, t, s, i) {
+  const a = await g(t), o = await g(s), h = await y(e.privateKey, a), d = await y(n.privateKey, o), f = await y(e.privateKey, o), x = i ? await y(i.privateKey, o) : null, u = $(h, d, f, ...x ? [x] : []);
+  return N(u);
+}
+async function y(n, e) {
+  return c().deriveBits({ name: "ECDH", public: e }, n, 256);
+}
+function $(...n) {
+  const e = n.reduce((i, a) => i + a.byteLength, 0), t = new Uint8Array(e);
+  let s = 0;
+  for (const i of n)
+    t.set(new Uint8Array(i), s), s += i.byteLength;
+  return t.buffer;
+}
+async function N(n) {
+  const e = await c().importKey("raw", n, "HKDF", !1, ["deriveKey"]);
+  return c().deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: new TextEncoder().encode("ObjectChat X3DH v1") },
+    e,
+    { name: "AES-GCM", length: 256 },
+    !1,
+    ["encrypt", "decrypt"]
+  );
+}
+const Ne = 20;
+class st {
+  constructor(e) {
+    // Live ECDH mode state
+    r(this, "kp");
+    r(this, "shared");
+    // X3DH async mode state
+    r(this, "identityKP");
+    r(this, "signedPreKP");
+    r(this, "signedPrekeyId");
+    r(this, "otpKeys", []);
+    // one-time prekeys awaiting matching
+    r(this, "x3dhShared");
+    // Queued init messages arriving before we could derive (shouldn't happen, but safe)
+    r(this, "pendingX3DH");
+    this.storageKey = e;
+  }
+  get ready() {
+    return !!(this.shared ?? this.x3dhShared);
+  }
+  /** Live ECDH mode: Generate/restore our keypair and return our public key to publish. */
+  async begin() {
+    return this.kp = await ze(this.storageKey), w(this.kp.publicKey);
+  }
+  /** Live ECDH mode: A peer published their key — derive the shared secret. */
+  async onPeerKey(e) {
+    this.kp && (this.shared = await Me(this.kp.privateKey, e));
+  }
+  // ── X3DH async mode ────────────────────────────────────────────────────────
+  /** X3DH: Generate identity key, signed prekey, and OTP prekeys.
+   *  Returns the upload frame payload the caller should send to the server. */
+  async initX3DH() {
+    this.identityKP = await L(this.storageKey), this.signedPreKP = await U(), this.signedPrekeyId = `spk-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    for (let i = 0; i < Ne; i++) this.otpKeys.push(await U());
+    const e = await w(this.signedPreKP.publicKey), t = await He(this.identityKP.ecdsaKP.privateKey, this.signedPreKP.publicKey), s = await Promise.all(this.otpKeys.map((i) => w(i.publicKey)));
+    return {
+      identityKey: this.identityKP.publicKeyB64,
+      signedPrekey: e,
+      signedPrekeyId: this.signedPrekeyId,
+      signature: t,
+      oneTimePrekeys: s
+    };
+  }
+  /** X3DH sender: given a recipient's prekey bundle, derive the shared key and
+   *  return the init message fields to embed in the first encrypted message. */
+  async x3dhSendTo(e) {
+    this.identityKP || (this.identityKP = await L(this.storageKey));
+    const { sharedKey: t, ephemeralPublicKey: s } = await Re(this.identityKP.ecdhKP, e);
+    return this.x3dhShared = t, { ephemeralKey: s, spkId: e.signedPrekeyId, usedOTP: !!e.oneTimePrekey, senderIK: this.identityKP.publicKeyB64 };
+  }
+  /** X3DH recipient: given an init message's sender IK + EK + SPK ID, derive the shared key. */
+  async x3dhReceiveFrom(e, t, s) {
+    if (!this.identityKP || !this.signedPreKP) {
+      this.pendingX3DH = { senderIK: e, ephemeralKey: t, spkId: s };
+      return;
+    }
+    const i = this.otpKeys.shift();
+    this.x3dhShared = await $e(this.identityKP.ecdhKP, this.signedPreKP, e, t, i);
+  }
+  /** Flush pending X3DH derivation after initX3DH() completes. */
+  async flushPendingX3DH() {
+    if (!this.pendingX3DH) return;
+    const { senderIK: e, ephemeralKey: t, spkId: s } = this.pendingX3DH;
+    this.pendingX3DH = void 0, await this.x3dhReceiveFrom(e, t, s);
+  }
+  /** Encrypt outgoing text into a wire content object. For X3DH init messages,
+   *  the caller should pass x3dhInit fields to embed in the content. */
+  async sealText(e, t) {
+    const s = this.x3dhShared ?? this.shared;
+    if (!s) throw new Error("secure channel not ready");
+    const { ct: i, iv: a } = await _e(s, e);
+    return {
+      kind: "text",
+      text: i,
+      enc: !0,
+      iv: a,
+      ...t ? { x3dhEK: t.ephemeralKey, x3dhSPK: t.spkId, x3dhIK: t.senderIK } : {}
+    };
+  }
+  /** Decrypt one content object if it is encrypted (otherwise pass through). */
+  async openContent(e) {
+    if (e.kind !== "text" || !e.enc || !e.iv) return e;
+    const t = this.x3dhShared ?? this.shared;
+    if (!t) return { kind: "text", text: "🔒 encrypted" };
+    try {
+      return { kind: "text", text: await Le(t, e.text, e.iv) };
+    } catch {
+      return { kind: "text", text: "🔒 unable to decrypt" };
+    }
+  }
+  /** Decrypt any encrypted message content carried by an incoming frame, in place. */
+  async openFrame(e) {
+    if (e.type === "message") e.message.content = await this.openContent(e.message.content);
+    else if (e.type === "sync")
+      for (const t of e.messages) t.content = await this.openContent(t.content);
+  }
+}
+function it(n) {
+  if (n.kind !== "text" || !n.enc) return null;
+  const e = n;
+  return !e.x3dhEK || !e.x3dhSPK || !e.x3dhIK ? null : { x3dhEK: e.x3dhEK, x3dhSPK: e.x3dhSPK, x3dhIK: e.x3dhIK };
+}
+export {
+  Qe as A,
+  et as C,
+  st as E,
+  tt as P,
+  Ve as a,
+  je as b,
+  Je as c,
+  Ze as d,
+  Xe as e,
+  Ye as f,
+  Ge as g,
+  We as h,
+  V as i,
+  Ae as j,
+  be as k,
+  Be as l,
+  it as m
+};
+//# sourceMappingURL=e2e.js.map