sip-connector 14.0.0 → 14.0.1-0

package/dist/SipConnector-CJN8qKAC.js

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