sip-connector 9.2.1 → 10.0.1

package/dist/SipConnector-JHUHYEf2.js

@@ -0,0 +1,1309 @@
+var At = Object.defineProperty;
+var Rt = (s, e, t) => e in s ? At(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var o = (s, e, t) => Rt(s, typeof e != "symbol" ? e + "" : e, t);
+import { CancelableRequest as g, isCanceledError as It } from "@krivega/cancelable-promise";
+import De from "events-constructor";
+import { repeatedCallsAsync as pe } from "repeated-calls";
+import x from "debug";
+const ft = "Connection Error", Le = "Request Timeout", mt = "SIP Failure Code", Pt = "Internal Error", Ot = "Busy", He = "Rejected", Dt = "Redirected", pt = "Unavailable", Mt = "Not Found", vt = "Address Incomplete", yt = "Incompatible SDP", wt = "Missing SDP", bt = "Authentication Error", We = "Terminated", Ut = "WebRTC Error", ke = "Canceled", Lt = "No Answer", Ht = "Expires", Wt = "No ACK", kt = "Dialog Error", Bt = "User Denied Media Access", qt = "Bad Media Description", Ft = "RTP Timeout", cs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ADDRESS_INCOMPLETE: vt,
+  AUTHENTICATION_ERROR: bt,
+  BAD_MEDIA_DESCRIPTION: qt,
+  BUSY: Ot,
+  BYE: We,
+  CANCELED: ke,
+  CONNECTION_ERROR: ft,
+  DIALOG_ERROR: kt,
+  EXPIRES: Ht,
+  INCOMPATIBLE_SDP: yt,
+  INTERNAL_ERROR: Pt,
+  MISSING_SDP: wt,
+  NOT_FOUND: Mt,
+  NO_ACK: Wt,
+  NO_ANSWER: Lt,
+  REDIRECTED: Dt,
+  REJECTED: He,
+  REQUEST_TIMEOUT: Le,
+  RTP_TIMEOUT: Ft,
+  SIP_FAILURE_CODE: mt,
+  UNAVAILABLE: pt,
+  USER_DENIED_MEDIA_ACCESS: Bt,
+  WEBRTC_ERROR: Ut
+}, Symbol.toStringTag, { value: "Module" })), V = "incomingCall", Y = "declinedIncomingCall", G = "failedIncomingCall", $ = "terminatedIncomingCall", H = "connecting", f = "connected", S = "disconnected", M = "newRTCSession", m = "registered", J = "unregistered", P = "registrationFailed", Be = "newMessage", X = "sipEvent", z = "availableSecondRemoteStream", Q = "notAvailableSecondRemoteStream", j = "mustStopPresentation", v = "shareState", K = "enterRoom", Z = "useLicense", ee = "peerconnection:confirmed", te = "peerconnection:ontrack", y = "channels", ne = "channels:notify", se = "ended:fromserver", ie = "main-cam-control", oe = "admin-stop-main-cam", re = "admin-start-main-cam", ae = "admin-stop-mic", ce = "admin-start-mic", w = "admin-force-sync-media-state", _e = "participant:added-to-list-moderators", Ee = "participant:removed-from-list-moderators", de = "participant:move-request-to-stream", he = "participant:move-request-to-spectators", le = "participation:accepting-word-request", Te = "participation:cancelling-word-request", ue = "webcast:started", Se = "webcast:stopped", Ne = "account:changed", ge = "account:deleted", Ce = "conference:participant-token-issued", O = "ended", qe = "sending", Fe = "reinvite", xe = "replaces", Ve = "refer", Ye = "progress", Ge = "accepted", b = "confirmed", U = "peerconnection", A = "failed", $e = "muted", Je = "unmuted", Ae = "newDTMF", Re = "newInfo", Xe = "hold", ze = "unhold", Qe = "update", je = "sdp", Ke = "icecandidate", Ze = "getusermediafailed", et = "peerconnection:createofferfailed", tt = "peerconnection:createanswerfailed", nt = "peerconnection:setlocaldescriptionfailed", st = "peerconnection:setremotedescriptionfailed", it = "presentation:start", ot = "presentation:started", rt = "presentation:end", Ie = "presentation:ended", L = "presentation:failed", at = "SPECTATOR", ct = 1e6, _s = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ACCEPTED: Ge,
+  ACCOUNT_CHANGED: Ne,
+  ACCOUNT_DELETED: ge,
+  ADMIN_FORCE_SYNC_MEDIA_STATE: w,
+  ADMIN_START_MAIN_CAM: re,
+  ADMIN_START_MIC: ce,
+  ADMIN_STOP_MAIN_CAM: oe,
+  ADMIN_STOP_MIC: ae,
+  AVAILABLE_SECOND_REMOTE_STREAM_EVENT: z,
+  CHANNELS: y,
+  CHANNELS_NOTIFY: ne,
+  CONFERENCE_PARTICIPANT_TOKEN_ISSUED: Ce,
+  CONFIRMED: b,
+  CONNECTED: f,
+  CONNECTING: H,
+  DECLINED_INCOMING_CALL: Y,
+  DISCONNECTED: S,
+  ENDED: O,
+  ENDED_FROM_SERVER: se,
+  ENTER_ROOM: K,
+  FAILED: A,
+  FAILED_INCOMING_CALL: G,
+  GET_USER_MEDIA_FAILED: Ze,
+  HOLD: Xe,
+  ICE_CANDIDATE: Ke,
+  INCOMING_CALL: V,
+  MAIN_CAM_CONTROL: ie,
+  MUST_STOP_PRESENTATION_EVENT: j,
+  MUTED: $e,
+  NEW_DTMF: Ae,
+  NEW_INFO: Re,
+  NEW_MESSAGE: Be,
+  NEW_RTC_SESSION: M,
+  NOT_AVAILABLE_SECOND_REMOTE_STREAM_EVENT: Q,
+  ONE_MEGABIT_IN_BITS: ct,
+  PARTICIPANT_ADDED_TO_LIST_MODERATORS: _e,
+  PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS: he,
+  PARTICIPANT_MOVE_REQUEST_TO_STREAM: de,
+  PARTICIPANT_REMOVED_FROM_LIST_MODERATORS: Ee,
+  PARTICIPATION_ACCEPTING_WORD_REQUEST: le,
+  PARTICIPATION_CANCELLING_WORD_REQUEST: Te,
+  PEER_CONNECTION: U,
+  PEER_CONNECTION_CONFIRMED: ee,
+  PEER_CONNECTION_CREATE_ANSWER_FAILED: tt,
+  PEER_CONNECTION_CREATE_OFFER_FAILED: et,
+  PEER_CONNECTION_ONTRACK: te,
+  PEER_CONNECTION_SET_LOCAL_DESCRIPTION_FAILED: nt,
+  PEER_CONNECTION_SET_REMOTE_DESCRIPTION_FAILED: st,
+  PRESENTATION_END: rt,
+  PRESENTATION_ENDED: Ie,
+  PRESENTATION_FAILED: L,
+  PRESENTATION_START: it,
+  PRESENTATION_STARTED: ot,
+  PROGRESS: Ye,
+  REFER: Ve,
+  REGISTERED: m,
+  REGISTRATION_FAILED: P,
+  REINVITE: Fe,
+  REPLACES: xe,
+  SDP: je,
+  SENDING: qe,
+  SHARE_STATE: v,
+  SIP_EVENT: X,
+  SPECTATOR: at,
+  TERMINATED_INCOMING_CALL: $,
+  UNHOLD: ze,
+  UNMUTED: Je,
+  UNREGISTERED: J,
+  UPDATE: Qe,
+  USE_LICENSE: Z,
+  WEBCAST_STARTED: ue,
+  WEBCAST_STOPPED: Se
+}, Symbol.toStringTag, { value: "Module" })), _t = [
+  V,
+  Y,
+  $,
+  G,
+  le,
+  Te,
+  de,
+  ne,
+  Ce,
+  Ne,
+  ge,
+  ue,
+  Se,
+  _e,
+  Ee
+], fe = [
+  H,
+  f,
+  S,
+  M,
+  m,
+  J,
+  P,
+  Be,
+  X
+], Et = [
+  z,
+  Q,
+  j,
+  v,
+  K,
+  Z,
+  ee,
+  te,
+  y,
+  se,
+  ie,
+  re,
+  oe,
+  ae,
+  ce,
+  w,
+  he
+], me = [
+  O,
+  H,
+  qe,
+  Fe,
+  xe,
+  Ve,
+  Ye,
+  Ge,
+  b,
+  U,
+  A,
+  $e,
+  Je,
+  Ae,
+  Re,
+  Xe,
+  ze,
+  Qe,
+  je,
+  Ke,
+  Ze,
+  et,
+  tt,
+  nt,
+  st,
+  it,
+  ot,
+  rt,
+  Ie,
+  L
+], dt = [...fe, ..._t], ht = [
+  ...me,
+  ...Et
+], Es = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SESSION_EVENT_NAMES: ht,
+  SESSION_JSSIP_EVENT_NAMES: me,
+  SESSION_SYNTHETICS_EVENT_NAMES: Et,
+  UA_EVENT_NAMES: dt,
+  UA_JSSIP_EVENT_NAMES: fe,
+  UA_SYNTHETICS_EVENT_NAMES: _t
+}, Symbol.toStringTag, { value: "Module" })), xt = (s) => {
+  const e = [];
+  return s && e.push(`X-Vinteo-Remote: ${s}`), e;
+}, Vt = "content-type", Yt = "x-webrtc-enter-room", D = "application/vinteo.webrtc.sharedesktop", Gt = "application/vinteo.webrtc.roomname", $t = "application/vinteo.webrtc.channels", Jt = "application/vinteo.webrtc.mediastate", Xt = "application/vinteo.webrtc.refusal", Me = "application/vinteo.webrtc.maincam", zt = "application/vinteo.webrtc.mic", Qt = "application/vinteo.webrtc.uselic", jt = "X-WEBRTC-USE-LICENSE", Kt = "X-WEBRTC-PARTICIPANT-NAME", ve = "X-WEBRTC-INPUT-CHANNELS", ye = "X-WEBRTC-OUTPUT-CHANNELS", Zt = "X-WEBRTC-MAINCAM", en = "X-WEBRTC-MIC", we = "X-WEBRTC-SYNC", tn = "X-WEBRTC-MAINCAM-RESOLUTION", nn = "X-WEBRTC-MEDIA-STATE", sn = "X-Vinteo-Media-Type", on = "X-Vinteo-MainCam-State", rn = "X-Vinteo-Mic-State", an = "application/vinteo.webrtc.partstate", cn = "X-WEBRTC-PARTSTATE", _n = "application/vinteo.webrtc.notify", En = "X-VINTEO-NOTIFY", R = "x-webrtc-share-state", dn = `${R}: LETMESTARTPRESENTATION`, hn = `${R}: STOPPRESENTATION`, lt = "YOUCANRECEIVECONTENT", Tt = "CONTENTEND", ut = "YOUMUSTSTOPSENDCONTENT", ln = `${R}: ${ut}`, Tn = `${R}: ${lt}`, un = `${R}: ${Tt}`, Sn = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE", Nn = `${Sn}: LETMESTARTMAINCAM`, Pe = "sip-connector", k = x(Pe), ds = () => {
+  x.enable(Pe);
+}, hs = () => {
+  x.enable(`-${Pe}`);
+}, gn = (s, e) => {
+  s.getVideoTracks().forEach((n) => {
+    "contentHint" in n && n.contentHint !== e && (n.contentHint = e);
+  });
+}, p = (s, {
+  videoMode: e,
+  audioMode: t,
+  contentHint: n
+} = {}) => {
+  if (!s || e === "recvonly" && t === "recvonly")
+    return;
+  const i = t === "recvonly" ? [] : s.getAudioTracks(), r = e === "recvonly" ? [] : s.getVideoTracks(), a = [...i, ...r], c = new MediaStream(a);
+  return c.getTracks = () => [...c.getAudioTracks(), ...c.getVideoTracks()], n && n !== "none" && gn(c, n), c;
+};
+var I = /* @__PURE__ */ ((s) => (s.PAUSE_MAIN_CAM = "PAUSEMAINCAM", s.RESUME_MAIN_CAM = "RESUMEMAINCAM", s.MAX_MAIN_CAM_RESOLUTION = "MAXMAINCAMRESOLUTION", s.ADMIN_STOP_MAIN_CAM = "ADMINSTOPMAINCAM", s.ADMIN_START_MAIN_CAM = "ADMINSTARTMAINCAM", s))(I || {}), B = /* @__PURE__ */ ((s) => (s.ADMIN_STOP_MIC = "ADMINSTOPMIC", s.ADMIN_START_MIC = "ADMINSTARTMIC", s))(B || {}), q = /* @__PURE__ */ ((s) => (s.ADMIN_SYNC_FORCED = "1", s.ADMIN_SYNC_NOT_FORCED = "0", s))(q || {}), Cn = /* @__PURE__ */ ((s) => (s.AUDIO = "AUDIO", s.VIDEO = "VIDEO", s.AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION", s))(Cn || {});
+function An(s) {
+  return (e) => `sip:${e}@${s}`;
+}
+const Rn = (s, e) => () => Math.floor(Math.random() * (e - s)) + s, be = (s) => s.trim().replaceAll(" ", "_"), In = Rn(1e5, 99999999), fn = (s) => s.some((t) => {
+  const { kind: n } = t;
+  return n === "video";
+}), mn = "Error decline with 603", Pn = 1006, On = (s) => typeof s == "object" && s !== null && "code" in s && s.code === Pn, Dn = (s) => s.message === mn, pn = (s, e) => s.find((t) => t.track && e.getTracks().includes(t.track)), Mn = (s, e) => (s.degradationPreference = e.degradationPreference, s), vn = (s, e) => {
+  s.encodings === void 0 && (s.encodings = []);
+  for (let t = s.encodings.length; t < e; t += 1)
+    s.encodings.push({});
+  return s;
+}, St = (s) => (e, t) => t !== void 0 && e !== t || t === void 0 && e !== s, yn = St(), wn = (s, e) => {
+  if (yn(s, e))
+    return s;
+}, bn = (s, e) => {
+  const t = s.maxBitrate, n = wn(e, t);
+  return n !== void 0 && (s.maxBitrate = n), s;
+}, Nt = 1, Un = St(
+  Nt
+), Ln = (s, e) => {
+  const t = s === void 0 ? void 0 : Math.max(s, Nt);
+  if (t !== void 0 && Un(
+    t,
+    e
+  ))
+    return t;
+}, Hn = (s, e) => {
+  const t = s.scaleResolutionDownBy, n = Ln(
+    e,
+    t
+  );
+  return n !== void 0 && (s.scaleResolutionDownBy = n), s;
+}, Wn = (s, e) => {
+  var n;
+  const t = ((n = e.encodings) == null ? void 0 : n.length) ?? 0;
+  return vn(s, t), s.encodings.forEach((i, r) => {
+    const a = ((e == null ? void 0 : e.encodings) ?? [])[r], c = a == null ? void 0 : a.maxBitrate, E = a == null ? void 0 : a.scaleResolutionDownBy;
+    bn(i, c), Hn(i, E);
+  }), s;
+}, kn = (s, e) => {
+  var t, n, i, r, a, c, E, d;
+  if (((t = s.codecs) == null ? void 0 : t.length) !== ((n = e.codecs) == null ? void 0 : n.length))
+    return !0;
+  for (let _ = 0; _ < (((i = s.codecs) == null ? void 0 : i.length) ?? 0); _++)
+    if (JSON.stringify(s.codecs[_]) !== JSON.stringify(e.codecs[_]))
+      return !0;
+  if (((r = s.headerExtensions) == null ? void 0 : r.length) !== ((a = e.headerExtensions) == null ? void 0 : a.length))
+    return !0;
+  for (let _ = 0; _ < (((c = s.headerExtensions) == null ? void 0 : c.length) ?? 0); _++)
+    if (JSON.stringify(s.headerExtensions[_]) !== JSON.stringify(e.headerExtensions[_]))
+      return !0;
+  if (((E = s.encodings) == null ? void 0 : E.length) !== ((d = e.encodings) == null ? void 0 : d.length))
+    return !0;
+  for (let _ = 0; _ < (s.encodings.length ?? 0); _++)
+    if (JSON.stringify(s.encodings[_]) !== JSON.stringify(e.encodings[_]))
+      return !0;
+  return s.rtcp.cname !== e.rtcp.cname || s.rtcp.reducedSize !== e.rtcp.reducedSize || s.degradationPreference !== e.degradationPreference;
+}, Bn = async (s, e) => {
+  const t = s.getParameters(), n = JSON.parse(JSON.stringify(t));
+  Wn(t, e), Mn(t, e);
+  const i = kn(n, t);
+  return i && await s.setParameters(t), { parameters: t, isChanged: i };
+}, qn = async (s, e, t) => {
+  const { isChanged: n, parameters: i } = await Bn(s, {
+    encodings: [
+      {
+        scaleResolutionDownBy: e.scaleResolutionDownBy,
+        maxBitrate: e.maxBitrate
+      }
+    ]
+  });
+  return n && t && t(i), { isChanged: n, parameters: i };
+}, Fn = async (s, e, t) => {
+  const n = pn(s, e);
+  if (n)
+    return qn(n, { maxBitrate: t });
+}, xn = 486, Vn = 487, F = "local", Ue = "remote", Yn = 3, Gn = 1, ls = (s = new Error()) => {
+  const { originator: e, cause: t } = s;
+  return It(s) ? !0 : typeof t == "string" ? t === Le || t === He || e === F && (t === ke || t === We) : !1;
+}, C = "SipConnector", $n = "channels", Jn = "WebcastStarted", Xn = "WebcastStopped", zn = "accountChanged", Qn = "accountDeleted", jn = "addedToListModerators", Kn = "removedFromListModerators", Zn = "ParticipationRequestAccepted", es = "ParticipationRequestRejected", ts = "ParticipantMovedToWebcast", ns = "ConferenceParticipantTokenIssued";
+class Ts {
+  constructor({ JsSIP: e }) {
+    o(this, "_isRegisterConfig", !1);
+    o(this, "_connectionConfiguration", {});
+    o(this, "_remoteStreams", {});
+    o(this, "JsSIP");
+    o(this, "_sessionEvents");
+    o(this, "_uaEvents");
+    o(this, "_cancelableConnect");
+    o(this, "_cancelableConnectWithRepeatedCalls");
+    o(this, "_cancelableSendPresentationWithRepeatedCalls");
+    o(this, "_cancelableInitUa");
+    o(this, "_cancelableDisconnect");
+    o(this, "_cancelableSet");
+    o(this, "_cancelableCall");
+    o(this, "_cancelableAnswer");
+    o(this, "_cancelableSendDTMF");
+    o(this, "getSipServerUrl", (e) => e);
+    o(this, "promisePendingStartPresentation");
+    o(this, "promisePendingStopPresentation");
+    o(this, "ua");
+    o(this, "session");
+    o(this, "incomingSession");
+    o(this, "_streamPresentationCurrent");
+    o(this, "socket");
+    o(this, "connect", async (e, t) => (this._cancelRequests(), this._connectWithDuplicatedCalls(e, t)));
+    o(this, "initUa", async (e) => this._cancelableInitUa.request(e));
+    o(this, "set", async (e) => this._cancelableSet.request(e));
+    o(this, "call", async (e) => this._cancelableCall.request(e));
+    o(this, "disconnect", async () => (this._cancelRequests(), this._disconnectWithoutCancelRequests()));
+    o(this, "answerToIncomingCall", async (e) => this._cancelableAnswer.request(e));
+    o(this, "sendDTMF", async (e) => this._cancelableSendDTMF.request(e));
+    o(this, "hangUp", async () => (this._cancelRequests(), this._hangUpWithoutCancelRequests()));
+    o(this, "tryRegister", async () => {
+      if (!this.isRegisterConfig)
+        throw new Error("Config is not registered");
+      this._uaEvents.trigger(H, void 0);
+      try {
+        await this.unregister();
+      } catch (e) {
+        k("tryRegister", e);
+      }
+      return this.register();
+    });
+    o(this, "declineToIncomingCall", async ({ statusCode: e = Vn } = {}) => new Promise((t, n) => {
+      if (!this.isAvailableIncomingCall) {
+        n(new Error("no incomingSession"));
+        return;
+      }
+      const i = this.incomingSession, r = this.remoteCallerData;
+      this._cancelableCall.cancelRequest(), this._cancelableAnswer.cancelRequest(), this.removeIncomingSession(), this._uaEvents.trigger(Y, r), t(i.terminate({ status_code: e }));
+    }));
+    o(this, "busyIncomingCall", async () => this.declineToIncomingCall({ statusCode: xn }));
+    o(this, "removeIncomingSession", () => {
+      delete this.incomingSession;
+    });
+    o(this, "_connectWithDuplicatedCalls", async (e, { callLimit: t = Yn } = {}) => {
+      const n = async () => this._cancelableConnect.request(e), i = (r) => {
+        var d;
+        const c = !!((d = this.ua) != null && d.isConnected()) && this.hasEqualConnectionConfiguration(e), E = !!r && !On(r);
+        return c || E;
+      };
+      return this._cancelableConnectWithRepeatedCalls = pe({
+        targetFunction: n,
+        isComplete: i,
+        callLimit: t,
+        isRejectAsValid: !0,
+        isCheckBeforeCall: !1,
+        onAfterCancel: () => {
+          this._cancelableConnect.cancelRequest();
+        }
+      }), this._cancelableConnectWithRepeatedCalls.then((r) => {
+        if (r instanceof this.JsSIP.UA)
+          return r;
+        throw r;
+      });
+    });
+    o(this, "handleNewRTCSession", ({ originator: e, session: t }) => {
+      if (e === Ue) {
+        this.incomingSession = t;
+        const n = this.remoteCallerData;
+        t.on(A, (i) => {
+          this.removeIncomingSession(), i.originator === F ? this._uaEvents.trigger($, n) : this._uaEvents.trigger(G, n);
+        }), this._uaEvents.trigger(V, n);
+      }
+    });
+    o(this, "_connect", async (e) => this.initUa(e).then(async () => this._start()));
+    o(this, "_initUa", async ({
+      user: e,
+      password: t,
+      sipServerUrl: n,
+      sipWebSocketServerURL: i,
+      remoteAddress: r,
+      sessionTimers: a,
+      registerExpires: c,
+      connectionRecoveryMinInterval: E,
+      connectionRecoveryMaxInterval: d,
+      userAgent: _,
+      displayName: h = "",
+      register: l = !1,
+      extraHeaders: T = []
+    }) => {
+      if (!n)
+        throw new Error("sipServerUrl is required");
+      if (!i)
+        throw new Error("sipWebSocketServerURL is required");
+      if (l && !e)
+        throw new Error("user is required for authorized connection");
+      if (l && !t)
+        throw new Error("password is required for authorized connection");
+      this._connectionConfiguration = {
+        sipServerUrl: n,
+        displayName: h,
+        register: l,
+        user: e,
+        password: t
+      };
+      const { configuration: N, helpers: u } = this.createUaConfiguration({
+        user: e,
+        sipServerUrl: n,
+        sipWebSocketServerURL: i,
+        password: t,
+        displayName: h,
+        register: l,
+        sessionTimers: a,
+        registerExpires: c,
+        connectionRecoveryMinInterval: E,
+        connectionRecoveryMaxInterval: d,
+        userAgent: _
+      });
+      return this.getSipServerUrl = u.getSipServerUrl, this.socket = u.socket, this.ua && await this._disconnectWithoutCancelRequests(), this._isRegisterConfig = !!l, this.ua = this._createUa({ ...N, remoteAddress: r, extraHeaders: T }), this._uaEvents.eachTriggers((W, gt) => {
+        const Oe = fe.find((Ct) => Ct === gt);
+        Oe && this.ua && this.ua.on(Oe, W);
+      }), this.ua;
+    });
+    o(this, "_createUa", ({
+      remoteAddress: e,
+      extraHeaders: t = [],
+      ...n
+    }) => {
+      const i = new this.JsSIP.UA(n), a = [...e ? xt(e) : [], ...t];
+      return a.length > 0 && i.registrator().setExtraHeaders(a), i;
+    });
+    o(this, "_start", async () => new Promise((e, t) => {
+      const { ua: n } = this;
+      if (!n) {
+        t(new Error("this.ua is not initialized"));
+        return;
+      }
+      const i = () => {
+        c(), e(n);
+      }, r = (E) => {
+        c(), t(E);
+      }, a = () => {
+        this.isRegisterConfig ? (this.on(m, i), this.on(P, r)) : this.on(f, i), this.on(S, r);
+      }, c = () => {
+        this.off(m, i), this.off(P, r), this.off(f, i), this.off(S, r);
+      };
+      a(), this.on(M, this.handleNewRTCSession), n.start();
+    }));
+    o(this, "_set", async ({ displayName: e, password: t }) => new Promise((n, i) => {
+      const { ua: r } = this;
+      if (!r) {
+        i(new Error("this.ua is not initialized"));
+        return;
+      }
+      let a = !1, c = !1;
+      e !== void 0 && e !== this._connectionConfiguration.displayName && (a = r.set("display_name", be(e)), this._connectionConfiguration.displayName = e), t !== void 0 && t !== this._connectionConfiguration.password && (c = r.set("password", t), this._connectionConfiguration.password = t);
+      const E = a || c;
+      c && this.isRegisterConfig ? this.register().then(() => {
+        n(E);
+      }).catch((d) => {
+        i(d);
+      }) : E ? n(E) : i(new Error("nothing changed"));
+    }));
+    o(this, "_disconnectWithoutCancelRequests", async () => this._cancelableDisconnect.request());
+    o(this, "_disconnect", async () => {
+      this.off(M, this.handleNewRTCSession);
+      const e = new Promise((t) => {
+        this.once(S, () => {
+          delete this.ua, t();
+        });
+      });
+      return this.ua ? (await this._hangUpWithoutCancelRequests(), this.ua ? this.ua.stop() : this._uaEvents.trigger(S, void 0)) : this._uaEvents.trigger(S, void 0), e;
+    });
+    o(this, "_call", async ({
+      number: e,
+      mediaStream: t,
+      extraHeaders: n = [],
+      ontrack: i,
+      iceServers: r,
+      videoMode: a,
+      audioMode: c,
+      onAddedSender: E,
+      contentHint: d,
+      offerToReceiveAudio: _ = !0,
+      offerToReceiveVideo: h = !0
+    }) => new Promise((l, T) => {
+      const { ua: N } = this;
+      if (!N) {
+        T(new Error("this.ua is not initialized"));
+        return;
+      }
+      this._connectionConfiguration.number = e, this._connectionConfiguration.answer = !1, this._handleCall({ ontrack: i }).then(l).catch((u) => {
+        T(u);
+      }), this.session = N.call(this.getSipServerUrl(e), {
+        extraHeaders: n,
+        mediaStream: p(t, {
+          videoMode: a,
+          audioMode: c,
+          contentHint: d
+        }),
+        eventHandlers: this._sessionEvents.triggers,
+        videoMode: a,
+        audioMode: c,
+        onAddedSender: E,
+        pcConfig: {
+          iceServers: r
+        },
+        rtcOfferConstraints: {
+          offerToReceiveAudio: _,
+          offerToReceiveVideo: h
+        }
+      });
+    }));
+    o(this, "_answer", async ({
+      mediaStream: e,
+      ontrack: t,
+      extraHeaders: n = [],
+      iceServers: i,
+      videoMode: r,
+      audioMode: a,
+      onAddedSender: c,
+      contentHint: E
+    }) => new Promise((d, _) => {
+      if (!this.isAvailableIncomingCall) {
+        _(new Error("no incomingSession"));
+        return;
+      }
+      this.session = this.incomingSession, this.removeIncomingSession();
+      const { session: h } = this;
+      if (!h) {
+        _(new Error("No session established"));
+        return;
+      }
+      this._sessionEvents.eachTriggers((T, N) => {
+        const u = me.find((W) => W === N);
+        u && h.on(u, T);
+      }), this._connectionConfiguration.answer = !0, this._connectionConfiguration.number = h.remote_identity.uri.user, this._handleCall({ ontrack: t }).then(d).catch((T) => {
+        _(T);
+      });
+      const l = p(e, {
+        videoMode: r,
+        audioMode: a,
+        contentHint: E
+      });
+      h.answer({
+        extraHeaders: n,
+        videoMode: r,
+        audioMode: a,
+        onAddedSender: c,
+        mediaStream: l,
+        pcConfig: {
+          iceServers: i
+        }
+      });
+    }));
+    o(this, "_handleCall", async ({ ontrack: e }) => new Promise((t, n) => {
+      const i = () => {
+        this.onSession(U, _), this.onSession(b, h);
+      }, r = () => {
+        this.offSession(U, _), this.offSession(b, h);
+      }, a = () => {
+        this.onSession(A, E), this.onSession(O, E);
+      }, c = () => {
+        this.offSession(A, E), this.offSession(O, E);
+      }, E = (l) => {
+        r(), c(), n(l);
+      };
+      let d;
+      const _ = ({ peerconnection: l }) => {
+        d = l, d.ontrack = (T) => {
+          this._sessionEvents.trigger(te, d), e && e(T);
+        };
+      }, h = () => {
+        d && this._sessionEvents.trigger(ee, d), r(), c(), t(d);
+      };
+      i(), a();
+    }));
+    o(this, "_restoreSession", () => {
+      this._cancelRequestsAndResetPresentation(), delete this._connectionConfiguration.number, delete this.session, this._remoteStreams = {};
+    });
+    o(this, "_sendDTMF", async (e) => new Promise((t, n) => {
+      const { session: i } = this;
+      if (!i) {
+        n(new Error("No session established"));
+        return;
+      }
+      this.onceSession(Ae, ({ originator: r }) => {
+        r === F && t();
+      }), i.sendDTMF(e, {
+        duration: 120,
+        interToneGap: 600
+      });
+    }));
+    o(this, "_hangUpWithoutCancelRequests", async () => {
+      if (this.ua && this.session) {
+        const { session: e } = this;
+        if (this._streamPresentationCurrent)
+          try {
+            await this.stopPresentation();
+          } catch (t) {
+            k("error stop presentation: ", t);
+          }
+        if (this._restoreSession(), !e.isEnded())
+          return e.terminateAsync();
+      }
+    });
+    o(this, "_handleShareState", (e) => {
+      switch (e) {
+        case lt: {
+          this._sessionEvents.trigger(z, void 0);
+          break;
+        }
+        case Tt: {
+          this._sessionEvents.trigger(Q, void 0);
+          break;
+        }
+        case ut: {
+          this._sessionEvents.trigger(j, void 0);
+          break;
+        }
+      }
+    });
+    o(this, "_maybeTriggerChannels", (e) => {
+      const t = e.getHeader(ve), n = e.getHeader(ye);
+      if (t && n) {
+        const i = {
+          inputChannels: t,
+          outputChannels: n
+        };
+        this._sessionEvents.trigger(y, i);
+      }
+    });
+    o(this, "_handleNotify", (e) => {
+      switch (e.cmd) {
+        case $n: {
+          const t = e;
+          this._triggerChannelsNotify(t);
+          break;
+        }
+        case Jn: {
+          const t = e;
+          this._triggerWebcastStartedNotify(t);
+          break;
+        }
+        case Xn: {
+          const t = e;
+          this._triggerWebcastStoppedNotify(t);
+          break;
+        }
+        case jn: {
+          const t = e;
+          this._triggerAddedToListModeratorsNotify(t);
+          break;
+        }
+        case Kn: {
+          const t = e;
+          this._triggerRemovedFromListModeratorsNotify(t);
+          break;
+        }
+        case Zn: {
+          const t = e;
+          this._triggerParticipationAcceptingWordRequest(t);
+          break;
+        }
+        case es: {
+          const t = e;
+          this._triggerParticipationCancellingWordRequest(t);
+          break;
+        }
+        case ts: {
+          const t = e;
+          this._triggerParticipantMoveRequestToStream(t);
+          break;
+        }
+        case zn: {
+          this._triggerAccountChangedNotify();
+          break;
+        }
+        case Qn: {
+          this._triggerAccountDeletedNotify();
+          break;
+        }
+        case ns: {
+          const t = e;
+          this._triggerConferenceParticipantTokenIssued(t);
+          break;
+        }
+        default:
+          k("unknown cmd", e.cmd);
+      }
+    });
+    o(this, "_triggerRemovedFromListModeratorsNotify", ({
+      conference: e
+    }) => {
+      const t = {
+        conference: e
+      };
+      this._uaEvents.trigger(
+        Ee,
+        t
+      );
+    });
+    o(this, "_triggerAddedToListModeratorsNotify", ({ conference: e }) => {
+      const t = {
+        conference: e
+      };
+      this._uaEvents.trigger(_e, t);
+    });
+    o(this, "_triggerWebcastStartedNotify", ({ body: { conference: e, type: t } }) => {
+      const n = {
+        conference: e,
+        type: t
+      };
+      this._uaEvents.trigger(ue, n);
+    });
+    o(this, "_triggerWebcastStoppedNotify", ({ body: { conference: e, type: t } }) => {
+      const n = {
+        conference: e,
+        type: t
+      };
+      this._uaEvents.trigger(Se, n);
+    });
+    o(this, "_triggerAccountChangedNotify", () => {
+      this._uaEvents.trigger(Ne, void 0);
+    });
+    o(this, "_triggerAccountDeletedNotify", () => {
+      this._uaEvents.trigger(ge, void 0);
+    });
+    o(this, "_triggerConferenceParticipantTokenIssued", ({
+      body: { conference: e, participant: t, jwt: n }
+    }) => {
+      const i = {
+        conference: e,
+        participant: t,
+        jwt: n
+      };
+      this._uaEvents.trigger(
+        Ce,
+        i
+      );
+    });
+    o(this, "_triggerChannelsNotify", (e) => {
+      const t = e.input, n = e.output, i = {
+        inputChannels: t,
+        outputChannels: n
+      };
+      this._uaEvents.trigger(ne, i);
+    });
+    o(this, "_triggerParticipationAcceptingWordRequest", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this._uaEvents.trigger(le, t);
+    });
+    o(this, "_triggerParticipationCancellingWordRequest", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this._uaEvents.trigger(Te, t);
+    });
+    o(this, "_triggerParticipantMoveRequestToStream", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this._uaEvents.trigger(de, t);
+    });
+    o(this, "_triggerEnterRoom", (e) => {
+      const t = e.getHeader(Yt), n = e.getHeader(Kt);
+      this._sessionEvents.trigger(K, { room: t, participantName: n });
+    });
+    o(this, "_triggerShareState", (e) => {
+      const t = e.getHeader(R);
+      this._sessionEvents.trigger(v, t);
+    });
+    o(this, "_maybeTriggerParticipantMoveRequestToSpectators", (e) => {
+      e.getHeader(cn) === at && this._sessionEvents.trigger(he, void 0);
+    });
+    o(this, "_triggerMainCamControl", (e) => {
+      const t = e.getHeader(Zt), n = e.getHeader(we), i = n === q.ADMIN_SYNC_FORCED;
+      if (t === I.ADMIN_START_MAIN_CAM) {
+        this._sessionEvents.trigger(re, { isSyncForced: i });
+        return;
+      }
+      if (t === I.ADMIN_STOP_MAIN_CAM) {
+        this._sessionEvents.trigger(oe, { isSyncForced: i });
+        return;
+      }
+      (t === I.RESUME_MAIN_CAM || t === I.PAUSE_MAIN_CAM) && n && this._sessionEvents.trigger(w, { isSyncForced: i });
+      const r = e.getHeader(tn);
+      this._sessionEvents.trigger(ie, {
+        mainCam: t,
+        resolutionMainCam: r
+      });
+    });
+    o(this, "_triggerMicControl", (e) => {
+      const t = e.getHeader(en), i = e.getHeader(we) === q.ADMIN_SYNC_FORCED;
+      t === B.ADMIN_START_MIC ? this._sessionEvents.trigger(ce, { isSyncForced: i }) : t === B.ADMIN_STOP_MIC && this._sessionEvents.trigger(ae, { isSyncForced: i });
+    });
+    o(this, "_triggerUseLicense", (e) => {
+      const t = e.getHeader(jt);
+      this._sessionEvents.trigger(Z, t);
+    });
+    o(this, "_handleNewInfo", (e) => {
+      const { originator: t } = e;
+      if (t !== "remote")
+        return;
+      const { request: n } = e, i = n.getHeader(Vt);
+      if (i)
+        switch (i) {
+          case Gt: {
+            this._triggerEnterRoom(n), this._maybeTriggerChannels(n);
+            break;
+          }
+          case _n: {
+            this._maybeHandleNotify(n);
+            break;
+          }
+          case D: {
+            this._triggerShareState(n);
+            break;
+          }
+          case Me: {
+            this._triggerMainCamControl(n);
+            break;
+          }
+          case zt: {
+            this._triggerMicControl(n);
+            break;
+          }
+          case Qt: {
+            this._triggerUseLicense(n);
+            break;
+          }
+          case an: {
+            this._maybeTriggerParticipantMoveRequestToSpectators(n);
+            break;
+          }
+        }
+    });
+    o(this, "_handleSipEvent", ({ request: e }) => {
+      this._maybeHandleNotify(e);
+    });
+    o(this, "_maybeHandleNotify", (e) => {
+      const t = e.getHeader(En);
+      if (t) {
+        const n = JSON.parse(t);
+        this._handleNotify(n);
+      }
+    });
+    o(this, "_handleEnded", (e) => {
+      const { originator: t } = e;
+      t === Ue && this._sessionEvents.trigger(se, e), this._restoreSession();
+    });
+    this.JsSIP = e, this._sessionEvents = new De(ht), this._uaEvents = new De(dt), this._cancelableConnect = new g(
+      this._connect,
+      {
+        moduleName: C,
+        afterCancelRequest: () => {
+          this._cancelableInitUa.cancelRequest(), this._cancelableDisconnect.cancelRequest();
+        }
+      }
+    ), this._cancelableInitUa = new g(
+      this._initUa,
+      { moduleName: C }
+    ), this._cancelableDisconnect = new g(
+      this._disconnect,
+      { moduleName: C }
+    ), this._cancelableSet = new g(this._set, {
+      moduleName: C
+    }), this._cancelableCall = new g(
+      this._call,
+      { moduleName: C }
+    ), this._cancelableAnswer = new g(this._answer, { moduleName: C }), this._cancelableSendDTMF = new g(this._sendDTMF, { moduleName: C }), this.onSession(v, this._handleShareState), this.onSession(Re, this._handleNewInfo), this.on(X, this._handleSipEvent), this.onSession(A, this._handleEnded), this.onSession(O, this._handleEnded);
+  }
+  async register() {
+    return new Promise((e, t) => {
+      this.isRegisterConfig && this.ua ? (this.ua.on(m, e), this.ua.on(P, t), this.ua.register()) : t(new Error("Config is not registered"));
+    });
+  }
+  async unregister() {
+    return new Promise((e, t) => {
+      this.isRegistered && this.ua ? (this.ua.on(J, e), this.ua.unregister()) : t(new Error("ua is not registered"));
+    });
+  }
+  async sendOptions(e, t, n) {
+    if (!this.ua)
+      throw new Error("is not connected");
+    return new Promise((i, r) => {
+      try {
+        this.ua.sendOptions(e, t, {
+          extraHeaders: n,
+          eventHandlers: {
+            succeeded: () => {
+              i();
+            },
+            failed: r
+          }
+        });
+      } catch (a) {
+        r(a);
+      }
+    });
+  }
+  async ping(e, t) {
+    var i;
+    if (!((i = this.ua) != null && i.configuration.uri))
+      throw new Error("is not connected");
+    const n = this.ua.configuration.uri;
+    return this.sendOptions(n, e, t);
+  }
+  async checkTelephony({
+    userAgent: e,
+    displayName: t,
+    sipServerUrl: n,
+    sipWebSocketServerURL: i,
+    remoteAddress: r,
+    extraHeaders: a
+  }) {
+    return new Promise((c, E) => {
+      const { configuration: d } = this.createUaConfiguration({
+        sipWebSocketServerURL: i,
+        displayName: t,
+        userAgent: e,
+        sipServerUrl: n
+      }), _ = this._createUa({ ...d, remoteAddress: r, extraHeaders: a }), h = () => {
+        const T = new Error("Telephony is not available");
+        E(T);
+      };
+      _.once(S, h);
+      const l = () => {
+        _.removeAllListeners(), _.once(S, c), _.stop();
+      };
+      _.once(f, l), _.start();
+    });
+  }
+  async replaceMediaStream(e, t) {
+    if (!this.session)
+      throw new Error("No session established");
+    const { contentHint: n } = t || {}, i = p(e, { contentHint: n });
+    return this.session.replaceMediaStream(i, t);
+  }
+  async askPermissionToEnableCam(e = {}) {
+    if (!this.session)
+      throw new Error("No session established");
+    const t = [Nn];
+    return this.session.sendInfo(Me, void 0, {
+      noTerminateWhenError: !0,
+      ...e,
+      extraHeaders: t
+    }).catch((n) => {
+      if (Dn(n))
+        throw n;
+    });
+  }
+  get isPendingPresentation() {
+    return !!this.promisePendingStartPresentation || !!this.promisePendingStopPresentation;
+  }
+  async _sendPresentationWithDuplicatedCalls({
+    session: e,
+    stream: t,
+    presentationOptions: n,
+    options: i = {
+      callLimit: Gn
+    }
+  }) {
+    const r = async () => this._sendPresentation(e, t, n), a = () => !!this._streamPresentationCurrent;
+    return this._cancelableSendPresentationWithRepeatedCalls = pe({
+      targetFunction: r,
+      isComplete: a,
+      isRejectAsValid: !0,
+      ...i
+    }), this._cancelableSendPresentationWithRepeatedCalls.then((c) => c);
+  }
+  hasEqualConnectionConfiguration(e) {
+    var i;
+    const { configuration: t } = this.createUaConfiguration(e), n = (i = this.ua) == null ? void 0 : i.configuration;
+    return (n == null ? void 0 : n.password) === t.password && (n == null ? void 0 : n.register) === t.register && (n == null ? void 0 : n.uri.toString()) === t.uri && (n == null ? void 0 : n.display_name) === t.display_name && (n == null ? void 0 : n.user_agent) === t.user_agent && (n == null ? void 0 : n.sockets) === t.sockets && (n == null ? void 0 : n.session_timers) === t.session_timers && (n == null ? void 0 : n.register_expires) === t.register_expires && (n == null ? void 0 : n.connection_recovery_min_interval) === t.connection_recovery_min_interval && (n == null ? void 0 : n.connection_recovery_max_interval) === t.connection_recovery_max_interval;
+  }
+  createUaConfiguration({
+    user: e,
+    password: t,
+    sipWebSocketServerURL: n,
+    displayName: i = "",
+    sipServerUrl: r,
+    register: a = !1,
+    sessionTimers: c = !1,
+    registerExpires: E = 60 * 5,
+    // 5 minutes in sec
+    connectionRecoveryMinInterval: d = 2,
+    connectionRecoveryMaxInterval: _ = 6,
+    userAgent: h
+  }) {
+    if (a && !t)
+      throw new Error("password is required for authorized connection");
+    const l = a && e ? e.trim() : `${In()}`, T = An(r), N = T(l), u = new this.JsSIP.WebSocketInterface(n);
+    return {
+      configuration: {
+        password: t,
+        register: a,
+        uri: N,
+        display_name: be(i),
+        user_agent: h,
+        sdp_semantics: "unified-plan",
+        sockets: [u],
+        session_timers: c,
+        register_expires: E,
+        connection_recovery_min_interval: d,
+        connection_recovery_max_interval: _
+      },
+      helpers: {
+        socket: u,
+        getSipServerUrl: T
+      }
+    };
+  }
+  async _sendPresentation(e, t, {
+    maxBitrate: n = ct,
+    onAddedSender: i,
+    isNeedReinvite: r = !0,
+    isP2P: a = !1,
+    contentHint: c = "detail"
+  }) {
+    const E = p(t, { contentHint: c });
+    this._streamPresentationCurrent = E;
+    const d = a ? [Tn] : [dn], _ = e.sendInfo(D, void 0, {
+      extraHeaders: d
+    }).then(async () => e.startPresentation(E, r, i)).then(async () => {
+      const { connection: h } = this;
+      if (!h || n === void 0)
+        return;
+      const l = h.getSenders();
+      await Fn(l, t, n);
+    }).then(() => t).catch((h) => {
+      throw this._removeStreamPresentationCurrent(), this._sessionEvents.trigger(L, h), h;
+    });
+    return this.promisePendingStartPresentation = _, _.finally(() => {
+      this.promisePendingStartPresentation = void 0;
+    });
+  }
+  async startPresentation(e, {
+    isNeedReinvite: t,
+    isP2P: n,
+    maxBitrate: i,
+    onAddedSender: r,
+    contentHint: a
+  } = {}, c) {
+    const E = this.establishedSession;
+    if (!E)
+      throw new Error("No session established");
+    if (this._streamPresentationCurrent)
+      throw new Error("Presentation is already started");
+    return n && await this.sendMustStopPresentation(E), this._sendPresentationWithDuplicatedCalls({
+      session: E,
+      stream: e,
+      presentationOptions: {
+        isNeedReinvite: t,
+        isP2P: n,
+        maxBitrate: i,
+        onAddedSender: r,
+        contentHint: a
+      },
+      options: c
+    });
+  }
+  async sendMustStopPresentation(e) {
+    await e.sendInfo(D, void 0, {
+      extraHeaders: [ln]
+    });
+  }
+  async stopPresentation({
+    isP2P: e = !1
+  } = {}) {
+    this._cancelSendPresentationWithRepeatedCalls();
+    const t = this._streamPresentationCurrent;
+    let n = this.promisePendingStartPresentation ?? Promise.resolve();
+    const i = e ? [un] : [hn], r = this.establishedSession;
+    return r && t && (n = n.then(async () => r.sendInfo(D, void 0, {
+      extraHeaders: i
+    })).then(async () => r.stopPresentation(t)).catch((a) => {
+      throw this._sessionEvents.trigger(L, a), a;
+    })), !r && t && this._sessionEvents.trigger(Ie, t), this.promisePendingStopPresentation = n, n.finally(() => {
+      this._resetPresentation();
+    });
+  }
+  async updatePresentation(e, {
+    isP2P: t,
+    maxBitrate: n,
+    onAddedSender: i,
+    contentHint: r
+  } = {}) {
+    const a = this.establishedSession;
+    if (!a)
+      throw new Error("No session established");
+    if (!this._streamPresentationCurrent)
+      throw new Error("Presentation has not started yet");
+    return this.promisePendingStartPresentation && await this.promisePendingStartPresentation, this._sendPresentation(a, e, {
+      isP2P: t,
+      maxBitrate: n,
+      onAddedSender: i,
+      contentHint: r,
+      isNeedReinvite: !1
+    });
+  }
+  _removeStreamPresentationCurrent() {
+    delete this._streamPresentationCurrent;
+  }
+  _resetPresentation() {
+    this._removeStreamPresentationCurrent(), this.promisePendingStartPresentation = void 0, this.promisePendingStopPresentation = void 0;
+  }
+  _cancelRequestsAndResetPresentation() {
+    this._cancelSendPresentationWithRepeatedCalls(), this._resetPresentation();
+  }
+  on(e, t) {
+    return this._uaEvents.on(e, t);
+  }
+  once(e, t) {
+    return this._uaEvents.once(e, t);
+  }
+  onceRace(e, t) {
+    return this._uaEvents.onceRace(e, t);
+  }
+  async wait(e) {
+    return this._uaEvents.wait(e);
+  }
+  off(e, t) {
+    this._uaEvents.off(e, t);
+  }
+  onSession(e, t) {
+    return this._sessionEvents.on(e, t);
+  }
+  onceSession(e, t) {
+    return this._sessionEvents.once(e, t);
+  }
+  onceRaceSession(e, t) {
+    return this._sessionEvents.onceRace(e, t);
+  }
+  async waitSession(e) {
+    return this._sessionEvents.wait(e);
+  }
+  offSession(e, t) {
+    this._sessionEvents.off(e, t);
+  }
+  isConfigured() {
+    return !!this.ua;
+  }
+  getConnectionConfiguration() {
+    return { ...this._connectionConfiguration };
+  }
+  getRemoteStreams() {
+    if (!this.connection)
+      return;
+    const t = this.connection.getReceivers().map(({ track: n }) => n);
+    return fn(t) ? this._generateStreams(t) : this._generateAudioStreams(t);
+  }
+  get connection() {
+    var t;
+    return (t = this.session) == null ? void 0 : t.connection;
+  }
+  get remoteCallerData() {
+    var e, t, n, i, r, a;
+    return {
+      displayName: (t = (e = this.incomingSession) == null ? void 0 : e.remote_identity) == null ? void 0 : t.display_name,
+      host: (i = (n = this.incomingSession) == null ? void 0 : n.remote_identity) == null ? void 0 : i.uri.host,
+      incomingNumber: (a = (r = this.incomingSession) == null ? void 0 : r.remote_identity) == null ? void 0 : a.uri.user,
+      session: this.incomingSession
+    };
+  }
+  get requested() {
+    return this._cancelableConnect.requested || this._cancelableInitUa.requested || this._cancelableCall.requested || this._cancelableAnswer.requested;
+  }
+  get establishedSession() {
+    var e;
+    return (e = this.session) != null && e.isEstablished() ? this.session : void 0;
+  }
+  get isRegistered() {
+    return !!this.ua && this.ua.isRegistered();
+  }
+  get isRegisterConfig() {
+    return !!this.ua && this._isRegisterConfig;
+  }
+  get isCallActive() {
+    return !!(this.ua && this.session);
+  }
+  get isAvailableIncomingCall() {
+    return !!this.incomingSession;
+  }
+  _generateStream(e, t) {
+    const { id: n } = e, i = this._remoteStreams[n] || new MediaStream();
+    return t && i.addTrack(t), i.addTrack(e), this._remoteStreams[n] = i, i;
+  }
+  _generateAudioStream(e) {
+    const { id: t } = e, n = this._remoteStreams[t] || new MediaStream();
+    return n.addTrack(e), this._remoteStreams[t] = n, n;
+  }
+  _generateStreams(e) {
+    const t = [];
+    return e.forEach((n, i) => {
+      if (n.kind === "audio")
+        return;
+      const r = n, a = e[i - 1];
+      let c;
+      a && a.kind === "audio" && (c = a);
+      const E = this._generateStream(r, c);
+      t.push(E);
+    }), t;
+  }
+  _generateAudioStreams(e) {
+    return e.map((n) => this._generateAudioStream(n));
+  }
+  _cancelRequests() {
+    this._cancelActionsRequests(), this._cancelCallRequests(), this._cancelConnectWithRepeatedCalls();
+  }
+  _cancelConnectWithRepeatedCalls() {
+    var e;
+    (e = this._cancelableConnectWithRepeatedCalls) == null || e.cancel();
+  }
+  _cancelSendPresentationWithRepeatedCalls() {
+    var e;
+    (e = this._cancelableSendPresentationWithRepeatedCalls) == null || e.cancel();
+  }
+  _cancelCallRequests() {
+    this._cancelableCall.cancelRequest(), this._cancelableAnswer.cancelRequest();
+  }
+  _cancelActionsRequests() {
+    this._cancelableAnswer.cancelRequest(), this._cancelableSendDTMF.cancelRequest();
+  }
+  async waitChannels() {
+    return this.waitSession(y);
+  }
+  async waitSyncMediaState() {
+    return this.waitSession(w);
+  }
+  async sendChannels({ inputChannels: e, outputChannels: t }) {
+    if (!this.session)
+      throw new Error("No session established");
+    const n = `${ve}: ${e}`, i = `${ye}: ${t}`, r = [
+      n,
+      i
+    ];
+    return this.session.sendInfo($t, void 0, { extraHeaders: r });
+  }
+  async sendMediaState({ cam: e, mic: t }, n = {}) {
+    if (!this.session)
+      throw new Error("No session established");
+    const i = `${nn}: currentstate`, r = `${on}: ${Number(e)}`, a = `${rn}: ${Number(t)}`, c = [
+      i,
+      r,
+      a
+    ];
+    return this.session.sendInfo(Jt, void 0, {
+      noTerminateWhenError: !0,
+      ...n,
+      extraHeaders: c
+    });
+  }
+  async _sendRefusalToTurnOn(e, t = {}) {
+    if (!this.session)
+      throw new Error("No session established");
+    const c = [`${sn}: ${e === "mic" ? 0 : 1}`];
+    return this.session.sendInfo(Xt, void 0, {
+      noTerminateWhenError: !0,
+      ...t,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOnMic(e = {}) {
+    if (!this.session)
+      throw new Error("No session established");
+    return this._sendRefusalToTurnOn("mic", { noTerminateWhenError: !0, ...e });
+  }
+  async sendRefusalToTurnOnCam(e = {}) {
+    if (!this.session)
+      throw new Error("No session established");
+    return this._sendRefusalToTurnOn("cam", { noTerminateWhenError: !0, ...e });
+  }
+}
+export {
+  qt as B,
+  I as E,
+  Mt as N,
+  He as R,
+  Ts as S,
+  dt as U,
+  qn as a,
+  _s as b,
+  cs as c,
+  hs as d,
+  Es as e,
+  ds as f,
+  B as g,
+  ls as h,
+  q as i,
+  Cn as j,
+  ht as k,
+  k as l,
+  Bn as s
+};