@telnyx/ai-agent-lib 0.2.8 → 0.2.11

package/dist/index.js

@@ -0,0 +1,4131 @@
+import ut, { useReducer as En, useEffect as pe, useDebugValue as Tn, useCallback as An, useContext as Vt, createContext as Gt, useState as Rn } from "react";
+function Wt(t, e) {
+  var n = {};
+  for (var i in t) Object.prototype.hasOwnProperty.call(t, i) && e.indexOf(i) < 0 && (n[i] = t[i]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function") {
+    var s = 0;
+    for (i = Object.getOwnPropertySymbols(t); s < i.length; s++) e.indexOf(i[s]) < 0 && Object.prototype.propertyIsEnumerable.call(t, i[s]) && (n[i[s]] = t[i[s]]);
+  }
+  return n;
+}
+function O(t, e, n, i) {
+  return new (n || (n = Promise))((function(s, a) {
+    function o(h) {
+      try {
+        d(i.next(h));
+      } catch (f) {
+        a(f);
+      }
+    }
+    function l(h) {
+      try {
+        d(i.throw(h));
+      } catch (f) {
+        a(f);
+      }
+    }
+    function d(h) {
+      var f;
+      h.done ? s(h.value) : (f = h.value, f instanceof n ? f : new n((function(m) {
+        m(f);
+      }))).then(o, l);
+    }
+    d((i = i.apply(t, [])).next());
+  }));
+}
+var gt = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto < "u" && typeof msCrypto.getRandomValues == "function" && msCrypto.getRandomValues.bind(msCrypto), xn = new Uint8Array(16);
+function Ln() {
+  if (!gt) throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return gt(xn);
+}
+for (var Ht = [], xe = 0; xe < 256; ++xe) Ht[xe] = (xe + 256).toString(16).substr(1);
+function ve(t, e, n) {
+  var i = e && n || 0;
+  typeof t == "string" && (e = t === "binary" ? new Array(16) : null, t = null);
+  var s = (t = t || {}).random || (t.rng || Ln)();
+  if (s[6] = 15 & s[6] | 64, s[8] = 63 & s[8] | 128, e) for (var a = 0; a < 16; ++a) e[i + a] = s[a];
+  return e || (function(o, l) {
+    var d = 0, h = Ht;
+    return [h[o[d++]], h[o[d++]], h[o[d++]], h[o[d++]], "-", h[o[d++]], h[o[d++]], "-", h[o[d++]], h[o[d++]], "-", h[o[d++]], h[o[d++]], "-", h[o[d++]], h[o[d++]], h[o[d++]], h[o[d++]], h[o[d++]], h[o[d++]]].join("");
+  })(s);
+}
+const mt = "wss://rtc.telnyx.com", qt = { urls: "stun:stun.l.google.com:19302" }, On = [{ urls: "stun:stun.telnyx.com:3478" }, qt, { urls: "turn:turn.telnyx.com:3478?transport=tcp", username: "testuser", credential: "testpassword" }], Mn = [{ urls: "stun:stundev.telnyx.com:3478" }, qt, { urls: "turn:turndev.telnyx.com:3478?transport=tcp", username: "testuser", credential: "testpassword" }];
+var L;
+(function(t) {
+  t.SocketOpen = "telnyx.socket.open", t.SocketClose = "telnyx.socket.close", t.SocketError = "telnyx.socket.error", t.SocketMessage = "telnyx.socket.message", t.SpeedTest = "telnyx.internal.speedtest", t.Ready = "telnyx.ready", t.Error = "telnyx.error", t.Notification = "telnyx.notification", t.StatsFrame = "telnyx.stats.frame", t.StatsReport = "telnyx.stats.report", t.Messages = "telnyx.messages", t.Calls = "telnyx.calls", t.MediaError = "telnyx.rtc.mediaError", t.PeerConnectionFailureError = "telnyx.rtc.peerConnectionFailureError";
+})(L || (L = {}));
+var Pn = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Jt(t, e) {
+  return t(e = { exports: {} }, e.exports), e.exports;
+}
+var Dn = Jt((function(t) {
+  var e, n;
+  e = Pn, n = function() {
+    var i = function() {
+    }, s = "undefined", a = typeof window !== s && typeof window.navigator !== s && /Trident\/|MSIE /.test(window.navigator.userAgent), o = ["trace", "debug", "info", "warn", "error"];
+    function l(p, _) {
+      var A = p[_];
+      if (typeof A.bind == "function") return A.bind(p);
+      try {
+        return Function.prototype.bind.call(A, p);
+      } catch {
+        return function() {
+          return Function.prototype.apply.apply(A, [p, arguments]);
+        };
+      }
+    }
+    function d() {
+      console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+    }
+    function h(p, _) {
+      for (var A = 0; A < o.length; A++) {
+        var E = o[A];
+        this[E] = A < p ? i : this.methodFactory(E, p, _);
+      }
+      this.log = this.debug;
+    }
+    function f(p, _, A) {
+      return function() {
+        typeof console !== s && (h.call(this, _, A), this[p].apply(this, arguments));
+      };
+    }
+    function m(p, _, A) {
+      return (function(E) {
+        return E === "debug" && (E = "log"), typeof console !== s && (E === "trace" && a ? d : console[E] !== void 0 ? l(console, E) : console.log !== void 0 ? l(console, "log") : i);
+      })(p) || f.apply(this, arguments);
+    }
+    function S(p, _, A) {
+      var E, P = this;
+      _ = _ ?? "WARN";
+      var D = "loglevel";
+      function q() {
+        var x;
+        if (typeof window !== s && D) {
+          try {
+            x = window.localStorage[D];
+          } catch {
+          }
+          if (typeof x === s) try {
+            var r = window.document.cookie, c = r.indexOf(encodeURIComponent(D) + "=");
+            c !== -1 && (x = /^([^;]+)/.exec(r.slice(c))[1]);
+          } catch {
+          }
+          return P.levels[x] === void 0 && (x = void 0), x;
+        }
+      }
+      typeof p == "string" ? D += ":" + p : typeof p == "symbol" && (D = void 0), P.name = p, P.levels = { TRACE: 0, DEBUG: 1, INFO: 2, WARN: 3, ERROR: 4, SILENT: 5 }, P.methodFactory = A || m, P.getLevel = function() {
+        return E;
+      }, P.setLevel = function(x, r) {
+        if (typeof x == "string" && P.levels[x.toUpperCase()] !== void 0 && (x = P.levels[x.toUpperCase()]), !(typeof x == "number" && x >= 0 && x <= P.levels.SILENT)) throw "log.setLevel() called with invalid level: " + x;
+        if (E = x, r !== !1 && (function(c) {
+          var u = (o[c] || "silent").toUpperCase();
+          if (typeof window !== s && D) {
+            try {
+              return void (window.localStorage[D] = u);
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(D) + "=" + u + ";";
+            } catch {
+            }
+          }
+        })(x), h.call(P, x, p), typeof console === s && x < P.levels.SILENT) return "No console available for logging";
+      }, P.setDefaultLevel = function(x) {
+        _ = x, q() || P.setLevel(x, !1);
+      }, P.resetLevel = function() {
+        P.setLevel(_, !1), (function() {
+          if (typeof window !== s && D) {
+            try {
+              return void window.localStorage.removeItem(D);
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(D) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+            } catch {
+            }
+          }
+        })();
+      }, P.enableAll = function(x) {
+        P.setLevel(P.levels.TRACE, x);
+      }, P.disableAll = function(x) {
+        P.setLevel(P.levels.SILENT, x);
+      };
+      var B = q();
+      B == null && (B = _), P.setLevel(B, !1);
+    }
+    var w = new S(), C = {};
+    w.getLogger = function(p) {
+      if (typeof p != "symbol" && typeof p != "string" || p === "") throw new TypeError("You must supply a name when creating a logger.");
+      var _ = C[p];
+      return _ || (_ = C[p] = new S(p, w.getLevel(), w.methodFactory)), _;
+    };
+    var k = typeof window !== s ? window.log : void 0;
+    return w.noConflict = function() {
+      return typeof window !== s && window.log === w && (window.log = k), w;
+    }, w.getLoggers = function() {
+      return C;
+    }, w.default = w, w;
+  }, t.exports ? t.exports = n() : e.log = n();
+}));
+const y = Dn.getLogger("telnyx"), Nn = y.methodFactory;
+y.methodFactory = (t, e, n) => {
+  const i = Nn(t, e, n);
+  return function() {
+    const s = [(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", ""), "-"];
+    for (let a = 0; a < arguments.length; a++) s.push(arguments[a]);
+    i.apply(void 0, s);
+  };
+}, y.setLevel("info");
+const Le = (t) => {
+  const [e, n, i, s, a, o] = t;
+  let l = {};
+  try {
+    l = JSON.parse(a.replace(/ID"/g, 'Id"'));
+  } catch {
+    y.warn("Verto LA invalid media JSON string:", a);
+  }
+  return { participantId: Number(e), participantNumber: n, participantName: i, codec: s, media: l, participantData: o };
+}, Yt = (t) => {
+  if (typeof t != "string") return t;
+  try {
+    return JSON.parse(t);
+  } catch {
+    return t;
+  }
+}, ye = (t) => t instanceof Function || typeof t == "function", De = (t) => typeof document == "object" && "getElementById" in document ? typeof t == "string" ? document.getElementById(t) || null : typeof t == "function" ? t() : t instanceof HTMLMediaElement ? t : null : null, Un = /^(ws|wss):\/\//, zt = (t, e = null) => {
+  const { result: n = {}, error: i } = t;
+  if (i) return { error: i };
+  const { result: s = null } = n;
+  if (s === null) return e !== null && (n.node_id = e), { result: n };
+  const { code: a = null, node_id: o = null, result: l = null } = s;
+  return a && a !== "200" ? { error: s } : l ? zt(l, o) : { result: s };
+}, Kt = (t, e) => Math.floor(Math.random() * (e - t + 1) + t), Ne = ({ login: t, passwd: e, password: n, login_token: i }) => !!(t && (e || n) || i), Ie = ({ anonymous_login: t }) => !!t && !!t.target_id && !!t.target_type, ht = (t) => {
+  var e, n, i, s, a, o;
+  let l = "", d = "";
+  return !((n = (e = t?.result) === null || e === void 0 ? void 0 : e.params) === null || n === void 0) && n.state && (l = (s = (i = t?.result) === null || i === void 0 ? void 0 : i.params) === null || s === void 0 ? void 0 : s.state), !((a = t?.params) === null || a === void 0) && a.state && (d = (o = t?.params) === null || o === void 0 ? void 0 : o.state), l || d;
+};
+function vt({ debounceTime: t }) {
+  let e, n;
+  return { promise: new Promise(((i, s) => {
+    e = t ? jn(i, t) : i, n = s;
+  })), resolve: e, reject: n };
+}
+const jn = (t, e) => {
+  let n;
+  return (...i) => {
+    clearTimeout(n), n = window.setTimeout((() => {
+      t(...i);
+    }), e);
+  };
+}, pt = "telnyx-voice-sdk-id";
+function fe() {
+  return sessionStorage.getItem(pt);
+}
+var K, le, $;
+typeof window < "u" && window.addEventListener("beforeunload", (() => {
+  sessionStorage.removeItem(pt);
+})), (function(t) {
+  t.Offer = "offer", t.Answer = "answer";
+})(K || (K = {})), (function(t) {
+  t.Inbound = "inbound", t.Outbound = "outbound";
+})(le || (le = {})), (function(t) {
+  t.Invite = "telnyx_rtc.invite", t.Attach = "telnyx_rtc.attach", t.Answer = "telnyx_rtc.answer", t.Info = "telnyx_rtc.info", t.Candidate = "telnyx_rtc.candidate", t.EndOfCandidates = "telnyx_rtc.endOfCandidates", t.Display = "telnyx_rtc.display", t.Media = "telnyx_rtc.media", t.Event = "telnyx_rtc.event", t.Bye = "telnyx_rtc.bye", t.Punt = "telnyx_rtc.punt", t.Broadcast = "telnyx_rtc.broadcast", t.Subscribe = "telnyx_rtc.subscribe", t.Unsubscribe = "telnyx_rtc.unsubscribe", t.ClientReady = "telnyx_rtc.clientReady", t.Modify = "telnyx_rtc.modify", t.Ringing = "telnyx_rtc.ringing", t.GatewayState = "telnyx_rtc.gatewayState", t.Ping = "telnyx_rtc.ping", t.Pong = "telnyx_rtc.pong";
+})($ || ($ = {}));
+const oe = { generic: "event", [$.Display]: "participantData", [$.Attach]: "participantData", conferenceUpdate: "conferenceUpdate", callUpdate: "callUpdate", vertoClientReady: "vertoClientReady", userMediaError: "userMediaError", peerConnectionFailureError: "peerConnectionFailureError" }, Fn = { destinationNumber: "", remoteCallerName: "Outbound Call", remoteCallerNumber: "", callerName: "", callerNumber: "", audio: !0, useStereo: !1, debug: !1, debugOutput: "socket", attach: !1, screenShare: !1, userVariables: {}, mediaSettings: { useSdpASBandwidthKbps: !1, sdpASBandwidthKbps: 0 }, mutedMicOnStart: !1 };
+var N, et, se, ae, te;
+(function(t) {
+  t[t.New = 0] = "New", t[t.Requesting = 1] = "Requesting", t[t.Trying = 2] = "Trying", t[t.Recovering = 3] = "Recovering", t[t.Ringing = 4] = "Ringing", t[t.Answering = 5] = "Answering", t[t.Early = 6] = "Early", t[t.Active = 7] = "Active", t[t.Held = 8] = "Held", t[t.Hangup = 9] = "Hangup", t[t.Destroy = 10] = "Destroy", t[t.Purge = 11] = "Purge";
+})(N || (N = {})), (function(t) {
+  t.Participant = "participant", t.Moderator = "moderator";
+})(et || (et = {})), (function(t) {
+  t.Join = "join", t.Leave = "leave", t.Bootstrap = "bootstrap", t.Add = "add", t.Modify = "modify", t.Delete = "delete", t.Clear = "clear", t.ChatMessage = "chatMessage", t.LayerInfo = "layerInfo", t.LogoInfo = "logoInfo", t.LayoutInfo = "layoutInfo", t.LayoutList = "layoutList", t.ModCmdResponse = "modCommandResponse";
+})(se || (se = {})), (function(t) {
+  t.Video = "videoinput", t.AudioIn = "audioinput", t.AudioOut = "audiooutput";
+})(ae || (ae = {})), (function(t) {
+  t.REGED = "REGED", t.UNREGED = "UNREGED", t.NOREG = "NOREG", t.FAILED = "FAILED", t.FAIL_WAIT = "FAIL_WAIT", t.REGISTER = "REGISTER", t.TRYING = "TRYING", t.EXPIRED = "EXPIRED", t.UNREGISTER = "UNREGISTER";
+})(te || (te = {}));
+const be = "GLOBAL", ie = {}, Ae = (t, e) => `${t}|${e}`, Qt = (t, e = be) => Ae(t, e) in ie, de = (t, e, n = be) => {
+  const i = Ae(t, n);
+  i in ie || (ie[i] = []), ie[i].push(e);
+}, Xt = (t, e, n = be) => {
+  const i = function(s) {
+    ue(t, i, n), e(s);
+  };
+  return i.prototype.targetRef = e, de(t, i, n);
+}, ue = (t, e, n = be) => {
+  if (!Qt(t, n)) return !1;
+  const i = Ae(t, n);
+  if (ye(e))
+    for (let s = ie[i].length - 1; s >= 0; s--) {
+      const a = ie[i][s];
+      (e === a || a.prototype && e === a.prototype.targetRef) && ie[i].splice(s, 1);
+    }
+  else ie[i] = [];
+  return ie[i].length === 0 && delete ie[i], !0;
+}, F = (t, e, n = be, i = !0) => {
+  const s = i && n !== be;
+  if (!Qt(t, n)) return s && F(t, e), !1;
+  const a = Ae(t, n), o = ie[a].length;
+  if (!o) return s && F(t, e), !1;
+  for (let l = o - 1; l >= 0; l--) ie[a][l](e);
+  return s && F(t, e), !0;
+}, Ke = (t) => {
+  const e = Ae(t, "");
+  Object.keys(ie).filter(((n) => n.indexOf(e) === 0)).forEach(((n) => delete ie[n]));
+};
+let $n = typeof WebSocket < "u" ? WebSocket : null;
+const Bn = 0, Vn = 1, Gn = 2, Wn = 3;
+class yt {
+  constructor(e) {
+    this.session = e, this.previousGatewayState = "", this._wsClient = null, this._host = mt, this._timers = {}, this._useCanaryRtcServer = !1, this._hasCanaryBeenUsed = !1, this.upDur = null, this.downDur = null;
+    const { host: n, env: i, region: s, trickleIce: a, useCanaryRtcServer: o } = e.options;
+    i && (this._host = i === "development" ? "wss://rtcdev.telnyx.com" : mt), n && (this._host = ((l) => `${Un.test(l) ? "" : "wss://"}${l}`)(n)), s && (this._host = this._host.replace(/rtc(dev)?/, `${s}.rtc$1`)), (a || o) && (this._useCanaryRtcServer = !0);
+  }
+  get connected() {
+    return this._wsClient && this._wsClient.readyState === Vn;
+  }
+  get connecting() {
+    return this._wsClient && this._wsClient.readyState === Bn;
+  }
+  get closing() {
+    return this._wsClient && this._wsClient.readyState === Gn;
+  }
+  get closed() {
+    return this._wsClient && this._wsClient.readyState === Wn;
+  }
+  get isAlive() {
+    return this.connecting || this.connected;
+  }
+  get isDead() {
+    return this.closing || this.closed;
+  }
+  connect() {
+    const e = new URL(this._host);
+    let n = fe();
+    this.session.options.rtcIp && this.session.options.rtcPort && (n = null, this._useCanaryRtcServer = !1, e.searchParams.set("rtc_ip", this.session.options.rtcIp), e.searchParams.set("rtc_port", this.session.options.rtcPort.toString())), n && e.searchParams.set("voice_sdk_id", n), this._useCanaryRtcServer && (e.searchParams.set("canary", "true"), n && !this._hasCanaryBeenUsed && (e.searchParams.delete("voice_sdk_id"), y.debug("first canary connection. Refreshing voice_sdk_id")), this._hasCanaryBeenUsed = !0), this._wsClient = new $n(e.toString()), this._wsClient.onopen = (i) => F(L.SocketOpen, i, this.session.uuid), this._wsClient.onclose = (i) => F(L.SocketClose, i, this.session.uuid), this._wsClient.onerror = (i) => F(L.SocketError, { error: i, sessionId: this.session.sessionid }, this.session.uuid), this._wsClient.onmessage = (i) => {
+      var s, a;
+      const o = Yt(i.data);
+      var l;
+      if (typeof o != "string") {
+        if (o.voice_sdk_id && (l = o.voice_sdk_id, sessionStorage.setItem(pt, l)), this._unsetTimer(o.id), y.debug(`RECV: 
+`, JSON.stringify(o, null, 2), `
+`), te[`${(a = (s = o?.result) === null || s === void 0 ? void 0 : s.params) === null || a === void 0 ? void 0 : a.state}`] || !F(o.id, o)) {
+          const d = ht(o);
+          F(L.SocketMessage, o, this.session.uuid), d && (this.previousGatewayState = d);
+        }
+      } else this._handleStringResponse(o);
+    };
+  }
+  sendRawText(e) {
+    this._wsClient.send(e);
+  }
+  send(e) {
+    const { request: n } = e, i = new Promise(((s, a) => {
+      if (n.hasOwnProperty("result")) return s();
+      Xt(n.id, ((o) => {
+        const { result: l, error: d } = zt(o);
+        return d ? a(d) : s(l);
+      }));
+    }));
+    return y.debug(`SEND: 
+`, JSON.stringify(n, null, 2), `
+`), this._wsClient.send(JSON.stringify(n)), i;
+  }
+  close() {
+    this._wsClient && (ye(this._wsClient._beginClose) ? this._wsClient._beginClose() : this._wsClient.close()), this._wsClient = null;
+  }
+  _unsetTimer(e) {
+    clearTimeout(this._timers[e]), delete this._timers[e];
+  }
+  _handleStringResponse(e) {
+    if (/^#SP/.test(e)) switch (e[3]) {
+      case "U":
+        this.upDur = parseInt(e.substring(4));
+        break;
+      case "D":
+        this.downDur = parseInt(e.substring(4)), F(L.SpeedTest, { upDur: this.upDur, downDur: this.downDur }, this.session.uuid);
+    }
+    else y.warn("Unknown message from socket", e);
+  }
+}
+class Re {
+  buildRequest(e) {
+    this.request = Object.assign({ jsonrpc: "2.0", id: ve() }, e);
+  }
+}
+const bt = { id: "callID", destinationNumber: "destination_number", remoteCallerName: "remote_caller_id_name", remoteCallerNumber: "remote_caller_id_number", callerName: "caller_id_name", callerNumber: "caller_id_number", customHeaders: "custom_headers" };
+class Z extends Re {
+  constructor(e = {}) {
+    if (super(), e.hasOwnProperty("dialogParams")) {
+      const n = Wt(e.dialogParams, ["remoteSdp", "localStream", "remoteStream", "onNotification", "camId", "micId", "speakerId"]);
+      for (const i in bt) i && n.hasOwnProperty(i) && (n[bt[i]] = n[i], delete n[i]);
+      e.dialogParams = n;
+    }
+    this.buildRequest({ method: this.toString(), params: e });
+  }
+}
+class Zt extends Z {
+  constructor(e) {
+    super(), this.method = $.GatewayState, this.buildRequest({ method: this.method, voice_sdk_id: e, params: {} });
+  }
+}
+class Hn {
+  constructor(e) {
+    this.pendingRequestId = null, this.onSocketMessage = (n) => O(this, void 0, void 0, (function* () {
+      n.id === this.pendingRequestId && this.gatewayStateTask.resolve(ht(n));
+    })), this.getIsRegistered = () => O(this, void 0, void 0, (function* () {
+      const n = new Zt(fe());
+      this.pendingRequestId = n.request.id, this.gatewayStateTask = vt({}), this.session.execute(n);
+      const i = yield this.gatewayStateTask.promise;
+      return !!i && [te.REGISTER, te.REGED].includes(i);
+    })), this.session = e, this.gatewayStateTask = vt({}), this.session.on("telnyx.socket.message", this.onSocketMessage);
+  }
+}
+class en extends Z {
+  constructor(e) {
+    super(), this.method = $.Ping, this.buildRequest({ method: this.method, voice_sdk_id: e, params: {} });
+  }
+}
+class qn {
+  constructor(e) {
+    if (this.options = e, this.uuid = ve(), this.sessionid = "", this.subscriptions = {}, this.signature = null, this.relayProtocol = null, this.contexts = [], this.timeoutErrorCode = -32e3, this.invalidMethodErrorCode = -32601, this.authenticationRequiredErrorCode = -32e3, this.connection = null, this._jwtAuth = !1, this._autoReconnect = !0, this._idle = !1, this._executeQueue = [], !this.validateOptions()) throw new Error("Invalid init options");
+    y.setLevel(e.debug ? "debug" : "info"), this._onSocketOpen = this._onSocketOpen.bind(this), this.onNetworkClose = this.onNetworkClose.bind(this), this._onSocketMessage = this._onSocketMessage.bind(this), this._handleLoginError = this._handleLoginError.bind(this), this._attachListeners(), this.connection = new yt(this), this.registerAgent = new Hn(this);
+  }
+  get __logger() {
+    return y;
+  }
+  get connected() {
+    return this.connection && this.connection.connected;
+  }
+  getIsRegistered() {
+    return O(this, void 0, void 0, (function* () {
+      return this.registerAgent.getIsRegistered();
+    }));
+  }
+  get reconnectDelay() {
+    return 1e3 * Kt(2, 6);
+  }
+  execute(e) {
+    return this._idle ? new Promise(((n) => this._executeQueue.push({ resolve: n, msg: e }))) : this.connected ? this.connection.send(e) : new Promise(((n) => {
+      this._executeQueue.push({ resolve: n, msg: e }), this.connect();
+    }));
+  }
+  executeRaw(e) {
+    this._idle ? this._executeQueue.push({ msg: e }) : this.connection.sendRawText(e);
+  }
+  validateOptions() {
+    return Ne(this.options) || Ie(this.options);
+  }
+  broadcast(e) {
+  }
+  disconnect() {
+    return O(this, void 0, void 0, (function* () {
+      clearTimeout(this._reconnectTimeout), this.subscriptions = {}, this._autoReconnect = !1, this.relayProtocol = null, this._closeConnection(), yield sessionStorage.removeItem(this.signature), this._executeQueue = [], this._detachListeners();
+    }));
+  }
+  on(e, n) {
+    return de(e, n, this.uuid), this;
+  }
+  off(e, n) {
+    return ue(e, n, this.uuid), this;
+  }
+  connect() {
+    return O(this, void 0, void 0, (function* () {
+      this.connection || (this.connection = new yt(this)), this._attachListeners(), this.connection.isAlive || this.connection.connect();
+    }));
+  }
+  _handleLoginError(e) {
+    F(L.Error, { error: e, sessionId: this.sessionid }, this.uuid);
+  }
+  _onSocketOpen() {
+    return O(this, void 0, void 0, (function* () {
+    }));
+  }
+  onNetworkClose() {
+    this.relayProtocol && Ke(this.relayProtocol);
+    for (const e in this.subscriptions) Ke(e);
+    this.subscriptions = {}, this.contexts = [], clearTimeout(this._keepAliveTimeout), this._autoReconnect && (this._reconnectTimeout = setTimeout((() => this.connect()), this.reconnectDelay));
+  }
+  _onSocketMessage(e) {
+  }
+  _removeSubscription(e, n) {
+    this._existsSubscription(e, n) && (n ? (delete this.subscriptions[e][n], ue(e, null, n)) : (delete this.subscriptions[e], Ke(e)));
+  }
+  _addSubscription(e, n = null, i) {
+    this._existsSubscription(e, i) || (this._existsSubscription(e) || (this.subscriptions[e] = {}), this.subscriptions[e][i] = {}, ye(n) && de(e, n, i));
+  }
+  _existsSubscription(e, n) {
+    return !(!this.subscriptions.hasOwnProperty(e) || !(!n || n && this.subscriptions[e].hasOwnProperty(n)));
+  }
+  _attachListeners() {
+    this._detachListeners(), this.on(L.SocketOpen, this._onSocketOpen), this.on(L.SocketClose, this.onNetworkClose), this.on(L.SocketError, this.onNetworkClose), this.on(L.SocketMessage, this._onSocketMessage);
+  }
+  _detachListeners() {
+    this.off(L.SocketOpen, this._onSocketOpen), this.off(L.SocketClose, this.onNetworkClose), this.off(L.SocketError, this.onNetworkClose), this.off(L.SocketMessage, this._onSocketMessage);
+  }
+  _emptyExecuteQueues() {
+    this._executeQueue.forEach((({ resolve: e, msg: n }) => {
+      typeof n == "string" ? this.executeRaw(n) : e(this.execute(n));
+    }));
+  }
+  _closeConnection() {
+    this._idle = !0, clearTimeout(this._keepAliveTimeout), this.connection && this.connection.close();
+  }
+  _resetKeepAlive() {
+    this._pong === !1 && (y.warn("No ping/pong received, forcing PING ACK to keep alive"), this.execute(new en(fe()))), clearTimeout(this._keepAliveTimeout), this._triggerKeepAliveTimeoutCheck();
+  }
+  _triggerKeepAliveTimeoutCheck() {
+    this._pong = !1, this._keepAliveTimeout = setTimeout((() => this._resetKeepAlive()), 35e3);
+  }
+  setPingReceived() {
+    y.debug("Ping received"), this._pong = !0;
+  }
+  static on(e, n) {
+    de(e, n);
+  }
+  static off(e) {
+    ue(e);
+  }
+  static uuid() {
+    return ve();
+  }
+  clearConnection() {
+    this.connection = null;
+  }
+  hasAutoReconnect() {
+    return this._autoReconnect;
+  }
+}
+const tt = (t) => navigator.mediaDevices.getUserMedia(t), ge = (t) => t && t instanceof MediaStream, Ee = (t, e) => {
+  const n = De(t);
+  n !== null && (n.getAttribute("autoplay") || n.setAttribute("autoplay", "autoplay"), n.getAttribute("playsinline") || n.setAttribute("playsinline", "playsinline"), n.srcObject = e);
+}, tn = (t, e) => O(void 0, void 0, void 0, (function* () {
+  const n = De(t);
+  if (n === null) return y.info("No HTMLMediaElement to attach the speakerId"), !1;
+  if (typeof e != "string") return y.info(`Invalid speaker deviceId: '${e}'`), !1;
+  try {
+    return yield n.setSinkId(e), !0;
+  } catch {
+    return !1;
+  }
+})), Jn = (t) => {
+  t && t.readyState === "live" && t.stop();
+}, Te = (t) => {
+  ge(t) && t.getTracks().forEach(Jn), t = null;
+}, Ue = (t) => O(void 0, void 0, void 0, (function* () {
+  y.info("RTCService.getUserMedia", t);
+  const { audio: e, video: n } = t;
+  if (!e && !n) return null;
+  try {
+    return yield tt(t);
+  } catch (i) {
+    throw y.error("getUserMedia error: ", i), i;
+  }
+})), ke = (t = null, e = !1) => O(void 0, void 0, void 0, (function* () {
+  let n = [];
+  const i = yield navigator.mediaDevices.getUserMedia(((s = null) => ({ audio: !s || s === ae.AudioIn || s === ae.AudioOut, video: !s || s === ae.Video }))(t)).catch(((s) => (y.error(s), null)));
+  if (i) {
+    if (Te(i), n = yield navigator.mediaDevices.enumerateDevices(), t && (n = n.filter(((a) => a.kind === t))), e === !0) return n;
+    const s = [];
+    n = n.filter(((a) => {
+      if (!a.groupId) return !0;
+      const o = `${a.kind}-${a.groupId}`;
+      return !s.includes(o) && (s.push(o), !0);
+    }));
+  }
+  return n;
+})), St = [[320, 240], [640, 360], [640, 480], [1280, 720], [1920, 1080]], je = (t, e, n) => O(void 0, void 0, void 0, (function* () {
+  const i = yield ke(n, !0);
+  for (let s = 0; s < i.length; s++) {
+    const { deviceId: a, label: o } = i[s];
+    if (t === a || e === o) return a;
+  }
+  return null;
+})), Yn = (t) => {
+  const e = navigator.mediaDevices.getSupportedConstraints();
+  Object.keys(t).map(((n) => {
+    e.hasOwnProperty(n) && t[n] !== null && t[n] !== void 0 || delete t[n];
+  }));
+}, nt = (t, e) => {
+  if (!t) return !1;
+  const { subscribed: n, alreadySubscribed: i } = it(t);
+  return n.includes(e) || i.includes(e);
+}, it = (t) => {
+  const e = { subscribed: [], alreadySubscribed: [], unauthorized: [], unsubscribed: [], notSubscribed: [] };
+  return Object.keys(e).forEach(((n) => {
+    e[n] = t[`${n}Channels`] || [];
+  })), e;
+}, me = (t, e = null, n = null) => {
+  if (!ge(t)) return null;
+  let i = [];
+  switch (e) {
+    case "audio":
+      i = t.getAudioTracks();
+      break;
+    case "video":
+      i = t.getVideoTracks();
+      break;
+    default:
+      i = t.getTracks();
+  }
+  i.forEach(((s) => {
+    switch (n) {
+      case "on":
+      case !0:
+        s.enabled = !0;
+        break;
+      case "off":
+      case !1:
+        s.enabled = !1;
+        break;
+      default:
+        s.enabled = !s.enabled;
+    }
+  }));
+}, _t = (t) => {
+  me(t, "audio", !0);
+}, st = (t) => {
+  me(t, "audio", !1);
+}, wt = (t) => {
+  me(t, "audio", null);
+}, zn = (t) => ((e, n = null) => {
+  if (!ge(e)) return null;
+  let i = [];
+  switch (n) {
+    case "audio":
+      i = e.getAudioTracks();
+      break;
+    case "video":
+      i = e.getVideoTracks();
+      break;
+    default:
+      i = e.getTracks();
+  }
+  return i.some(((s) => s.enabled));
+})(t, "audio");
+function Kn() {
+  try {
+    const { browserInfo: t, name: e, version: n, supportAudio: i, supportVideo: s } = (function() {
+      if (!window || !window.navigator || !window.navigator.userAgent) throw new Error("You should use @telnyx/webrtc in a web browser such as Chrome|Firefox|Safari");
+      if (navigator.userAgent.match(/chrom(e|ium)/gim) && !navigator.userAgent.match(/OPR\/[0-9]{2}/gi) && !navigator.userAgent.match(/edg/gim)) {
+        const f = navigator.userAgent.match(/chrom(e|ium)\/[0-9]+\./gim)[0].split("/"), m = f[0], S = parseInt(f[1], 10);
+        return { browserInfo: navigator.userAgent, name: m, version: S, supportAudio: !0, supportVideo: !0 };
+      }
+      if (navigator.userAgent.match(/firefox/gim) && !navigator.userAgent.match(/OPR\/[0-9]{2}/gi) && !navigator.userAgent.match(/edg/gim)) {
+        const f = navigator.userAgent.match(/firefox\/[0-9]+\./gim)[0].split("/"), m = f[0], S = parseInt(f[1], 10);
+        return { browserInfo: navigator.userAgent, name: m, version: S, supportAudio: !0, supportVideo: !1 };
+      }
+      if (navigator.userAgent.match(/safari/gim) && !navigator.userAgent.match(/OPR\/[0-9]{2}/gi) && !navigator.userAgent.match(/edg/gim)) {
+        const f = navigator.userAgent.match(/safari/gim)[0], m = navigator.userAgent.match(/version\/[0-9]+\./gim)[0].split("/"), S = parseInt(m[1], 10);
+        return { browserInfo: navigator.userAgent, name: f, version: S, supportAudio: !0, supportVideo: !0 };
+      }
+      if (navigator.userAgent.match(/edg/gim) && !navigator.userAgent.match(/OPR\/[0-9]{2}/gi)) {
+        const f = navigator.userAgent.match(/edg\/[0-9]+\./gim)[0].split("/"), m = f[0], S = parseInt(f[1], 10);
+        return { browserInfo: navigator.userAgent, name: m, version: S, supportAudio: !0, supportVideo: !0 };
+      }
+      throw new Error("This browser does not support @telnyx/webrtc. To see browser support list: `TelnyxRTC.webRTCSupportedBrowserList()`");
+    })(), a = window.RTCPeerConnection, o = window.RTCSessionDescription, l = window.RTCIceCandidate, d = window.navigator && window.navigator.mediaDevices, h = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.msGetUserMedia || navigator.mozGetUserMedia;
+    return { browserInfo: t, browserName: e, browserVersion: n, supportWebRTC: !!(a && o && l && d && h), supportWebRTCAudio: i, supportWebRTCVideo: s, supportRTCPeerConnection: !!a, supportSessionDescription: !!o, supportIceCandidate: !!l, supportMediaDevices: !!d, supportGetUserMedia: !!Ue };
+  } catch (t) {
+    return t.message;
+  }
+}
+var H;
+function Ct(t, e) {
+  const n = document.getElementById(e);
+  if (n) return n;
+  if (t && e) {
+    const i = document.createElement("audio");
+    return i.id = e, i.loop = !0, i.src = t, i.preload = "auto", i.load(), document.body.appendChild(i), i;
+  }
+  return null;
+}
+function kt(t) {
+  t && (t._playFulfilled = !1, t._promise = t.play(), t._promise.then((() => {
+    t._playFulfilled = !0;
+  })).catch(((e) => {
+    y.error("playAudio", e), t._playFulfilled = !0;
+  })));
+}
+function It(t) {
+  t && (t._playFulfilled ? (t.pause(), t.currentTime = 0) : t._promise && t._promise.then ? t._promise.then((() => {
+    t.pause(), t.currentTime = 0;
+  })) : setTimeout((() => {
+    t.pause(), t.currentTime = 0;
+  }), 1e3));
+}
+(function(t) {
+  t.not_supported = "not supported", t.full = "full", t.partial = "partial";
+})(H || (H = {}));
+var nn = "2.25.14", We = nn;
+class sn extends Z {
+  constructor(e, n, i, s, a = {}, o) {
+    super(), this.method = "login";
+    const l = { login: e, passwd: n, login_token: i, userVariables: a, reconnection: o, loginParams: {}, "User-Agent": { sdkVersion: We, data: navigator.userAgent } };
+    s && (l.sessid = s), this.buildRequest({ method: this.method, params: l });
+  }
+}
+class Qn extends Z {
+  constructor(e, n) {
+    super(), this.buildRequest({ id: e, result: { method: n } });
+  }
+}
+class Et extends Z {
+  toString() {
+    return $.Invite;
+  }
+}
+class Tt extends Z {
+  toString() {
+    return $.Answer;
+  }
+}
+class ot extends Z {
+  toString() {
+    return $.Attach;
+  }
+}
+class Xn extends Z {
+  toString() {
+    return $.Bye;
+  }
+}
+class on extends Z {
+  toString() {
+    return $.Candidate;
+  }
+}
+class Zn extends Z {
+  toString() {
+    return $.EndOfCandidates;
+  }
+}
+class Qe extends Z {
+  toString() {
+    return $.Modify;
+  }
+}
+class At extends Z {
+  toString() {
+    return $.Info;
+  }
+}
+class ei extends Z {
+  toString() {
+    return $.Broadcast;
+  }
+}
+class ti extends Z {
+  toString() {
+    return $.Subscribe;
+  }
+}
+class ni extends Z {
+  toString() {
+    return $.Unsubscribe;
+  }
+}
+class ii extends Re {
+  constructor(e, n) {
+    super(), this.method = "ai_conversation", this.buildRequest({ method: this.method, params: { type: "conversation.item.create", previous_item_id: null, item: { id: ve(), type: "message", role: "user", content: [{ type: "input_text", text: e }, ...n?.map(((i) => ({ type: "image_url", image_url: { url: i } })))] } } });
+  }
+}
+var Oe, rn = Jt((function(t, e) {
+  var n;
+  function i() {
+  }
+  function s() {
+    s.init.call(this);
+  }
+  function a(r) {
+    return r._maxListeners === void 0 ? s.defaultMaxListeners : r._maxListeners;
+  }
+  function o(r, c, u, g) {
+    var b, T, I;
+    if (typeof u != "function") throw new TypeError('"listener" argument must be a function');
+    if ((T = r._events) ? (T.newListener && (r.emit("newListener", c, u.listener ? u.listener : u), T = r._events), I = T[c]) : (T = r._events = new i(), r._eventsCount = 0), I) {
+      if (typeof I == "function" ? I = T[c] = g ? [u, I] : [I, u] : g ? I.unshift(u) : I.push(u), !I.warned && (b = a(r)) && 0 < b && I.length > b) {
+        I.warned = !0;
+        var R = new Error("Possible EventEmitter memory leak detected. " + I.length + " " + c + " listeners added. Use emitter.setMaxListeners() to increase limit");
+        R.name = "MaxListenersExceededWarning", R.emitter = r, R.type = c, R.count = I.length, (function(j) {
+          typeof console.warn == "function" ? console.warn(j) : console.log(j);
+        })(R);
+      }
+    } else I = T[c] = u, ++r._eventsCount;
+    return r;
+  }
+  function l(r, c, u) {
+    function g() {
+      r.removeListener(c, g), b || (b = !0, u.apply(r, arguments));
+    }
+    var b = !1;
+    return g.listener = u, g;
+  }
+  function d(r) {
+    var c = this._events;
+    if (c) {
+      var u = c[r];
+      if (typeof u == "function") return 1;
+      if (u) return u.length;
+    }
+    return 0;
+  }
+  function h(r, c) {
+    for (var u = Array(c); c--; ) u[c] = r[c];
+    return u;
+  }
+  Object.defineProperty(e, "__esModule", { value: !0 }), i.prototype = /* @__PURE__ */ Object.create(null), s.EventEmitter = s, s.usingDomains = !1, s.prototype.domain = void 0, s.prototype._events = void 0, s.prototype._maxListeners = void 0, s.defaultMaxListeners = 10, s.init = function() {
+    this.domain = null, s.usingDomains && n.active && !(this instanceof n.Domain) && (this.domain = n.active), this._events && this._events !== Object.getPrototypeOf(this)._events || (this._events = new i(), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+  }, s.prototype.setMaxListeners = function(r) {
+    if (typeof r != "number" || 0 > r || isNaN(r)) throw new TypeError('"n" argument must be a positive number');
+    return this._maxListeners = r, this;
+  }, s.prototype.getMaxListeners = function() {
+    return a(this);
+  }, s.prototype.emit = function(r) {
+    var c, u, g, b, T, I, R, j = r === "error";
+    if (I = this._events) j = j && I.error == null;
+    else if (!j) return !1;
+    if (R = this.domain, j) {
+      if (c = arguments[1], !R) {
+        if (c instanceof Error) throw c;
+        var ee = new Error('Uncaught, unspecified "error" event. (' + c + ")");
+        throw ee.context = c, ee;
+      }
+      return c || (c = new Error('Uncaught, unspecified "error" event')), c.domainEmitter = this, c.domain = R, c.domainThrown = !1, R.emit("error", c), !1;
+    }
+    if (!(u = I[r])) return !1;
+    var ne = typeof u == "function";
+    switch (g = arguments.length) {
+      case 1:
+        (function(G, v, M) {
+          if (v) G.call(M);
+          else for (var U = G.length, V = h(G, U), Y = 0; Y < U; ++Y) V[Y].call(M);
+        })(u, ne, this);
+        break;
+      case 2:
+        (function(G, v, M, U) {
+          if (v) G.call(M, U);
+          else for (var V = G.length, Y = h(G, V), Q = 0; Q < V; ++Q) Y[Q].call(M, U);
+        })(u, ne, this, arguments[1]);
+        break;
+      case 3:
+        (function(G, v, M, U, V) {
+          if (v) G.call(M, U, V);
+          else for (var Y = G.length, Q = h(G, Y), W = 0; W < Y; ++W) Q[W].call(M, U, V);
+        })(u, ne, this, arguments[1], arguments[2]);
+        break;
+      case 4:
+        (function(G, v, M, U, V, Y) {
+          if (v) G.call(M, U, V, Y);
+          else for (var Q = G.length, W = h(G, Q), re = 0; re < Q; ++re) W[re].call(M, U, V, Y);
+        })(u, ne, this, arguments[1], arguments[2], arguments[3]);
+        break;
+      default:
+        for (b = Array(g - 1), T = 1; T < g; T++) b[T - 1] = arguments[T];
+        (function(G, v, M, U) {
+          if (v) G.apply(M, U);
+          else for (var V = G.length, Y = h(G, V), Q = 0; Q < V; ++Q) Y[Q].apply(M, U);
+        })(u, ne, this, b);
+    }
+    return !0;
+  }, s.prototype.addListener = function(r, c) {
+    return o(this, r, c, !1);
+  }, s.prototype.on = s.prototype.addListener, s.prototype.prependListener = function(r, c) {
+    return o(this, r, c, !0);
+  }, s.prototype.once = function(r, c) {
+    if (typeof c != "function") throw new TypeError('"listener" argument must be a function');
+    return this.on(r, l(this, r, c)), this;
+  }, s.prototype.prependOnceListener = function(r, c) {
+    if (typeof c != "function") throw new TypeError('"listener" argument must be a function');
+    return this.prependListener(r, l(this, r, c)), this;
+  }, s.prototype.removeListener = function(r, c) {
+    var u, g, b, T, I;
+    if (typeof c != "function") throw new TypeError('"listener" argument must be a function');
+    if (!(g = this._events)) return this;
+    if (!(u = g[r])) return this;
+    if (u === c || u.listener && u.listener === c) --this._eventsCount == 0 ? this._events = new i() : (delete g[r], g.removeListener && this.emit("removeListener", r, u.listener || c));
+    else if (typeof u != "function") {
+      for (b = -1, T = u.length; 0 < T--; ) if (u[T] === c || u[T].listener && u[T].listener === c) {
+        I = u[T].listener, b = T;
+        break;
+      }
+      if (0 > b) return this;
+      if (u.length === 1) {
+        if (u[0] = void 0, --this._eventsCount == 0) return this._events = new i(), this;
+        delete g[r];
+      } else (function(R, j) {
+        for (var ee = j, ne = ee + 1, G = R.length; ne < G; ee += 1, ne += 1) R[ee] = R[ne];
+        R.pop();
+      })(u, b);
+      g.removeListener && this.emit("removeListener", r, I || c);
+    }
+    return this;
+  }, s.prototype.removeAllListeners = function(r) {
+    var c, u;
+    if (!(u = this._events)) return this;
+    if (!u.removeListener) return arguments.length === 0 ? (this._events = new i(), this._eventsCount = 0) : u[r] && (--this._eventsCount == 0 ? this._events = new i() : delete u[r]), this;
+    if (arguments.length === 0) {
+      for (var g, b = Object.keys(u), T = 0; T < b.length; ++T) (g = b[T]) !== "removeListener" && this.removeAllListeners(g);
+      return this.removeAllListeners("removeListener"), this._events = new i(), this._eventsCount = 0, this;
+    }
+    if (typeof (c = u[r]) == "function") this.removeListener(r, c);
+    else if (c) do
+      this.removeListener(r, c[c.length - 1]);
+    while (c[0]);
+    return this;
+  }, s.prototype.listeners = function(r) {
+    var c, u, g = this._events;
+    return g ? u = (c = g[r]) ? typeof c == "function" ? [c.listener || c] : (function(b) {
+      for (var T = Array(b.length), I = 0; I < T.length; ++I) T[I] = b[I].listener || b[I];
+      return T;
+    })(c) : [] : u = [], u;
+  }, s.listenerCount = function(r, c) {
+    return typeof r.listenerCount == "function" ? r.listenerCount(c) : d.call(r, c);
+  }, s.prototype.listenerCount = d, s.prototype.eventNames = function() {
+    return 0 < this._eventsCount ? Reflect.ownKeys(this._events) : [];
+  };
+  var f, m = new Uint8Array(16);
+  function S() {
+    if (!f && !(f = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto < "u" && typeof msCrypto.getRandomValues == "function" && msCrypto.getRandomValues.bind(msCrypto))) throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    return f(m);
+  }
+  for (var w = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i, C = [], k = 0; 256 > k; ++k) C.push((k + 256).toString(16).substr(1));
+  function p(r) {
+    var c = 1 < arguments.length && arguments[1] !== void 0 ? arguments[1] : 0, u = (C[r[c + 0]] + C[r[c + 1]] + C[r[c + 2]] + C[r[c + 3]] + "-" + C[r[c + 4]] + C[r[c + 5]] + "-" + C[r[c + 6]] + C[r[c + 7]] + "-" + C[r[c + 8]] + C[r[c + 9]] + "-" + C[r[c + 10]] + C[r[c + 11]] + C[r[c + 12]] + C[r[c + 13]] + C[r[c + 14]] + C[r[c + 15]]).toLowerCase();
+    if (!(function(g) {
+      return typeof g == "string" && w.test(g);
+    })(u)) throw TypeError("Stringified UUID is invalid");
+    return u;
+  }
+  function _(r, c, u) {
+    var g = (r = r || {}).random || (r.rng || S)();
+    return g[6] = 64 | 15 & g[6], g[8] = 128 | 63 & g[8], p(g);
+  }
+  function A(r, c) {
+    if (!r || !c) return {};
+    const u = { ...r };
+    if (u.localCandidateId) {
+      const g = c.get(u.localCandidateId);
+      u.local = { ...g };
+    }
+    if (u.remoteCandidateId) {
+      const g = c.get(u.remoteCandidateId);
+      u.remote = { ...g };
+    }
+    return u;
+  }
+  function E(r, c, u) {
+    return 8 * (function(g, b, T) {
+      const I = g[T], R = b ? b[T] : null;
+      return I === null || R === null ? null : (I - R) / (g.timestamp - b.timestamp) * 1e3;
+    })(r, c, u);
+  }
+  function P(r) {
+    if (!r.entries) return r;
+    const c = {};
+    return r.forEach((function(u, g) {
+      c[g] = u;
+    })), c;
+  }
+  function D(r, c, u = {}) {
+    if (!r) return null;
+    let g = { audio: { inbound: [], outbound: [] }, video: { inbound: [], outbound: [] }, connection: { inbound: [], outbound: [] } };
+    u.remote && (g.remote = { audio: { inbound: [], outbound: [] }, video: { inbound: [], outbound: [] } });
+    for (const b of r.values()) switch (b.type) {
+      case "outbound-rtp": {
+        const T = b.mediaType || b.kind, I = {};
+        let R = {};
+        if (!["audio", "video"].includes(T)) continue;
+        if (b.codecId) {
+          const j = r.get(b.codecId);
+          j && (I.clockRate = j.clockRate, I.mimeType = j.mimeType, I.payloadType = j.payloadType);
+        }
+        R = r.get(b.mediaSourceId) || r.get(b.trackId) || {}, g[T].outbound.push({ ...b, ...I, track: { ...R } });
+        break;
+      }
+      case "inbound-rtp": {
+        let T = b.mediaType || b.kind, I = {};
+        const R = {};
+        if (!["audio", "video"].includes(T)) if (b.id.includes("Video")) T = "video";
+        else {
+          if (!b.id.includes("Audio")) continue;
+          T = "audio";
+        }
+        if (b.codecId) {
+          const j = r.get(b.codecId);
+          j && (R.clockRate = j.clockRate, R.mimeType = j.mimeType, R.payloadType = j.payloadType);
+        }
+        if (!g.connection.id && b.transportId) {
+          const j = r.get(b.transportId);
+          if (j && j.selectedCandidatePairId) {
+            const ee = r.get(j.selectedCandidatePairId);
+            g.connection = A(ee, r);
+          }
+        }
+        I = r.get(b.mediaSourceId) || r.get(b.trackId) || {}, g[T].inbound.push({ ...b, ...R, track: { ...I } });
+        break;
+      }
+      case "peer-connection":
+        g.connection.dataChannelsClosed = b.dataChannelsClosed, g.connection.dataChannelsOpened = b.dataChannelsOpened;
+        break;
+      case "remote-inbound-rtp": {
+        if (!u.remote) break;
+        let T = b.mediaType || b.kind;
+        const I = {};
+        if (!["audio", "video"].includes(T)) if (b.id.includes("Video")) T = "video";
+        else {
+          if (!b.id.includes("Audio")) continue;
+          T = "audio";
+        }
+        if (b.codecId) {
+          const R = r.get(b.codecId);
+          R && (I.clockRate = R.clockRate, I.mimeType = R.mimeType, I.payloadType = R.payloadType);
+        }
+        if (!g.connection.id && b.transportId) {
+          const R = r.get(b.transportId);
+          if (R && R.selectedCandidatePairId) {
+            const j = r.get(R.selectedCandidatePairId);
+            g.connection = A(j, r);
+          }
+        }
+        g.remote[T].inbound.push({ ...b, ...I });
+        break;
+      }
+      case "remote-outbound-rtp": {
+        if (!u.remote) break;
+        const T = b.mediaType || b.kind, I = {};
+        if (!["audio", "video"].includes(T)) continue;
+        if (b.codecId) {
+          const R = r.get(b.codecId);
+          R && (I.clockRate = R.clockRate, I.mimeType = R.mimeType, I.payloadType = R.payloadType);
+        }
+        g.remote[T].outbound.push({ ...b, ...I });
+        break;
+      }
+    }
+    if (!g.connection.id) for (const b of r.values()) b.type === "candidate-pair" && b.nominated && b.state === "succeeded" && (g.connection = A(b, r));
+    return g = (function(b, T) {
+      return T && (b.audio.inbound.map(((I) => {
+        let R = T.audio.inbound.find(((j) => j.id === I.id));
+        I.bitrate = E(I, R, "bytesReceived"), I.packetRate = E(I, R, "packetsReceived");
+      })), b.audio.outbound.map(((I) => {
+        let R = T.audio.outbound.find(((j) => j.id === I.id));
+        I.bitrate = E(I, R, "bytesSent"), I.packetRate = E(I, R, "packetsSent");
+      })), b.video.inbound.map(((I) => {
+        let R = T.video.inbound.find(((j) => j.id === I.id));
+        I.bitrate = E(I, R, "bytesReceived"), I.packetRate = E(I, R, "packetsReceived");
+      })), b.video.outbound.map(((I) => {
+        let R = T.video.outbound.find(((j) => j.id === I.id));
+        I.bitrate = E(I, R, "bytesSent"), I.packetRate = E(I, R, "packetsSent");
+      }))), b;
+    })(g, c), g;
+  }
+  let q, B = {}, x = [];
+  e.WebRTCStats = class extends s {
+    constructor(r) {
+      if (super(), this.monitoringSetInterval = 0, this.connectionMonitoringSetInterval = 0, this.connectionMonitoringInterval = 1e3, this.remote = !0, this.peersToMonitor = {}, this.timeline = [], this.statsToMonitor = ["inbound-rtp", "outbound-rtp", "remote-inbound-rtp", "remote-outbound-rtp", "peer-connection", "data-channel", "stream", "track", "sender", "receiver", "transport", "candidate-pair", "local-candidate", "remote-candidate"], typeof window > "u") throw new Error("WebRTCStats only works in browser");
+      const c = { ...r };
+      this.isEdge = !!window.RTCIceGatherer, this.getStatsInterval = c.getStatsInterval || 1e3, this.rawStats = !!c.rawStats, this.statsObject = !!c.statsObject, this.filteredStats = !!c.filteredStats, this.shouldWrapGetUserMedia = !!c.wrapGetUserMedia, typeof c.remote == "boolean" && (this.remote = c.remote), this.debug = !!c.debug, this.logLevel = c.logLevel || "none", this.shouldWrapGetUserMedia && this.wrapGetUserMedia();
+    }
+    async addPeer(r, c) {
+      return console.warn("The addPeer() method has been deprecated, please use addConnection()"), this.addConnection({ peerId: r, pc: c });
+    }
+    async addConnection(r) {
+      const { pc: c, peerId: u } = r;
+      let { connectionId: g, remote: b } = r;
+      if (b = typeof b == "boolean" ? b : this.remote, !(c && c instanceof RTCPeerConnection)) throw new Error("Missing argument 'pc' or is not of instance RTCPeerConnection");
+      if (!u) throw new Error("Missing argument peerId");
+      if (this.isEdge) throw new Error("Can't monitor peers in Edge at this time.");
+      if (this.peersToMonitor[u]) {
+        if (g && g in this.peersToMonitor[u]) throw new Error(`We are already monitoring connection with id ${g}.`);
+        for (let I in this.peersToMonitor[u]) {
+          const R = this.peersToMonitor[u][I];
+          if (R.pc === c) throw new Error(`We are already monitoring peer with id ${u}.`);
+          R.pc.connectionState === "closed" && this.removeConnection({ pc: R.pc });
+        }
+      }
+      const T = c.getConfiguration();
+      return T.iceServers && T.iceServers.forEach((function(I) {
+        delete I.credential;
+      })), g || (g = _()), this.emitEvent({ event: "addConnection", tag: "peer", peerId: u, connectionId: g, data: { options: r, peerConfiguration: T } }), this.monitorPeer({ peerId: u, connectionId: g, pc: c, remote: b }), { connectionId: g };
+    }
+    getTimeline(r) {
+      return this.timeline = this.timeline.sort(((c, u) => c.timestamp.getTime() - u.timestamp.getTime())), r ? this.timeline.filter(((c) => c.tag === r)) : this.timeline;
+    }
+    get logger() {
+      const r = (c) => {
+        const u = ["none", "error", "warn", "info", "debug"];
+        return u.slice(0, u.indexOf(this.logLevel) + 1).indexOf(c) > -1;
+      };
+      return { error(...c) {
+        this.debug && r("error") && console.error("[webrtc-stats][error] ", ...c);
+      }, warn(...c) {
+        this.debug && r("warn") && console.warn("[webrtc-stats][warn] ", ...c);
+      }, info(...c) {
+        this.debug && r("info") && console.log("[webrtc-stats][info] ", ...c);
+      }, debug(...c) {
+        this.debug && r("debug") && console.debug("[webrtc-stats][debug] ", ...c);
+      } };
+    }
+    removeConnection(r) {
+      let c, { connectionId: u, pc: g } = r;
+      if (!g && !u) throw new Error("Missing arguments. You need to either send pc or a connectionId.");
+      if (u) {
+        if (typeof u != "string") throw new Error("connectionId must be a string.");
+        for (let b in this.peersToMonitor) u in this.peersToMonitor[b] && (g = this.peersToMonitor[b][u].pc, c = b);
+      } else if (g) {
+        if (!(g instanceof RTCPeerConnection)) throw new Error("pc must be an instance of RTCPeerConnection.");
+        for (let b in this.peersToMonitor) for (let T in this.peersToMonitor[b]) this.peersToMonitor[b][T].pc === g && (u = T, c = b);
+      }
+      if (!g || !u) throw new Error("Could not find the desired connection.");
+      return this.removePeerConnectionEventListeners(u, g), delete this.peersToMonitor[c][u], Object.values(this.peersToMonitor[c]).length === 0 && delete this.peersToMonitor[c], { connectionId: u };
+    }
+    removeAllPeers() {
+      for (let r in this.peersToMonitor) this.removePeer(r);
+    }
+    removePeer(r) {
+      if (this.logger.info(`Removing PeerConnection with id ${r}.`), this.peersToMonitor[r]) {
+        for (let c in this.peersToMonitor[r]) {
+          let u = this.peersToMonitor[r][c].pc;
+          this.removePeerConnectionEventListeners(c, u);
+        }
+        delete this.peersToMonitor[r];
+      }
+    }
+    destroy() {
+      this.removeAllPeers(), x.forEach(((r) => {
+        this.removeTrackEventListeners(r);
+      })), x = [], this.shouldWrapGetUserMedia && q && (navigator.mediaDevices.getUserMedia = q);
+    }
+    monitorPeer(r) {
+      let { peerId: c, connectionId: u, pc: g, remote: b } = r;
+      if (!g) return void this.logger.warn("Did not receive pc argument when calling monitorPeer()");
+      const T = { pc: g, connectionId: u, stream: null, stats: { parsed: null, raw: null }, options: { remote: b } };
+      if (this.peersToMonitor[c]) {
+        if (u in this.peersToMonitor[c]) return void this.logger.warn(`Already watching connection with ID ${u}`);
+        this.peersToMonitor[c][u] = T;
+      } else this.peersToMonitor[c] = { [u]: T };
+      this.addPeerConnectionEventListeners(c, u, g), this.numberOfMonitoredPeers === 1 && (this.startStatsMonitoring(), this.startConnectionStateMonitoring());
+    }
+    startStatsMonitoring() {
+      this.monitoringSetInterval || (this.monitoringSetInterval = window.setInterval((() => {
+        this.numberOfMonitoredPeers || this.stopStatsMonitoring(), this.getStats().then(((r) => {
+          r.forEach(((c) => {
+            this.emitEvent(c);
+          }));
+        }));
+      }), this._getStatsInterval));
+    }
+    stopStatsMonitoring() {
+      this.monitoringSetInterval && (window.clearInterval(this.monitoringSetInterval), this.monitoringSetInterval = 0);
+    }
+    async getStats(r = null) {
+      this.logger.info(r ? `Getting stats from peer ${r}` : "Getting stats from all peers");
+      let c = {};
+      if (r) {
+        if (!this.peersToMonitor[r]) throw new Error(`Cannot get stats. Peer with id ${r} does not exist`);
+        c[r] = this.peersToMonitor[r];
+      } else c = this.peersToMonitor;
+      let u = [];
+      for (const g in c) for (const b in c[g]) {
+        const T = c[g][b], I = T.pc;
+        if (I && !this.checkIfConnectionIsClosed(g, b, I)) try {
+          const R = this.getTimestamp(), j = I.getStats(null);
+          if (j) {
+            const ee = await j, ne = this.getTimestamp(), G = P(ee), v = { remote: T.options.remote }, M = D(ee, T.stats.parsed, v), U = { event: "stats", tag: "stats", peerId: g, connectionId: b, timeTaken: ne - R, data: M };
+            this.rawStats === !0 && (U.rawStats = ee), this.statsObject === !0 && (U.statsObject = G), this.filteredStats === !0 && (U.filteredStats = this.filteroutStats(G)), u.push(U), T.stats.parsed = M;
+          } else this.logger.error(`PeerConnection from peer ${g} did not return any stats data`);
+        } catch (R) {
+          this.logger.error(R);
+        }
+      }
+      return u;
+    }
+    startConnectionStateMonitoring() {
+      this.connectionMonitoringSetInterval = window.setInterval((() => {
+        this.numberOfMonitoredPeers || this.stopConnectionStateMonitoring();
+        for (const r in this.peersToMonitor) for (const c in this.peersToMonitor[r]) {
+          const u = this.peersToMonitor[r][c].pc;
+          this.checkIfConnectionIsClosed(r, c, u);
+        }
+      }), this.connectionMonitoringInterval);
+    }
+    checkIfConnectionIsClosed(r, c, u) {
+      const g = this.isConnectionClosed(u);
+      if (g) {
+        this.removeConnection({ pc: u });
+        let b = u.connectionState === "closed" ? "onconnectionstatechange" : "oniceconnectionstatechange";
+        this.emitEvent({ event: b, peerId: r, connectionId: c, tag: "connection", data: "closed" });
+      }
+      return g;
+    }
+    isConnectionClosed(r) {
+      return r.connectionState === "closed" || r.iceConnectionState === "closed";
+    }
+    stopConnectionStateMonitoring() {
+      this.connectionMonitoringSetInterval && (window.clearInterval(this.connectionMonitoringSetInterval), this.connectionMonitoringSetInterval = 0);
+    }
+    wrapGetUserMedia() {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) return void this.logger.warn("'navigator.mediaDevices.getUserMedia' is not available in browser. Will not wrap getUserMedia.");
+      this.logger.info("Wrapping getUsermedia functions."), q = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+      const r = this.parseGetUserMedia.bind(this);
+      navigator.mediaDevices.getUserMedia = (function() {
+        return r({ constraints: arguments[0] }), q.apply(navigator.mediaDevices, arguments).then(((c) => (r({ stream: c }), c)), ((c) => (r({ error: c }), Promise.reject(c))));
+      }).bind(navigator.mediaDevices);
+    }
+    filteroutStats(r = {}) {
+      const c = { ...r };
+      for (const g in c) {
+        var u = c[g];
+        this.statsToMonitor.includes(u.type) || delete c[g];
+      }
+      return c;
+    }
+    get peerConnectionListeners() {
+      return { icecandidate: (r, c, u, g) => {
+        this.logger.debug("[pc-event] icecandidate | peerId: ${peerId}", g), this.emitEvent({ event: "onicecandidate", tag: "connection", peerId: r, connectionId: c, data: g.candidate });
+      }, track: (r, c, u, g) => {
+        this.logger.debug(`[pc-event] track | peerId: ${r}`, g);
+        const b = g.track, T = g.streams[0];
+        r in this.peersToMonitor && c in this.peersToMonitor[r] && (this.peersToMonitor[r][c].stream = T), this.addTrackEventListeners(b, c), this.emitEvent({ event: "ontrack", tag: "track", peerId: r, connectionId: c, data: { stream: T ? this.getStreamDetails(T) : null, track: b ? this.getMediaTrackDetails(b) : null, title: g.track.kind + ":" + g.track.id + " " + g.streams.map((function(I) {
+          return "stream:" + I.id;
+        })) } });
+      }, signalingstatechange: (r, c, u) => {
+        this.logger.debug(`[pc-event] signalingstatechange | peerId: ${r}`), this.emitEvent({ event: "onsignalingstatechange", tag: "connection", peerId: r, connectionId: c, data: { signalingState: u.signalingState, localDescription: u.localDescription, remoteDescription: u.remoteDescription } });
+      }, iceconnectionstatechange: (r, c, u) => {
+        this.logger.debug(`[pc-event] iceconnectionstatechange | peerId: ${r}`), this.emitEvent({ event: "oniceconnectionstatechange", tag: "connection", peerId: r, connectionId: c, data: u.iceConnectionState });
+      }, icegatheringstatechange: (r, c, u) => {
+        this.logger.debug(`[pc-event] icegatheringstatechange | peerId: ${r}`), this.emitEvent({ event: "onicegatheringstatechange", tag: "connection", peerId: r, connectionId: c, data: u.iceGatheringState });
+      }, icecandidateerror: (r, c, u, g) => {
+        this.logger.debug(`[pc-event] icecandidateerror | peerId: ${r}`), this.emitEvent({ event: "onicecandidateerror", tag: "connection", peerId: r, connectionId: c, error: { errorCode: g.errorCode } });
+      }, connectionstatechange: (r, c, u) => {
+        this.logger.debug(`[pc-event] connectionstatechange | peerId: ${r}`), this.emitEvent({ event: "onconnectionstatechange", tag: "connection", peerId: r, connectionId: c, data: u.connectionState });
+      }, negotiationneeded: (r, c, u) => {
+        this.logger.debug(`[pc-event] negotiationneeded | peerId: ${r}`), this.emitEvent({ event: "onnegotiationneeded", tag: "connection", peerId: r, connectionId: c });
+      }, datachannel: (r, c, u, g) => {
+        this.logger.debug(`[pc-event] datachannel | peerId: ${r}`, g), this.emitEvent({ event: "ondatachannel", tag: "datachannel", peerId: r, connectionId: c, data: g.channel });
+      } };
+    }
+    addPeerConnectionEventListeners(r, c, u) {
+      this.logger.debug(`Adding event listeners for peer ${r} and connection ${c}.`), B[c] = {}, Object.keys(this.peerConnectionListeners).forEach(((g) => {
+        B[c][g] = this.peerConnectionListeners[g].bind(this, r, c, u), u.addEventListener(g, B[c][g], !1);
+      }));
+    }
+    parseGetUserMedia(r) {
+      try {
+        const c = { event: "getUserMedia", tag: "getUserMedia", data: { ...r } };
+        r.stream && (c.data.details = this.parseStream(r.stream), r.stream.getTracks().map(((u) => {
+          this.addTrackEventListeners(u), x.push(u);
+        }))), this.emitEvent(c);
+      } catch {
+      }
+    }
+    parseStream(r) {
+      const c = { audio: [], video: [] };
+      return r.getTracks().forEach(((u) => {
+        c[u.kind].push(this.getMediaTrackDetails(u));
+      })), c;
+    }
+    getMediaTrackDetails(r) {
+      return { enabled: r.enabled, id: r.id, contentHint: r.contentHint, kind: r.kind, label: r.label, muted: r.muted, readyState: r.readyState, constructorName: r.constructor.name, capabilities: r.getCapabilities ? r.getCapabilities() : {}, constraints: r.getConstraints ? r.getConstraints() : {}, settings: r.getSettings ? r.getSettings() : {}, _track: r };
+    }
+    getStreamDetails(r) {
+      return { active: r.active, id: r.id, _stream: r };
+    }
+    getTrackEventObject(r) {
+      return { mute: (c) => {
+        this.emitEvent({ event: "mute", tag: "track", connectionId: r, data: { event: c } });
+      }, unmute: (c) => {
+        this.emitEvent({ event: "unmute", tag: "track", connectionId: r, data: { event: c } });
+      }, overconstrained: (c) => {
+        this.emitEvent({ event: "overconstrained", tag: "track", connectionId: r, data: { event: c } });
+      }, ended: (c) => {
+        this.emitEvent({ event: "ended", tag: "track", connectionId: r, data: { event: c } }), this.removeTrackEventListeners(c.target);
+      } };
+    }
+    addTrackEventListeners(r, c) {
+      B[r.id] = {};
+      const u = this.getTrackEventObject(c);
+      Object.keys(u).forEach(((g) => {
+        B[r.id][g] = u[g].bind(this), r.addEventListener(g, B[r.id][g]);
+      })), B[r.id].readyState = setInterval((() => {
+        if (r.readyState === "ended") {
+          let g = new CustomEvent("ended", { detail: { check: "readyState" } });
+          r.dispatchEvent(g);
+        }
+      }), 1e3);
+    }
+    removeTrackEventListeners(r) {
+      if (r.id in B) {
+        const c = this.getTrackEventObject();
+        Object.keys(c).forEach(((u) => {
+          r.removeEventListener(u, B[r.id][u]);
+        })), clearInterval(B[r.id].readyState), delete B[r.id];
+      }
+    }
+    addToTimeline(r) {
+      this.timeline.push(r), this.emit("timeline", r);
+    }
+    emitEvent(r) {
+      const c = { ...r, timestamp: /* @__PURE__ */ new Date() };
+      this.addToTimeline(c), c.tag && this.emit(c.tag, c);
+    }
+    set getStatsInterval(r) {
+      if (!Number.isInteger(r)) throw new Error(`getStatsInterval should be an integer, got: ${r}`);
+      this._getStatsInterval = r, this.monitoringSetInterval && (this.stopStatsMonitoring(), this.startStatsMonitoring());
+    }
+    get numberOfMonitoredPeers() {
+      return Object.keys(this.peersToMonitor).length;
+    }
+    removePeerConnectionEventListeners(r, c) {
+      r in B && (Object.keys(this.peerConnectionListeners).forEach(((u) => {
+        c.removeEventListener(u, B[r][u], !1);
+      })), delete B[r]), c.getSenders().forEach(((u) => {
+        u.track && this.removeTrackEventListeners(u.track);
+      })), c.getReceivers().forEach(((u) => {
+        u.track && this.removeTrackEventListeners(u.track);
+      }));
+    }
+    getTimestamp() {
+      return Date.now();
+    }
+    wrapGetDisplayMedia() {
+      const r = this;
+      if (navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
+        const c = navigator.mediaDevices.getDisplayMedia.bind(navigator.mediaDevices), u = function() {
+          return r.debug("navigator.mediaDevices.getDisplayMedia", null, arguments[0]), c.apply(navigator.mediaDevices, arguments).then((function(g) {
+            return g;
+          }), (function(g) {
+            return r.debug("navigator.mediaDevices.getDisplayMediaOnFailure", null, g.name), Promise.reject(g);
+          }));
+        };
+        navigator.mediaDevices.getDisplayMedia = u.bind(navigator.mediaDevices);
+      }
+    }
+  };
+}));
+(Oe = rn) && Oe.__esModule && Object.prototype.hasOwnProperty.call(Oe, "default") && Oe.default;
+var si = rn.WebRTCStats;
+function oi(t) {
+  const { packetsLost: e, packetsReceived: n, jitter: i, rtt: s } = t, a = (function(h) {
+    const { jitter: f, rtt: m } = h, S = f + m / 2;
+    return 0.024 * S + 0.11 * (S - 177.3) * (S > 177.3 ? 1 : 0);
+  })({ rtt: s, jitter: i }), o = (function(h) {
+    const { packetsLost: f, packetsReceived: m } = h, S = f / (m + f) * 100;
+    return 20 * Math.log(1 + S);
+  })({ packetsLost: e, packetsReceived: n }), l = 93.2 - a - o + 0, d = 1 + 0.035 * l + 7e-6 * l * (l - 60) * (100 - l);
+  return Math.min(Math.max(d, 1), 5);
+}
+function ri(t) {
+  return isNaN(t) ? null : t > 4.2 ? "excellent" : t >= 4.1 && t <= 4.2 ? "good" : t >= 3.7 && t <= 4 ? "fair" : t >= 3.1 && t <= 3.6 ? "poor" : "bad";
+}
+class ai extends Re {
+  constructor(e, n) {
+    super(), this.buildRequest({ type: "debug_report_start", debug_report_id: e, debug_report_version: 1, call_id: n });
+  }
+}
+class ci extends Re {
+  constructor(e, n) {
+    super(), this.buildRequest({ type: "debug_report_stop", debug_report_id: e, debug_report_version: 1, call_id: n });
+  }
+}
+class li extends Re {
+  constructor(e, n) {
+    super(), this.buildRequest({ type: "debug_report_data", debug_report_id: e, debug_report_version: 1, debug_report_data: n });
+  }
+}
+function Rt(t, e) {
+  var n, i;
+  return { errorCode: t.errorCode, errorText: t.errorText, url: t.url, address: t.address, port: t.port, connectionState: e.connectionState, iceConnectionState: e.iceConnectionState, iceGatheringState: e.iceGatheringState, signalingState: e.signalingState, localDescriptionType: (n = e.localDescription) === null || n === void 0 ? void 0 : n.type, remoteDescriptionType: (i = e.remoteDescription) === null || i === void 0 ? void 0 : i.type };
+}
+function di(t, e) {
+  const n = ve(), i = new si({ getStatsInterval: 1e3, rawStats: !1, statsObject: !0, filteredStats: !1, remote: !0, debug: !1, logLevel: "warn" }), s = (a) => O(this, void 0, void 0, (function* () {
+    a.event === "stats" && F(L.StatsFrame, (function({ data: o }) {
+      var l, d, h, f, m, S, w, C;
+      const { audio: k, remote: p } = o, { audio: _ } = p, A = (d = (l = _.inbound[0]) === null || l === void 0 ? void 0 : l.jitter) !== null && d !== void 0 ? d : 1 / 0, E = (f = (h = _.inbound[0]) === null || h === void 0 ? void 0 : h.roundTripTime) !== null && f !== void 0 ? f : 1 / 0, P = (S = (m = k.inbound[0]) === null || m === void 0 ? void 0 : m.packetsReceived) !== null && S !== void 0 ? S : -1, D = (C = (w = k.inbound[0]) === null || w === void 0 ? void 0 : w.packetsLost) !== null && C !== void 0 ? C : -1, q = oi({ jitter: 1e3 * A, rtt: 1e3 * E, packetsLost: D, packetsReceived: P });
+      return { jitter: A, rtt: E, mos: q, quality: ri(q), inboundAudio: k.inbound[0], outboundAudio: k.outbound[0], remoteInboundAudio: _.inbound[0], remoteOutboundAudio: _.outbound[0] };
+    })(a), t.uuid), yield t.execute(new li(n, a));
+  }));
+  return { start: (a, o, l) => O(this, void 0, void 0, (function* () {
+    yield t.execute(new ai(n, e)), i.on("timeline", s), yield new Promise(((d) => setTimeout(d, 500))), i.addConnection({ pc: a, peerId: o, connectionId: l });
+  })), stop: (a) => O(this, void 0, void 0, (function* () {
+    const o = i.getTimeline();
+    F(L.StatsReport, o, t.uuid), a === "file" && (function(l, d) {
+      const h = new Blob([JSON.stringify(l)], { type: "application/json" }), f = URL.createObjectURL(h), m = document.createElement("a");
+      m.href = f, m.download = `${d}.json`, m.click(), URL.revokeObjectURL(f);
+    })(o, `webrtc-stats-${n}-${Date.now()}`), yield t.execute(new ci(n, e)), i.removeAllPeers(), i.destroy();
+  })), reportConnectionStateChange: (a) => {
+    const o = { event: "connectionstatechange-detailed", tag: "connection", timestamp: (/* @__PURE__ */ new Date()).toISOString(), data: a };
+    s(o);
+  }, reportIceCandidateError: (a) => {
+    const o = { event: "icecandidateerror-detailed", tag: "connection", timestamp: (/* @__PURE__ */ new Date()).toISOString(), data: a };
+    s(o);
+  } };
+}
+const an = (t, e) => {
+  const { contentType: n, canvasType: i, callID: s, canvasInfo: a = null, currentLayerIdx: o = -1 } = e;
+  a && i !== "mcu-personal-canvas" && delete a.memberID;
+  const l = { type: oe.conferenceUpdate, call: t.calls[s], canvasInfo: ui(a), currentLayerIdx: o };
+  switch (n) {
+    case "layer-info": {
+      const d = Object.assign({ action: se.LayerInfo }, l);
+      F(L.Notification, d, t.uuid);
+      break;
+    }
+    case "layout-info": {
+      const d = Object.assign({ action: se.LayoutInfo }, l);
+      F(L.Notification, d, t.uuid);
+      break;
+    }
+  }
+}, ui = (t) => {
+  const e = JSON.stringify(t).replace(/memberID/g, "participantId").replace(/ID"/g, 'Id"').replace(/POS"/g, 'Pos"');
+  return Yt(e);
+};
+class xt {
+  constructor(e, n, i, s, a) {
+    this.type = e, this.options = n, this.onSdpReadyTwice = null, this.statsReporter = null, this._negotiating = !1, this._prevConnectionState = null, this._restartedIceOnConnectionStateFailed = !1, this._sleepWakeupIntervalId = null, this.handleConnectionStateChange = (o) => O(this, void 0, void 0, (function* () {
+      const { connectionState: l } = this.instance;
+      if (y.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Connection State changed: ${this._prevConnectionState} -> ${l}`), l === "failed" || l === "disconnected") {
+        const d = () => O(this, void 0, void 0, (function* () {
+          if (this.isDebugEnabled && this.statsReporter) {
+            const h = yield (function(f, m) {
+              return O(this, void 0, void 0, (function* () {
+                const S = { connectionState: f.connectionState, previousConnectionState: m, iceConnectionState: f.iceConnectionState, iceGatheringState: f.iceGatheringState, signalingState: f.signalingState }, w = f.getTransceivers();
+                if (w.length > 0) {
+                  const C = w[0].sender, k = C?.transport;
+                  k && (S.dtlsState = k.state);
+                }
+                f.sctp && (S.sctpState = f.sctp.state);
+                try {
+                  const C = yield f.getStats();
+                  C.forEach(((k) => {
+                    k.type === "candidate-pair" && k.state === "succeeded" && (S.candidatePairState = k.state, C.forEach(((p) => {
+                      p.type === "local-candidate" && p.id === k.localCandidateId && (S.localCandidateType = p.candidateType, S.selectedCandidatePair = S.selectedCandidatePair || { local: {}, remote: {} }, S.selectedCandidatePair.local = { address: p.address, port: p.port, protocol: p.protocol, candidateType: p.candidateType }), p.type === "remote-candidate" && p.id === k.remoteCandidateId && (S.remoteCandidateType = p.candidateType, S.selectedCandidatePair = S.selectedCandidatePair || { local: {}, remote: {} }, S.selectedCandidatePair.remote = { address: p.address, port: p.port, protocol: p.protocol, candidateType: p.candidateType });
+                    }))), k.type === "transport" && (S.dtlsCipher = k.dtlsCipher, S.srtpCipher = k.srtpCipher, S.tlsVersion = k.tlsVersion, k.dtlsState && (S.dtlsState = k.dtlsState));
+                  }));
+                } catch (C) {
+                  y.error("Error gathering connection state details:", C);
+                }
+                return S;
+              }));
+            })(this.instance, this._prevConnectionState);
+            this.statsReporter.reportConnectionStateChange(h);
+          }
+          this._restartedIceOnConnectionStateFailed ? (y.debug("Peer Connection failed again after ICE restart. Recovering call via peer reconnection through error handling."), F(L.PeerConnectionFailureError, { error: new Error(`Peer Connection failed twice. previous state: ${this._prevConnectionState}, current state: ${l}`), sessionId: this._session.sessionid }, this.options.id)) : (this.instance.restartIce(), l === "failed" && (this._restartedIceOnConnectionStateFailed = !0, y.debug("ICE has been restarted on connection state failed.")), this._isTrickleIce() ? yield this.startTrickleIceNegotiation() : this.startNegotiation()), window.removeEventListener("online", d);
+        }));
+        navigator.onLine ? d() : window.addEventListener("online", d);
+      }
+      this._prevConnectionState === "connected" && l === "disconnected" && (yield this._resetJitterBuffer()), this._prevConnectionState === "disconnected" && l === "connected" && (yield this._resetJitterBuffer()), this._prevConnectionState = l, this._isTrickleIce() && (l === "connecting" && performance.mark("peer-connection-connecting"), l === "connected" && (performance.mark("peer-connection-connected"), console.group("Performance Metrics"), console.table(this.trickleIcePerformanceMetrics), console.groupEnd(), performance.clearMarks())), this._restartNegotiationOnDeviceSleepWakeup();
+    })), this._handleIceConnectionStateChange = (o) => {
+      y.debug(`[${(/* @__PURE__ */ new Date()).toISOString()}] ICE Connection State`, this.instance.iceConnectionState);
+    }, this._handleIceGatheringStateChange = (o) => {
+      y.debug(`[${(/* @__PURE__ */ new Date()).toISOString()}] ICE Gathering State`, this.instance.iceGatheringState);
+    }, this._setCodecs = (o, l) => {
+      if (o.setCodecPreferences) return o.setCodecPreferences(l);
+    }, y.info("New Peer with type:", this.type, "Options:", this.options), this._constraints = { offerToReceiveAudio: !0, offerToReceiveVideo: !!n.video }, this._sdpReady = this._sdpReady.bind(this), this.handleSignalingStateChangeEvent = this.handleSignalingStateChangeEvent.bind(this), this.handleNegotiationNeededEvent = this.handleNegotiationNeededEvent.bind(this), this.handleTrackEvent = this.handleTrackEvent.bind(this), this.createPeerConnection = this.createPeerConnection.bind(this), this._session = i, this._trickleIceSdpFn = s, this._registerPeerEvents = a;
+  }
+  get isOffer() {
+    return this.type === K.Offer;
+  }
+  get isAnswer() {
+    return this.type === K.Answer;
+  }
+  get isDebugEnabled() {
+    return this.options.debug || this._session.options.debug;
+  }
+  get debugOutput() {
+    return this.options.debugOutput || this._session.options.debugOutput;
+  }
+  get keepConnectionAliveOnSocketClose() {
+    return this.options.keepConnectionAliveOnSocketClose || this._session.options.keepConnectionAliveOnSocketClose;
+  }
+  startNegotiation() {
+    performance.mark("ice-gathering-start"), this._negotiating = !0, this._isOffer() ? this._createOffer() : this._createAnswer();
+  }
+  startTrickleIceNegotiation() {
+    return O(this, void 0, void 0, (function* () {
+      performance.mark("ice-gathering-start"), this._negotiating = !0, this._isOffer() ? yield this._createOffer().then(this._trickleIceSdpFn.bind(this)) : yield this._createAnswer().then(this._trickleIceSdpFn.bind(this));
+    }));
+  }
+  _logTransceivers() {
+    y.info("Number of transceivers:", this.instance.getTransceivers().length), this.instance.getTransceivers().forEach(((e, n) => {
+      y.info(`>> Transceiver [${n}]:`, e.mid, e.direction, e.stopped), y.info(`>> Sender Params [${n}]:`, JSON.stringify(e.sender.getParameters(), null, 2));
+    }));
+  }
+  get trickleIcePerformanceMetrics() {
+    const e = performance.measure("new-call", "new-call-start", "new-call-end"), n = performance.measure("peer-creation", "peer-creation-start", "peer-creation-end"), i = performance.measure("ice-gathering", "ice-gathering-start", "ice-gathering-end"), s = performance.measure("sdp-send", "sdp-send-start", "sdp-send-end"), a = performance.measure("invite-send", "new-call-start", "sdp-send-start"), o = performance.measure("total-duration", "peer-creation-start", "sdp-send-end"), l = (d) => `${d.toFixed(2)}ms`;
+    return { "New Call": { duration: l(e.duration) }, "Peer Creation": { duration: l(n.duration) }, "ICE Gathering": { duration: l(i.duration) }, [this._isOffer() ? "Invite Send" : "Answer Send"]: { duration: l(a.duration) }, "SDP Send": { duration: l(s.duration) }, "Total Duration": { duration: l(o.duration) } };
+  }
+  handleSignalingStateChangeEvent(e) {
+    switch (y.info("signalingState:", this.instance.signalingState), this.instance.signalingState) {
+      case "stable":
+        this._negotiating = !1;
+        break;
+      case "closed":
+        if (this.keepConnectionAliveOnSocketClose) return void y.debug("Keeping peer connection alive due to keepConnectionAliveOnSocketClose option");
+        this.instance = null;
+        break;
+      default:
+        this._negotiating = !0;
+    }
+  }
+  handleNegotiationNeededEvent() {
+    y.info("Negotiation needed event"), this.instance.signalingState !== "stable" || this._negotiating ? y.debug("Skipping negotiation, state:", this.instance.signalingState, "negotiating:", this._negotiating) : this._isTrickleIce() ? this.startTrickleIceNegotiation() : this.startNegotiation();
+  }
+  handleTrackEvent(e) {
+    const { streams: [n] } = e, { remoteElement: i, screenShare: s } = this.options;
+    let { remoteStream: a } = this.options;
+    a = n, s === !1 && Ee(i, a);
+  }
+  createPeerConnection() {
+    return O(this, void 0, void 0, (function* () {
+      var e;
+      this.instance = (e = this._config(), new window.RTCPeerConnection(e)), this.instance.onsignalingstatechange = this.handleSignalingStateChangeEvent, this.instance.onnegotiationneeded = this.handleNegotiationNeededEvent, this.instance.ontrack = this.handleTrackEvent, this.instance.addEventListener("connectionstatechange", this.handleConnectionStateChange), this.instance.addEventListener("iceconnectionstatechange", this._handleIceConnectionStateChange), this.instance.addEventListener("icegatheringstatechange", this._handleIceGatheringStateChange), this.instance.addEventListener("addstream", ((n) => {
+        this.options.remoteStream = n.stream;
+      })), this._registerPeerEvents(this.instance), this._prevConnectionState = this.instance.connectionState, this.isAnswer && (yield this._setRemoteDescription({ sdp: this.options.remoteSdp, type: K.Offer })), this.options.localStream = yield this._retrieveLocalStream().catch(((n) => (F(L.MediaError, n, this.options.id), null))), this.options.mutedMicOnStart && ge(this.options.localStream) && (y.info("Muting local audio tracks on start"), st(this.options.localStream)), performance.mark("peer-creation-end");
+    }));
+  }
+  init() {
+    var e;
+    return O(this, void 0, void 0, (function* () {
+      yield this.createPeerConnection(), this.isDebugEnabled && (this.statsReporter = di(this._session, this.options.id), yield (e = this.statsReporter) === null || e === void 0 ? void 0 : e.start(this.instance, this._session.sessionid, this._session.sessionid));
+      const { localElement: n, localStream: i = null, screenShare: s = !1 } = this.options;
+      if (ge(i)) {
+        const a = i.getAudioTracks();
+        let o = [...a];
+        if (y.info("Local audio tracks: ", a), typeof this.options.audio == "object" && a.forEach(((h) => {
+          y.info("Local audio tracks constraints: ", h.getConstraints());
+        })), this.options.video) {
+          const h = i.getVideoTracks();
+          o = [...a, ...h], y.info("Local video tracks: ", h), typeof this.options.video == "object" && h.forEach(((f) => {
+            y.info("Local video tracks constraints: ", f.getConstraints());
+          }));
+        }
+        const { audioCodecs: l, videoCodecs: d } = ((h) => {
+          const f = [], m = [];
+          return h && h.length !== 0 ? (h.forEach(((S) => {
+            const w = S.mimeType.toLocaleLowerCase();
+            w.startsWith("audio/") ? f.push(S) : w.startsWith("video/") && m.push(S);
+          })), { audioCodecs: f, videoCodecs: m }) : { audioCodecs: f, videoCodecs: m };
+        })(this.options.preferred_codecs);
+        if (this.isOffer && typeof this.instance.addTransceiver == "function") {
+          const h = { direction: "sendrecv", streams: [i] };
+          o.forEach(((f) => {
+            f.kind === "audio" && (this.options.userVariables.microphoneLabel = f.label), f.kind === "video" && (this.options.userVariables.cameraLabel = f.label);
+            const m = this.instance.addTransceiver(f, h);
+            f.kind === "audio" && l.length > 0 && this._setCodecs(m, l), f.kind === "video" && d.length > 0 && this._setCodecs(m, d);
+          }));
+        } else typeof this.instance.addTrack == "function" ? (o.forEach(((h) => {
+          h.kind === "audio" && (this.options.userVariables.microphoneLabel = h.label), h.kind === "video" && (this.options.userVariables.cameraLabel = h.label), this.instance.addTrack(h, i);
+        })), this.instance.getTransceivers().forEach(((h) => {
+          h.receiver.track.kind === "audio" && l.length > 0 && this._setCodecs(h, l), h.receiver.track.kind === "video" && d.length > 0 && this._setCodecs(h, d);
+        }))) : this.instance.addStream(i);
+        s === !1 && Ee(n, i);
+      }
+      this.isOffer ? (this.options.negotiateAudio && this._checkMediaToNegotiate("audio"), this.options.negotiateVideo && this._checkMediaToNegotiate("video")) : this._isTrickleIce() || this.startNegotiation(), this._isTrickleIce() && this.startTrickleIceNegotiation(), this._logTransceivers();
+    }));
+  }
+  _getSenderByKind(e) {
+    return this.instance.getSenders().find((({ track: n }) => n && n.kind === e));
+  }
+  _checkMediaToNegotiate(e) {
+    if (!this._getSenderByKind(e)) {
+      const n = this.instance.addTransceiver(e);
+      y.info("Add transceiver", e, n);
+    }
+  }
+  _createOffer() {
+    return O(this, void 0, void 0, (function* () {
+      if (this._isOffer()) {
+        this._constraints.offerToReceiveAudio = this.options.audio !== !1, this._constraints.offerToReceiveVideo = !!this.options.video, y.info("_createOffer - this._constraints", this._constraints);
+        try {
+          const e = yield this.instance.createOffer(this._constraints);
+          return yield this._setLocalDescription(e), this._isTrickleIce() || this._sdpReady(), e;
+        } catch (e) {
+          y.error("Peer _createOffer error:", e);
+        }
+      }
+    }));
+  }
+  _setRemoteDescription(e) {
+    return O(this, void 0, void 0, (function* () {
+      y.debug("Setting remote description", e), yield this.instance.setRemoteDescription(e);
+    }));
+  }
+  _createAnswer() {
+    return O(this, void 0, void 0, (function* () {
+      if (this._isAnswer()) {
+        if (this.instance.signalingState !== "stable" && this.instance.signalingState !== "have-remote-offer") return y.debug("Skipping negotiation, state:", this.instance.signalingState), y.debug("  - But the signaling state isn't stable, so triggering rollback"), void (yield Promise.all([this.instance.setLocalDescription({ type: "rollback" }), this.instance.setRemoteDescription({ sdp: this.options.remoteSdp, type: K.Offer })]));
+        this._logTransceivers();
+        try {
+          const e = yield this.instance.createAnswer();
+          return yield this._setLocalDescription(e), e;
+        } catch (e) {
+          y.error("Peer _createAnswer error:", e);
+        }
+      }
+    }));
+  }
+  _setLocalDescription(e) {
+    return O(this, void 0, void 0, (function* () {
+      yield this.instance.setLocalDescription(e);
+    }));
+  }
+  _sdpReady() {
+    ye(this.onSdpReadyTwice) && this.onSdpReadyTwice(this.instance.localDescription);
+  }
+  _retrieveLocalStream() {
+    return O(this, void 0, void 0, (function* () {
+      if (ge(this.options.localStream)) return this.options.localStream;
+      const e = yield (n = this.options, O(void 0, void 0, void 0, (function* () {
+        let { audio: i = !0, micId: s, video: a = !1, camId: o } = n;
+        const { micLabel: l = "", camLabel: d = "" } = n;
+        return s && (s = yield je(s, l, ae.AudioIn).catch(((h) => null)), s && (typeof i == "boolean" && (i = {}), i.deviceId = { exact: s })), o && (o = yield je(o, d, ae.Video).catch(((h) => null)), o && (typeof a == "boolean" && (a = {}), a.deviceId = { exact: o })), { audio: i, video: a };
+      })));
+      var n;
+      return Ue(e);
+    }));
+  }
+  _resetJitterBuffer() {
+    return O(this, void 0, void 0, (function* () {
+      try {
+        const n = this.instance.getReceivers().find(((s) => s.track && s.track.kind === "audio")), i = this.instance.getReceivers().find(((s) => s.track && s.track.kind === "video"));
+        n && "jitterBufferTarget" in n && (n.jitterBufferTarget = 20, y.debug("audio [jitter] target set to", n.jitterBufferTarget, "ms")), i && "jitterBufferTarget" in i && (i.jitterBufferTarget = 20, y.debug("video [jitter] target set to", i.jitterBufferTarget, "ms"));
+      } catch (e) {
+        y.error("Peer _resetJitterBuffer error:", e);
+      }
+    }));
+  }
+  _restartNegotiationOnDeviceSleepWakeup() {
+    return O(this, void 0, void 0, (function* () {
+      this._sleepWakeupIntervalId !== null && (clearInterval(this._sleepWakeupIntervalId), this._sleepWakeupIntervalId = null);
+      let e = Date.now();
+      this._sleepWakeupIntervalId = setInterval((() => O(this, void 0, void 0, (function* () {
+        var n;
+        const i = Date.now();
+        if (i - e > 5e3) {
+          if (y.warn(`Device sleep/wake detected. Time jump: ${i - e}ms, connectionState: ${(n = this.instance) === null || n === void 0 ? void 0 : n.connectionState}`), !this.instance) return void y.debug("Peer connection closed, skipping ICE restart");
+          y.info("Restarting ICE and renegotiating due to device wakeup"), this.instance.restartIce(), this._isTrickleIce() ? yield this.startTrickleIceNegotiation() : this.startNegotiation();
+        }
+        e = i;
+      }))), 1e3);
+    }));
+  }
+  _isOffer() {
+    return this.type === K.Offer;
+  }
+  _isAnswer() {
+    return this.type === K.Answer;
+  }
+  _isTrickleIce() {
+    return this.options.trickleIce === !0;
+  }
+  _config() {
+    const { prefetchIceCandidates: e, forceRelayCandidate: n, iceServers: i } = this.options, s = { bundlePolicy: "balanced", iceCandidatePoolSize: e ? 10 : 0, iceServers: i, iceTransportPolicy: n ? "relay" : "all" };
+    return y.info("RTC config", s), s;
+  }
+  close() {
+    var e;
+    return O(this, void 0, void 0, (function* () {
+      this._sleepWakeupIntervalId !== null && (clearInterval(this._sleepWakeupIntervalId), this._sleepWakeupIntervalId = null), yield (e = this.statsReporter) === null || e === void 0 ? void 0 : e.stop(this.debugOutput), this.instance && (this.instance.close(), this.instance = null);
+    }));
+  }
+}
+const Lt = We;
+class cn {
+  constructor(e, n) {
+    this.session = e, this.id = "", this.state = N[N.New], this.prevState = "", this.channels = [], this.role = et.Participant, this.extension = null, this._state = N.New, this._prevState = N.New, this.gotAnswer = !1, this.gotEarly = !1, this._lastSerno = 0, this._targetNodeId = null, this._iceTimeout = null, this._iceDone = !1, this._statsBindings = [], this._statsIntervalId = null, this._pendingIceCandidates = [], this._isRemoteDescriptionSet = !1, this._checkConferenceSerno = (p) => {
+      const _ = p < 0 || !this._lastSerno || this._lastSerno && p === this._lastSerno + 1;
+      return _ && p >= 0 && (this._lastSerno = p), _;
+    }, this._doStats = () => {
+      this.peer && this.peer.instance && this._statsBindings.length !== 0 && this.peer.instance.getStats().then(((p) => {
+        p.forEach(((_) => {
+          this._statsBindings.forEach(((A) => {
+            if (A.callback) {
+              if (A.constraints) {
+                for (var E in A.constraints) if (A.constraints.hasOwnProperty(E) && A.constraints[E] !== _[E]) return;
+              }
+              A.callback(_);
+            }
+          }));
+        }));
+      }));
+    };
+    const { iceServers: i, speaker: s, micId: a, micLabel: o, camId: l, camLabel: d, localElement: h, remoteElement: f, options: m, mediaConstraints: { audio: S, video: w }, ringtoneFile: C, ringbackFile: k } = e;
+    this.options = Object.assign({}, Fn, { audio: S, video: w, iceServers: n?.iceServers && Array.isArray(n.iceServers) ? n.iceServers : i, localElement: h, remoteElement: f, micId: a, micLabel: o, camId: l, camLabel: d, speakerId: s, ringtoneFile: C, ringbackFile: k, debug: m.debug, debugOutput: m.debugOutput, trickleIce: m.trickleIce, prefetchIceCandidates: m.prefetchIceCandidates, keepConnectionAliveOnSocketClose: m.keepConnectionAliveOnSocketClose, mutedMicOnStart: m.mutedMicOnStart }, n), this._onMediaError = this._onMediaError.bind(this), this._onPeerConnectionFailureError = this._onPeerConnectionFailureError.bind(this), this._onTrickleIceSdp = this._onTrickleIceSdp.bind(this), this._registerPeerEvents = this._registerPeerEvents.bind(this), this._registerTrickleIcePeerEvents = this._registerTrickleIcePeerEvents.bind(this), this._init(), this.options && (this._ringtone = Ct(this.options.ringtoneFile, "_ringtone"), this._ringback = Ct(this.options.ringbackFile, "_ringback"));
+  }
+  get performanceMetrics() {
+    const e = performance.measure("peer-creation", "peer-creation-start", "peer-creation-end"), n = performance.measure("ice-gathering", "ice-gathering-start", "ice-gathering-end"), i = performance.measure("sdp-send", "sdp-send-start", "sdp-send-end"), s = performance.measure("total-duration", "peer-creation-start", "sdp-send-end"), a = (o) => `${o.toFixed(2)}ms`;
+    return { "Peer Creation": { duration: a(e.duration) }, "ICE Gathering": { duration: a(n.duration) }, "SDP Send": { duration: a(i.duration) }, "Total Duration": { duration: a(s.duration) } };
+  }
+  get nodeId() {
+    return this._targetNodeId;
+  }
+  set nodeId(e) {
+    this._targetNodeId = e;
+  }
+  get isVideoCall() {
+    return !!this.options.video;
+  }
+  get telnyxIDs() {
+    return { telnyxCallControlId: this.options.telnyxCallControlId, telnyxSessionId: this.options.telnyxSessionId, telnyxLegId: this.options.telnyxLegId };
+  }
+  get localStream() {
+    return this.options.localStream;
+  }
+  get remoteStream() {
+    return this.options.remoteStream;
+  }
+  get memberChannel() {
+    return `conference-member.${this.id}`;
+  }
+  get isAudioMuted() {
+    return !zn(this.options.localStream);
+  }
+  invite() {
+    return O(this, void 0, void 0, (function* () {
+      this.direction = le.Outbound, this.options.trickleIce && this._resetTrickleIceCandidateState(), performance.mark("peer-creation-start"), this.peer = new xt(K.Offer, this.options, this.session, this._onTrickleIceSdp, this.options.trickleIce ? this._registerTrickleIcePeerEvents : this._registerPeerEvents), yield this.peer.init();
+    }));
+  }
+  answer(e = {}) {
+    var n;
+    return O(this, void 0, void 0, (function* () {
+      performance.mark("new-call-start"), this.stopRingtone(), this.direction = le.Inbound, ((n = e?.customHeaders) === null || n === void 0 ? void 0 : n.length) > 0 && (this.options = Object.assign(Object.assign({}, this.options), { customHeaders: e.customHeaders })), this.options.trickleIce && this._resetTrickleIceCandidateState(), performance.mark("peer-creation-start"), this.peer = new xt(K.Answer, this.options, this.session, this._onTrickleIceSdp, this.options.trickleIce ? this._registerTrickleIcePeerEvents : this._registerPeerEvents), yield this.peer.init(), performance.mark("new-call-end");
+    }));
+  }
+  playRingtone() {
+    kt(this._ringtone);
+  }
+  stopRingtone() {
+    It(this._ringtone);
+  }
+  playRingback() {
+    kt(this._ringback);
+  }
+  stopRingback() {
+    It(this._ringback);
+  }
+  hangup(e, n) {
+    var i, s, a;
+    let o = e || {}, l = n !== !1;
+    this.cause = o.cause || "NORMAL_CLEARING", this.causeCode = o.causeCode || 16, this.sipCode = o.sipCode || null, this.sipReason = o.sipReason || null, this.sipCallId = o.sip_call_id || null, this.options.customHeaders = [...(i = this.options.customHeaders) !== null && i !== void 0 ? i : [], ...(a = (s = o?.dialogParams) === null || s === void 0 ? void 0 : s.customHeaders) !== null && a !== void 0 ? a : []], this.setState(N.Hangup);
+    const d = () => {
+      var h;
+      return (h = this.peer) === null || h === void 0 || h.close(), this.setState(N.Destroy);
+    };
+    if (this.stopRingtone(), this.stopRingback(), l) {
+      const h = new Xn({ sipCode: this.sipCode, sip_call_id: this.sipCallId, sessid: this.session.sessionid, dialogParams: this.options, cause: "USER_BUSY", causeCode: 17 });
+      this._execute(h).catch(((f) => {
+        y.error("telnyx_rtc.bye failed!", f), F(L.Error, { error: f, sessionId: this.session.sessionid }, this.session.uuid);
+      })).then(d.bind(this));
+    } else d();
+  }
+  hold() {
+    const e = new Qe({ sessid: this.session.sessionid, action: "hold", dialogParams: this.options });
+    return this._execute(e).then(this._handleChangeHoldStateSuccess.bind(this)).catch(this._handleChangeHoldStateError.bind(this));
+  }
+  unhold() {
+    const e = new Qe({ sessid: this.session.sessionid, action: "unhold", dialogParams: this.options });
+    return this._execute(e).then(this._handleChangeHoldStateSuccess.bind(this)).catch(this._handleChangeHoldStateError.bind(this));
+  }
+  toggleHold() {
+    const e = new Qe({ sessid: this.session.sessionid, action: "toggleHold", dialogParams: this.options });
+    return this._execute(e).then(this._handleChangeHoldStateSuccess.bind(this)).catch(this._handleChangeHoldStateError.bind(this));
+  }
+  dtmf(e) {
+    const n = new At({ sessid: this.session.sessionid, dtmf: e, dialogParams: this.options });
+    this._execute(n);
+  }
+  message(e, n) {
+    const i = { from: this.session.options.login, to: e, body: n }, s = new At({ sessid: this.session.sessionid, msg: i, dialogParams: this.options });
+    this._execute(s);
+  }
+  muteAudio() {
+    st(this.options.localStream);
+  }
+  unmuteAudio() {
+    _t(this.options.localStream);
+  }
+  toggleAudioMute() {
+    wt(this.options.localStream);
+  }
+  setAudioInDevice(e, n = this.options.mutedMicOnStart) {
+    return O(this, void 0, void 0, (function* () {
+      const { instance: i } = this.peer, s = i.getSenders().find((({ track: { kind: a } }) => a === "audio"));
+      if (s) {
+        const a = yield tt({ audio: { deviceId: { exact: e } } }), o = a.getAudioTracks()[0];
+        o.enabled = !n, s.replaceTrack(o), this.options.micId = e;
+        const { localStream: l } = this.options;
+        l.getAudioTracks().forEach(((d) => d.stop())), l.getVideoTracks().forEach(((d) => a.addTrack(d))), this.options.localStream = a;
+      }
+    }));
+  }
+  muteVideo() {
+    var e;
+    e = this.options.localStream, me(e, "video", !1);
+  }
+  unmuteVideo() {
+    var e;
+    e = this.options.localStream, me(e, "video", !0);
+  }
+  toggleVideoMute() {
+    var e;
+    e = this.options.localStream, me(e, "video", null);
+  }
+  setVideoDevice(e) {
+    return O(this, void 0, void 0, (function* () {
+      const { instance: n } = this.peer, i = n.getSenders().find((({ track: { kind: s } }) => s === "video"));
+      if (i) {
+        const s = yield tt({ video: { deviceId: { exact: e } } }), a = s.getVideoTracks()[0];
+        i.replaceTrack(a);
+        const { localElement: o, localStream: l } = this.options;
+        Ee(o, s), this.options.camId = e, l.getAudioTracks().forEach(((d) => s.addTrack(d))), l.getVideoTracks().forEach(((d) => d.stop())), this.options.localStream = s;
+      }
+    }));
+  }
+  deaf() {
+    st(this.options.remoteStream);
+  }
+  undeaf() {
+    _t(this.options.remoteStream);
+  }
+  toggleDeaf() {
+    wt(this.options.remoteStream);
+  }
+  setBandwidthEncodingsMaxBps(e, n) {
+    return O(this, void 0, void 0, (function* () {
+      if (!this || !this.peer) return void y.error("Could not set bandwidth (reason: no peer connection). Dynamic bandwidth can only be set when there is a call running - is there any call running?)");
+      const { instance: i } = this.peer, s = i.getSenders();
+      if (!s) return void y.error("Could not set bandwidth (reason: no senders). Dynamic bandwidth can only be set when there is a call running - is there any call running?)");
+      const a = s.find((({ track: { kind: o } }) => o === n));
+      if (a) {
+        const o = a.getParameters();
+        o.encodings || (o.encodings = [{ rid: "h" }]), y.info("Parameters: ", o), y.info("Setting max ", n === "audio" ? "audio" : "video", " bandwidth to: ", e, " [bps]"), o.encodings[0].maxBitrate = e, yield a.setParameters(o).then((() => {
+          y.info(n === "audio" ? "New audio" : "New video", " bandwidth settings in use: ", a.getParameters());
+        })).catch(((l) => y.error(l)));
+      } else y.error("Could not set bandwidth (reason: no " + n + " sender). Dynamic bandwidth can only be set when there is a call running - is there any call running?)");
+    }));
+  }
+  setAudioBandwidthEncodingsMaxBps(e) {
+    this.setBandwidthEncodingsMaxBps(e, "audio");
+  }
+  setVideoBandwidthEncodingsMaxBps(e) {
+    this.setBandwidthEncodingsMaxBps(e, "video");
+  }
+  getStats(e, n) {
+    if (!e) return;
+    const i = { callback: e, constraints: n };
+    this._statsBindings.push(i), !this._statsIntervalId && this._startStats(2e3);
+  }
+  setState(e) {
+    switch (this._prevState = this._state, this._state = e, this.state = N[this._state].toLowerCase(), this.prevState = N[this._prevState].toLowerCase(), y.debug(`Call ${this.id} state change from ${this.prevState} to ${this.state}`), this._dispatchNotification({ type: oe.callUpdate, call: this }), e) {
+      case N.Purge:
+        y.debug(`Call ${this.id} hangup call due to purge state`), this.hangup({ cause: "PURGE", causeCode: "01" }, !1);
+        break;
+      case N.Active:
+        setTimeout((() => {
+          const { remoteElement: n, speakerId: i } = this.options;
+          n && i && tn(n, i);
+        }), 0);
+        break;
+      case N.Destroy:
+        this._finalize();
+    }
+  }
+  handleMessage(e) {
+    const { method: n, params: i } = e;
+    switch (n) {
+      case $.Answer:
+        if (this.gotAnswer = !0, this._state >= N.Active) return;
+        this._state >= N.Early && this.setState(N.Active), this.gotEarly || this._onRemoteSdp(i.sdp), this.stopRingback(), this.stopRingtone();
+        break;
+      case $.Media:
+        if (this._state >= N.Early) return;
+        this.gotEarly = !0, this._onRemoteSdp(i.sdp);
+        break;
+      case $.Display:
+      case $.Attach: {
+        const { display_name: a, display_number: o, display_direction: l } = i;
+        this.extension = o;
+        const d = l === le.Inbound ? le.Outbound : le.Inbound, h = { type: oe[n], call: this, displayName: a, displayNumber: o, displayDirection: d };
+        F(L.Notification, h, this.id) || F(L.Notification, h, this.session.uuid);
+        break;
+      }
+      case $.Candidate:
+        this._addIceCandidate(i);
+        break;
+      case $.Info:
+      case $.Event: {
+        const a = Object.assign(Object.assign({}, i), { type: oe.generic, call: this });
+        F(L.Notification, a, this.id) || F(L.Notification, a, this.session.uuid);
+        break;
+      }
+      case $.Ringing:
+        this.playRingback(), i.telnyx_call_control_id && (this.options.telnyxCallControlId = i.telnyx_call_control_id), i.telnyx_session_id && (this.options.telnyxSessionId = i.telnyx_session_id), i.telnyx_leg_id && (this.options.telnyxLegId = i.telnyx_leg_id);
+        break;
+      case $.Bye:
+        const s = i.client_state || i.clientState;
+        s && (this.options.clientState = s), this.stopRingback(), this.stopRingtone(), this.hangup(i, !1);
+    }
+  }
+  handleConferenceUpdate(e, n) {
+    return O(this, void 0, void 0, (function* () {
+      if (!this._checkConferenceSerno(e.wireSerno) && e.name !== n.laName) return y.error("ConferenceUpdate invalid wireSerno or packet name:", e), "INVALID_PACKET";
+      const { action: i, data: s, hashKey: a = String(this._lastSerno), arrIndex: o } = e;
+      switch (i) {
+        case "bootObj": {
+          this._lastSerno = 0;
+          const { chatChannel: l, infoChannel: d, modChannel: h, laName: f, conferenceMemberID: m, role: S } = n;
+          this._dispatchConferenceUpdate({ action: se.Join, conferenceName: f, participantId: Number(m), role: S }), l && (yield this._subscribeConferenceChat(l)), d && (yield this._subscribeConferenceInfo(d));
+          const w = [];
+          for (const C in s) w.push(Object.assign({ callId: s[C][0], index: Number(C) }, Le(s[C][1])));
+          this._dispatchConferenceUpdate({ action: se.Bootstrap, participants: w });
+          break;
+        }
+        case "add":
+          this._dispatchConferenceUpdate(Object.assign({ action: se.Add, callId: a, index: o }, Le(s)));
+          break;
+        case "modify":
+          this._dispatchConferenceUpdate(Object.assign({ action: se.Modify, callId: a, index: o }, Le(s)));
+          break;
+        case "del":
+          this._dispatchConferenceUpdate(Object.assign({ action: se.Delete, callId: a, index: o }, Le(s)));
+          break;
+        case "clear":
+          this._dispatchConferenceUpdate({ action: se.Clear });
+          break;
+        default:
+          this._dispatchConferenceUpdate({ action: i, data: s, callId: a, index: o });
+      }
+    }));
+  }
+  _addChannel(e) {
+    this.channels.includes(e) || this.channels.push(e);
+    const n = this.session.relayProtocol;
+    this.session._existsSubscription(n, e) && (this.session.subscriptions[n][e] = Object.assign(Object.assign({}, this.session.subscriptions[n][e]), { callId: this.id }));
+  }
+  _subscribeConferenceChat(e) {
+    return O(this, void 0, void 0, (function* () {
+      const n = { nodeId: this.nodeId, channels: [e], handler: (s) => {
+        const { direction: a, from: o, fromDisplay: l, message: d, type: h } = s.data;
+        this._dispatchConferenceUpdate({ action: se.ChatMessage, direction: a, participantNumber: o, participantName: l, messageText: d, messageType: h, messageId: s.eventSerno });
+      } }, i = yield this.session.vertoSubscribe(n).catch(((s) => {
+        y.error("ConfChat subscription error:", s);
+      }));
+      nt(i, e) && (this._addChannel(e), Object.defineProperties(this, { sendChatMessage: { configurable: !0, value: (s, a) => {
+        this.session.vertoBroadcast({ nodeId: this.nodeId, channel: e, data: { action: "send", message: s, type: a } });
+      } } }));
+    }));
+  }
+  _subscribeConferenceInfo(e) {
+    return O(this, void 0, void 0, (function* () {
+      const n = { nodeId: this.nodeId, channels: [e], handler: (s) => {
+        const { eventData: a } = s;
+        a.contentType === "layout-info" ? (a.callID = this.id, an(this.session, a)) : y.error("Conference-Info unknown contentType", s);
+      } }, i = yield this.session.vertoSubscribe(n).catch(((s) => {
+        y.error("ConfInfo subscription error:", s);
+      }));
+      nt(i, e) && this._addChannel(e);
+    }));
+  }
+  _confControl(e, n = {}) {
+    const i = Object.assign({ application: "conf-control", callID: this.id, value: null }, n);
+    this.session.vertoBroadcast({ nodeId: this.nodeId, channel: e, data: i });
+  }
+  _handleChangeHoldStateSuccess(e) {
+    return e.holdState === "active" ? this.setState(N.Active) : this.setState(N.Held), !0;
+  }
+  _handleChangeHoldStateError(e) {
+    return y.error(`Failed to ${e.action} on call ${this.id}`), !1;
+  }
+  _onRemoteSdp(e) {
+    return O(this, void 0, void 0, (function* () {
+      const n = new RTCSessionDescription({ sdp: e, type: K.Answer });
+      yield this.peer.instance.setRemoteDescription(n).then((() => {
+        this.options.trickleIce && (this._isRemoteDescriptionSet = !0, this._flushPendingTrickleIceCandidates()), this.gotEarly && this.setState(N.Early), this.gotAnswer && this.setState(N.Active);
+      })).catch(((i) => {
+        y.error("Call setRemoteDescription Error: ", i), this.hangup();
+      }));
+    }));
+  }
+  _requestAnotherLocalDescription() {
+    ye(this.peer.onSdpReadyTwice) ? F(L.Error, { error: new Error("SDP without candidates for the second time!"), sessionId: this.session.sessionid }, this.session.uuid) : (Object.defineProperty(this.peer, "onSdpReadyTwice", { value: this._onIceSdp.bind(this) }), this._iceDone = !1, this.peer.startNegotiation());
+  }
+  _onIceSdp(e) {
+    var n, i;
+    this._iceTimeout && clearTimeout(this._iceTimeout), this._iceTimeout = null, this._iceDone = !0;
+    const { sdp: s, type: a } = e;
+    if (s.indexOf("candidate") === -1) return y.info(`No candidate - retry 
+`), void this._requestAnotherLocalDescription();
+    (i = (n = this.peer) === null || n === void 0 ? void 0 : n.instance) === null || i === void 0 || i.removeEventListener("icecandidate", this._onIce), performance.mark("ice-gathering-end");
+    let o = null;
+    const l = { sessid: this.session.sessionid, sdp: s, dialogParams: this.options, "User-Agent": `Web-${Lt}` };
+    switch (a) {
+      case K.Offer:
+        this.setState(N.Requesting), o = new Et(l);
+        break;
+      case K.Answer:
+        this.setState(N.Answering), o = this.options.attach === !0 ? new ot(l) : new Tt(l);
+        break;
+      default:
+        return y.error(`${this.id} - Unknown local SDP type:`, e), this.hangup({}, !1);
+    }
+    performance.mark("sdp-send-start"), this._execute(o).then(((d) => {
+      const { node_id: h = null } = d;
+      this._targetNodeId = h, a === K.Offer ? this.setState(N.Trying) : this.setState(N.Active);
+    })).catch(((d) => {
+      y.error(`${this.id} - Sending ${a} error:`, d), this.hangup();
+    })).finally((() => {
+      performance.mark("sdp-send-end"), console.group("Performance Metrics"), console.table(this.performanceMetrics), console.groupEnd(), performance.clearMarks();
+    }));
+  }
+  _onTrickleIceSdp(e) {
+    if (!e) return y.error("No SDP data provided"), this.hangup({}, !1);
+    const { sdp: n, type: i } = e;
+    let s = null;
+    const a = { sessid: this.session.sessionid, sdp: n, dialogParams: this.options, trickle: !0, "User-Agent": `Web-${Lt}` };
+    switch (i) {
+      case K.Offer:
+        this.setState(N.Requesting), s = new Et(a);
+        break;
+      case K.Answer:
+        this.setState(N.Answering), s = this.options.attach === !0 ? new ot(a) : new Tt(a);
+        break;
+      default:
+        return y.error(`${this.id} - Unknown local SDP type:`, e), this.hangup({}, !1);
+    }
+    performance.mark("sdp-send-start"), this._execute(s).then(((o) => {
+      const { node_id: l = null } = o;
+      this._targetNodeId = l, i === K.Offer ? this.setState(N.Trying) : this.setState(N.Active);
+    })).catch(((o) => {
+      y.error(`${this.id} - Sending ${i} error:`, o), this.hangup();
+    })).finally((() => {
+      performance.mark("sdp-send-end");
+    }));
+  }
+  _onIce(e) {
+    const { instance: n } = this.peer;
+    this._iceTimeout === null && (this._iceTimeout = setTimeout((() => this._onIceSdp(n.localDescription)), 1e3)), e.candidate ? y.debug("RTCPeer Candidate:", e.candidate) : this._onIceSdp(n.localDescription);
+  }
+  _onTrickleIce(e) {
+    e.candidate && e.candidate.candidate ? (y.debug("RTCPeer Candidate:", e.candidate), this._sendIceCandidate(e.candidate)) : this._sendEndOfCandidates();
+  }
+  _sendIceCandidate(e) {
+    const n = new on({ sessid: this.session.sessionid, candidate: e.candidate, sdpMLineIndex: e.sdpMLineIndex, sdpMid: e.sdpMid, dialogParams: this.options });
+    this._execute(n);
+  }
+  _addIceCandidate(e) {
+    if (!this._isRemoteDescriptionSet) return y.debug("Remote description not set. Queued ICE candidate.", e), void this._pendingIceCandidates.push(e);
+    this._addIceCandidateToPeer(e);
+  }
+  _addIceCandidateToPeer(e) {
+    const n = this.peer.instance.addIceCandidate(e);
+    Promise.resolve(n).then((() => {
+      y.debug("Successfully added ICE candidate:", e);
+    })).catch(((i) => {
+      y.error("Failed to add ICE candidate:", i, e);
+    }));
+  }
+  _sendEndOfCandidates() {
+    const e = new Zn({ sessid: this.session.sessionid, endOfCandidates: !0, dialogParams: this.options });
+    this._execute(e), performance.mark("ice-gathering-end");
+  }
+  _resetTrickleIceCandidateState() {
+    this._pendingIceCandidates = [], this._isRemoteDescriptionSet = !1;
+  }
+  _flushPendingTrickleIceCandidates() {
+    if (!this._pendingIceCandidates.length) return;
+    const e = [...this._pendingIceCandidates];
+    this._pendingIceCandidates = [], e.forEach(((n) => {
+      this._addIceCandidateToPeer(n);
+    }));
+  }
+  _registerPeerEvents(e) {
+    this._iceDone = !1, e.onicecandidate = (n) => {
+      this._iceDone || this._onIce(n);
+    }, e.onicecandidateerror = (n) => {
+      var i;
+      if (y.debug("ICE candidate error:", n), (i = this.peer) === null || i === void 0 ? void 0 : i.statsReporter) {
+        const s = Rt(n, e);
+        this.peer.statsReporter.reportIceCandidateError(s);
+      }
+    }, e.addEventListener("addstream", ((n) => {
+      this.options.remoteStream = n.stream;
+    })), e.addEventListener("track", ((n) => {
+      this.options.remoteStream = n.streams[0];
+      const { remoteElement: i, remoteStream: s, screenShare: a } = this.options;
+      a === !1 && Ee(i, s);
+    }));
+  }
+  _registerTrickleIcePeerEvents(e) {
+    e.onicecandidate = (n) => {
+      this._onTrickleIce(n);
+    }, e.onicegatheringstatechange = (n) => {
+      y.debug("ICE gathering state changed:", e.iceGatheringState), e.iceGatheringState === "complete" && y.debug("Finished gathering candidates");
+    }, e.onicecandidateerror = (n) => {
+      var i;
+      if (y.debug("ICE candidate error:", n), (i = this.peer) === null || i === void 0 ? void 0 : i.statsReporter) {
+        const s = Rt(n, e);
+        this.peer.statsReporter.reportIceCandidateError(s);
+      }
+    }, e.addEventListener("addstream", ((n) => {
+      this.options.remoteStream = n.stream;
+    })), e.addEventListener("track", ((n) => {
+      this.options.remoteStream = n.streams[0];
+      const { remoteElement: i, remoteStream: s, screenShare: a } = this.options;
+      a === !1 && Ee(i, s);
+    }));
+  }
+  _onMediaError(e) {
+    this._dispatchNotification({ type: oe.userMediaError, error: e }), y.error("Media error, hanging up call", e), this.hangup({}, !1);
+  }
+  _onPeerConnectionFailureError(e) {
+    this._dispatchNotification({ type: oe.peerConnectionFailureError, error: e }), y.error("Peer connection failure error, hanging up call", e), this.hangup({}, !1);
+  }
+  _dispatchConferenceUpdate(e) {
+    this._dispatchNotification(Object.assign({ type: oe.conferenceUpdate, call: this }, e));
+  }
+  _dispatchNotification(e) {
+    this.options.screenShare !== !0 && (F(L.Notification, e, this.id, !1) || F(L.Notification, e, this.session.uuid));
+  }
+  _execute(e) {
+    return this.nodeId && (e.targetNodeId = this.nodeId), this.session.execute(e);
+  }
+  _init() {
+    const { id: e, userVariables: n, remoteCallerNumber: i, onNotification: s } = this.options;
+    var a;
+    this.options.id = e ? e.toString() : ve(), this.id = this.options.id, n && (a = n, Object.keys(a).length !== 0) || (this.options.userVariables = this.session.options.userVariables || {}), i || (this.options.remoteCallerNumber = this.options.destinationNumber), this.session.calls[this.id] = this, de(L.MediaError, this._onMediaError, this.id), de(L.PeerConnectionFailureError, this._onPeerConnectionFailureError, this.id), ye(s) && de(L.Notification, s.bind(this), this.id), this.setState(N.New), y.info("New Call with Options:", this.options);
+  }
+  _finalize() {
+    var e;
+    this._stopStats(), (e = this.peer) === null || e === void 0 || e.close();
+    const { remoteStream: n, localStream: i } = this.options;
+    Te(n), Te(i), ue(L.MediaError, null, this.id), ue(L.PeerConnectionFailureError, null, this.id), this.session.calls[this.id] = null, delete this.session.calls[this.id];
+  }
+  _startStats(e) {
+    this._statsIntervalId = setInterval(this._doStats, e), y.info("Stats started");
+  }
+  _stopStats() {
+    this._statsIntervalId && (clearInterval(this._statsIntervalId), this._statsIntervalId = null), y.debug("Stats stopped");
+  }
+}
+cn.setStateTelnyx = (t) => {
+  if (t) {
+    switch (t._state) {
+      case N.Requesting:
+      case N.Recovering:
+      case N.Trying:
+      case N.Early:
+        t.state = "connecting";
+        break;
+      case N.Active:
+        t.state = "active";
+        break;
+      case N.Held:
+        t.state = "held";
+        break;
+      case N.Hangup:
+      case N.Destroy:
+        t.state = "done";
+        break;
+      case N.Answering:
+        t.state = "ringing";
+        break;
+      case N.New:
+        t.state = "new";
+    }
+    return t;
+  }
+};
+class he extends cn {
+  constructor() {
+    super(...arguments), this._statsInterval = null, this.sendConversationMessage = (e, n) => this.session.execute(new ii(e, n));
+  }
+  hangup(e = {}, n = !0) {
+    this.screenShare instanceof he && this.screenShare.hangup(e, n), super.hangup(e, n);
+  }
+  startScreenShare(e) {
+    return O(this, void 0, void 0, (function* () {
+      const n = yield (i = { video: !0 }, navigator.mediaDevices.getDisplayMedia(i));
+      var i;
+      n.getTracks().forEach(((h) => {
+        h.addEventListener("ended", (() => {
+          this.screenShare && this.screenShare.hangup();
+        }));
+      }));
+      const { remoteCallerName: s, remoteCallerNumber: a, callerName: o, callerNumber: l } = this.options, d = Object.assign({ screenShare: !0, localStream: n, destinationNumber: `${this.extension}-screen`, remoteCallerName: s, remoteCallerNumber: `${a}-screen`, callerName: `${o} (Screen)`, callerNumber: `${l} (Screen)` }, e);
+      return this.screenShare = new he(this.session, d), this.screenShare.invite(), this.screenShare;
+    }));
+  }
+  stopScreenShare() {
+    this.screenShare instanceof he && this.screenShare.hangup();
+  }
+  setAudioOutDevice(e) {
+    return O(this, void 0, void 0, (function* () {
+      this.options.speakerId = e;
+      const { remoteElement: n, speakerId: i } = this.options;
+      return !(!n || !i) && tn(n, i);
+    }));
+  }
+  _finalize() {
+    this._stats(!1), super._finalize();
+  }
+  _stats(e = !0) {
+    if (e === !1) return clearInterval(this._statsInterval);
+    y.setLevel(2), this._statsInterval = window.setInterval((() => O(this, void 0, void 0, (function* () {
+      const n = yield this.peer.instance.getStats(null);
+      let i = "";
+      const s = ["certificate", "codec", "peer-connection", "stream", "local-candidate", "remote-candidate"], a = ["id", "type", "timestamp"];
+      n.forEach(((o) => {
+        s.includes(o.type) || (i += `
+${o.type}
+`, Object.keys(o).forEach(((l) => {
+          a.includes(l) || (i += `	${l}: ${o[l]}
+`);
+        })));
+      })), y.info(i);
+    }))), 2e3);
+  }
+}
+class hi extends qn {
+  constructor(e) {
+    super(e), this.calls = {}, this.autoRecoverCalls = !0, this._iceServers = [], this._localElement = null, this._remoteElement = null, this._jwtAuth = !0, this._audioConstraints = !0, this._previousAudioConstraints = !0, this._videoConstraints = !1, this._speaker = null, this._onlineHandler = null, this._offlineHandler = null, this._wasOffline = !1, this._videoConstraints = e.video || !1, this.iceServers = e.iceServers, this.ringtoneFile = e.ringtoneFile, this.ringbackFile = e.ringbackFile, this._setupNetworkListeners();
+  }
+  get reconnectDelay() {
+    return 1e3;
+  }
+  getIsRegistered() {
+    const e = Object.create(null, { getIsRegistered: { get: () => super.getIsRegistered } });
+    return O(this, void 0, void 0, (function* () {
+      return e.getIsRegistered.call(this);
+    }));
+  }
+  connect() {
+    const e = Object.create(null, { connect: { get: () => super.connect } });
+    return O(this, void 0, void 0, (function* () {
+      e.connect.call(this);
+    }));
+  }
+  checkPermissions(e = !0, n = !0) {
+    return O(this, void 0, void 0, (function* () {
+      try {
+        const i = yield Ue({ audio: e, video: n });
+        return Te(i), !0;
+      } catch {
+        return !1;
+      }
+    }));
+  }
+  logout() {
+    this.disconnect();
+  }
+  disconnect() {
+    const e = Object.create(null, { disconnect: { get: () => super.disconnect } });
+    return O(this, void 0, void 0, (function* () {
+      Object.keys(this.calls).forEach(((n) => this.calls[n].setState(N.Purge))), this.calls = {}, this._cleanupNetworkListeners(), yield e.disconnect.call(this);
+    }));
+  }
+  socketDisconnect() {
+    this._closeConnection();
+  }
+  handleLoginError(e) {
+    super._handleLoginError(e);
+  }
+  speedTest(e) {
+    return new Promise(((n, i) => {
+      if (Xt(L.SpeedTest, ((o) => {
+        const { upDur: l, downDur: d } = o, h = d ? 8 * e / (d / 1e3) / 1024 : 0;
+        n({ upDur: l, downDur: d, upKps: (l ? 8 * e / (l / 1e3) / 1024 : 0).toFixed(0), downKps: h.toFixed(0) });
+      }), this.uuid), !(e = Number(e))) return i(`Invalid parameter 'bytes': ${e}`);
+      this.executeRaw(`#SPU ${e}`);
+      let s = e / 1024;
+      e % 1024 && s++;
+      const a = ".".repeat(1024);
+      for (let o = 0; o < s; o++) this.executeRaw(`#SPB ${a}`);
+      this.executeRaw("#SPE");
+    }));
+  }
+  getDevices() {
+    return ke().catch(((e) => (F(L.MediaError, e, this.uuid), [])));
+  }
+  getVideoDevices() {
+    return ke(ae.Video).catch(((e) => (F(L.MediaError, e, this.uuid), [])));
+  }
+  getAudioInDevices() {
+    return ke(ae.AudioIn).catch(((e) => (F(L.MediaError, e, this.uuid), [])));
+  }
+  getAudioOutDevices() {
+    return ke(ae.AudioOut).catch(((e) => (y.error("getAudioOutDevices", e), F(L.MediaError, e, this.uuid), [])));
+  }
+  validateDeviceId(e, n, i) {
+    return je(e, n, i);
+  }
+  getDeviceResolutions(e) {
+    return O(this, void 0, void 0, (function* () {
+      try {
+        return yield ((n) => O(void 0, void 0, void 0, (function* () {
+          const i = [], s = yield Ue({ video: { deviceId: { exact: n } } }), a = s.getVideoTracks()[0];
+          for (let o = 0; o < St.length; o++) {
+            const [l, d] = St[o];
+            (yield a.applyConstraints({ width: { exact: l }, height: { exact: d } }).then((() => !0)).catch((() => !1))) && i.push({ resolution: `${l}x${d}`, width: l, height: d });
+          }
+          return Te(s), i;
+        })))(e);
+      } catch (n) {
+        throw n;
+      }
+    }));
+  }
+  get mediaConstraints() {
+    return { audio: this._audioConstraints, video: this._videoConstraints };
+  }
+  setAudioSettings(e) {
+    return O(this, void 0, void 0, (function* () {
+      if (!e) throw new Error("You need to provide the settings object");
+      const { micId: n, micLabel: i } = e, s = Wt(e, ["micId", "micLabel"]);
+      return Yn(s), this._audioConstraints = yield ((a, o, l, d) => O(void 0, void 0, void 0, (function* () {
+        const { deviceId: h } = d;
+        if (h === void 0 && (a || o)) {
+          const f = yield je(a, o, l).catch(((m) => null));
+          f && (d.deviceId = { exact: f });
+        }
+        return d;
+      })))(n, i, "audioinput", s), this.micId = n, this.micLabel = i, this._audioConstraints;
+    }));
+  }
+  disableMicrophone() {
+    this._previousAudioConstraints = this._audioConstraints, this._audioConstraints = !1;
+  }
+  enableMicrophone() {
+    this._audioConstraints = this._previousAudioConstraints || !0;
+  }
+  set iceServers(e) {
+    if (e && Array.isArray(e)) this._iceServers = e;
+    else {
+      const n = this.options.env === "development";
+      this._iceServers = n ? Mn : On;
+    }
+  }
+  get iceServers() {
+    return this._iceServers;
+  }
+  set speaker(e) {
+    this._speaker = e;
+  }
+  get speaker() {
+    return this._speaker;
+  }
+  set localElement(e) {
+    this._localElement = De(e);
+  }
+  get localElement() {
+    return this._localElement;
+  }
+  set remoteElement(e) {
+    this._remoteElement = De(e);
+  }
+  get remoteElement() {
+    return this._remoteElement;
+  }
+  vertoBroadcast({ nodeId: e, channel: n = "", data: i }) {
+    if (!n) throw new Error(`Invalid channel for broadcast: ${n}`);
+    const s = new ei({ sessid: this.sessionid, eventChannel: n, data: i });
+    e && (s.targetNodeId = e), this.execute(s).catch(((a) => a));
+  }
+  vertoSubscribe({ nodeId: e, channels: n = [], handler: i }) {
+    return O(this, void 0, void 0, (function* () {
+      if (!(n = n.filter(((d) => d && !this._existsSubscription(this.relayProtocol, d)))).length) return {};
+      const s = new ti({ sessid: this.sessionid, eventChannel: n });
+      e && (s.targetNodeId = e);
+      const a = yield this.execute(s), { unauthorized: o = [], subscribed: l = [] } = it(a);
+      return o.length && o.forEach(((d) => this._removeSubscription(this.relayProtocol, d))), l.forEach(((d) => this._addSubscription(this.relayProtocol, i, d))), a;
+    }));
+  }
+  vertoUnsubscribe({ nodeId: e, channels: n = [] }) {
+    return O(this, void 0, void 0, (function* () {
+      if (!(n = n.filter(((l) => l && this._existsSubscription(this.relayProtocol, l)))).length) return {};
+      const i = new ni({ sessid: this.sessionid, eventChannel: n });
+      e && (i.targetNodeId = e);
+      const s = yield this.execute(i), { unsubscribed: a = [], notSubscribed: o = [] } = it(s);
+      return a.forEach(((l) => this._removeSubscription(this.relayProtocol, l))), o.forEach(((l) => this._removeSubscription(this.relayProtocol, l))), s;
+    }));
+  }
+  _setupNetworkListeners() {
+    typeof window < "u" && (this._onlineHandler = () => {
+      this._wasOffline && (y.debug(`Network connectivity restored for session ${this.sessionid}. Reconnecting...`), this.socketDisconnect(), this.connect()), this._wasOffline = !1;
+    }, this._offlineHandler = () => {
+      this._wasOffline = !0, y.debug(`Network connectivity lost for session ${this.sessionid}`);
+    }, window.addEventListener("online", this._onlineHandler), window.addEventListener("offline", this._offlineHandler));
+  }
+  _cleanupNetworkListeners() {
+    typeof window < "u" && this._onlineHandler && this._offlineHandler && (window.removeEventListener("online", this._onlineHandler), window.removeEventListener("offline", this._offlineHandler), this._onlineHandler = null, this._offlineHandler = null);
+  }
+  static telnyxStateCall(e) {
+    return he.setStateTelnyx(e);
+  }
+}
+class Ot {
+  constructor(e, n) {
+    this.code = n, this.message = e;
+  }
+}
+class ln extends Z {
+  constructor(e) {
+    super(), this.method = "anonymous_login";
+    const { target_type: n, target_id: i, target_version_id: s, userVariables: a, sessionId: o, reconnection: l } = e, d = { target_type: n, target_id: i, userVariables: a, reconnection: l, "User-Agent": { sdkVersion: We, data: navigator.userAgent } };
+    o && (d.sessid = o), s && (d.target_version_id = s), this.buildRequest({ method: this.method, params: d });
+  }
+}
+const pi = We;
+class J {
+  constructor(e) {
+    this.session = e, this.handleLogin = () => O(this, void 0, void 0, (function* () {
+      const { login: n, password: i, passwd: s, login_token: a, userVariables: o } = this.session.options, l = new sn(n, i || s, a, this.session.sessionid, o, !!fe()), d = yield this.session.execute(l).catch(this.session.handleLoginError);
+      d && (this.session.sessionid = d.sessid);
+    })), this.handleAnonymousLogin = () => O(this, void 0, void 0, (function* () {
+      const { anonymous_login: n } = this.session.options, i = new ln({ target_id: n.target_id, target_type: n.target_type, target_version_id: n.target_version_id, sessionId: this.session.sessionid, userVariables: this.session.options.userVariables, reconnection: !!fe() }), s = yield this.session.execute(i).catch(this.session.handleLoginError);
+      s && (this.session.sessionid = s.sessid);
+    }));
+  }
+  _ack(e, n) {
+    const i = new Qn(e, n);
+    this.nodeId && (i.targetNodeId = this.nodeId), this.session.execute(i);
+  }
+  reconnectDelay() {
+    return 1e3 * Kt(2, 6);
+  }
+  handleMessage(e) {
+    var n;
+    const { session: i } = this, { id: s, method: a, params: o = {}, voice_sdk_id: l } = e, d = o?.callID, h = o?.eventChannel, f = o?.eventType, m = a === $.Attach, S = a === $.Punt;
+    let w = !1;
+    if (f === "channelPvtData") return this._handlePvtEvent(o.pvtData);
+    if (d && i.calls.hasOwnProperty(d)) {
+      if (!m) return i.calls[d].handleMessage(e), void this._ack(s, a);
+      w = (i.options.keepConnectionAliveOnSocketClose || i.calls[d].options.keepConnectionAliveOnSocketClose) && !!(!((n = this.session.calls[d].peer) === null || n === void 0) && n.instance), w ? y.info(`[${(/* @__PURE__ */ new Date()).toISOString()}][${d}] re-attaching call due to ATTACH and keepConnectionAliveOnSocketClose`) : (y.info(`[${(/* @__PURE__ */ new Date()).toISOString()}][${d}] Hanging up the call due to ATTACH`), i.calls[d].hangup({}, !1));
+    }
+    if (S && i.options.keepConnectionAliveOnSocketClose) return y.info(`[${(/* @__PURE__ */ new Date()).toISOString()}][${d}] keeping call alive due to PUNT and keepConnectionAliveOnSocketClose. Disconnecting base session...`), this.session.socketDisconnect(), void this._ack(s, a);
+    const C = () => {
+      var _, A, E, P, D, q;
+      const B = { id: d, audio: !0, video: i.options.video, remoteSdp: o.sdp, destinationNumber: o.callee_id_number, remoteCallerName: o.caller_id_name, remoteCallerNumber: o.caller_id_number, callerName: o.callee_id_name, callerNumber: o.callee_id_number, attach: m, mediaSettings: o.mediaSettings, debug: (_ = i.options.debug) !== null && _ !== void 0 && _, debugOutput: (A = i.options.debugOutput) !== null && A !== void 0 ? A : "socket", trickleIce: (E = i.options.trickleIce) !== null && E !== void 0 && E, prefetchIceCandidates: (P = i.options.prefetchIceCandidates) !== null && P !== void 0 && P, forceRelayCandidate: (D = i.options.forceRelayCandidate) !== null && D !== void 0 && D, keepConnectionAliveOnSocketClose: (q = i.options.keepConnectionAliveOnSocketClose) !== null && q !== void 0 && q };
+      o.telnyx_call_control_id && (B.telnyxCallControlId = o.telnyx_call_control_id), o.telnyx_session_id && (B.telnyxSessionId = o.telnyx_session_id), o.telnyx_leg_id && (B.telnyxLegId = o.telnyx_leg_id), o.client_state && (B.clientState = o.client_state), o.dialogParams && o.dialogParams.custom_headers && o.dialogParams.custom_headers.length && (B.customHeaders = o.dialogParams.custom_headers);
+      const x = new he(i, B);
+      return x.nodeId = this.nodeId, x;
+    }, k = new Zt(l), p = new en(l);
+    switch (a) {
+      case $.Ping:
+        this.session.setPingReceived(), this.session.execute(p).then((() => {
+          J.receivedAuthenticationRequired = 0;
+        })).catch(((E) => O(this, void 0, void 0, (function* () {
+          E.code === this.session.authenticationRequiredErrorCode && J.receivedAuthenticationRequired >= 0 && (J.receivedAuthenticationRequired += 1, J.receivedAuthenticationRequired > 1 && this.session.hasAutoReconnect() && (y.warn("Ping failed twice with Authentication Required. Re-logging in..."), Ne(this.session.options) ? this.handleLogin() : Ie(this.session.options) && this.handleAnonymousLogin(), J.receivedAuthenticationRequired = -1));
+        }))));
+        break;
+      case $.Punt:
+        i.disconnect();
+        break;
+      case $.Invite: {
+        const E = C();
+        E.playRingtone(), E.setState(N.Ringing), E.direction = le.Inbound, this._ack(s, a);
+        break;
+      }
+      case $.Attach: {
+        if (w) return void this.session.execute(new ot({ sessid: this.session.sessionid, sdp: this.session.calls[d].peer.instance.localDescription.sdp, dialogParams: this.session.calls[d].options, "User-Agent": `Web-${pi}` }));
+        y.info(`[${(/* @__PURE__ */ new Date()).toISOString()}][${d}] Re-creating call instance.`);
+        const E = C();
+        this.session.autoRecoverCalls ? E.answer() : E.setState(N.Recovering), E.handleMessage(e);
+        break;
+      }
+      case $.Event:
+      case "webrtc.event":
+        if (!h) return void y.error("Verto received an unknown event:", o);
+        const _ = i.relayProtocol, A = h.split(".")[0];
+        i._existsSubscription(_, h) ? F(_, o, h) : h === i.sessionid ? this._handleSessionEvent(o.eventData) : i._existsSubscription(_, A) ? F(_, o, A) : i.calls.hasOwnProperty(h) ? i.calls[h].handleMessage(e) : F(L.Notification, o, i.uuid);
+        break;
+      case $.Info:
+        o.type = oe.generic, F(L.Notification, o, i.uuid);
+        break;
+      case $.ClientReady:
+        this.session.execute(k);
+        break;
+      default: {
+        const E = ht(e);
+        if (E) {
+          switch (E) {
+            case te.REGISTER:
+            case te.REGED:
+              i.connection.previousGatewayState !== te.REGED && i.connection.previousGatewayState !== te.REGISTER && (this.session._triggerKeepAliveTimeoutCheck(), J.retriedRegister = 0, o.type = oe.vertoClientReady, F(L.Ready, o, i.uuid), i.options.trickleIce && (y.debug("Trickle ICE is enabled. Checking Gateway support"), this.session.execute(new on({ candidate: "" })).catch(((P) => {
+                P.code === this.session.invalidMethodErrorCode ? (y.warn("Trickle ICE is not supported by the server, disabling it."), y.debug("Trickle ICE check error:", JSON.stringify(P, null, 2)), i.options.trickleIce = !1) : y.debug("Trickle ICE check:", JSON.stringify(P, null, 2));
+              }))));
+              break;
+            case te.UNREGED:
+            case te.NOREG:
+              if (J.retriedRegister += 1, J.retriedRegister === 5) {
+                J.retriedRegister = 0, F(L.Error, { error: new Ot("Fail to register the user, the server tried 5 times", "UNREGED|NOREG"), sessionId: i.sessionid }, i.uuid);
+                break;
+              }
+              setTimeout((() => {
+                this.session.execute(k);
+              }), this.reconnectDelay());
+              break;
+            case te.FAILED:
+            case te.FAIL_WAIT:
+              if (i.connection.previousGatewayState !== te.FAILED && i.connection.previousGatewayState !== te.FAIL_WAIT) {
+                if (!this.session.hasAutoReconnect()) {
+                  J.retriedConnect = 0, F(L.Error, { error: new Ot("Fail to connect the server, the server tried 5 times", "FAILED|FAIL_WAIT"), sessionId: i.sessionid }, i.uuid);
+                  break;
+                }
+                if (J.retriedConnect += 1, J.retriedConnect === 5) {
+                  J.retriedConnect = 0, F(L.Error, { error: new Error("Connection Retry Failed"), sessionId: i.sessionid }, i.uuid);
+                  break;
+                }
+                setTimeout((() => {
+                  if (y.debug(`Reconnecting... Retry ${J.retriedConnect} of 5`), this.session.options.keepConnectionAliveOnSocketClose) return y.debug("Reconnecting by keeping the existing session due to keepConnectionAliveOnSocketClose option being set."), this.session.socketDisconnect(), void this.session.connect();
+                  this.session.disconnect().then((() => {
+                    this.session.clearConnection(), this.session.connect();
+                  }));
+                }), this.reconnectDelay());
+              }
+              break;
+            default:
+              y.warn("GatewayState message unknown method:", e);
+          }
+          break;
+        }
+        y.debug("Verto message unknown method:", e);
+        break;
+      }
+    }
+  }
+  _retrieveCallId(e, n) {
+    const i = Object.keys(this.session.calls);
+    if (e.action !== "bootObj") return i.find(((s) => this.session.calls[s].channels.includes(n)));
+    {
+      const s = e.data.find(((a) => i.includes(a[0])));
+      if (s instanceof Array) return s[0];
+    }
+  }
+  _handlePvtEvent(e) {
+    return O(this, void 0, void 0, (function* () {
+      const { session: n } = this, i = n.relayProtocol, { action: s, laChannel: a, laName: o, chatChannel: l, infoChannel: d, modChannel: h, conferenceMemberID: f, role: m, callID: S } = e;
+      switch (s) {
+        case "conference-liveArray-join": {
+          const w = () => {
+            n.vertoBroadcast({ nodeId: this.nodeId, channel: a, data: { liveArray: { command: "bootstrap", context: a, name: o } } });
+          }, C = { nodeId: this.nodeId, channels: [a], handler: ({ data: p }) => {
+            const _ = S || this._retrieveCallId(p, a);
+            if (_ && n.calls.hasOwnProperty(_)) {
+              const A = n.calls[_];
+              A._addChannel(a), A.extension = o, A.handleConferenceUpdate(p, e).then(((E) => {
+                E === "INVALID_PACKET" && w();
+              }));
+            }
+          } }, k = yield n.vertoSubscribe(C).catch(((p) => {
+            y.error("liveArray subscription error:", p);
+          }));
+          nt(k, a) && w();
+          break;
+        }
+        case "conference-liveArray-part": {
+          let w = null;
+          if (a && n._existsSubscription(i, a)) {
+            const { callId: k = null } = n.subscriptions[i][a];
+            if (w = n.calls[k] || null, k !== null) {
+              const p = { type: oe.conferenceUpdate, action: se.Leave, conferenceName: o, participantId: Number(f), role: m };
+              F(L.Notification, p, k, !1) || F(L.Notification, p, n.uuid), w === null && ue(L.Notification, null, k);
+            }
+          }
+          const C = [a, l, d, h];
+          n.vertoUnsubscribe({ nodeId: this.nodeId, channels: C }).then((({ unsubscribedChannels: k = [] }) => {
+            w && (w.channels = w.channels.filter(((p) => !k.includes(p))));
+          })).catch(((k) => {
+            y.error("liveArray unsubscribe error:", k);
+          }));
+          break;
+        }
+      }
+    }));
+  }
+  _handleSessionEvent(e) {
+    switch (e.contentType) {
+      case "layout-info":
+      case "layer-info":
+        an(this.session, e);
+        break;
+      case "logo-info": {
+        const n = { type: oe.conferenceUpdate, action: se.LogoInfo, logo: e.logoURL };
+        F(L.Notification, n, this.session.uuid);
+        break;
+      }
+    }
+  }
+}
+J.retriedConnect = 0, J.retriedRegister = 0, J.receivedAuthenticationRequired = 0;
+class fi extends hi {
+  constructor(e) {
+    super(e), this.relayProtocol = "verto-protocol", this.timeoutErrorCode = -329990, this.handleLoginOnSocketOpen = () => O(this, void 0, void 0, (function* () {
+      this._idle = !1;
+      const { login: n, password: i, passwd: s, login_token: a, userVariables: o, autoReconnect: l = !0 } = this.options, d = new sn(n, i || s, a, this.sessionid, o, !!fe()), h = yield this.execute(d).catch(this._handleLoginError);
+      h && (this._autoReconnect = l, this.sessionid = h.sessid);
+    })), this.handleAnonymousLoginOnSocketOpen = () => O(this, void 0, void 0, (function* () {
+      this._idle = !1;
+      const { anonymous_login: n } = this.options, i = new ln({ target_id: n.target_id, target_type: n.target_type, target_version_id: n.target_version_id, sessionId: this.sessionid, userVariables: this.options.userVariables, reconnection: !!fe() }), s = yield this.execute(i).catch(this._handleLoginError);
+      s && (this.sessionid = s.sessid);
+    })), window.addEventListener("beforeunload", ((n) => {
+      this.calls && Object.keys(this.calls).forEach(((i) => {
+        this.calls[i] && (y.info(`Hanging up call due to window unload: ${i}`), this.calls[i].hangup({}, !0));
+      }));
+    }));
+  }
+  validateOptions() {
+    return Ne(this.options) || Ie(this.options);
+  }
+  newCall(e) {
+    if (!this.validateCallOptions(e)) throw new Error("Verto.newCall() error: destinationNumber is required.");
+    performance.mark("new-call-start");
+    const n = new he(this, e);
+    return n.invite(), performance.mark("new-call-end"), n;
+  }
+  broadcast(e) {
+    return this.vertoBroadcast(e);
+  }
+  subscribe(e) {
+    return this.vertoSubscribe(e);
+  }
+  unsubscribe(e) {
+    return this.vertoUnsubscribe(e);
+  }
+  validateCallOptions(e) {
+    return !!Ie(this.options) || !!e.destinationNumber;
+  }
+  _onSocketOpen() {
+    return O(this, void 0, void 0, (function* () {
+      return Ne(this.options) ? this.handleLoginOnSocketOpen() : Ie(this.options) ? this.handleAnonymousLoginOnSocketOpen() : void 0;
+    }));
+  }
+  _onSocketMessage(e) {
+    new J(this).handleMessage(e);
+  }
+}
+class gi extends fi {
+  constructor(e) {
+    super(e), y.info(`SDK version: ${nn}`);
+  }
+  newCall(e) {
+    return super.newCall(e);
+  }
+  static webRTCInfo() {
+    return Kn();
+  }
+  static webRTCSupportedBrowserList() {
+    return [{ operationSystem: "Android", supported: [{ browserName: "Chrome", features: ["audio"], supported: H.full }, { browserName: "Firefox", features: ["audio"], supported: H.partial }, { browserName: "Safari", supported: H.not_supported }, { browserName: "Edge", supported: H.not_supported }] }, { operationSystem: "iOS", supported: [{ browserName: "Chrome", supported: H.not_supported }, { browserName: "Firefox", supported: H.not_supported }, { browserName: "Safari", features: ["video", "audio"], supported: H.full }, { browserName: "Edge", supported: H.not_supported }] }, { operationSystem: "Linux", supported: [{ browserName: "Chrome", features: ["video", "audio"], supported: H.full }, { browserName: "Firefox", features: ["audio"], supported: H.partial }, { browserName: "Safari", supported: H.not_supported }, { browserName: "Edge", supported: H.not_supported }] }, { operationSystem: "MacOS", supported: [{ browserName: "Chrome", features: ["video", "audio"], supported: H.full }, { browserName: "Firefox", features: ["audio"], supported: H.partial }, { browserName: "Safari", features: ["video", "audio"], supported: H.full }, { browserName: "Edge", features: ["audio"], supported: H.partial }] }, { operationSystem: "Windows", supported: [{ browserName: "Chrome", features: ["video", "audio"], supported: H.full }, { browserName: "Firefox", features: ["audio"], supported: H.partial }, { browserName: "Safari", supported: H.not_supported }, { browserName: "Edge", features: ["audio"], supported: H.partial }] }];
+  }
+}
+function dn(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var Xe = { exports: {} }, Mt;
+function mi() {
+  return Mt || (Mt = 1, (function(t) {
+    var e = Object.prototype.hasOwnProperty, n = "~";
+    function i() {
+    }
+    Object.create && (i.prototype = /* @__PURE__ */ Object.create(null), new i().__proto__ || (n = !1));
+    function s(d, h, f) {
+      this.fn = d, this.context = h, this.once = f || !1;
+    }
+    function a(d, h, f, m, S) {
+      if (typeof f != "function")
+        throw new TypeError("The listener must be a function");
+      var w = new s(f, m || d, S), C = n ? n + h : h;
+      return d._events[C] ? d._events[C].fn ? d._events[C] = [d._events[C], w] : d._events[C].push(w) : (d._events[C] = w, d._eventsCount++), d;
+    }
+    function o(d, h) {
+      --d._eventsCount === 0 ? d._events = new i() : delete d._events[h];
+    }
+    function l() {
+      this._events = new i(), this._eventsCount = 0;
+    }
+    l.prototype.eventNames = function() {
+      var h = [], f, m;
+      if (this._eventsCount === 0) return h;
+      for (m in f = this._events)
+        e.call(f, m) && h.push(n ? m.slice(1) : m);
+      return Object.getOwnPropertySymbols ? h.concat(Object.getOwnPropertySymbols(f)) : h;
+    }, l.prototype.listeners = function(h) {
+      var f = n ? n + h : h, m = this._events[f];
+      if (!m) return [];
+      if (m.fn) return [m.fn];
+      for (var S = 0, w = m.length, C = new Array(w); S < w; S++)
+        C[S] = m[S].fn;
+      return C;
+    }, l.prototype.listenerCount = function(h) {
+      var f = n ? n + h : h, m = this._events[f];
+      return m ? m.fn ? 1 : m.length : 0;
+    }, l.prototype.emit = function(h, f, m, S, w, C) {
+      var k = n ? n + h : h;
+      if (!this._events[k]) return !1;
+      var p = this._events[k], _ = arguments.length, A, E;
+      if (p.fn) {
+        switch (p.once && this.removeListener(h, p.fn, void 0, !0), _) {
+          case 1:
+            return p.fn.call(p.context), !0;
+          case 2:
+            return p.fn.call(p.context, f), !0;
+          case 3:
+            return p.fn.call(p.context, f, m), !0;
+          case 4:
+            return p.fn.call(p.context, f, m, S), !0;
+          case 5:
+            return p.fn.call(p.context, f, m, S, w), !0;
+          case 6:
+            return p.fn.call(p.context, f, m, S, w, C), !0;
+        }
+        for (E = 1, A = new Array(_ - 1); E < _; E++)
+          A[E - 1] = arguments[E];
+        p.fn.apply(p.context, A);
+      } else {
+        var P = p.length, D;
+        for (E = 0; E < P; E++)
+          switch (p[E].once && this.removeListener(h, p[E].fn, void 0, !0), _) {
+            case 1:
+              p[E].fn.call(p[E].context);
+              break;
+            case 2:
+              p[E].fn.call(p[E].context, f);
+              break;
+            case 3:
+              p[E].fn.call(p[E].context, f, m);
+              break;
+            case 4:
+              p[E].fn.call(p[E].context, f, m, S);
+              break;
+            default:
+              if (!A) for (D = 1, A = new Array(_ - 1); D < _; D++)
+                A[D - 1] = arguments[D];
+              p[E].fn.apply(p[E].context, A);
+          }
+      }
+      return !0;
+    }, l.prototype.on = function(h, f, m) {
+      return a(this, h, f, m, !1);
+    }, l.prototype.once = function(h, f, m) {
+      return a(this, h, f, m, !0);
+    }, l.prototype.removeListener = function(h, f, m, S) {
+      var w = n ? n + h : h;
+      if (!this._events[w]) return this;
+      if (!f)
+        return o(this, w), this;
+      var C = this._events[w];
+      if (C.fn)
+        C.fn === f && (!S || C.once) && (!m || C.context === m) && o(this, w);
+      else {
+        for (var k = 0, p = [], _ = C.length; k < _; k++)
+          (C[k].fn !== f || S && !C[k].once || m && C[k].context !== m) && p.push(C[k]);
+        p.length ? this._events[w] = p.length === 1 ? p[0] : p : o(this, w);
+      }
+      return this;
+    }, l.prototype.removeAllListeners = function(h) {
+      var f;
+      return h ? (f = n ? n + h : h, this._events[f] && o(this, f)) : (this._events = new i(), this._eventsCount = 0), this;
+    }, l.prototype.off = l.prototype.removeListener, l.prototype.addListener = l.prototype.on, l.prefixed = n, l.EventEmitter = l, t.exports = l;
+  })(Xe)), Xe.exports;
+}
+var vi = mi();
+const ft = /* @__PURE__ */ dn(vi), Fe = new ft();
+var Pe = { exports: {} }, yi = Pe.exports, Pt;
+function bi() {
+  return Pt || (Pt = 1, (function(t) {
+    (function(e, n) {
+      t.exports ? t.exports = n() : e.log = n();
+    })(yi, function() {
+      var e = function() {
+      }, n = "undefined", i = typeof window !== n && typeof window.navigator !== n && /Trident\/|MSIE /.test(window.navigator.userAgent), s = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ], a = {}, o = null;
+      function l(k, p) {
+        var _ = k[p];
+        if (typeof _.bind == "function")
+          return _.bind(k);
+        try {
+          return Function.prototype.bind.call(_, k);
+        } catch {
+          return function() {
+            return Function.prototype.apply.apply(_, [k, arguments]);
+          };
+        }
+      }
+      function d() {
+        console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+      }
+      function h(k) {
+        return k === "debug" && (k = "log"), typeof console === n ? !1 : k === "trace" && i ? d : console[k] !== void 0 ? l(console, k) : console.log !== void 0 ? l(console, "log") : e;
+      }
+      function f() {
+        for (var k = this.getLevel(), p = 0; p < s.length; p++) {
+          var _ = s[p];
+          this[_] = p < k ? e : this.methodFactory(_, k, this.name);
+        }
+        if (this.log = this.debug, typeof console === n && k < this.levels.SILENT)
+          return "No console available for logging";
+      }
+      function m(k) {
+        return function() {
+          typeof console !== n && (f.call(this), this[k].apply(this, arguments));
+        };
+      }
+      function S(k, p, _) {
+        return h(k) || m.apply(this, arguments);
+      }
+      function w(k, p) {
+        var _ = this, A, E, P, D = "loglevel";
+        typeof k == "string" ? D += ":" + k : typeof k == "symbol" && (D = void 0);
+        function q(u) {
+          var g = (s[u] || "silent").toUpperCase();
+          if (!(typeof window === n || !D)) {
+            try {
+              window.localStorage[D] = g;
+              return;
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(D) + "=" + g + ";";
+            } catch {
+            }
+          }
+        }
+        function B() {
+          var u;
+          if (!(typeof window === n || !D)) {
+            try {
+              u = window.localStorage[D];
+            } catch {
+            }
+            if (typeof u === n)
+              try {
+                var g = window.document.cookie, b = encodeURIComponent(D), T = g.indexOf(b + "=");
+                T !== -1 && (u = /^([^;]+)/.exec(
+                  g.slice(T + b.length + 1)
+                )[1]);
+              } catch {
+              }
+            return _.levels[u] === void 0 && (u = void 0), u;
+          }
+        }
+        function x() {
+          if (!(typeof window === n || !D)) {
+            try {
+              window.localStorage.removeItem(D);
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(D) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+            } catch {
+            }
+          }
+        }
+        function r(u) {
+          var g = u;
+          if (typeof g == "string" && _.levels[g.toUpperCase()] !== void 0 && (g = _.levels[g.toUpperCase()]), typeof g == "number" && g >= 0 && g <= _.levels.SILENT)
+            return g;
+          throw new TypeError("log.setLevel() called with invalid level: " + u);
+        }
+        _.name = k, _.levels = {
+          TRACE: 0,
+          DEBUG: 1,
+          INFO: 2,
+          WARN: 3,
+          ERROR: 4,
+          SILENT: 5
+        }, _.methodFactory = p || S, _.getLevel = function() {
+          return P ?? E ?? A;
+        }, _.setLevel = function(u, g) {
+          return P = r(u), g !== !1 && q(P), f.call(_);
+        }, _.setDefaultLevel = function(u) {
+          E = r(u), B() || _.setLevel(u, !1);
+        }, _.resetLevel = function() {
+          P = null, x(), f.call(_);
+        }, _.enableAll = function(u) {
+          _.setLevel(_.levels.TRACE, u);
+        }, _.disableAll = function(u) {
+          _.setLevel(_.levels.SILENT, u);
+        }, _.rebuild = function() {
+          if (o !== _ && (A = r(o.getLevel())), f.call(_), o === _)
+            for (var u in a)
+              a[u].rebuild();
+        }, A = r(
+          o ? o.getLevel() : "WARN"
+        );
+        var c = B();
+        c != null && (P = r(c)), f.call(_);
+      }
+      o = new w(), o.getLogger = function(p) {
+        if (typeof p != "symbol" && typeof p != "string" || p === "")
+          throw new TypeError("You must supply a name when creating a logger.");
+        var _ = a[p];
+        return _ || (_ = a[p] = new w(
+          p,
+          o.methodFactory
+        )), _;
+      };
+      var C = typeof window !== n ? window.log : void 0;
+      return o.noConflict = function() {
+        return typeof window !== n && window.log === o && (window.log = C), o;
+      }, o.getLoggers = function() {
+        return a;
+      }, o.default = o, o;
+    });
+  })(Pe)), Pe.exports;
+}
+var Si = bi();
+const _i = /* @__PURE__ */ dn(Si), wi = () => (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", ""), z = _i.getLogger("telnyx-ai-agent"), Ci = z.methodFactory;
+z.methodFactory = (t, e, n) => {
+  const i = Ci(t, e, n);
+  return function(...s) {
+    i(wi(), "-", ...s);
+  };
+};
+z.setLevel("info");
+function ki(t, e) {
+  let n = 0;
+  return (...i) => {
+    const s = Date.now();
+    s - n >= e && (n = s, t(...i));
+  };
+}
+const Ii = 10, Ei = 500, Ti = 100, Dt = 20;
+class Ai {
+  remoteIntervalId = null;
+  localIntervalId = null;
+  remoteStream = null;
+  localStream = null;
+  remoteAudioContext = null;
+  remoteSource = null;
+  remoteAnalyser = null;
+  localAudioContext = null;
+  localSource = null;
+  localAnalyser = null;
+  thinkingStartTime = null;
+  lastState = null;
+  // Local stream (user) state tracking
+  userIsSpeaking = !1;
+  lastUserAudioTime = null;
+  userSpeechStartTime = null;
+  // Latency measurement tracking
+  userSilenceStartTime = null;
+  isFirstAgentSpeech = !0;
+  monitorStartTime = null;
+  // Configurable VAD options
+  volumeThreshold;
+  silenceDurationMs;
+  minSpeechDurationMs;
+  maxLatencyMs;
+  constructor(e) {
+    this.volumeThreshold = e?.volumeThreshold ?? Ii, this.silenceDurationMs = e?.silenceDurationMs ?? Ei, this.minSpeechDurationMs = e?.minSpeechDurationMs ?? Ti, this.maxLatencyMs = e?.maxLatencyMs;
+  }
+  updateAgentState = ki((e) => {
+    z.debug("AudioStreamMonitor updateAgentState", e), z.debug("Previous state:", this.lastState), e.state !== this.lastState && (this.lastState = e.state, Fe.emit("conversation.agent.state", e));
+  }, 100);
+  /**
+   * Set the remote audio stream (agent's voice) to monitor for speech detection
+   */
+  setRemoteStream(e) {
+    this.remoteStream && this.stopRemoteMonitor(), this.remoteStream = e, this.startRemoteMonitor();
+  }
+  /**
+   * Set the local audio stream (user's microphone) to monitor for VAD
+   */
+  setLocalStream(e) {
+    this.localStream && this.stopLocalMonitor(), this.localStream = e, this.startLocalMonitor();
+  }
+  // Legacy method for backwards compatibility
+  setMonitoredAudioStream(e) {
+    this.setRemoteStream(e);
+  }
+  stopRemoteMonitor() {
+    this.remoteIntervalId && (clearInterval(this.remoteIntervalId), this.remoteIntervalId = null), this.remoteSource?.disconnect(), this.remoteAudioContext?.close(), this.remoteAudioContext = null, this.remoteSource = null, this.remoteAnalyser = null;
+  }
+  stopLocalMonitor() {
+    this.localIntervalId && (clearInterval(this.localIntervalId), this.localIntervalId = null), this.localSource?.disconnect(), this.localAudioContext?.close(), this.localAudioContext = null, this.localSource = null, this.localAnalyser = null;
+  }
+  /**
+   * Reset all latency tracking state for a fresh call.
+   * Should be called when a call ends to prevent stale data affecting the next call.
+   */
+  resetLatencyState() {
+    this.thinkingStartTime = null, this.lastState = null, this.userIsSpeaking = !1, this.lastUserAudioTime = null, this.userSpeechStartTime = null, this.userSilenceStartTime = null, this.isFirstAgentSpeech = !0, this.monitorStartTime = null;
+  }
+  stopAudioStreamMonitor() {
+    this.stopRemoteMonitor(), this.stopLocalMonitor(), this.resetLatencyState();
+  }
+  /**
+   * Monitor remote stream (agent's audio) for speech detection
+   * Detects when agent starts speaking to calculate latency
+   */
+  startRemoteMonitor() {
+    if (!this.remoteStream) {
+      z.debug("Remote monitor: no stream, skipping");
+      return;
+    }
+    this.monitorStartTime = performance.now(), this.remoteAudioContext = new AudioContext(), z.debug("Remote AudioContext state:", this.remoteAudioContext.state), this.remoteAudioContext.state === "suspended" && (z.debug("Resuming suspended AudioContext..."), this.remoteAudioContext.resume().then(() => {
+      z.debug("AudioContext resumed, state:", this.remoteAudioContext?.state);
+    })), this.remoteSource = this.remoteAudioContext.createMediaStreamSource(
+      this.remoteStream
+    ), this.remoteAnalyser = this.remoteAudioContext.createAnalyser(), this.remoteSource.connect(this.remoteAnalyser);
+    const e = this.remoteAudioContext.createGain();
+    e.gain.value = 0, this.remoteAnalyser.connect(e), e.connect(this.remoteAudioContext.destination), this.remoteAnalyser.fftSize = 512;
+    const n = new Uint8Array(this.remoteAnalyser.frequencyBinCount);
+    let i = !1;
+    const s = () => {
+      this.remoteAnalyser?.getByteFrequencyData(n);
+      const a = n.reduce((l, d) => l + d, 0) / n.length, o = a >= this.volumeThreshold;
+      if (Math.random() < 0.01 && z.debug("Remote audio volume:", a, "threshold:", this.volumeThreshold, "above:", o), o)
+        if (i)
+          this.updateAgentState({ state: "speaking" });
+        else if (this.isFirstAgentSpeech && this.monitorStartTime !== null) {
+          const l = Math.round(performance.now() - this.monitorStartTime);
+          this.isFirstAgentSpeech = !1, this.thinkingStartTime = null, this.userSilenceStartTime = null, this.userSpeechStartTime = null, this.updateAgentState({ state: "speaking", greetingLatencyMs: l });
+        } else if (this.userSilenceStartTime !== null) {
+          const l = Math.round(performance.now() - this.userSilenceStartTime);
+          this.thinkingStartTime = null, this.userSilenceStartTime = null, this.maxLatencyMs === void 0 || l < this.maxLatencyMs ? this.updateAgentState({ state: "speaking", userPerceivedLatencyMs: l }) : this.updateAgentState({ state: "speaking" });
+        } else
+          this.updateAgentState({ state: "speaking" });
+      else
+        this.thinkingStartTime === null && this.updateAgentState({ state: "listening" });
+      i = o;
+    };
+    this.remoteIntervalId = window.setInterval(s, Dt);
+  }
+  /**
+   * Monitor local stream (user's microphone) for VAD
+   * Detects when user stops speaking (1000ms of silence) to start latency measurement
+   */
+  startLocalMonitor() {
+    if (!this.localStream) {
+      z.debug("Local monitor: no stream, skipping");
+      return;
+    }
+    this.localAudioContext = new AudioContext(), z.debug("Local AudioContext state:", this.localAudioContext.state), this.localAudioContext.state === "suspended" && (z.debug("Resuming suspended local AudioContext..."), this.localAudioContext.resume()), this.localSource = this.localAudioContext.createMediaStreamSource(
+      this.localStream
+    ), this.localAnalyser = this.localAudioContext.createAnalyser(), this.localSource.connect(this.localAnalyser), this.localAnalyser.fftSize = 512;
+    const e = new Uint8Array(this.localAnalyser.frequencyBinCount), n = () => {
+      this.localAnalyser?.getByteFrequencyData(e);
+      const i = e.reduce((a, o) => a + o, 0) / e.length;
+      if (Math.random() < 0.02 && z.debug("Local audio volume:", i), i >= this.volumeThreshold)
+        this.userIsSpeaking || (this.userIsSpeaking = !0, this.userSpeechStartTime = performance.now(), this.userSilenceStartTime = null), this.lastUserAudioTime = performance.now();
+      else if (this.userIsSpeaking && this.lastUserAudioTime !== null && (this.lastUserAudioTime - (this.userSpeechStartTime || this.lastUserAudioTime) >= this.minSpeechDurationMs && this.userSilenceStartTime === null && (this.userSilenceStartTime = this.lastUserAudioTime), performance.now() - this.lastUserAudioTime > this.silenceDurationMs)) {
+        this.userIsSpeaking = !1, this.userSpeechStartTime = null, this.thinkingStartTime = performance.now();
+        const l = (/* @__PURE__ */ new Date()).toISOString();
+        this.updateAgentState({ state: "thinking", thinkingStartedAt: l });
+      }
+    };
+    this.localIntervalId = window.setInterval(n, Dt);
+  }
+  destroy() {
+    this.stopAudioStreamMonitor();
+  }
+}
+function Ri(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  const e = t;
+  return e.method === "ai_conversation" && typeof e.params == "object";
+}
+function xi(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  const e = t;
+  return e.params.type !== "response.text.delta" ? !1 : !!e.params.delta;
+}
+function Li(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  const e = t;
+  return e.params.type !== "conversation.item.created" ? !1 : !!e.params.item.content;
+}
+function Oi(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  const e = t;
+  return e.params?.type !== "conversation.item.deleted" ? !1 : !!e.params.item_id;
+}
+function Mi(t) {
+  return xi(t) ? {
+    id: `${t.params.item_id}-${Date.now()}`,
+    role: "assistant",
+    content: t.params.delta,
+    timestamp: /* @__PURE__ */ new Date()
+  } : null;
+}
+function Pi(t) {
+  if (!Li(t) || t.params.item.role !== "user" || t.params.item.status !== "completed")
+    return null;
+  let e = "", n = [];
+  return Array.isArray(t.params.item.content) ? (e = t.params.item.content.reduce((i, s) => (s.type === "text" && (i += s.text), i), ""), n = t.params.item.content.reduce((i, s) => (s.type === "image_url" && s.image_url.url && i.push({ type: "image", url: s.image_url.url }), i), [])) : e = t.params.item.content, {
+    id: t.params.item.id,
+    role: t.params.item.role,
+    timestamp: /* @__PURE__ */ new Date(),
+    content: e,
+    attachments: n
+  };
+}
+class Di extends ft {
+  telnyxRTC;
+  transcript = [];
+  constructor(e) {
+    super(), this.telnyxRTC = e, this.telnyxRTC.on(L.SocketMessage, this.onSocketMessage);
+  }
+  onSocketMessage = (e) => {
+    if (Ri(e))
+      switch (e.params.type) {
+        case "response.text.delta": {
+          const n = Mi(e);
+          n && (this.transcript.push(n), this.emit("transcript.item", n), Fe.emit("conversation.agent.state", { state: "listening" }));
+          return;
+        }
+        case "conversation.item.deleted": {
+          if (Oi(e)) {
+            const n = e.params.item_id, i = this.transcript.findIndex((s) => s.id === n);
+            i !== -1 && this.transcript.splice(i, 1);
+          }
+          return;
+        }
+        case "conversation.item.created": {
+          const n = Pi(e);
+          if (n) {
+            const i = this.transcript.findIndex(
+              (s) => s.id === n.id
+            );
+            i !== -1 ? this.transcript[i] = n : this.transcript.push(n), this.emit("transcript.item", n);
+          }
+          return;
+        }
+      }
+  };
+}
+class Nt extends ft {
+  telnyxRTC;
+  transcription;
+  agentId;
+  versionId;
+  debug;
+  audioStreamMonitor;
+  activeCall;
+  constructor(e) {
+    super(), this.agentId = e.agentId, this.versionId = e.versionId || "main", this.debug = e.debug || !1, this.activeCall = null, z.setLevel(this.debug ? "debug" : "info"), this.telnyxRTC = new gi({
+      // @ts-expect-error hidden argument
+      environment: e.environment || "production",
+      anonymous_login: {
+        target_id: e.agentId,
+        target_type: "ai_assistant",
+        target_version_id: e.versionId
+      },
+      debug: e.debug || !1,
+      trickleIce: e.trickleIce
+    }), this.telnyxRTC.on(L.Ready, this.onClientReady), this.telnyxRTC.on(L.Error, this.onClientOrSocketError), this.telnyxRTC.on(L.SocketError, this.onClientOrSocketError), this.telnyxRTC.on(L.Notification, this.onNotification), this.transcription = new Di(this.telnyxRTC), this.transcription.addListener("transcript.item", this.onTranscriptItem), Fe.addListener(
+      "conversation.agent.state",
+      this.onAgentStateChange
+    ), this.audioStreamMonitor = new Ai(e.vad);
+  }
+  /**
+   * Connects to the Telnyx WebRTC service and establishes a session with the AI agent.
+   *
+   * @returns Promise that resolves when the connection is established
+   */
+  async connect() {
+    return this.telnyxRTC.connect();
+  }
+  /**
+   * Disconnects from the Telnyx WebRTC service and cleans up all event listeners.
+   * Emits an 'agent.disconnected' event before completing cleanup.
+   */
+  async disconnect() {
+    this.audioStreamMonitor.destroy(), this.telnyxRTC.disconnect(), this.telnyxRTC.off(L.Ready, this.onClientReady), this.telnyxRTC.off(L.Error, this.onClientOrSocketError), this.telnyxRTC.off(L.SocketError, this.onClientOrSocketError), this.telnyxRTC.off(L.Notification, this.onNotification), this.emit("agent.disconnected"), this.transcription.removeAllListeners(), Fe.removeAllListeners(), this.removeAllListeners();
+  }
+  /**
+   * Sends a text message to the AI agent during an active conversation.
+   * Requires an active conversation to be in progress.
+   *
+   * @param message - The text message to send to the AI agent
+   * @param attachments - Optional array of base64 encoded file attachments (defaults to empty array)
+   *
+   * @example
+   * client.sendConversationMessage('Hello, I need help with my account');
+   *
+   * @example
+   * // With attachments
+   * client.sendConversationMessage('Please review this document', ['base64EncodedData...']);
+   */
+  sendConversationMessage(e, n = []) {
+    if (!this.activeCall) {
+      z.error("No active call to send message.");
+      return;
+    }
+    this.activeCall.sendConversationMessage(e, n);
+  }
+  /**
+   * Gets the current conversation transcript.
+   *
+   * @returns Array of transcript items containing all messages exchanged during the conversation
+   */
+  get transcript() {
+    return this.transcription.transcript;
+  }
+  /**
+   * Initiates a conversation with the AI agent.
+   *
+   * @param options - Optional configuration for the call.
+   * Note: This method will ALWAYS call the AI agent, the optional parameters are primarily used for log referencing or passing parameters to the agent via the custom headers.
+   * @param options.destinationNumber - The destination phone number (defaults to "xxx"). Note, regardless of the destination number, the call will be made to the AI agent.
+   * @param options.callerNumber - The caller's phone number
+   * @param options.callerName - The caller's display name
+   * @param options.customHeaders - Custom SIP headers to pass to the AI agent. Headers with the `X-` prefix
+   * will be mapped to dynamic variables in the AI assistant (e.g., `X-Account-Number` becomes `{{account_number}}`).
+   * Note: Hyphens in header names are converted to underscores in variable names.
+   *
+   * @example
+   * // Start conversation with custom headers for dynamic variables
+   * client.startConversation({
+   *   callerName: 'John Doe',
+   *   customHeaders: [
+   *     { name: 'X-User-Name', value: 'user-name' },
+   *     { name: 'X-Agent-Session', value: 'session-abc' }
+   *   ]
+   * });
+   * // These headers will be available in your AI assistant as {{user_name}} and {{agent_session}}
+   * @param options.audio - Audio constraints for the call (boolean or MediaTrackConstraints)
+   */
+  async startConversation(e) {
+    if (!this.telnyxRTC) {
+      z.error("Client is not initialized.");
+      return;
+    }
+    const i = RTCRtpReceiver.getCapabilities("audio")?.codecs?.find(
+      (h) => h.mimeType.toLowerCase().includes("opus")
+    ), {
+      customHeaders: s,
+      audio: a,
+      ...o
+    } = e || {}, l = s ? [...s] : [];
+    this.versionId && l.push({
+      name: "X-AI-Assistant-Version-ID",
+      value: this.versionId
+    });
+    const d = this.telnyxRTC.newCall({
+      destinationNumber: "xxx",
+      ...o,
+      audio: a ?? !0,
+      preferred_codecs: [i],
+      customHeaders: l.length > 0 ? l : void 0
+    });
+    this.emit("conversation.update", { call: d, type: "callUpdate" });
+  }
+  /**
+   * Ends the current active conversation with the AI agent.
+   *
+   * @returns Promise that resolves when the call is hung up, or undefined if there is no active call
+   */
+  endConversation() {
+    return this.activeCall?.hangup();
+  }
+  /**
+   * Sets the remote audio stream for monitoring agent speech.
+   * Use this when call.remoteStream is not available and you need to provide
+   * the stream from the peer connection receiver.
+   *
+   * @param stream - The MediaStream containing the remote (agent) audio
+   */
+  setRemoteStream(e) {
+    this.audioStreamMonitor.setRemoteStream(e);
+  }
+  onClientReady = () => {
+    this.emit("agent.connected");
+  };
+  onClientOrSocketError = (e) => {
+    this.emit("agent.error", e);
+  };
+  onNotification = (e) => {
+    e.type !== "callUpdate" || !e.call || (this.emit("conversation.update", e), e.call.state === "active" ? (this.activeCall = e.call, e.call.remoteStream && this.audioStreamMonitor.setRemoteStream(e.call.remoteStream), e.call.localStream && this.audioStreamMonitor.setLocalStream(e.call.localStream)) : (this.activeCall = null, this.audioStreamMonitor.stopAudioStreamMonitor()));
+  };
+  onTranscriptItem = (e) => {
+    this.emit("transcript.item", e);
+  };
+  onAgentStateChange = (e) => {
+    this.emit("conversation.agent.state", e);
+  };
+}
+var Me = { exports: {} }, Se = {};
+var Ut;
+function Ni() {
+  if (Ut) return Se;
+  Ut = 1;
+  var t = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function n(i, s, a) {
+    var o = null;
+    if (a !== void 0 && (o = "" + a), s.key !== void 0 && (o = "" + s.key), "key" in s) {
+      a = {};
+      for (var l in s)
+        l !== "key" && (a[l] = s[l]);
+    } else a = s;
+    return s = a.ref, {
+      $$typeof: t,
+      type: i,
+      key: o,
+      ref: s !== void 0 ? s : null,
+      props: a
+    };
+  }
+  return Se.Fragment = e, Se.jsx = n, Se.jsxs = n, Se;
+}
+var _e = {};
+var jt;
+function Ui() {
+  return jt || (jt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(v) {
+      if (v == null) return null;
+      if (typeof v == "function")
+        return v.$$typeof === u ? null : v.displayName || v.name || null;
+      if (typeof v == "string") return v;
+      switch (v) {
+        case p:
+          return "Fragment";
+        case A:
+          return "Profiler";
+        case _:
+          return "StrictMode";
+        case q:
+          return "Suspense";
+        case B:
+          return "SuspenseList";
+        case c:
+          return "Activity";
+      }
+      if (typeof v == "object")
+        switch (typeof v.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), v.$$typeof) {
+          case k:
+            return "Portal";
+          case P:
+            return v.displayName || "Context";
+          case E:
+            return (v._context.displayName || "Context") + ".Consumer";
+          case D:
+            var M = v.render;
+            return v = v.displayName, v || (v = M.displayName || M.name || "", v = v !== "" ? "ForwardRef(" + v + ")" : "ForwardRef"), v;
+          case x:
+            return M = v.displayName || null, M !== null ? M : t(v.type) || "Memo";
+          case r:
+            M = v._payload, v = v._init;
+            try {
+              return t(v(M));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function e(v) {
+      return "" + v;
+    }
+    function n(v) {
+      try {
+        e(v);
+        var M = !1;
+      } catch {
+        M = !0;
+      }
+      if (M) {
+        M = console;
+        var U = M.error, V = typeof Symbol == "function" && Symbol.toStringTag && v[Symbol.toStringTag] || v.constructor.name || "Object";
+        return U.call(
+          M,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          V
+        ), e(v);
+      }
+    }
+    function i(v) {
+      if (v === p) return "<>";
+      if (typeof v == "object" && v !== null && v.$$typeof === r)
+        return "<...>";
+      try {
+        var M = t(v);
+        return M ? "<" + M + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function s() {
+      var v = g.A;
+      return v === null ? null : v.getOwner();
+    }
+    function a() {
+      return Error("react-stack-top-frame");
+    }
+    function o(v) {
+      if (b.call(v, "key")) {
+        var M = Object.getOwnPropertyDescriptor(v, "key").get;
+        if (M && M.isReactWarning) return !1;
+      }
+      return v.key !== void 0;
+    }
+    function l(v, M) {
+      function U() {
+        R || (R = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          M
+        ));
+      }
+      U.isReactWarning = !0, Object.defineProperty(v, "key", {
+        get: U,
+        configurable: !0
+      });
+    }
+    function d() {
+      var v = t(this.type);
+      return j[v] || (j[v] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), v = this.props.ref, v !== void 0 ? v : null;
+    }
+    function h(v, M, U, V, Y, Q) {
+      var W = U.ref;
+      return v = {
+        $$typeof: C,
+        type: v,
+        key: M,
+        props: U,
+        _owner: V
+      }, (W !== void 0 ? W : null) !== null ? Object.defineProperty(v, "ref", {
+        enumerable: !1,
+        get: d
+      }) : Object.defineProperty(v, "ref", { enumerable: !1, value: null }), v._store = {}, Object.defineProperty(v._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(v, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(v, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Y
+      }), Object.defineProperty(v, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Q
+      }), Object.freeze && (Object.freeze(v.props), Object.freeze(v)), v;
+    }
+    function f(v, M, U, V, Y, Q) {
+      var W = M.children;
+      if (W !== void 0)
+        if (V)
+          if (T(W)) {
+            for (V = 0; V < W.length; V++)
+              m(W[V]);
+            Object.freeze && Object.freeze(W);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else m(W);
+      if (b.call(M, "key")) {
+        W = t(v);
+        var re = Object.keys(M).filter(function(In) {
+          return In !== "key";
+        });
+        V = 0 < re.length ? "{key: someKey, " + re.join(": ..., ") + ": ...}" : "{key: someKey}", G[W + V] || (re = 0 < re.length ? "{" + re.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          V,
+          W,
+          re,
+          W
+        ), G[W + V] = !0);
+      }
+      if (W = null, U !== void 0 && (n(U), W = "" + U), o(M) && (n(M.key), W = "" + M.key), "key" in M) {
+        U = {};
+        for (var ze in M)
+          ze !== "key" && (U[ze] = M[ze]);
+      } else U = M;
+      return W && l(
+        U,
+        typeof v == "function" ? v.displayName || v.name || "Unknown" : v
+      ), h(
+        v,
+        W,
+        U,
+        s(),
+        Y,
+        Q
+      );
+    }
+    function m(v) {
+      S(v) ? v._store && (v._store.validated = 1) : typeof v == "object" && v !== null && v.$$typeof === r && (v._payload.status === "fulfilled" ? S(v._payload.value) && v._payload.value._store && (v._payload.value._store.validated = 1) : v._store && (v._store.validated = 1));
+    }
+    function S(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === C;
+    }
+    var w = ut, C = Symbol.for("react.transitional.element"), k = Symbol.for("react.portal"), p = Symbol.for("react.fragment"), _ = Symbol.for("react.strict_mode"), A = Symbol.for("react.profiler"), E = Symbol.for("react.consumer"), P = Symbol.for("react.context"), D = Symbol.for("react.forward_ref"), q = Symbol.for("react.suspense"), B = Symbol.for("react.suspense_list"), x = Symbol.for("react.memo"), r = Symbol.for("react.lazy"), c = Symbol.for("react.activity"), u = Symbol.for("react.client.reference"), g = w.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, b = Object.prototype.hasOwnProperty, T = Array.isArray, I = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    w = {
+      react_stack_bottom_frame: function(v) {
+        return v();
+      }
+    };
+    var R, j = {}, ee = w.react_stack_bottom_frame.bind(
+      w,
+      a
+    )(), ne = I(i(a)), G = {};
+    _e.Fragment = p, _e.jsx = function(v, M, U) {
+      var V = 1e4 > g.recentlyCreatedOwnerStacks++;
+      return f(
+        v,
+        M,
+        U,
+        !1,
+        V ? Error("react-stack-top-frame") : ee,
+        V ? I(i(v)) : ne
+      );
+    }, _e.jsxs = function(v, M, U) {
+      var V = 1e4 > g.recentlyCreatedOwnerStacks++;
+      return f(
+        v,
+        M,
+        U,
+        !0,
+        V ? Error("react-stack-top-frame") : ee,
+        V ? I(i(v)) : ne
+      );
+    };
+  })()), _e;
+}
+var Ft;
+function ji() {
+  return Ft || (Ft = 1, process.env.NODE_ENV === "production" ? Me.exports = Ni() : Me.exports = Ui()), Me.exports;
+}
+var we = ji();
+const ce = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 };
+function un(t) {
+  return "init" in t;
+}
+function rt(t) {
+  return !!t.write;
+}
+function $t(t) {
+  return "v" in t || "e" in t;
+}
+function $e(t) {
+  if ("e" in t)
+    throw t.e;
+  if ((ce ? "production" : void 0) !== "production" && !("v" in t))
+    throw new Error("[Bug] atom state is not initialized");
+  return t.v;
+}
+const Be = /* @__PURE__ */ new WeakMap();
+function hn(t) {
+  var e;
+  return Ve(t) && !!((e = Be.get(t)) != null && e[0]);
+}
+function Fi(t) {
+  const e = Be.get(t);
+  e?.[0] && (e[0] = !1, e[1].forEach((n) => n()));
+}
+function at(t, e) {
+  let n = Be.get(t);
+  if (!n) {
+    n = [!0, /* @__PURE__ */ new Set()], Be.set(t, n);
+    const i = () => {
+      n[0] = !1;
+    };
+    t.then(i, i);
+  }
+  n[1].add(e);
+}
+function Ve(t) {
+  return typeof t?.then == "function";
+}
+function pn(t, e, n) {
+  if (!n.p.has(t)) {
+    n.p.add(t);
+    const i = () => n.p.delete(t);
+    e.then(i, i);
+  }
+}
+function fn(t, e, n) {
+  var i;
+  const s = /* @__PURE__ */ new Set();
+  for (const a of ((i = n.get(t)) == null ? void 0 : i.t) || [])
+    s.add(a);
+  for (const a of e.p)
+    s.add(a);
+  return s;
+}
+const $i = (t, e, ...n) => e.read(...n), Bi = (t, e, ...n) => e.write(...n), Vi = (t, e) => {
+  if (e.INTERNAL_onInit)
+    return e.INTERNAL_onInit(t);
+  if (e.unstable_onInit)
+    return console.warn(
+      "[DEPRECATED] atom.unstable_onInit is renamed to atom.INTERNAL_onInit."
+    ), e.unstable_onInit(t);
+}, Gi = (t, e, n) => {
+  var i;
+  return (i = e.onMount) == null ? void 0 : i.call(e, n);
+}, Wi = (t, e) => {
+  var n;
+  const i = X(t), s = i[0], a = i[6], o = i[9];
+  if ((ce ? "production" : void 0) !== "production" && !e)
+    throw new Error("Atom is undefined or null");
+  let l = s.get(e);
+  return l || (l = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 }, s.set(e, l), (n = a.i) == null || n.call(a, e), o?.(t, e)), l;
+}, Hi = (t) => {
+  const e = X(t), n = e[1], i = e[3], s = e[4], a = e[5], o = e[6], l = e[13], d = [], h = (f) => {
+    try {
+      f();
+    } catch (m) {
+      d.push(m);
+    }
+  };
+  do {
+    o.f && h(o.f);
+    const f = /* @__PURE__ */ new Set(), m = f.add.bind(f);
+    i.forEach((S) => {
+      var w;
+      return (w = n.get(S)) == null ? void 0 : w.l.forEach(m);
+    }), i.clear(), a.forEach(m), a.clear(), s.forEach(m), s.clear(), f.forEach(h), i.size && l(t);
+  } while (i.size || a.size || s.size);
+  if (d.length)
+    throw new AggregateError(d);
+}, qi = (t) => {
+  const e = X(t), n = e[1], i = e[2], s = e[3], a = e[11], o = e[14], l = e[17], d = [], h = /* @__PURE__ */ new WeakSet(), f = /* @__PURE__ */ new WeakSet(), m = Array.from(s);
+  for (; m.length; ) {
+    const S = m[m.length - 1], w = a(t, S);
+    if (f.has(S)) {
+      m.pop();
+      continue;
+    }
+    if (h.has(S)) {
+      if (i.get(S) === w.n)
+        d.push([S, w]);
+      else if ((ce ? "production" : void 0) !== "production" && i.has(S))
+        throw new Error("[Bug] invalidated atom exists");
+      f.add(S), m.pop();
+      continue;
+    }
+    h.add(S);
+    for (const C of fn(S, w, n))
+      h.has(C) || m.push(C);
+  }
+  for (let S = d.length - 1; S >= 0; --S) {
+    const [w, C] = d[S];
+    let k = !1;
+    for (const p of C.d.keys())
+      if (p !== w && s.has(p)) {
+        k = !0;
+        break;
+      }
+    k && (o(t, w), l(t, w)), i.delete(w);
+  }
+}, ct = /* @__PURE__ */ new WeakSet(), Ji = (t, e) => {
+  var n, i;
+  const s = X(t), a = s[1], o = s[2], l = s[3], d = s[6], h = s[7], f = s[11], m = s[12], S = s[13], w = s[14], C = s[16], k = s[17], p = f(t, e);
+  if ($t(p)) {
+    if (a.has(e) && o.get(e) !== p.n)
+      return p;
+    let x = !1;
+    for (const [r, c] of p.d)
+      if (w(t, r).n !== c) {
+        x = !0;
+        break;
+      }
+    if (!x)
+      return p;
+  }
+  p.d.clear();
+  let _ = !0;
+  function A() {
+    a.has(e) && (k(t, e), S(t), m(t));
+  }
+  function E(x) {
+    var r;
+    if (x === e) {
+      const u = f(t, x);
+      if (!$t(u))
+        if (un(x))
+          Ge(t, x, x.init);
+        else
+          throw new Error("no atom init");
+      return $e(u);
+    }
+    const c = w(t, x);
+    try {
+      return $e(c);
+    } finally {
+      p.d.set(x, c.n), hn(p.v) && pn(e, p.v, c), a.has(e) && ((r = a.get(x)) == null || r.t.add(e)), _ || A();
+    }
+  }
+  let P, D;
+  const q = {
+    get signal() {
+      return P || (P = new AbortController()), P.signal;
+    },
+    get setSelf() {
+      return (ce ? "production" : void 0) !== "production" && !rt(e) && console.warn("setSelf function cannot be used with read-only atom"), !D && rt(e) && (D = (...x) => {
+        if ((ce ? "production" : void 0) !== "production" && _ && console.warn("setSelf function cannot be called in sync"), !_)
+          try {
+            return C(t, e, ...x);
+          } finally {
+            S(t), m(t);
+          }
+      }), D;
+    }
+  }, B = p.n;
+  try {
+    (ce ? "production" : void 0) !== "production" && ct.delete(t);
+    const x = h(t, e, E, q);
+    return (ce ? "production" : void 0) !== "production" && ct.has(t) && console.warn(
+      "Detected store mutation during atom read. This is not supported."
+    ), Ge(t, e, x), Ve(x) && (at(x, () => P?.abort()), x.then(A, A)), (n = d.r) == null || n.call(d, e), p;
+  } catch (x) {
+    return delete p.v, p.e = x, ++p.n, p;
+  } finally {
+    _ = !1, B !== p.n && o.get(e) === B && (o.set(e, p.n), l.add(e), (i = d.c) == null || i.call(d, e));
+  }
+}, Yi = (t, e) => {
+  const n = X(t), i = n[1], s = n[2], a = n[11], o = [e];
+  for (; o.length; ) {
+    const l = o.pop(), d = a(t, l);
+    for (const h of fn(l, d, i)) {
+      const f = a(t, h);
+      s.set(h, f.n), o.push(h);
+    }
+  }
+}, gn = (t, e, ...n) => {
+  const i = X(t), s = i[3], a = i[6], o = i[8], l = i[11], d = i[12], h = i[13], f = i[14], m = i[15], S = i[17];
+  let w = !0;
+  const C = (p) => $e(f(t, p)), k = (p, ..._) => {
+    var A;
+    const E = l(t, p);
+    try {
+      if (p === e) {
+        if (!un(p))
+          throw new Error("atom not writable");
+        (ce ? "production" : void 0) !== "production" && ct.add(t);
+        const P = E.n, D = _[0];
+        Ge(t, p, D), S(t, p), P !== E.n && (s.add(p), m(t, p), (A = a.c) == null || A.call(a, p));
+        return;
+      } else
+        return gn(t, p, ..._);
+    } finally {
+      w || (h(t), d(t));
+    }
+  };
+  try {
+    return o(t, e, C, k, ...n);
+  } finally {
+    w = !1;
+  }
+}, zi = (t, e) => {
+  var n;
+  const i = X(t), s = i[1], a = i[3], o = i[6], l = i[11], d = i[15], h = i[18], f = i[19], m = l(t, e), S = s.get(e);
+  if (S && !hn(m.v)) {
+    for (const [w, C] of m.d)
+      if (!S.d.has(w)) {
+        const k = l(t, w);
+        h(t, w).t.add(e), S.d.add(w), C !== k.n && (a.add(w), d(t, w), (n = o.c) == null || n.call(o, w));
+      }
+    for (const w of S.d)
+      if (!m.d.has(w)) {
+        S.d.delete(w);
+        const C = f(t, w);
+        C?.t.delete(e);
+      }
+  }
+}, mn = (t, e) => {
+  var n;
+  const i = X(t), s = i[1], a = i[4], o = i[6], l = i[10], d = i[11], h = i[12], f = i[13], m = i[14], S = i[16], w = d(t, e);
+  let C = s.get(e);
+  if (!C) {
+    m(t, e);
+    for (const k of w.d.keys())
+      mn(t, k).t.add(e);
+    if (C = {
+      l: /* @__PURE__ */ new Set(),
+      d: new Set(w.d.keys()),
+      t: /* @__PURE__ */ new Set()
+    }, s.set(e, C), rt(e)) {
+      const k = () => {
+        let p = !0;
+        const _ = (...A) => {
+          try {
+            return S(t, e, ...A);
+          } finally {
+            p || (f(t), h(t));
+          }
+        };
+        try {
+          const A = l(t, e, _);
+          A && (C.u = () => {
+            p = !0;
+            try {
+              A();
+            } finally {
+              p = !1;
+            }
+          });
+        } finally {
+          p = !1;
+        }
+      };
+      a.add(k);
+    }
+    (n = o.m) == null || n.call(o, e);
+  }
+  return C;
+}, Ki = (t, e) => {
+  var n, i;
+  const s = X(t), a = s[1], o = s[5], l = s[6], d = s[11], h = s[19], f = d(t, e);
+  let m = a.get(e);
+  if (!m || m.l.size)
+    return m;
+  let S = !1;
+  for (const w of m.t)
+    if ((n = a.get(w)) != null && n.d.has(e)) {
+      S = !0;
+      break;
+    }
+  if (!S) {
+    m.u && o.add(m.u), m = void 0, a.delete(e);
+    for (const w of f.d.keys()) {
+      const C = h(t, w);
+      C?.t.delete(e);
+    }
+    (i = l.u) == null || i.call(l, e);
+    return;
+  }
+  return m;
+}, Ge = (t, e, n) => {
+  const i = X(t)[11], s = i(t, e), a = "v" in s, o = s.v;
+  if (Ve(n))
+    for (const l of s.d.keys())
+      pn(
+        e,
+        n,
+        i(t, l)
+      );
+  s.v = n, delete s.e, (!a || !Object.is(o, s.v)) && (++s.n, Ve(o) && Fi(o));
+}, Qi = (t, e) => {
+  const n = X(t)[14];
+  return $e(n(t, e));
+}, Xi = (t, e, ...n) => {
+  const i = X(t), s = i[12], a = i[13], o = i[16];
+  try {
+    return o(t, e, ...n);
+  } finally {
+    a(t), s(t);
+  }
+}, Zi = (t, e, n) => {
+  const i = X(t), s = i[12], a = i[18], o = i[19], d = a(t, e).l;
+  return d.add(n), s(t), () => {
+    d.delete(n), o(t, e), s(t);
+  };
+}, vn = /* @__PURE__ */ new WeakMap(), X = (t) => {
+  const e = vn.get(t);
+  if ((ce ? "production" : void 0) !== "production" && !e)
+    throw new Error(
+      "Store must be created by buildStore to read its building blocks"
+    );
+  return e;
+};
+function es(...t) {
+  const e = {
+    get(i) {
+      const s = X(e)[21];
+      return s(e, i);
+    },
+    set(i, ...s) {
+      const a = X(e)[22];
+      return a(e, i, ...s);
+    },
+    sub(i, s) {
+      const a = X(e)[23];
+      return a(e, i, s);
+    }
+  }, n = [
+    // store state
+    /* @__PURE__ */ new WeakMap(),
+    // atomStateMap
+    /* @__PURE__ */ new WeakMap(),
+    // mountedMap
+    /* @__PURE__ */ new WeakMap(),
+    // invalidatedAtoms
+    /* @__PURE__ */ new Set(),
+    // changedAtoms
+    /* @__PURE__ */ new Set(),
+    // mountCallbacks
+    /* @__PURE__ */ new Set(),
+    // unmountCallbacks
+    {},
+    // storeHooks
+    // atom interceptors
+    $i,
+    Bi,
+    Vi,
+    Gi,
+    // building-block functions
+    Wi,
+    Hi,
+    qi,
+    Ji,
+    Yi,
+    gn,
+    zi,
+    mn,
+    Ki,
+    Ge,
+    Qi,
+    Xi,
+    Zi,
+    void 0
+  ].map((i, s) => t[s] || i);
+  return vn.set(e, Object.freeze(n)), e;
+}
+const yn = {};
+let ts = 0;
+function He(t, e) {
+  const n = `atom${++ts}`, i = {
+    toString() {
+      return (yn ? "production" : void 0) !== "production" && this.debugLabel ? n + ":" + this.debugLabel : n;
+    }
+  };
+  return typeof t == "function" ? i.read = t : (i.init = t, i.read = ns, i.write = is), i;
+}
+function ns(t) {
+  return t(this);
+}
+function is(t, e, n) {
+  return e(
+    this,
+    typeof n == "function" ? n(t(this)) : n
+  );
+}
+function ss() {
+  return es();
+}
+let Ce;
+function os() {
+  return Ce || (Ce = ss(), (yn ? "production" : void 0) !== "production" && (globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = Ce), globalThis.__JOTAI_DEFAULT_STORE__ !== Ce && console.warn(
+    "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+  ))), Ce;
+}
+const rs = {}, as = Gt(
+  void 0
+);
+function bn(t) {
+  return Vt(as) || os();
+}
+const lt = (t) => typeof t?.then == "function", dt = (t) => {
+  t.status || (t.status = "pending", t.then(
+    (e) => {
+      t.status = "fulfilled", t.value = e;
+    },
+    (e) => {
+      t.status = "rejected", t.reason = e;
+    }
+  ));
+}, cs = ut.use || // A shim for older React versions
+((t) => {
+  if (t.status === "pending")
+    throw t;
+  if (t.status === "fulfilled")
+    return t.value;
+  throw t.status === "rejected" ? t.reason : (dt(t), t);
+}), Ze = /* @__PURE__ */ new WeakMap(), Bt = (t, e) => {
+  let n = Ze.get(t);
+  return n || (n = new Promise((i, s) => {
+    let a = t;
+    const o = (h) => (f) => {
+      a === h && i(f);
+    }, l = (h) => (f) => {
+      a === h && s(f);
+    }, d = () => {
+      try {
+        const h = e();
+        lt(h) ? (Ze.set(h, n), a = h, h.then(o(h), l(h)), at(h, d)) : i(h);
+      } catch (h) {
+        s(h);
+      }
+    };
+    t.then(o(t), l(t)), at(t, d);
+  }), Ze.set(t, n)), n;
+};
+function qe(t, e) {
+  const { delay: n, unstable_promiseStatus: i = !ut.use } = {}, s = bn(), [[a, o, l], d] = En(
+    (f) => {
+      const m = s.get(t);
+      return Object.is(f[0], m) && f[1] === s && f[2] === t ? f : [m, s, t];
+    },
+    void 0,
+    () => [s.get(t), s, t]
+  );
+  let h = a;
+  if ((o !== s || l !== t) && (d(), h = s.get(t)), pe(() => {
+    const f = s.sub(t, () => {
+      if (i)
+        try {
+          const m = s.get(t);
+          lt(m) && dt(
+            Bt(m, () => s.get(t))
+          );
+        } catch {
+        }
+      if (typeof n == "number") {
+        setTimeout(d, n);
+        return;
+      }
+      d();
+    });
+    return d(), f;
+  }, [s, t, n, i]), Tn(h), lt(h)) {
+    const f = Bt(h, () => s.get(t));
+    return i && dt(f), cs(f);
+  }
+  return h;
+}
+function Je(t, e) {
+  const n = bn();
+  return An(
+    (...s) => {
+      if ((rs ? "production" : void 0) !== "production" && !("write" in t))
+        throw new Error("not writable atom");
+      return n.set(t, ...s);
+    },
+    [n, t]
+  );
+}
+const Sn = He([]);
+function ys() {
+  return qe(Sn);
+}
+function ls() {
+  return Je(Sn);
+}
+const Ye = () => {
+  const t = Vt(kn);
+  if (!t)
+    throw new Error("useClient must be used within a TelnyxAIAgentProvider");
+  return t;
+};
+function ds() {
+  const t = Ye(), e = ls();
+  return pe(() => {
+    const n = (i) => e((s) => [...s, i]);
+    return t.addListener("transcript.item", n), () => {
+      t.removeListener("transcript.item", n);
+    };
+  }, [t, e]), null;
+}
+const _n = He("connecting");
+function bs() {
+  return qe(_n);
+}
+function us() {
+  return Je(_n);
+}
+function hs() {
+  const t = Ye(), e = us();
+  return pe(() => {
+    const n = () => e("connected"), i = () => e("disconnected"), s = () => e("error");
+    return t.addListener("agent.connected", n), t.addListener("agent.disconnected", i), t.addListener("agent.error", s), () => {
+      t.removeListener("agent.connected", n), t.removeListener("agent.disconnected", i), t.removeListener("agent.error", s);
+    };
+  }, [t, e]), null;
+}
+const wn = He(null);
+function Ss() {
+  return qe(wn);
+}
+function ps() {
+  return Je(wn);
+}
+const fs = () => {
+  const t = Ye(), e = ps();
+  return pe(() => {
+    const n = (i) => {
+      e(i);
+    };
+    return t.addListener("conversation.update", n), () => {
+      t.removeListener("conversation.update", n);
+    };
+  }, [t, e]), null;
+}, Cn = He({ state: "listening" });
+function _s() {
+  return qe(Cn);
+}
+function gs() {
+  return Je(Cn);
+}
+function ms() {
+  const t = Ye(), e = gs();
+  return pe(() => {
+    const n = (i) => {
+      e(i);
+    };
+    return t.addListener("conversation.agent.state", n), () => {
+      t.removeListener("conversation.agent.state", n);
+    };
+  }, [t, e]), null;
+}
+const kn = Gt(null), ws = ({
+  children: t,
+  agentId: e,
+  environment: n,
+  versionId: i,
+  debug: s,
+  vad: a
+}) => {
+  const [o, l] = Rn(() => new Nt({ agentId: e, environment: n, versionId: i, debug: s, vad: a }));
+  return pe(() => {
+    if (!o) {
+      const d = new Nt({ agentId: e, environment: n, versionId: i, vad: a });
+      return l(d), () => {
+        d.disconnect();
+      };
+    }
+  }, [e, o, n, i, a]), pe(() => {
+    o?.connect();
+  }, [o]), /* @__PURE__ */ we.jsxs(kn.Provider, { value: o, children: [
+    /* @__PURE__ */ we.jsx(ds, {}),
+    /* @__PURE__ */ we.jsx(hs, {}),
+    /* @__PURE__ */ we.jsx(fs, {}),
+    /* @__PURE__ */ we.jsx(ms, {}),
+    t
+  ] });
+};
+export {
+  kn as ClientContext,
+  L as SwEvent,
+  Nt as TelnyxAIAgent,
+  ws as TelnyxAIAgentProvider,
+  _s as useAgentState,
+  Ye as useClient,
+  bs as useConnectionState,
+  Ss as useConversation,
+  gs as useSetAgentState,
+  us as useSetConnectionState,
+  ps as useSetConversation,
+  ls as useSetTranscript,
+  ys as useTranscript
+};