sip-connector 6.20.1 → 6.21.0

package/dist/SipConnector-abcad4a1.js

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