sip-connector 14.1.2-1 → 14.1.2-2

package/dist/SipConnector-DTNc5BfW.js

@@ -0,0 +1,1352 @@
+var _t = Object.defineProperty;
+var At = (s, e, t) => e in s ? _t(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var r = (s, e, t) => At(s, typeof e != "symbol" ? e + "" : e, t);
+import { isCanceledError as Rt } from "@krivega/cancelable-promise";
+import pe from "events-constructor";
+import { repeatedCallsAsync as ve, hasCanceledError as ft } from "repeated-calls";
+import Y from "debug";
+const It = "Connection Error", He = "Request Timeout", Pt = "SIP Failure Code", mt = "Internal Error", Ot = "Busy", We = "Rejected", Mt = "Redirected", Dt = "Unavailable", pt = "Not Found", vt = "Address Incomplete", yt = "Incompatible SDP", wt = "Missing SDP", bt = "Authentication Error", ke = "Terminated", Lt = "WebRTC Error", q = "Canceled", Ut = "No Answer", Ht = "Expires", Wt = "No ACK", kt = "Dialog Error", Bt = "User Denied Media Access", xt = "Bad Media Description", Ft = "RTP Timeout", ds = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ADDRESS_INCOMPLETE: vt,
+  AUTHENTICATION_ERROR: bt,
+  BAD_MEDIA_DESCRIPTION: xt,
+  BUSY: Ot,
+  BYE: ke,
+  CANCELED: q,
+  CONNECTION_ERROR: It,
+  DIALOG_ERROR: kt,
+  EXPIRES: Ht,
+  INCOMPATIBLE_SDP: yt,
+  INTERNAL_ERROR: mt,
+  MISSING_SDP: wt,
+  NOT_FOUND: pt,
+  NO_ACK: Wt,
+  NO_ANSWER: Ut,
+  REDIRECTED: Mt,
+  REJECTED: We,
+  REQUEST_TIMEOUT: He,
+  RTP_TIMEOUT: Ft,
+  SIP_FAILURE_CODE: Pt,
+  UNAVAILABLE: Dt,
+  USER_DENIED_MEDIA_ACCESS: Bt,
+  WEBRTC_ERROR: Lt
+}, Symbol.toStringTag, { value: "Module" })), $ = "incomingCall", G = "declinedIncomingCall", J = "failedIncomingCall", X = "terminatedIncomingCall", W = "connecting", P = "connected", C = "disconnected", v = "newRTCSession", m = "registered", z = "unregistered", O = "registrationFailed", Be = "newMessage", Q = "sipEvent", j = "availableSecondRemoteStream", K = "notAvailableSecondRemoteStream", Z = "mustStopPresentation", y = "shareState", ee = "enterRoom", te = "useLicense", ne = "peerconnection:confirmed", se = "peerconnection:ontrack", w = "channels", ie = "channels:notify", oe = "ended:fromserver", re = "main-cam-control", ae = "admin-stop-main-cam", ce = "admin-start-main-cam", Ee = "admin-stop-mic", de = "admin-start-mic", b = "admin-force-sync-media-state", he = "participant:added-to-list-moderators", Se = "participant:removed-from-list-moderators", Te = "participant:move-request-to-stream", le = "participant:move-request-to-spectators", ue = "participant:move-request-to-participants", ge = "participation:accepting-word-request", Ce = "participation:cancelling-word-request", Ne = "webcast:started", _e = "webcast:stopped", Ae = "account:changed", Re = "account:deleted", fe = "conference:participant-token-issued", M = "ended", xe = "sending", Fe = "reinvite", Ve = "replaces", Ye = "refer", qe = "progress", $e = "accepted", L = "confirmed", U = "peerconnection", A = "failed", Ge = "muted", Je = "unmuted", Ie = "newDTMF", Pe = "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", me = "presentation:ended", H = "presentation:failed", at = "SPECTATOR", ct = "PARTICIPANT", Et = 1e6;
+var N = /* @__PURE__ */ ((s) => (s.LOCAL = "local", s.REMOTE = "remote", s.SYSTEM = "system", s))(N || {});
+const hs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ACCEPTED: $e,
+  ACCOUNT_CHANGED: Ae,
+  ACCOUNT_DELETED: Re,
+  ADMIN_FORCE_SYNC_MEDIA_STATE: b,
+  ADMIN_START_MAIN_CAM: ce,
+  ADMIN_START_MIC: de,
+  ADMIN_STOP_MAIN_CAM: ae,
+  ADMIN_STOP_MIC: Ee,
+  AVAILABLE_SECOND_REMOTE_STREAM_EVENT: j,
+  CHANNELS: w,
+  CHANNELS_NOTIFY: ie,
+  CONFERENCE_PARTICIPANT_TOKEN_ISSUED: fe,
+  CONFIRMED: L,
+  CONNECTED: P,
+  CONNECTING: W,
+  DECLINED_INCOMING_CALL: G,
+  DISCONNECTED: C,
+  ENDED: M,
+  ENDED_FROM_SERVER: oe,
+  ENTER_ROOM: ee,
+  FAILED: A,
+  FAILED_INCOMING_CALL: J,
+  GET_USER_MEDIA_FAILED: Ze,
+  HOLD: Xe,
+  ICE_CANDIDATE: Ke,
+  INCOMING_CALL: $,
+  MAIN_CAM_CONTROL: re,
+  MUST_STOP_PRESENTATION_EVENT: Z,
+  MUTED: Ge,
+  NEW_DTMF: Ie,
+  NEW_INFO: Pe,
+  NEW_MESSAGE: Be,
+  NEW_RTC_SESSION: v,
+  NOT_AVAILABLE_SECOND_REMOTE_STREAM_EVENT: K,
+  ONE_MEGABIT_IN_BITS: Et,
+  Originator: N,
+  PARTICIPANT: ct,
+  PARTICIPANT_ADDED_TO_LIST_MODERATORS: he,
+  PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS: ue,
+  PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS: le,
+  PARTICIPANT_MOVE_REQUEST_TO_STREAM: Te,
+  PARTICIPANT_REMOVED_FROM_LIST_MODERATORS: Se,
+  PARTICIPATION_ACCEPTING_WORD_REQUEST: ge,
+  PARTICIPATION_CANCELLING_WORD_REQUEST: Ce,
+  PEER_CONNECTION: U,
+  PEER_CONNECTION_CONFIRMED: ne,
+  PEER_CONNECTION_CREATE_ANSWER_FAILED: tt,
+  PEER_CONNECTION_CREATE_OFFER_FAILED: et,
+  PEER_CONNECTION_ONTRACK: se,
+  PEER_CONNECTION_SET_LOCAL_DESCRIPTION_FAILED: nt,
+  PEER_CONNECTION_SET_REMOTE_DESCRIPTION_FAILED: st,
+  PRESENTATION_END: rt,
+  PRESENTATION_ENDED: me,
+  PRESENTATION_FAILED: H,
+  PRESENTATION_START: it,
+  PRESENTATION_STARTED: ot,
+  PROGRESS: qe,
+  REFER: Ye,
+  REGISTERED: m,
+  REGISTRATION_FAILED: O,
+  REINVITE: Fe,
+  REPLACES: Ve,
+  SDP: je,
+  SENDING: xe,
+  SHARE_STATE: y,
+  SIP_EVENT: Q,
+  SPECTATOR: at,
+  TERMINATED_INCOMING_CALL: X,
+  UNHOLD: ze,
+  UNMUTED: Je,
+  UNREGISTERED: z,
+  UPDATE: Qe,
+  USE_LICENSE: te,
+  WEBCAST_STARTED: Ne,
+  WEBCAST_STOPPED: _e
+}, Symbol.toStringTag, { value: "Module" })), dt = [
+  $,
+  G,
+  X,
+  J,
+  ge,
+  Ce,
+  Te,
+  ie,
+  fe,
+  Ae,
+  Re,
+  Ne,
+  _e,
+  he,
+  Se
+], Oe = [
+  W,
+  P,
+  C,
+  v,
+  m,
+  z,
+  O,
+  Be,
+  Q
+], ht = [
+  j,
+  K,
+  Z,
+  y,
+  ee,
+  te,
+  ne,
+  se,
+  w,
+  oe,
+  re,
+  ce,
+  ae,
+  Ee,
+  de,
+  b,
+  le,
+  ue
+], Me = [
+  M,
+  W,
+  xe,
+  Fe,
+  Ve,
+  Ye,
+  qe,
+  $e,
+  L,
+  U,
+  A,
+  Ge,
+  Je,
+  Ie,
+  Pe,
+  Xe,
+  ze,
+  Qe,
+  je,
+  Ke,
+  Ze,
+  et,
+  tt,
+  nt,
+  st,
+  it,
+  ot,
+  rt,
+  me,
+  H
+], St = [...Oe, ...dt], Tt = [
+  ...Me,
+  ...ht
+], Ss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SESSION_EVENT_NAMES: Tt,
+  SESSION_JSSIP_EVENT_NAMES: Me,
+  SESSION_SYNTHETICS_EVENT_NAMES: ht,
+  UA_EVENT_NAMES: St,
+  UA_JSSIP_EVENT_NAMES: Oe,
+  UA_SYNTHETICS_EVENT_NAMES: dt
+}, Symbol.toStringTag, { value: "Module" })), De = "sip-connector", x = Y(De), Ts = () => {
+  Y.enable(De);
+}, ls = () => {
+  Y.enable(`-${De}`);
+}, Vt = (s, e) => (s.degradationPreference = e.degradationPreference, s), Yt = (s, e) => {
+  s.encodings === void 0 && (s.encodings = []);
+  for (let t = s.encodings.length; t < e; t += 1)
+    s.encodings.push({});
+  return s;
+}, lt = (s) => (e, t) => t !== void 0 && e !== t || t === void 0 && e !== s, qt = lt(), $t = (s, e) => {
+  if (qt(s, e))
+    return s;
+}, Gt = (s, e) => {
+  const t = s.maxBitrate, n = $t(e, t);
+  return n !== void 0 && (s.maxBitrate = n), s;
+}, ut = 1, Jt = lt(
+  ut
+), Xt = (s, e) => {
+  const t = s === void 0 ? void 0 : Math.max(s, ut);
+  if (t !== void 0 && Jt(
+    t,
+    e
+  ))
+    return t;
+}, zt = (s, e) => {
+  const t = s.scaleResolutionDownBy, n = Xt(
+    e,
+    t
+  );
+  return n !== void 0 && (s.scaleResolutionDownBy = n), s;
+}, Qt = (s, e) => {
+  var n;
+  const t = ((n = e.encodings) == null ? void 0 : n.length) ?? 0;
+  return Yt(s, t), s.encodings.forEach((i, o) => {
+    const a = ((e == null ? void 0 : e.encodings) ?? [])[o], c = a == null ? void 0 : a.maxBitrate, E = a == null ? void 0 : a.scaleResolutionDownBy;
+    Gt(i, c), zt(i, E);
+  }), s;
+}, jt = (s, e) => {
+  var t, n, i, o, a, c, E, d, T, l, S, u;
+  if (((t = s.codecs) == null ? void 0 : t.length) !== ((n = e.codecs) == null ? void 0 : n.length))
+    return !0;
+  for (let h = 0; h < (((i = s.codecs) == null ? void 0 : i.length) ?? 0); h++)
+    if (JSON.stringify(s.codecs[h]) !== JSON.stringify(e.codecs[h]))
+      return !0;
+  if (((o = s.headerExtensions) == null ? void 0 : o.length) !== ((a = e.headerExtensions) == null ? void 0 : a.length))
+    return !0;
+  for (let h = 0; h < (((c = s.headerExtensions) == null ? void 0 : c.length) ?? 0); h++)
+    if (JSON.stringify(s.headerExtensions[h]) !== JSON.stringify(e.headerExtensions[h]))
+      return !0;
+  if (((E = s.encodings) == null ? void 0 : E.length) !== ((d = e.encodings) == null ? void 0 : d.length))
+    return !0;
+  for (let h = 0; h < (s.encodings.length ?? 0); h++)
+    if (JSON.stringify(s.encodings[h]) !== JSON.stringify(e.encodings[h]))
+      return !0;
+  return ((T = s.rtcp) == null ? void 0 : T.cname) !== ((l = e.rtcp) == null ? void 0 : l.cname) || ((S = s.rtcp) == null ? void 0 : S.reducedSize) !== ((u = e.rtcp) == null ? void 0 : u.reducedSize) || s.degradationPreference !== e.degradationPreference;
+}, Kt = async (s, e) => {
+  const t = s.getParameters(), n = JSON.parse(
+    JSON.stringify(t)
+  );
+  Qt(t, e), Vt(t, e);
+  const i = jt(n, t);
+  return i && await s.setParameters(t), { parameters: t, isChanged: i };
+};
+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 || {}), F = /* @__PURE__ */ ((s) => (s.ADMIN_STOP_MIC = "ADMINSTOPMIC", s.ADMIN_START_MIC = "ADMINSTARTMIC", s))(F || {}), V = /* @__PURE__ */ ((s) => (s.ADMIN_SYNC_FORCED = "1", s.ADMIN_SYNC_NOT_FORCED = "0", s))(V || {}), Zt = /* @__PURE__ */ ((s) => (s.AUDIO = "AUDIO", s.VIDEO = "VIDEO", s.AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION", s))(Zt || {}), en = /* @__PURE__ */ ((s) => (s.VP8 = "video/VP8", s.VP9 = "video/VP9", s.H264 = "video/H264", s.AV1 = "video/AV1", s.rtx = "video/rtx", s.red = "video/red", s.flexfec03 = "video/flexfec-03", s))(en || {});
+const tn = async (s, e, t) => {
+  const { isChanged: n, parameters: i } = await Kt(s, {
+    encodings: [
+      {
+        scaleResolutionDownBy: e.scaleResolutionDownBy,
+        maxBitrate: e.maxBitrate
+      }
+    ]
+  });
+  return n && t && t(i), { isChanged: n, parameters: i };
+};
+function nn(s) {
+  return (e) => `sip:${e}@${s}`;
+}
+const sn = (s, e) => () => Math.floor(Math.random() * (e - s)) + s, ye = (s) => s.trim().replaceAll(" ", "_"), on = sn(1e5, 99999999), rn = (s) => s.some((t) => {
+  const { kind: n } = t;
+  return n === "video";
+}), an = (s) => {
+  const e = [];
+  return s !== void 0 && s !== "" && e.push(`X-Vinteo-Remote: ${s}`), e;
+}, cn = "content-type", En = "x-webrtc-enter-room", D = "application/vinteo.webrtc.sharedesktop", dn = "application/vinteo.webrtc.roomname", hn = "application/vinteo.webrtc.channels", Sn = "application/vinteo.webrtc.mediastate", Tn = "application/vinteo.webrtc.refusal", we = "application/vinteo.webrtc.maincam", ln = "application/vinteo.webrtc.mic", un = "application/vinteo.webrtc.uselic", gn = "X-WEBRTC-USE-LICENSE", Cn = "X-WEBRTC-PARTICIPANT-NAME", be = "X-WEBRTC-INPUT-CHANNELS", Le = "X-WEBRTC-OUTPUT-CHANNELS", Nn = "X-WEBRTC-MAINCAM", _n = "X-WEBRTC-MIC", Ue = "X-WEBRTC-SYNC", An = "X-WEBRTC-MAINCAM-RESOLUTION", Rn = "X-WEBRTC-MEDIA-STATE", fn = "X-Vinteo-Media-Type", In = "X-Vinteo-MainCam-State", Pn = "X-Vinteo-Mic-State", mn = "application/vinteo.webrtc.partstate", On = "X-WEBRTC-PARTSTATE", Mn = "application/vinteo.webrtc.notify", Dn = "X-VINTEO-NOTIFY", R = "x-webrtc-share-state", pn = `${R}: LETMESTARTPRESENTATION`, vn = `${R}: STOPPRESENTATION`, gt = "YOUCANRECEIVECONTENT", Ct = "CONTENTEND", Nt = "YOUMUSTSTOPSENDCONTENT", yn = `${R}: ${Nt}`, wn = `${R}: ${gt}`, bn = `${R}: ${Ct}`, Ln = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE", Un = `${Ln}: LETMESTARTMAINCAM`, Hn = (s, e) => {
+  s.getVideoTracks().forEach((n) => {
+    "contentHint" in n && n.contentHint !== e && (n.contentHint = e);
+  });
+}, p = (s, {
+  directionVideo: e,
+  directionAudio: t,
+  contentHint: n
+} = {}) => {
+  if (!s || e === "recvonly" && t === "recvonly")
+    return;
+  const i = t === "recvonly" ? [] : s.getAudioTracks(), o = e === "recvonly" ? [] : s.getVideoTracks(), a = [...i, ...o], c = new MediaStream(a);
+  return c.getTracks = () => [...c.getAudioTracks(), ...c.getVideoTracks()], n && n !== "none" && Hn(c, n), c;
+}, Wn = "Error decline with 603", kn = 1006, Bn = (s) => typeof s == "object" && s !== null && "code" in s && s.code === kn, xn = (s) => s.message === Wn, Fn = (s, e) => s.find((t) => t.track && e.getTracks().includes(t.track)), Vn = async (s, e, t) => {
+  const n = Fn(s, e);
+  if (n)
+    return tn(n, { maxBitrate: t });
+}, Yn = 486, qn = 487, $n = 3, Gn = 1, Jn = (s) => s instanceof Object && ("originator" in s || "cause" in s), us = (s) => {
+  if (Rt(s))
+    return !0;
+  if (!Jn(s))
+    return !1;
+  const { originator: e, cause: t } = s;
+  return typeof t == "string" ? t === He || t === We || e === N.LOCAL && (t === q || t === ke) : !1;
+}, gs = (s) => ft(s), Xn = "channels", zn = "WebcastStarted", Qn = "WebcastStopped", jn = "accountChanged", Kn = "accountDeleted", Zn = "addedToListModerators", es = "removedFromListModerators", ts = "ParticipationRequestAccepted", ns = "ParticipationRequestRejected", ss = "ParticipantMovedToWebcast", is = "ConferenceParticipantTokenIssued";
+class Cs {
+  constructor({ JsSIP: e }) {
+    r(this, "promisePendingStartPresentation");
+    r(this, "promisePendingStopPresentation");
+    r(this, "ua");
+    r(this, "rtcSession");
+    r(this, "incomingRTCSession");
+    r(this, "streamPresentationCurrent");
+    r(this, "socket");
+    r(this, "isRegisterConfigInner", !1);
+    r(this, "connectionConfiguration", {});
+    r(this, "remoteStreams", {});
+    r(this, "JsSIP");
+    r(this, "sessionEvents");
+    r(this, "uaEvents");
+    r(this, "cancelableConnectWithRepeatedCalls");
+    r(this, "cancelableSendPresentationWithRepeatedCalls");
+    r(this, "isPendingConnect", !1);
+    r(this, "isPendingInitUa", !1);
+    r(this, "isPendingCall", !1);
+    r(this, "isPendingAnswer", !1);
+    r(this, "connect", async (e, t) => (this.cancelRequests(), this.connectWithDuplicatedCalls(e, t)));
+    r(this, "hangUp", async () => (this.cancelRequests(), this.hangUpWithoutCancelRequests()));
+    r(this, "tryRegister", async () => {
+      if (!this.isRegisterConfig)
+        throw new Error("Config is not registered");
+      this.uaEvents.trigger(W, void 0);
+      try {
+        await this.unregister();
+      } catch (e) {
+        x("tryRegister", e);
+      }
+      return this.register();
+    });
+    r(this, "declineToIncomingCall", async ({
+      statusCode: e = qn
+    } = {}) => new Promise((t, n) => {
+      try {
+        const i = this.getIncomingRTCSession(), o = this.remoteCallerData;
+        this.removeIncomingSession(), this.uaEvents.trigger(G, o), i.terminate({ status_code: e }), t();
+      } catch (i) {
+        n(i);
+      }
+    }));
+    r(this, "busyIncomingCall", async () => this.declineToIncomingCall({ statusCode: Yn }));
+    r(this, "set", async ({ displayName: e, password: t }) => new Promise((n, i) => {
+      const { ua: o } = this;
+      if (!o) {
+        i(new Error("this.ua is not initialized"));
+        return;
+      }
+      let a = !1, c = !1;
+      e !== void 0 && e !== this.connectionConfiguration.displayName && (a = o.set("display_name", ye(e)), this.connectionConfiguration.displayName = e), t !== void 0 && t !== this.connectionConfiguration.password && (c = o.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"));
+    }));
+    r(this, "disconnect", async () => {
+      this.off(v, this.handleNewRTCSession);
+      const e = new Promise((n) => {
+        this.once(C, () => {
+          n();
+        });
+      }), { ua: t } = this;
+      return t ? (await this.hangUpWithoutCancelRequests(), t.stop()) : this.uaEvents.trigger(C, void 0), e.finally(() => {
+        delete this.ua;
+      });
+    });
+    r(this, "call", async ({
+      number: e,
+      mediaStream: t,
+      extraHeaders: n = [],
+      ontrack: i,
+      iceServers: o,
+      directionVideo: a,
+      directionAudio: c,
+      contentHint: E,
+      offerToReceiveAudio: d = !0,
+      offerToReceiveVideo: T = !0,
+      sendEncodings: l,
+      onAddedTransceiver: S
+    }) => (this.isPendingCall = !0, new Promise((u, h) => {
+      const { ua: g } = this;
+      if (!g) {
+        h(new Error("this.ua is not initialized"));
+        return;
+      }
+      this.connectionConfiguration.number = e, this.connectionConfiguration.answer = !1, this.handleCall({ ontrack: i }).then(u).catch((_) => {
+        h(_);
+      }), this.rtcSession = g.call(this.getSipServerUrl(e), {
+        extraHeaders: n,
+        mediaStream: p(t, {
+          directionVideo: a,
+          directionAudio: c,
+          contentHint: E
+        }),
+        eventHandlers: this.sessionEvents.triggers,
+        directionVideo: a,
+        directionAudio: c,
+        pcConfig: {
+          iceServers: o
+        },
+        rtcOfferConstraints: {
+          offerToReceiveAudio: d,
+          offerToReceiveVideo: T
+        },
+        sendEncodings: l,
+        onAddedTransceiver: S
+      });
+    }).finally(() => {
+      this.isPendingCall = !1;
+    })));
+    r(this, "answerToIncomingCall", async ({
+      mediaStream: e,
+      ontrack: t,
+      extraHeaders: n = [],
+      iceServers: i,
+      directionVideo: o,
+      directionAudio: a,
+      offerToReceiveAudio: c,
+      offerToReceiveVideo: E,
+      contentHint: d,
+      sendEncodings: T,
+      onAddedTransceiver: l
+    }) => (this.isPendingAnswer = !0, new Promise((S, u) => {
+      try {
+        const h = this.getIncomingRTCSession();
+        this.rtcSession = h, this.removeIncomingSession(), this.sessionEvents.eachTriggers((_, k) => {
+          const f = Me.find((B) => B === k);
+          f && h.on(f, _);
+        }), this.connectionConfiguration.answer = !0, this.connectionConfiguration.number = h.remote_identity.uri.user, this.handleCall({ ontrack: t }).then(S).catch((_) => {
+          u(_);
+        });
+        const g = p(e, {
+          directionVideo: o,
+          directionAudio: a,
+          contentHint: d
+        });
+        h.answer({
+          extraHeaders: n,
+          directionVideo: o,
+          directionAudio: a,
+          mediaStream: g,
+          pcConfig: {
+            iceServers: i
+          },
+          rtcOfferConstraints: {
+            offerToReceiveAudio: c,
+            offerToReceiveVideo: E
+          },
+          sendEncodings: T,
+          onAddedTransceiver: l
+        });
+      } catch (h) {
+        u(h);
+      }
+    }).finally(() => {
+      this.isPendingAnswer = !1;
+    })));
+    r(this, "sendDTMF", async (e) => new Promise((t, n) => {
+      const { rtcSession: i } = this;
+      if (!i) {
+        n(new Error("No rtcSession established"));
+        return;
+      }
+      this.onceSession(Ie, ({ originator: o }) => {
+        o === N.LOCAL && t();
+      }), i.sendDTMF(e, {
+        duration: 120,
+        interToneGap: 600
+      });
+    }));
+    r(this, "removeIncomingSession", () => {
+      delete this.incomingRTCSession;
+    });
+    // eslint-disable-next-line class-methods-use-this
+    r(this, "getSipServerUrl", (e) => e);
+    r(this, "connectWithDuplicatedCalls", async (e, { callLimit: t = $n } = {}) => {
+      const n = async () => this.connectInner(e), i = (o) => {
+        var d;
+        const c = ((d = this.ua) == null ? void 0 : d.isConnected()) === !0 && this.hasEqualConnectionConfiguration(e), E = o != null && !Bn(o);
+        return c || E;
+      };
+      return this.isPendingConnect = !0, this.cancelableConnectWithRepeatedCalls = ve({
+        targetFunction: n,
+        isComplete: i,
+        callLimit: t,
+        isRejectAsValid: !0,
+        isCheckBeforeCall: !1
+      }), this.cancelableConnectWithRepeatedCalls.then((o) => {
+        if (o instanceof this.JsSIP.UA)
+          return o;
+        throw o;
+      }).finally(() => {
+        this.isPendingConnect = !1;
+      });
+    });
+    r(this, "handleNewRTCSession", ({
+      originator: e,
+      session: t
+    }) => {
+      if (e === N.REMOTE) {
+        this.incomingRTCSession = t;
+        const n = this.remoteCallerData;
+        t.on(A, (i) => {
+          this.removeIncomingSession(), i.originator === N.LOCAL ? this.uaEvents.trigger(X, n) : this.uaEvents.trigger(J, n);
+        }), this.uaEvents.trigger($, n);
+      }
+    });
+    r(this, "connectInner", async (e) => this.initUa(e).then(async () => this.start()));
+    r(this, "initUa", async ({
+      user: e,
+      password: t,
+      sipServerUrl: n,
+      sipWebSocketServerURL: i,
+      remoteAddress: o,
+      sessionTimers: a,
+      registerExpires: c,
+      connectionRecoveryMinInterval: E,
+      connectionRecoveryMaxInterval: d,
+      userAgent: T,
+      displayName: l = "",
+      register: S = !1,
+      extraHeaders: u = []
+    }) => {
+      if (!n)
+        throw new Error("sipServerUrl is required");
+      if (!i)
+        throw new Error("sipWebSocketServerURL is required");
+      if (S && (e === void 0 || e === ""))
+        throw new Error("user is required for authorized connection");
+      if (S && (t === void 0 || t === ""))
+        throw new Error("password is required for authorized connection");
+      this.isPendingInitUa = !0;
+      try {
+        this.connectionConfiguration = {
+          sipServerUrl: n,
+          displayName: l,
+          register: S,
+          user: e,
+          password: t
+        };
+        const { configuration: h, helpers: g } = this.createUaConfiguration({
+          user: e,
+          sipServerUrl: n,
+          sipWebSocketServerURL: i,
+          password: t,
+          displayName: l,
+          register: S,
+          sessionTimers: a,
+          registerExpires: c,
+          connectionRecoveryMinInterval: E,
+          connectionRecoveryMaxInterval: d,
+          userAgent: T
+        });
+        return this.getSipServerUrl = g.getSipServerUrl, this.socket = g.socket, this.ua && await this.disconnect(), this.isRegisterConfigInner = !!S, this.ua = this.createUa({ ...h, remoteAddress: o, extraHeaders: u }), this.uaEvents.eachTriggers((_, k) => {
+          const f = Oe.find((B) => B === k);
+          f && this.ua && this.ua.on(f, _);
+        }), this.ua;
+      } finally {
+        this.isPendingInitUa = !1;
+      }
+    });
+    r(this, "createUa", ({
+      remoteAddress: e,
+      extraHeaders: t = [],
+      ...n
+    }) => {
+      const i = new this.JsSIP.UA(n), a = [...e !== void 0 && e !== "" ? an(e) : [], ...t];
+      return a.length > 0 && i.registrator().setExtraHeaders(a), i;
+    });
+    r(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);
+      }, o = (E) => {
+        c(), t(E);
+      }, a = () => {
+        this.isRegisterConfig ? (this.on(m, i), this.on(O, o)) : this.on(P, i), this.on(C, o);
+      }, c = () => {
+        this.off(m, i), this.off(O, o), this.off(P, i), this.off(C, o);
+      };
+      a(), this.on(v, this.handleNewRTCSession), n.start();
+    }));
+    r(this, "handleCall", async ({
+      ontrack: e
+    }) => new Promise((t, n) => {
+      const i = () => {
+        this.onSession(U, T), this.onSession(L, l);
+      }, o = () => {
+        this.offSession(U, T), this.offSession(L, l);
+      }, a = () => {
+        this.onSession(A, E), this.onSession(M, E);
+      }, c = () => {
+        this.offSession(A, E), this.offSession(M, E);
+      }, E = (S) => {
+        o(), c(), n(S);
+      };
+      let d;
+      const T = ({ peerconnection: S }) => {
+        d = S, d.ontrack = (u) => {
+          this.sessionEvents.trigger(se, d), e && e(u);
+        };
+      }, l = () => {
+        d !== void 0 && this.sessionEvents.trigger(ne, d), o(), c(), t(d);
+      };
+      i(), a();
+    }));
+    r(this, "restoreSession", () => {
+      this.cancelRequestsAndResetPresentation(), delete this.connectionConfiguration.number, delete this.rtcSession, this.remoteStreams = {};
+    });
+    r(this, "hangUpWithoutCancelRequests", async () => {
+      if (this.ua && this.rtcSession) {
+        const { rtcSession: e } = this;
+        if (this.streamPresentationCurrent)
+          try {
+            await this.stopPresentation();
+          } catch (t) {
+            x("error stop presentation: ", t);
+          }
+        if (this.restoreSession(), !e.isEnded())
+          return e.terminateAsync({
+            cause: q
+          });
+      }
+    });
+    r(this, "handleShareState", (e) => {
+      switch (e) {
+        case gt: {
+          this.sessionEvents.trigger(j, void 0);
+          break;
+        }
+        case Ct: {
+          this.sessionEvents.trigger(K, void 0);
+          break;
+        }
+        case Nt: {
+          this.sessionEvents.trigger(Z, void 0);
+          break;
+        }
+      }
+    });
+    r(this, "maybeTriggerChannels", (e) => {
+      const t = e.getHeader(be), n = e.getHeader(Le);
+      if (t && n) {
+        const i = {
+          inputChannels: t,
+          outputChannels: n
+        };
+        this.sessionEvents.trigger(w, i);
+      }
+    });
+    r(this, "handleNotify", (e) => {
+      switch (e.cmd) {
+        case Xn: {
+          const t = e;
+          this.triggerChannelsNotify(t);
+          break;
+        }
+        case zn: {
+          const t = e;
+          this.triggerWebcastStartedNotify(t);
+          break;
+        }
+        case Qn: {
+          const t = e;
+          this.triggerWebcastStoppedNotify(t);
+          break;
+        }
+        case Zn: {
+          const t = e;
+          this.triggerAddedToListModeratorsNotify(t);
+          break;
+        }
+        case es: {
+          const t = e;
+          this.triggerRemovedFromListModeratorsNotify(t);
+          break;
+        }
+        case ts: {
+          const t = e;
+          this.triggerParticipationAcceptingWordRequest(t);
+          break;
+        }
+        case ns: {
+          const t = e;
+          this.triggerParticipationCancellingWordRequest(t);
+          break;
+        }
+        case ss: {
+          const t = e;
+          this.triggerParticipantMoveRequestToStream(t);
+          break;
+        }
+        case jn: {
+          this.triggerAccountChangedNotify();
+          break;
+        }
+        case Kn: {
+          this.triggerAccountDeletedNotify();
+          break;
+        }
+        case is: {
+          const t = e;
+          this.triggerConferenceParticipantTokenIssued(t);
+          break;
+        }
+        default:
+          x("unknown cmd", e.cmd);
+      }
+    });
+    r(this, "triggerRemovedFromListModeratorsNotify", ({
+      conference: e
+    }) => {
+      const t = {
+        conference: e
+      };
+      this.uaEvents.trigger(
+        Se,
+        t
+      );
+    });
+    r(this, "triggerAddedToListModeratorsNotify", ({
+      conference: e
+    }) => {
+      const t = {
+        conference: e
+      };
+      this.uaEvents.trigger(he, t);
+    });
+    r(this, "triggerWebcastStartedNotify", ({
+      body: { conference: e, type: t }
+    }) => {
+      const n = {
+        conference: e,
+        type: t
+      };
+      this.uaEvents.trigger(Ne, n);
+    });
+    r(this, "triggerWebcastStoppedNotify", ({
+      body: { conference: e, type: t }
+    }) => {
+      const n = {
+        conference: e,
+        type: t
+      };
+      this.uaEvents.trigger(_e, n);
+    });
+    r(this, "triggerAccountChangedNotify", () => {
+      this.uaEvents.trigger(Ae, void 0);
+    });
+    r(this, "triggerAccountDeletedNotify", () => {
+      this.uaEvents.trigger(Re, void 0);
+    });
+    r(this, "triggerConferenceParticipantTokenIssued", ({
+      body: { conference: e, participant: t, jwt: n }
+    }) => {
+      const i = {
+        conference: e,
+        participant: t,
+        jwt: n
+      };
+      this.uaEvents.trigger(
+        fe,
+        i
+      );
+    });
+    r(this, "triggerChannelsNotify", (e) => {
+      const t = e.input, n = e.output, i = {
+        inputChannels: t,
+        outputChannels: n
+      };
+      this.uaEvents.trigger(ie, i);
+    });
+    r(this, "triggerParticipationAcceptingWordRequest", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this.uaEvents.trigger(ge, t);
+    });
+    r(this, "triggerParticipationCancellingWordRequest", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this.uaEvents.trigger(Ce, t);
+    });
+    r(this, "triggerParticipantMoveRequestToStream", ({
+      body: { conference: e }
+    }) => {
+      const t = {
+        conference: e
+      };
+      this.uaEvents.trigger(Te, t);
+    });
+    r(this, "triggerEnterRoom", (e) => {
+      const t = e.getHeader(En), n = e.getHeader(Cn);
+      this.sessionEvents.trigger(ee, { room: t, participantName: n });
+    });
+    r(this, "triggerShareState", (e) => {
+      const t = e.getHeader(R);
+      this.sessionEvents.trigger(y, t);
+    });
+    r(this, "maybeTriggerParticipantMoveRequest", (e) => {
+      const t = e.getHeader(On);
+      t === at && this.sessionEvents.trigger(le, void 0), t === ct && this.sessionEvents.trigger(ue, void 0);
+    });
+    r(this, "triggerMainCamControl", (e) => {
+      const t = e.getHeader(Nn), n = e.getHeader(Ue), i = n === V.ADMIN_SYNC_FORCED;
+      if (t === I.ADMIN_START_MAIN_CAM) {
+        this.sessionEvents.trigger(ce, { isSyncForced: i });
+        return;
+      }
+      if (t === I.ADMIN_STOP_MAIN_CAM) {
+        this.sessionEvents.trigger(ae, { isSyncForced: i });
+        return;
+      }
+      (t === I.RESUME_MAIN_CAM || t === I.PAUSE_MAIN_CAM) && n !== void 0 && this.sessionEvents.trigger(b, { isSyncForced: i });
+      const o = e.getHeader(An);
+      this.sessionEvents.trigger(re, {
+        mainCam: t,
+        resolutionMainCam: o
+      });
+    });
+    r(this, "triggerMicControl", (e) => {
+      const t = e.getHeader(_n), i = e.getHeader(Ue) === V.ADMIN_SYNC_FORCED;
+      t === F.ADMIN_START_MIC ? this.sessionEvents.trigger(de, { isSyncForced: i }) : t === F.ADMIN_STOP_MIC && this.sessionEvents.trigger(Ee, { isSyncForced: i });
+    });
+    r(this, "triggerUseLicense", (e) => {
+      const t = e.getHeader(gn);
+      this.sessionEvents.trigger(te, t);
+    });
+    r(this, "handleNewInfo", (e) => {
+      const { originator: t } = e;
+      if (t !== N.REMOTE)
+        return;
+      const { request: n } = e, i = n.getHeader(cn);
+      if (i)
+        switch (i) {
+          case dn: {
+            this.triggerEnterRoom(n), this.maybeTriggerChannels(n);
+            break;
+          }
+          case Mn: {
+            this.maybeHandleNotify(n);
+            break;
+          }
+          case D: {
+            this.triggerShareState(n);
+            break;
+          }
+          case we: {
+            this.triggerMainCamControl(n);
+            break;
+          }
+          case ln: {
+            this.triggerMicControl(n);
+            break;
+          }
+          case un: {
+            this.triggerUseLicense(n);
+            break;
+          }
+          case mn: {
+            this.maybeTriggerParticipantMoveRequest(n);
+            break;
+          }
+        }
+    });
+    r(this, "handleSipEvent", ({ request: e }) => {
+      this.maybeHandleNotify(e);
+    });
+    r(this, "maybeHandleNotify", (e) => {
+      const t = e.getHeader(Dn);
+      if (t) {
+        const n = JSON.parse(t);
+        this.handleNotify(n);
+      }
+    });
+    r(this, "handleEnded", (e) => {
+      const { originator: t } = e;
+      t === N.REMOTE && this.sessionEvents.trigger(oe, e), this.restoreSession();
+    });
+    this.JsSIP = e, this.sessionEvents = new pe(Tt), this.uaEvents = new pe(St), this.onSession(y, this.handleShareState), this.onSession(Pe, this.handleNewInfo), this.on(Q, this.handleSipEvent), this.onSession(A, this.handleEnded), this.onSession(M, this.handleEnded);
+  }
+  get connection() {
+    var t;
+    return (t = this.rtcSession) == null ? void 0 : t.connection;
+  }
+  get remoteCallerData() {
+    var e, t, n;
+    return {
+      displayName: (e = this.incomingRTCSession) == null ? void 0 : e.remote_identity.display_name,
+      host: (t = this.incomingRTCSession) == null ? void 0 : t.remote_identity.uri.host,
+      incomingNumber: (n = this.incomingRTCSession) == null ? void 0 : n.remote_identity.uri.user,
+      rtcSession: this.incomingRTCSession
+    };
+  }
+  get requested() {
+    return this.isPendingInitUa || this.isPendingConnect || this.isPendingCall || this.isPendingAnswer;
+  }
+  get establishedRTCSession() {
+    var e;
+    return ((e = this.rtcSession) == null ? void 0 : e.isEstablished()) === !0 ? this.rtcSession : void 0;
+  }
+  get isRegistered() {
+    return !!this.ua && this.ua.isRegistered();
+  }
+  get isRegisterConfig() {
+    return !!this.ua && this.isRegisterConfigInner;
+  }
+  get isCallActive() {
+    return !!(this.ua && this.rtcSession);
+  }
+  get isAvailableIncomingCall() {
+    return !!this.incomingRTCSession;
+  }
+  get isPendingPresentation() {
+    return !!this.promisePendingStartPresentation || !!this.promisePendingStopPresentation;
+  }
+  async register() {
+    return new Promise((e, t) => {
+      this.isRegisterConfig && this.ua ? (this.ua.on(m, e), this.ua.on(O, 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(z, 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, o) => {
+      try {
+        this.ua.sendOptions(e, t, {
+          extraHeaders: n,
+          eventHandlers: {
+            succeeded: () => {
+              i();
+            },
+            failed: o
+          }
+        });
+      } catch (a) {
+        o(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: o,
+    extraHeaders: a
+  }) {
+    return new Promise((c, E) => {
+      const { configuration: d } = this.createUaConfiguration({
+        sipWebSocketServerURL: i,
+        displayName: t,
+        userAgent: e,
+        sipServerUrl: n
+      }), T = this.createUa({ ...d, remoteAddress: o, extraHeaders: a }), l = () => {
+        const u = new Error("Telephony is not available");
+        E(u);
+      };
+      T.once(C, l);
+      const S = () => {
+        T.removeAllListeners(), T.once(C, c), T.stop();
+      };
+      T.once(P, S), T.start();
+    });
+  }
+  async replaceMediaStream(e, t) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const { contentHint: n } = t ?? {}, i = p(e, { contentHint: n });
+    if (i === void 0)
+      throw new Error("No preparedMediaStream");
+    return this.rtcSession.replaceMediaStream(i, t);
+  }
+  async askPermissionToEnableCam(e = {}) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const t = [Un];
+    return this.rtcSession.sendInfo(we, void 0, {
+      noTerminateWhenError: !0,
+      ...e,
+      extraHeaders: t
+    }).catch((n) => {
+      if (xn(n))
+        throw n;
+    });
+  }
+  async startPresentation(e, {
+    isNeedReinvite: t,
+    isP2P: n,
+    maxBitrate: i,
+    contentHint: o,
+    sendEncodings: a,
+    onAddedTransceiver: c
+  } = {}, E) {
+    const d = this.establishedRTCSession;
+    if (!d)
+      throw new Error("No rtcSession established");
+    if (this.streamPresentationCurrent)
+      throw new Error("Presentation is already started");
+    return n === !0 && await this.sendMustStopPresentation(), this.sendPresentationWithDuplicatedCalls({
+      rtcSession: d,
+      stream: e,
+      presentationOptions: {
+        isNeedReinvite: t,
+        isP2P: n,
+        maxBitrate: i,
+        contentHint: o,
+        sendEncodings: a,
+        onAddedTransceiver: c
+      },
+      options: E
+    });
+  }
+  async stopPresentation({
+    isP2P: e = !1
+  } = {}) {
+    this.cancelSendPresentationWithRepeatedCalls();
+    const t = this.streamPresentationCurrent;
+    let n = this.promisePendingStartPresentation ?? Promise.resolve(void 0);
+    const i = e ? [bn] : [vn], o = this.establishedRTCSession;
+    return o && t && (n = n.then(async () => o.sendInfo(D, void 0, {
+      extraHeaders: i
+    })).then(async () => o.stopPresentation(t)).catch((a) => {
+      throw this.sessionEvents.trigger(H, a), a;
+    })), !o && t && this.sessionEvents.trigger(me, t), this.promisePendingStopPresentation = n, n.finally(() => {
+      this.resetPresentation();
+    });
+  }
+  async updatePresentation(e, {
+    isP2P: t,
+    maxBitrate: n,
+    contentHint: i,
+    sendEncodings: o,
+    onAddedTransceiver: a
+  } = {}) {
+    const c = this.establishedRTCSession;
+    if (!c)
+      throw new Error("No rtcSession established");
+    if (!this.streamPresentationCurrent)
+      throw new Error("Presentation has not started yet");
+    return this.promisePendingStartPresentation && await this.promisePendingStartPresentation, this.sendPresentation(c, e, {
+      isP2P: t,
+      maxBitrate: n,
+      contentHint: i,
+      isNeedReinvite: !1,
+      sendEncodings: o,
+      onAddedTransceiver: a
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.uaEvents.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.uaEvents.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.uaEvents.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.uaEvents.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.uaEvents.off(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onSession(e, t) {
+    return this.sessionEvents.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceSession(e, t) {
+    return this.sessionEvents.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRaceSession(e, t) {
+    return this.sessionEvents.onceRace(e, t);
+  }
+  async waitSession(e) {
+    return this.sessionEvents.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  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 rn(t) ? this.generateStreams(t) : this.generateAudioStreams(t);
+  }
+  getIncomingRTCSession() {
+    const { incomingRTCSession: e } = this;
+    if (!e)
+      throw new Error("No incomingRTCSession");
+    return e;
+  }
+  cancelSendPresentationWithRepeatedCalls() {
+    var e;
+    (e = this.cancelableSendPresentationWithRepeatedCalls) == null || e.cancel();
+  }
+  async waitChannels() {
+    return this.waitSession(w);
+  }
+  async waitSyncMediaState() {
+    return this.waitSession(b);
+  }
+  async sendChannels({ inputChannels: e, outputChannels: t }) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const n = `${be}: ${e}`, i = `${Le}: ${t}`, o = [
+      n,
+      i
+    ];
+    return this.rtcSession.sendInfo(hn, void 0, { extraHeaders: o });
+  }
+  async sendMediaState({ cam: e, mic: t }, n = {}) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const i = `${Rn}: currentstate`, o = `${In}: ${Number(e)}`, a = `${Pn}: ${Number(t)}`, c = [
+      i,
+      o,
+      a
+    ];
+    return this.rtcSession.sendInfo(Sn, void 0, {
+      noTerminateWhenError: !0,
+      ...n,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOn(e, t = {}) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const c = [`${fn}: ${e === "mic" ? 0 : 1}`];
+    return this.rtcSession.sendInfo(Tn, void 0, {
+      noTerminateWhenError: !0,
+      ...t,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOnMic(e = {}) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    return this.sendRefusalToTurnOn("mic", { noTerminateWhenError: !0, ...e });
+  }
+  async sendRefusalToTurnOnCam(e = {}) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    return this.sendRefusalToTurnOn("cam", { noTerminateWhenError: !0, ...e });
+  }
+  async sendMustStopPresentation() {
+    const e = this.establishedRTCSession;
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(D, void 0, {
+      extraHeaders: [yn]
+    });
+  }
+  async sendPresentationWithDuplicatedCalls({
+    rtcSession: e,
+    stream: t,
+    presentationOptions: n,
+    options: i = {
+      callLimit: Gn
+    }
+  }) {
+    const o = async () => this.sendPresentation(e, t, n), a = () => !!this.streamPresentationCurrent;
+    return this.cancelableSendPresentationWithRepeatedCalls = ve({
+      targetFunction: o,
+      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.uri.toString() === t.uri && n.display_name === t.display_name && n.user_agent === t.user_agent && n.sockets === t.sockets && n.session_timers === t.session_timers && n.register_expires === t.register_expires && n.connection_recovery_min_interval === t.connection_recovery_min_interval && n.connection_recovery_max_interval === t.connection_recovery_max_interval;
+  }
+  createUaConfiguration({
+    user: e,
+    password: t,
+    sipWebSocketServerURL: n,
+    displayName: i = "",
+    sipServerUrl: o,
+    register: a = !1,
+    sessionTimers: c = !1,
+    registerExpires: E = 60 * 5,
+    // 5 minutes in sec
+    connectionRecoveryMinInterval: d = 2,
+    connectionRecoveryMaxInterval: T = 6,
+    userAgent: l
+  }) {
+    if (a && (t === void 0 || t === ""))
+      throw new Error("password is required for authorized connection");
+    const S = a && e !== void 0 && e.trim() !== "" ? e.trim() : `${on()}`, u = nn(o), h = u(S), g = new this.JsSIP.WebSocketInterface(n);
+    return {
+      configuration: {
+        password: t,
+        register: a,
+        uri: h,
+        display_name: ye(i),
+        user_agent: l,
+        sdp_semantics: "unified-plan",
+        sockets: [g],
+        session_timers: c,
+        register_expires: E,
+        connection_recovery_min_interval: d,
+        connection_recovery_max_interval: T
+      },
+      helpers: {
+        socket: g,
+        getSipServerUrl: u
+      }
+    };
+  }
+  async sendPresentation(e, t, {
+    maxBitrate: n = Et,
+    isNeedReinvite: i = !0,
+    isP2P: o = !1,
+    contentHint: a = "detail",
+    sendEncodings: c,
+    onAddedTransceiver: E
+  }) {
+    const d = p(t, { contentHint: a });
+    if (d === void 0)
+      throw new Error("No streamPresentationCurrent");
+    this.streamPresentationCurrent = d;
+    const T = o ? [wn] : [pn], l = e.sendInfo(D, void 0, {
+      extraHeaders: T
+    }).then(async () => e.startPresentation(d, i, {
+      sendEncodings: c,
+      onAddedTransceiver: E
+    })).then(async () => {
+      const { connection: S } = this;
+      if (!S)
+        return;
+      const u = S.getSenders();
+      await Vn(u, t, n);
+    }).then(() => t).catch((S) => {
+      throw this.removeStreamPresentationCurrent(), this.sessionEvents.trigger(H, S), S;
+    });
+    return this.promisePendingStartPresentation = l, l.finally(() => {
+      this.promisePendingStartPresentation = void 0;
+    });
+  }
+  removeStreamPresentationCurrent() {
+    delete this.streamPresentationCurrent;
+  }
+  resetPresentation() {
+    this.removeStreamPresentationCurrent(), this.promisePendingStartPresentation = void 0, this.promisePendingStopPresentation = void 0;
+  }
+  cancelRequestsAndResetPresentation() {
+    this.cancelSendPresentationWithRepeatedCalls(), this.resetPresentation();
+  }
+  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 o = n, a = e[i - 1];
+      let c;
+      (a == null ? void 0 : a.kind) === "audio" && (c = a);
+      const E = this.generateStream(o, c);
+      t.push(E);
+    }), t;
+  }
+  generateAudioStreams(e) {
+    return e.map((n) => this.generateAudioStream(n));
+  }
+  cancelRequests() {
+    this.cancelConnectWithRepeatedCalls();
+  }
+  cancelConnectWithRepeatedCalls() {
+    var e;
+    (e = this.cancelableConnectWithRepeatedCalls) == null || e.cancel();
+  }
+}
+export {
+  xt as B,
+  I as E,
+  pt as N,
+  le as P,
+  We as R,
+  Cs as S,
+  Oe as U,
+  Kt as a,
+  ue as b,
+  ds as c,
+  hs as d,
+  Ss as e,
+  ls as f,
+  Ts as g,
+  us as h,
+  gs as i,
+  F as j,
+  V as k,
+  x as l,
+  Zt as m,
+  en as n,
+  Tt as o,
+  tn as s
+};