sip-connector 14.1.2-7 → 15.1.0

package/dist/@SipConnector-G96OmJEP.js

@@ -0,0 +1,2248 @@
+import { Events as O } from "events-constructor";
+import "@krivega/cancelable-promise";
+import k from "debug";
+import { hasCanceledError as K, repeatedCallsAsync as V } from "repeated-calls";
+import { setup as j, createActor as Z } from "xstate";
+var N = /* @__PURE__ */ ((n) => (n.PEER_CONNECTION = "peerconnection", n.CONNECTING = "connecting", n.SENDING = "sending", n.PROGRESS = "progress", n.ACCEPTED = "accepted", n.CONFIRMED = "confirmed", n.ENDED = "ended", n.FAILED = "failed", n.NEW_DTMF = "newDTMF", n.NEW_INFO = "newInfo", n.HOLD = "hold", n.UNHOLD = "unhold", n.MUTED = "muted", n.UNMUTED = "unmuted", n.REINVITE = "reinvite", n.UPDATE = "update", n.REFER = "refer", n.REPLACES = "replaces", n.SDP = "sdp", n.ICE_CANDIDATE = "icecandidate", n.GET_USER_MEDIA_FAILED = "getusermediafailed", n.PEER_CONNECTION_CREATE_OFFER_FAILED = "peerconnection:createofferfailed", n.PEER_CONNECTION_CREATE_ANSWER_FAILED = "peerconnection:createanswerfailed", n.PEER_CONNECTION_SET_LOCAL_DESCRIPTION_FAILED = "peerconnection:setlocaldescriptionfailed", n.PEER_CONNECTION_SET_REMOTE_DESCRIPTION_FAILED = "peerconnection:setremotedescriptionfailed", n.START_PRESENTATION = "presentation:start", n.STARTED_PRESENTATION = "presentation:started", n.END_PRESENTATION = "presentation:end", n.ENDED_PRESENTATION = "presentation:ended", n.FAILED_PRESENTATION = "presentation:failed", n.PEER_CONNECTION_CONFIRMED = "peerconnection:confirmed", n.PEER_CONNECTION_ONTRACK = "peerconnection:ontrack", n.ENDED_FROM_SERVER = "ended:fromserver", n))(N || {}), b = /* @__PURE__ */ ((n) => (n.LOCAL = "local", n.REMOTE = "remote", n.SYSTEM = "system", n))(b || {});
+const H = [
+  "peerconnection",
+  "connecting",
+  "sending",
+  "progress",
+  "accepted",
+  "confirmed",
+  "ended",
+  "failed",
+  "newInfo",
+  "newDTMF",
+  "presentation:start",
+  "presentation:started",
+  "presentation:end",
+  "presentation:ended",
+  "presentation:failed",
+  "reinvite",
+  "update",
+  "refer",
+  "replaces",
+  "sdp",
+  "icecandidate",
+  "getusermediafailed",
+  "peerconnection:createofferfailed",
+  "peerconnection:createanswerfailed",
+  "peerconnection:setlocaldescriptionfailed",
+  "peerconnection:setremotedescriptionfailed"
+], ee = [
+  "peerconnection:confirmed",
+  "peerconnection:ontrack",
+  "ended:fromserver"
+], G = [
+  ...H,
+  ...ee
+], te = (n, e) => {
+  n.getVideoTracks().forEach((s) => {
+    "contentHint" in s && s.contentHint !== e && (s.contentHint = e);
+  });
+}, v = (n, {
+  directionVideo: e,
+  directionAudio: t,
+  contentHint: s
+} = {}) => {
+  if (!n || e === "recvonly" && t === "recvonly")
+    return;
+  const i = t === "recvonly" ? [] : n.getAudioTracks(), r = e === "recvonly" ? [] : n.getVideoTracks(), a = [...i, ...r], o = new MediaStream(a);
+  return o.getTracks = () => [...o.getAudioTracks(), ...o.getVideoTracks()], s && s !== "none" && te(o, s), o;
+};
+function ne(n) {
+  return (e) => `sip:${e}@${n}`;
+}
+const se = (n, e) => () => Math.floor(Math.random() * (e - n)) + n, B = (n) => n.trim().replaceAll(" ", "_"), ie = se(1e5, 99999999), re = (n) => n.some((t) => {
+  const { kind: s } = t;
+  return s === "video";
+});
+class ae {
+  isPendingCall = !1;
+  isPendingAnswer = !1;
+  rtcSession;
+  remoteStreams = {};
+  events;
+  callConfiguration = {};
+  constructor(e) {
+    this.events = e;
+  }
+}
+var x = /* @__PURE__ */ ((n) => (n.BYE = "Terminated", n.WEBRTC_ERROR = "WebRTC Error", n.CANCELED = "Canceled", n.REQUEST_TIMEOUT = "Request Timeout", n.REJECTED = "Rejected", n.REDIRECTED = "Redirected", n.UNAVAILABLE = "Unavailable", n.NOT_FOUND = "Not Found", n.ADDRESS_INCOMPLETE = "Address Incomplete", n.INCOMPATIBLE_SDP = "Incompatible SDP", n.BAD_MEDIA_DESCRIPTION = "Bad Media Description", n))(x || {});
+class oe {
+  remoteStreams = {};
+  reset() {
+    this.remoteStreams = {};
+  }
+  generateStream(e, t) {
+    const { id: s } = e, i = this.remoteStreams[s] ?? new MediaStream();
+    return t && i.addTrack(t), i.addTrack(e), this.remoteStreams[s] = i, i;
+  }
+  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, i) => {
+      if (s.kind === "audio")
+        return;
+      const r = s, a = e[i - 1];
+      let o;
+      a?.kind === "audio" && (o = a);
+      const c = this.generateStream(r, o);
+      t.push(c);
+    }), t;
+  }
+  generateAudioStreams(e) {
+    return e.map((t) => this.generateAudioStream(t));
+  }
+}
+class ce extends ae {
+  remoteStreamsManager = new oe();
+  disposers = /* @__PURE__ */ new Set();
+  constructor(e) {
+    super(e), e.on(N.FAILED, this.handleEnded), e.on(N.ENDED, this.handleEnded);
+  }
+  get requested() {
+    return this.isPendingCall || this.isPendingAnswer;
+  }
+  get connection() {
+    return this.rtcSession?.connection;
+  }
+  get isCallActive() {
+    return this.rtcSession?.isEstablished() === !0;
+  }
+  get establishedRTCSession() {
+    return this.rtcSession?.isEstablished() === !0 ? this.rtcSession : void 0;
+  }
+  startCall = async (e, t, {
+    number: s,
+    mediaStream: i,
+    extraHeaders: r = [],
+    ontrack: a,
+    iceServers: o,
+    directionVideo: c,
+    directionAudio: T,
+    contentHint: d,
+    offerToReceiveAudio: l = !0,
+    offerToReceiveVideo: E = !0,
+    sendEncodings: S,
+    onAddedTransceiver: R
+  }) => (this.isPendingCall = !0, new Promise((C, p) => {
+    this.callConfiguration.number = s, this.callConfiguration.answer = !1, this.handleCall({ ontrack: a }).then(C).catch((w) => {
+      p(w);
+    }), this.rtcSession = e.call(t(s), {
+      extraHeaders: r,
+      mediaStream: v(i, {
+        directionVideo: c,
+        directionAudio: T,
+        contentHint: d
+      }),
+      // необходимо передавать в методе call, чтобы подписаться на события peerconnection,
+      // так как в методе call создается RTCSession
+      // и после создания нет возможности подписаться на события peerconnection через subscribeToSessionEvents
+      eventHandlers: this.events.triggers,
+      directionVideo: c,
+      directionAudio: T,
+      pcConfig: {
+        iceServers: o
+      },
+      rtcOfferConstraints: {
+        offerToReceiveAudio: l,
+        offerToReceiveVideo: E
+      },
+      sendEncodings: S,
+      onAddedTransceiver: R
+    });
+  }).finally(() => {
+    this.isPendingCall = !1;
+  }));
+  async endCall() {
+    const { rtcSession: e } = this;
+    if (e && !e.isEnded())
+      return e.terminateAsync({
+        cause: x.CANCELED
+      }).finally(() => {
+        this.reset();
+      });
+    this.reset();
+  }
+  answerToIncomingCall = async (e, {
+    mediaStream: t,
+    ontrack: s,
+    extraHeaders: i = [],
+    iceServers: r,
+    directionVideo: a,
+    directionAudio: o,
+    offerToReceiveAudio: c,
+    offerToReceiveVideo: T,
+    contentHint: d,
+    sendEncodings: l,
+    onAddedTransceiver: E
+  }) => (this.isPendingAnswer = !0, new Promise((S, R) => {
+    try {
+      const C = e();
+      this.rtcSession = C, this.subscribeToSessionEvents(C), this.callConfiguration.answer = !0, this.callConfiguration.number = C.remote_identity.uri.user, this.handleCall({ ontrack: s }).then(S).catch((w) => {
+        R(w);
+      });
+      const p = v(t, {
+        directionVideo: a,
+        directionAudio: o,
+        contentHint: d
+      });
+      C.answer({
+        extraHeaders: i,
+        directionVideo: a,
+        directionAudio: o,
+        mediaStream: p,
+        pcConfig: {
+          iceServers: r
+        },
+        rtcOfferConstraints: {
+          offerToReceiveAudio: c,
+          offerToReceiveVideo: T
+        },
+        sendEncodings: l,
+        onAddedTransceiver: E
+      });
+    } catch (C) {
+      R(C);
+    }
+  }).finally(() => {
+    this.isPendingAnswer = !1;
+  }));
+  getEstablishedRTCSession() {
+    return this.rtcSession?.isEstablished() === !0 ? this.rtcSession : void 0;
+  }
+  getCallConfiguration() {
+    return { ...this.callConfiguration };
+  }
+  getRemoteStreams() {
+    if (!this.connection)
+      return;
+    const t = this.connection.getReceivers().map(({ track: s }) => s);
+    return re(t) ? this.remoteStreamsManager.generateStreams(t) : this.remoteStreamsManager.generateAudioStreams(t);
+  }
+  async replaceMediaStream(e, t) {
+    if (!this.rtcSession)
+      throw new Error("No rtcSession established");
+    const { contentHint: s } = t ?? {}, i = v(e, { contentHint: s });
+    if (i === void 0)
+      throw new Error("No preparedMediaStream");
+    return this.rtcSession.replaceMediaStream(i, t);
+  }
+  handleCall = async ({
+    ontrack: e
+  }) => new Promise((t, s) => {
+    const i = () => {
+      this.events.on(N.PEER_CONNECTION, d), this.events.on(N.CONFIRMED, l);
+    }, r = () => {
+      this.events.off(N.PEER_CONNECTION, d), this.events.off(N.CONFIRMED, l);
+    }, a = () => {
+      this.events.on(N.FAILED, c), this.events.on(N.ENDED, c);
+    }, o = () => {
+      this.events.off(N.FAILED, c), this.events.off(N.ENDED, c);
+    }, c = (E) => {
+      r(), o(), s(E);
+    };
+    let T;
+    const d = ({ peerconnection: E }) => {
+      T = E;
+      const S = (R) => {
+        this.events.trigger(N.PEER_CONNECTION_ONTRACK, E), e && e(R);
+      };
+      E.addEventListener("track", S), this.disposers.add(() => {
+        E.removeEventListener("track", S);
+      });
+    }, l = () => {
+      T !== void 0 && this.events.trigger(N.PEER_CONNECTION_CONFIRMED, T), r(), o(), t(T);
+    };
+    i(), a();
+  });
+  subscribeToSessionEvents(e) {
+    this.events.eachTriggers((t, s) => {
+      const i = H.find((r) => r === s);
+      i && (e.on(i, t), this.disposers.add(() => {
+        e.off(i, t);
+      }));
+    });
+  }
+  unsubscribeFromSessionEvents() {
+    this.disposers.forEach((e) => {
+      e();
+    }), this.disposers.clear();
+  }
+  handleEnded = (e) => {
+    const { originator: t } = e;
+    t === b.REMOTE && this.events.trigger(N.ENDED_FROM_SERVER, e), this.reset();
+  };
+  reset = () => {
+    delete this.rtcSession, this.remoteStreamsManager.reset(), this.unsubscribeFromSessionEvents(), this.callConfiguration.number = void 0, this.callConfiguration.answer = !1;
+  };
+}
+class ge {
+  events;
+  strategy;
+  constructor(e) {
+    this.events = new O(G), this.strategy = e ?? new ce(this.events);
+  }
+  get requested() {
+    return this.strategy.requested;
+  }
+  get connection() {
+    return this.strategy.connection;
+  }
+  get establishedRTCSession() {
+    return this.strategy.establishedRTCSession;
+  }
+  get isCallActive() {
+    return this.strategy.isCallActive;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  setStrategy(e) {
+    this.strategy = e;
+  }
+  startCall = async (...e) => this.strategy.startCall(...e);
+  endCall = async () => this.strategy.endCall();
+  answerToIncomingCall = async (...e) => this.strategy.answerToIncomingCall(...e);
+  getEstablishedRTCSession = () => this.strategy.getEstablishedRTCSession();
+  getCallConfiguration = () => this.strategy.getCallConfiguration();
+  getRemoteStreams = () => this.strategy.getRemoteStreams();
+  replaceMediaStream = async (...e) => this.strategy.replaceMediaStream(...e);
+}
+const W = "sip-connector", m = k(W), He = () => {
+  k.enable(W);
+}, Ge = () => {
+  k.enable(`-${W}`);
+}, Te = "Error decline with 603", he = 1006, de = (n) => typeof n == "object" && n !== null && "code" in n && n.code === he, Ee = (n) => n.message === Te;
+var h = /* @__PURE__ */ ((n) => (n.CONTENT_TYPE = "content-type", n.CONTENT_ENTER_ROOM = "x-webrtc-enter-room", n.CONTENT_USE_LICENSE = "X-WEBRTC-USE-LICENSE", n.PARTICIPANT_NAME = "X-WEBRTC-PARTICIPANT-NAME", n.INPUT_CHANNELS = "X-WEBRTC-INPUT-CHANNELS", n.OUTPUT_CHANNELS = "X-WEBRTC-OUTPUT-CHANNELS", n.MAIN_CAM = "X-WEBRTC-MAINCAM", n.MIC = "X-WEBRTC-MIC", n.MEDIA_SYNC = "X-WEBRTC-SYNC", n.MAIN_CAM_RESOLUTION = "X-WEBRTC-MAINCAM-RESOLUTION", n.MEDIA_STATE = "X-WEBRTC-MEDIA-STATE", n.MEDIA_TYPE = "X-Vinteo-Media-Type", n.MAIN_CAM_STATE = "X-Vinteo-MainCam-State", n.MIC_STATE = "X-Vinteo-Mic-State", n.CONTENT_PARTICIPANT_STATE = "X-WEBRTC-PARTSTATE", n.NOTIFY = "X-VINTEO-NOTIFY", n.CONTENT_ENABLE_MEDIA_DEVICE = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE", n.CONTENT_SHARE_STATE = "x-webrtc-share-state", n.MUST_STOP_PRESENTATION_P2P = "x-webrtc-share-state: YOUMUSTSTOPSENDCONTENT", n.START_PRESENTATION_P2P = "x-webrtc-share-state: YOUCANRECEIVECONTENT", n.STOP_PRESENTATION_P2P = "x-webrtc-share-state: CONTENTEND", n.STOP_PRESENTATION = "x-webrtc-share-state: STOPPRESENTATION", n.START_PRESENTATION = "x-webrtc-share-state: LETMESTARTPRESENTATION", n.ENABLE_MAIN_CAM = "X-WEBRTC-REQUEST-ENABLE-MEDIA-DEVICE: LETMESTARTMAINCAM", n))(h || {}), y = /* @__PURE__ */ ((n) => (n.AVAILABLE_SECOND_REMOTE_STREAM = "YOUCANRECEIVECONTENT", n.NOT_AVAILABLE_SECOND_REMOTE_STREAM = "CONTENTEND", n.MUST_STOP_PRESENTATION = "YOUMUSTSTOPSENDCONTENT", n))(y || {}), U = /* @__PURE__ */ ((n) => (n.SPECTATOR = "SPECTATOR", n.PARTICIPANT = "PARTICIPANT", n.SPECTATOR_OVER_SFU = "SPECTATOROVERSFU", n))(U || {}), M = /* @__PURE__ */ ((n) => (n.ENTER_ROOM = "application/vinteo.webrtc.roomname", n.MIC = "application/vinteo.webrtc.mic", n.USE_LICENSE = "application/vinteo.webrtc.uselic", n.PARTICIPANT_STATE = "application/vinteo.webrtc.partstate", n.NOTIFY = "application/vinteo.webrtc.notify", n.SHARE_STATE = "application/vinteo.webrtc.sharedesktop", n.MAIN_CAM = "application/vinteo.webrtc.maincam", n))(M || {}), _ = /* @__PURE__ */ ((n) => (n.CHANNELS = "application/vinteo.webrtc.channels", n.MEDIA_STATE = "application/vinteo.webrtc.mediastate", n.REFUSAL = "application/vinteo.webrtc.refusal", n.SHARE_STATE = "application/vinteo.webrtc.sharedesktop", n.MAIN_CAM = "application/vinteo.webrtc.maincam", n))(_ || {}), f = /* @__PURE__ */ ((n) => (n.PAUSE_MAIN_CAM = "PAUSEMAINCAM", n.RESUME_MAIN_CAM = "RESUMEMAINCAM", n.MAX_MAIN_CAM_RESOLUTION = "MAXMAINCAMRESOLUTION", n.ADMIN_STOP_MAIN_CAM = "ADMINSTOPMAINCAM", n.ADMIN_START_MAIN_CAM = "ADMINSTARTMAINCAM", n))(f || {}), L = /* @__PURE__ */ ((n) => (n.ADMIN_STOP_MIC = "ADMINSTOPMIC", n.ADMIN_START_MIC = "ADMINSTARTMIC", n))(L || {}), F = /* @__PURE__ */ ((n) => (n.ADMIN_SYNC_FORCED = "1", n.ADMIN_SYNC_NOT_FORCED = "0", n))(F || {}), Se = /* @__PURE__ */ ((n) => (n.AUDIO = "AUDIO", n.VIDEO = "VIDEO", n.AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION", n))(Se || {}), g = /* @__PURE__ */ ((n) => (n.CHANNELS_NOTIFY = "channels:notify", n.PARTICIPANT_ADDED_TO_LIST_MODERATORS = "participant:added-to-list-moderators", n.PARTICIPANT_REMOVED_FROM_LIST_MODERATORS = "participant:removed-from-list-moderators", n.PARTICIPANT_MOVE_REQUEST_TO_STREAM = "participant:move-request-to-stream", n.PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS = "participant:move-request-to-spectators", n.PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS = "participant:move-request-to-participants", n.PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS_OVER_SFU = "participant:move-request-to-spectators-over-sfu", n.PARTICIPATION_ACCEPTING_WORD_REQUEST = "participation:accepting-word-request", n.PARTICIPATION_CANCELLING_WORD_REQUEST = "participation:cancelling-word-request", n.WEBCAST_STARTED = "webcast:started", n.WEBCAST_STOPPED = "webcast:stopped", n.ACCOUNT_CHANGED = "account:changed", n.ACCOUNT_DELETED = "account:deleted", n.CONFERENCE_PARTICIPANT_TOKEN_ISSUED = "conference:participant-token-issued", n.CHANNELS = "channels", n.ENTER_ROOM = "enterRoom", n.SHARE_STATE = "shareState", n.MAIN_CAM_CONTROL = "main-cam-control", n.USE_LICENSE = "useLicense", n.ADMIN_START_MAIN_CAM = "admin-start-main-cam", n.ADMIN_STOP_MAIN_CAM = "admin-stop-main-cam", n.ADMIN_START_MIC = "admin-start-mic", n.ADMIN_STOP_MIC = "admin-stop-mic", n.ADMIN_FORCE_SYNC_MEDIA_STATE = "admin-force-sync-media-state", n.AVAILABLE_SECOND_REMOTE_STREAM = "availableSecondRemoteStream", n.NOT_AVAILABLE_SECOND_REMOTE_STREAM = "notAvailableSecondRemoteStream", n.MUST_STOP_PRESENTATION = "mustStopPresentation", n.NEW_DTMF = "newDTMF", n))(g || {});
+const q = [
+  "participation:accepting-word-request",
+  "participation:cancelling-word-request",
+  "participant:move-request-to-stream",
+  "channels:notify",
+  "conference:participant-token-issued",
+  "account:changed",
+  "account:deleted",
+  "webcast:started",
+  "webcast:stopped",
+  "participant:added-to-list-moderators",
+  "participant:removed-from-list-moderators",
+  "participant:move-request-to-spectators",
+  "participant:move-request-to-participants",
+  "participant:move-request-to-spectators-over-sfu",
+  "channels",
+  "enterRoom",
+  "shareState",
+  "main-cam-control",
+  "useLicense",
+  "admin-start-main-cam",
+  "admin-stop-main-cam",
+  "admin-start-mic",
+  "admin-stop-mic",
+  "admin-force-sync-media-state",
+  "availableSecondRemoteStream",
+  "notAvailableSecondRemoteStream",
+  "mustStopPresentation",
+  "newDTMF"
+];
+var A = /* @__PURE__ */ ((n) => (n.CHANNELS = "channels", n.WEBCAST_STARTED = "WebcastStarted", n.WEBCAST_STOPPED = "WebcastStopped", n.ACCOUNT_CHANGED = "accountChanged", n.ACCOUNT_DELETED = "accountDeleted", n.ADDED_TO_LIST_MODERATORS = "addedToListModerators", n.REMOVED_FROM_LIST_MODERATORS = "removedFromListModerators", n.ACCEPTING_WORD_REQUEST = "ParticipationRequestAccepted", n.CANCELLING_WORD_REQUEST = "ParticipationRequestRejected", n.MOVE_REQUEST_TO_STREAM = "ParticipantMovedToWebcast", n.CONFERENCE_PARTICIPANT_TOKEN_ISSUED = "ConferenceParticipantTokenIssued", n))(A || {});
+class le {
+  events;
+  connectionManager;
+  callManager;
+  constructor({
+    connectionManager: e,
+    callManager: t
+  }) {
+    this.connectionManager = e, this.callManager = t, this.events = new O(q), this.subscribe();
+  }
+  async waitChannels() {
+    return this.wait(g.CHANNELS);
+  }
+  async waitSyncMediaState() {
+    return this.wait(g.ADMIN_FORCE_SYNC_MEDIA_STATE);
+  }
+  async sendDTMF(e) {
+    return new Promise((t, s) => {
+      let i;
+      try {
+        i = this.getEstablishedRTCSessionProtected();
+      } catch (r) {
+        s(r);
+      }
+      i && (this.callManager.once("newDTMF", ({ originator: r }) => {
+        r === b.LOCAL && t();
+      }), i.sendDTMF(e, {
+        duration: 120,
+        interToneGap: 600
+      }));
+    });
+  }
+  async sendChannels({ inputChannels: e, outputChannels: t }) {
+    const s = this.getEstablishedRTCSessionProtected(), i = `${h.INPUT_CHANNELS}: ${e}`, r = `${h.OUTPUT_CHANNELS}: ${t}`, a = [
+      i,
+      r
+    ];
+    return s.sendInfo(_.CHANNELS, void 0, { extraHeaders: a });
+  }
+  async sendMediaState({ cam: e, mic: t }, s = {}) {
+    const i = this.getEstablishedRTCSessionProtected(), r = `${h.MEDIA_STATE}: currentstate`, a = `${h.MAIN_CAM_STATE}: ${Number(e)}`, o = `${h.MIC_STATE}: ${Number(t)}`, c = [
+      r,
+      a,
+      o
+    ];
+    return i.sendInfo(_.MEDIA_STATE, void 0, {
+      noTerminateWhenError: !0,
+      ...s,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOn(e, t = {}) {
+    const s = this.getEstablishedRTCSessionProtected(), a = e === "mic" ? 0 : 1, c = [`${h.MEDIA_TYPE}: ${a}`];
+    return s.sendInfo(_.REFUSAL, void 0, {
+      noTerminateWhenError: !0,
+      ...t,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOnMic(e = {}) {
+    return this.sendRefusalToTurnOn("mic", { noTerminateWhenError: !0, ...e });
+  }
+  async sendRefusalToTurnOnCam(e = {}) {
+    return this.sendRefusalToTurnOn("cam", { noTerminateWhenError: !0, ...e });
+  }
+  async sendMustStopPresentationP2P() {
+    await this.getEstablishedRTCSessionProtected().sendInfo(_.SHARE_STATE, void 0, {
+      extraHeaders: [h.MUST_STOP_PRESENTATION_P2P]
+    });
+  }
+  async sendStoppedPresentationP2P() {
+    await this.getEstablishedRTCSessionProtected().sendInfo(_.SHARE_STATE, void 0, {
+      extraHeaders: [h.STOP_PRESENTATION_P2P]
+    });
+  }
+  async sendStoppedPresentation() {
+    await this.getEstablishedRTCSessionProtected().sendInfo(_.SHARE_STATE, void 0, {
+      extraHeaders: [h.STOP_PRESENTATION]
+    });
+  }
+  async askPermissionToStartPresentationP2P() {
+    await this.getEstablishedRTCSessionProtected().sendInfo(_.SHARE_STATE, void 0, {
+      extraHeaders: [h.START_PRESENTATION_P2P]
+    });
+  }
+  async askPermissionToStartPresentation() {
+    await this.getEstablishedRTCSessionProtected().sendInfo(_.SHARE_STATE, void 0, {
+      extraHeaders: [h.START_PRESENTATION]
+    });
+  }
+  async askPermissionToEnableCam(e = {}) {
+    const t = this.getEstablishedRTCSessionProtected(), s = [h.ENABLE_MAIN_CAM];
+    return t.sendInfo(_.MAIN_CAM, void 0, {
+      noTerminateWhenError: !0,
+      ...e,
+      extraHeaders: s
+    }).catch((i) => {
+      if (Ee(i))
+        throw i;
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  getEstablishedRTCSessionProtected = () => {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    return e;
+  };
+  subscribe() {
+    this.connectionManager.on("sipEvent", this.handleSipEvent), this.callManager.on("newInfo", this.handleNewInfo), this.callManager.on("newDTMF", (e) => {
+      this.events.trigger("newDTMF", e);
+    });
+  }
+  handleSipEvent = ({ request: e }) => {
+    this.maybeHandleNotify(e);
+  };
+  maybeHandleNotify = (e) => {
+    try {
+      const t = e.getHeader(h.NOTIFY);
+      if (t) {
+        const s = JSON.parse(t);
+        this.handleNotify(s);
+      }
+    } catch (t) {
+      m("error parse notify", t);
+    }
+  };
+  handleNotify = (e) => {
+    switch (e.cmd) {
+      case A.CHANNELS: {
+        const t = e;
+        this.triggerChannelsNotify(t);
+        break;
+      }
+      case A.WEBCAST_STARTED: {
+        const t = e;
+        this.triggerWebcastStartedNotify(t);
+        break;
+      }
+      case A.WEBCAST_STOPPED: {
+        const t = e;
+        this.triggerWebcastStoppedNotify(t);
+        break;
+      }
+      case A.ADDED_TO_LIST_MODERATORS: {
+        const t = e;
+        this.triggerAddedToListModeratorsNotify(t);
+        break;
+      }
+      case A.REMOVED_FROM_LIST_MODERATORS: {
+        const t = e;
+        this.triggerRemovedFromListModeratorsNotify(t);
+        break;
+      }
+      case A.ACCEPTING_WORD_REQUEST: {
+        const t = e;
+        this.triggerParticipationAcceptingWordRequest(t);
+        break;
+      }
+      case A.CANCELLING_WORD_REQUEST: {
+        const t = e;
+        this.triggerParticipationCancellingWordRequest(t);
+        break;
+      }
+      case A.MOVE_REQUEST_TO_STREAM: {
+        const t = e;
+        this.triggerParticipantMoveRequestToStream(t);
+        break;
+      }
+      case A.ACCOUNT_CHANGED: {
+        this.triggerAccountChangedNotify();
+        break;
+      }
+      case A.ACCOUNT_DELETED: {
+        this.triggerAccountDeletedNotify();
+        break;
+      }
+      case A.CONFERENCE_PARTICIPANT_TOKEN_ISSUED: {
+        const t = e;
+        this.triggerConferenceParticipantTokenIssued(t);
+        break;
+      }
+      default:
+        m("unknown cmd", e);
+    }
+  };
+  handleNewInfo = (e) => {
+    const { originator: t } = e;
+    if (t !== b.REMOTE)
+      return;
+    const { request: s } = e, i = s.getHeader(h.CONTENT_TYPE);
+    if (i !== void 0)
+      switch (i) {
+        case M.ENTER_ROOM: {
+          this.triggerEnterRoom(s), this.maybeTriggerChannels(s);
+          break;
+        }
+        case M.NOTIFY: {
+          this.maybeHandleNotify(s);
+          break;
+        }
+        case M.SHARE_STATE: {
+          this.triggerShareState(s);
+          break;
+        }
+        case M.MAIN_CAM: {
+          this.triggerMainCamControl(s);
+          break;
+        }
+        case M.MIC: {
+          this.triggerMicControl(s);
+          break;
+        }
+        case M.USE_LICENSE: {
+          this.triggerUseLicense(s);
+          break;
+        }
+        case M.PARTICIPANT_STATE: {
+          this.maybeTriggerParticipantMoveRequest(s);
+          break;
+        }
+      }
+  };
+  triggerChannelsNotify = (e) => {
+    const t = e.input, s = e.output, i = {
+      inputChannels: t,
+      outputChannels: s
+    };
+    this.events.trigger(g.CHANNELS_NOTIFY, i);
+  };
+  triggerWebcastStartedNotify = ({
+    body: { conference: e, type: t }
+  }) => {
+    const s = {
+      conference: e,
+      type: t
+    };
+    this.events.trigger(g.WEBCAST_STARTED, s);
+  };
+  triggerWebcastStoppedNotify = ({
+    body: { conference: e, type: t }
+  }) => {
+    const s = {
+      conference: e,
+      type: t
+    };
+    this.events.trigger(g.WEBCAST_STOPPED, s);
+  };
+  triggerAddedToListModeratorsNotify = ({
+    conference: e
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(
+      g.PARTICIPANT_ADDED_TO_LIST_MODERATORS,
+      t
+    );
+  };
+  triggerRemovedFromListModeratorsNotify = ({
+    conference: e
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(
+      g.PARTICIPANT_REMOVED_FROM_LIST_MODERATORS,
+      t
+    );
+  };
+  triggerParticipationAcceptingWordRequest = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(g.PARTICIPATION_ACCEPTING_WORD_REQUEST, t);
+  };
+  triggerParticipationCancellingWordRequest = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(g.PARTICIPATION_CANCELLING_WORD_REQUEST, t);
+  };
+  triggerParticipantMoveRequestToStream = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(g.PARTICIPANT_MOVE_REQUEST_TO_STREAM, t);
+  };
+  triggerAccountChangedNotify = () => {
+    this.events.trigger(g.ACCOUNT_CHANGED, void 0);
+  };
+  triggerAccountDeletedNotify = () => {
+    this.events.trigger(g.ACCOUNT_DELETED, void 0);
+  };
+  triggerConferenceParticipantTokenIssued = ({
+    body: { conference: e, participant: t, jwt: s }
+  }) => {
+    const i = {
+      conference: e,
+      participant: t,
+      jwt: s
+    };
+    this.events.trigger(
+      g.CONFERENCE_PARTICIPANT_TOKEN_ISSUED,
+      i
+    );
+  };
+  maybeTriggerChannels = (e) => {
+    const t = e.getHeader(h.INPUT_CHANNELS), s = e.getHeader(h.OUTPUT_CHANNELS);
+    if (t && s) {
+      const i = {
+        inputChannels: t,
+        outputChannels: s
+      };
+      this.events.trigger(g.CHANNELS, i);
+    }
+  };
+  triggerEnterRoom = (e) => {
+    const t = e.getHeader(h.CONTENT_ENTER_ROOM), s = e.getHeader(h.PARTICIPANT_NAME);
+    this.events.trigger(g.ENTER_ROOM, { room: t, participantName: s });
+  };
+  triggerShareState = (e) => {
+    const t = e.getHeader(h.CONTENT_SHARE_STATE);
+    if (t !== void 0)
+      switch (t) {
+        case y.AVAILABLE_SECOND_REMOTE_STREAM: {
+          this.events.trigger(g.AVAILABLE_SECOND_REMOTE_STREAM, void 0);
+          break;
+        }
+        case y.NOT_AVAILABLE_SECOND_REMOTE_STREAM: {
+          this.events.trigger(g.NOT_AVAILABLE_SECOND_REMOTE_STREAM, void 0);
+          break;
+        }
+        case y.MUST_STOP_PRESENTATION: {
+          this.events.trigger(g.MUST_STOP_PRESENTATION, void 0);
+          break;
+        }
+      }
+  };
+  maybeTriggerParticipantMoveRequest = (e) => {
+    const t = e.getHeader(h.CONTENT_PARTICIPANT_STATE);
+    t === U.SPECTATOR && this.events.trigger(g.PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS, void 0), t === U.PARTICIPANT && this.events.trigger(g.PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS, void 0), t === U.SPECTATOR_OVER_SFU && this.events.trigger(g.PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS_OVER_SFU, void 0);
+  };
+  triggerMainCamControl = (e) => {
+    const t = e.getHeader(h.MAIN_CAM), s = e.getHeader(h.MEDIA_SYNC), i = s === F.ADMIN_SYNC_FORCED;
+    if (t === f.ADMIN_START_MAIN_CAM) {
+      this.events.trigger(g.ADMIN_START_MAIN_CAM, { isSyncForced: i });
+      return;
+    }
+    if (t === f.ADMIN_STOP_MAIN_CAM) {
+      this.events.trigger(g.ADMIN_STOP_MAIN_CAM, { isSyncForced: i });
+      return;
+    }
+    (t === f.RESUME_MAIN_CAM || t === f.PAUSE_MAIN_CAM) && s !== void 0 && this.events.trigger(g.ADMIN_FORCE_SYNC_MEDIA_STATE, { isSyncForced: i });
+    const r = e.getHeader(h.MAIN_CAM_RESOLUTION);
+    this.events.trigger(g.MAIN_CAM_CONTROL, {
+      mainCam: t,
+      resolutionMainCam: r
+    });
+  };
+  triggerMicControl = (e) => {
+    const t = e.getHeader(h.MIC), i = e.getHeader(h.MEDIA_SYNC) === F.ADMIN_SYNC_FORCED;
+    t === L.ADMIN_START_MIC ? this.events.trigger(g.ADMIN_START_MIC, { isSyncForced: i }) : t === L.ADMIN_STOP_MIC && this.events.trigger(g.ADMIN_STOP_MIC, { isSyncForced: i });
+  };
+  triggerUseLicense = (e) => {
+    const t = e.getHeader(h.CONTENT_USE_LICENSE);
+    this.events.trigger(g.USE_LICENSE, t);
+  };
+}
+var I = /* @__PURE__ */ ((n) => (n.START_PRESENTATION = "presentation:start", n.STARTED_PRESENTATION = "presentation:started", n.END_PRESENTATION = "presentation:end", n.ENDED_PRESENTATION = "presentation:ended", n.FAILED_PRESENTATION = "presentation:failed", n))(I || {});
+const Y = [
+  "presentation:start",
+  "presentation:started",
+  "presentation:end",
+  "presentation:ended",
+  "presentation:failed"
+], Ce = 1, Be = (n) => K(n);
+class Ne {
+  events;
+  promisePendingStartPresentation;
+  promisePendingStopPresentation;
+  streamPresentationCurrent;
+  cancelableSendPresentationWithRepeatedCalls;
+  callManager;
+  constructor({ callManager: e }) {
+    this.callManager = e, this.events = new O(Y), this.subscribe();
+  }
+  get isPendingPresentation() {
+    return !!this.promisePendingStartPresentation || !!this.promisePendingStopPresentation;
+  }
+  // eslint-disable-next-line @typescript-eslint/max-params
+  async startPresentation(e, t, {
+    isNeedReinvite: s,
+    maxBitrate: i,
+    contentHint: r,
+    sendEncodings: a,
+    onAddedTransceiver: o
+  } = {}, c) {
+    const T = this.getRtcSessionProtected();
+    if (this.streamPresentationCurrent)
+      throw new Error("Presentation is already started");
+    return this.sendPresentationWithDuplicatedCalls(e, {
+      rtcSession: T,
+      stream: t,
+      presentationOptions: {
+        isNeedReinvite: s,
+        maxBitrate: i,
+        contentHint: r,
+        sendEncodings: a,
+        onAddedTransceiver: o
+      },
+      options: c
+    });
+  }
+  async stopPresentation(e) {
+    this.cancelSendPresentationWithRepeatedCalls();
+    const t = this.streamPresentationCurrent;
+    let s = this.promisePendingStartPresentation ?? Promise.resolve(void 0);
+    const i = this.callManager.getEstablishedRTCSession();
+    return i && t ? s = e().then(async () => i.stopPresentation(t)).catch((r) => {
+      throw this.events.trigger(I.FAILED_PRESENTATION, r), r;
+    }) : t && this.events.trigger(I.ENDED_PRESENTATION, t), this.promisePendingStopPresentation = s, s.finally(() => {
+      this.resetPresentation();
+    });
+  }
+  async updatePresentation(e, t, {
+    // maxBitrate,
+    contentHint: s,
+    sendEncodings: i,
+    onAddedTransceiver: r
+  } = {}) {
+    const a = this.getRtcSessionProtected();
+    if (!this.streamPresentationCurrent)
+      throw new Error("Presentation has not started yet");
+    return this.promisePendingStartPresentation && await this.promisePendingStartPresentation, this.sendPresentation(e, a, t, {
+      // maxBitrate,
+      contentHint: s,
+      isNeedReinvite: !1,
+      sendEncodings: i,
+      onAddedTransceiver: r
+    });
+  }
+  cancelSendPresentationWithRepeatedCalls() {
+    this.cancelableSendPresentationWithRepeatedCalls?.cancel();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  subscribe() {
+    this.callManager.on("presentation:start", (e) => {
+      this.events.trigger(I.START_PRESENTATION, e);
+    }), this.callManager.on("presentation:started", (e) => {
+      this.events.trigger(I.STARTED_PRESENTATION, e);
+    }), this.callManager.on("presentation:end", (e) => {
+      this.events.trigger(I.END_PRESENTATION, e);
+    }), this.callManager.on("presentation:ended", (e) => {
+      this.events.trigger(I.ENDED_PRESENTATION, e);
+    }), this.callManager.on("presentation:failed", (e) => {
+      this.events.trigger(I.FAILED_PRESENTATION, e);
+    }), this.callManager.on("failed", this.handleEnded), this.callManager.on("ended", this.handleEnded);
+  }
+  async sendPresentationWithDuplicatedCalls(e, {
+    rtcSession: t,
+    stream: s,
+    presentationOptions: i,
+    options: r = {
+      callLimit: Ce
+    }
+  }) {
+    const a = async () => this.sendPresentation(
+      e,
+      t,
+      s,
+      i
+    ), o = () => !!this.streamPresentationCurrent;
+    return this.cancelableSendPresentationWithRepeatedCalls = V({
+      targetFunction: a,
+      isComplete: o,
+      isRejectAsValid: !0,
+      ...r
+    }), this.cancelableSendPresentationWithRepeatedCalls.then((c) => c);
+  }
+  // eslint-disable-next-line @typescript-eslint/max-params
+  async sendPresentation(e, t, s, {
+    // maxBitrate = ONE_MEGABIT_IN_BITS,
+    isNeedReinvite: i = !0,
+    contentHint: r = "detail",
+    sendEncodings: a,
+    onAddedTransceiver: o
+  }) {
+    const c = v(s, { contentHint: r });
+    if (c === void 0)
+      throw new Error("No streamPresentationTarget");
+    this.streamPresentationCurrent = c;
+    const T = e().then(async () => t.startPresentation(c, i, {
+      sendEncodings: a,
+      onAddedTransceiver: o
+    })).then(() => s).catch((d) => {
+      throw this.removeStreamPresentationCurrent(), this.events.trigger(I.FAILED_PRESENTATION, d), d;
+    });
+    return this.promisePendingStartPresentation = T, T.finally(() => {
+      this.promisePendingStartPresentation = void 0;
+    });
+  }
+  getRtcSessionProtected = () => {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    return e;
+  };
+  handleEnded = () => {
+    this.reset();
+  };
+  reset() {
+    this.cancelSendPresentationWithRepeatedCalls(), this.resetPresentation();
+  }
+  resetPresentation() {
+    this.removeStreamPresentationCurrent(), this.promisePendingStartPresentation = void 0, this.promisePendingStopPresentation = void 0;
+  }
+  removeStreamPresentationCurrent() {
+    delete this.streamPresentationCurrent;
+  }
+}
+class ue {
+  data = {};
+  getUa;
+  constructor(e) {
+    this.getUa = e.getUa;
+  }
+  /**
+   * Проверяет, настроено ли соединение
+   */
+  isConfigured() {
+    return this.getUa() !== void 0;
+  }
+  /**
+   * Получает текущую конфигурацию подключения
+   */
+  get() {
+    return { ...this.data };
+  }
+  /**
+   * Устанавливает конфигурацию подключения
+   */
+  set(e) {
+    this.data = { ...e };
+  }
+  /**
+   * Обновляет конфигурацию подключения
+   */
+  update(e, t) {
+    this.data[e] = t;
+  }
+  /**
+   * Очищает конфигурацию
+   */
+  clear() {
+    this.data = {};
+  }
+  /**
+   * Проверяет, включена ли регистрация в конфигурации
+   */
+  isRegister() {
+    return this.data.register === !0;
+  }
+  /**
+   * Получает SIP сервер URL из конфигурации
+   */
+  getSipServerUrl() {
+    return this.data.sipServerUrl;
+  }
+  /**
+   * Получает display name из конфигурации
+   */
+  getDisplayName() {
+    return this.data.displayName;
+  }
+  /**
+   * Получает пользователя из конфигурации
+   */
+  getUser() {
+    return this.data.user;
+  }
+  /**
+   * Получает пароль из конфигурации
+   */
+  getPassword() {
+    return this.data.password;
+  }
+  /**
+   * Проверяет, включена ли регистрация
+   */
+  isRegisterEnabled() {
+    return this.data.register === !0;
+  }
+}
+var u = /* @__PURE__ */ ((n) => (n.CONNECTING = "connecting", n.CONNECTED = "connected", n.DISCONNECTED = "disconnected", n.NEW_RTC_SESSION = "newRTCSession", n.REGISTERED = "registered", n.UNREGISTERED = "unregistered", n.REGISTRATION_FAILED = "registrationFailed", n.NEW_MESSAGE = "newMessage", n.SIP_EVENT = "sipEvent", n))(u || {});
+const Q = [
+  "connecting",
+  "connected",
+  "disconnected",
+  "newRTCSession",
+  "registered",
+  "unregistered",
+  "registrationFailed",
+  "newMessage",
+  "sipEvent"
+], z = [...Q], Ae = 3;
+class _e {
+  cancelableConnectWithRepeatedCalls;
+  JsSIP;
+  events;
+  uaFactory;
+  stateMachine;
+  registrationManager;
+  getUa;
+  setUa;
+  getConnectionConfiguration;
+  setConnectionConfiguration;
+  updateConnectionConfiguration;
+  setSipServerUrl;
+  setSocket;
+  constructor(e) {
+    this.JsSIP = e.JsSIP, this.events = e.events, this.uaFactory = e.uaFactory, this.stateMachine = e.stateMachine, this.registrationManager = e.registrationManager, this.getUa = e.getUa, this.setUa = e.setUa, this.getConnectionConfiguration = e.getConnectionConfiguration, this.setConnectionConfiguration = e.setConnectionConfiguration, this.updateConnectionConfiguration = e.updateConnectionConfiguration, this.setSipServerUrl = e.setSipServerUrl, this.setSocket = e.setSocket;
+  }
+  connect = async (e, t) => (this.cancelRequests(), this.connectWithDuplicatedCalls(e, t));
+  set = async ({ displayName: e }) => new Promise((t, s) => {
+    const i = this.getUa();
+    if (!i) {
+      s(new Error("this.ua is not initialized"));
+      return;
+    }
+    let r = !1;
+    const a = this.getConnectionConfiguration();
+    e !== void 0 && e !== a.displayName && (r = i.set("display_name", B(e)), this.updateConnectionConfiguration("displayName", e));
+    const o = r;
+    o ? t(o) : s(new Error("nothing changed"));
+  });
+  disconnect = async () => {
+    const e = new Promise((s) => {
+      this.events.once(u.DISCONNECTED, () => {
+        s();
+      });
+    }), t = this.getUa();
+    return t ? t.stop() : this.events.trigger(u.DISCONNECTED, void 0), e.finally(() => {
+      this.setUa(void 0), this.stateMachine.reset();
+    });
+  };
+  cancelRequests() {
+    this.cancelConnectWithRepeatedCalls();
+  }
+  connectWithDuplicatedCalls = async (e, { callLimit: t = Ae } = {}) => {
+    const s = async () => this.connectInner(e), i = (r) => {
+      const c = this.getUa()?.isConnected() === !0 && this.hasEqualConnectionConfiguration(e), T = r != null && !de(r);
+      return c || T;
+    };
+    return this.stateMachine.startConnect(), this.cancelableConnectWithRepeatedCalls = V({
+      targetFunction: s,
+      isComplete: i,
+      callLimit: t,
+      isRejectAsValid: !0,
+      isCheckBeforeCall: !1
+    }), this.cancelableConnectWithRepeatedCalls.then((r) => {
+      if (r instanceof this.JsSIP.UA)
+        return r;
+      throw r;
+    });
+  };
+  hasEqualConnectionConfiguration(e) {
+    const { configuration: t } = this.uaFactory.createConfiguration(e), i = this.getUa()?.configuration;
+    return i ? i.password === t.password && i.register === t.register && i.uri.toString() === t.uri && i.display_name === t.display_name && i.user_agent === t.user_agent && i.sockets === t.sockets && i.session_timers === t.session_timers && i.register_expires === t.register_expires && i.connection_recovery_min_interval === t.connection_recovery_min_interval && i.connection_recovery_max_interval === t.connection_recovery_max_interval : !1;
+  }
+  connectInner = async (e) => this.initUa(e).then(async () => this.start());
+  initUa = async ({
+    user: e,
+    password: t,
+    sipServerUrl: s,
+    sipWebSocketServerURL: i,
+    remoteAddress: r,
+    sessionTimers: a,
+    registerExpires: o,
+    connectionRecoveryMinInterval: c,
+    connectionRecoveryMaxInterval: T,
+    userAgent: d,
+    displayName: l = "",
+    register: E = !1,
+    extraHeaders: S = []
+  }) => {
+    this.stateMachine.startInitUa(), this.setConnectionConfiguration({
+      sipServerUrl: s,
+      displayName: l,
+      register: E,
+      user: e,
+      password: t
+    }), this.getUa() && await this.disconnect();
+    const { ua: C, helpers: p } = this.uaFactory.createUAWithConfiguration(
+      {
+        user: e,
+        password: t,
+        sipServerUrl: s,
+        sipWebSocketServerURL: i,
+        displayName: l,
+        register: E,
+        sessionTimers: a,
+        registerExpires: o,
+        connectionRecoveryMinInterval: c,
+        connectionRecoveryMaxInterval: T,
+        userAgent: d,
+        remoteAddress: r,
+        extraHeaders: S
+      },
+      this.events
+    );
+    return this.setUa(C), this.setSipServerUrl(p.getSipServerUrl), this.setSocket(p.socket), C;
+  };
+  start = async () => new Promise((e, t) => {
+    const s = this.getUa();
+    if (!s) {
+      t(new Error("this.ua is not initialized"));
+      return;
+    }
+    let i;
+    i = ((c, T) => {
+      if (this.getConnectionConfiguration().register === !0)
+        return this.registrationManager.subscribeToStartEvents(c, T);
+      const l = u.CONNECTED, E = [u.DISCONNECTED];
+      return this.events.on(l, c), E.forEach((S) => {
+        this.events.on(S, T);
+      }), () => {
+        this.events.off(l, c), E.forEach((S) => {
+          this.events.off(S, T);
+        });
+      };
+    })(() => {
+      i?.(), e(s);
+    }, (c) => {
+      i?.(), t(c);
+    }), s.start();
+  });
+  cancelConnectWithRepeatedCalls() {
+    this.cancelableConnectWithRepeatedCalls?.cancel();
+  }
+}
+var X = /* @__PURE__ */ ((n) => (n.START_CONNECT = "START_CONNECT", n.START_INIT_UA = "START_INIT_UA", n.UA_CONNECTED = "UA_CONNECTED", n.UA_REGISTERED = "UA_REGISTERED", n.UA_UNREGISTERED = "UA_UNREGISTERED", n.UA_DISCONNECTED = "UA_DISCONNECTED", n.CONNECTION_FAILED = "CONNECTION_FAILED", n.RESET = "RESET", n))(X || {});
+const Re = j({
+  types: {
+    context: {},
+    events: {}
+  },
+  actions: {
+    logTransition: (n, e) => {
+      m(`State transition: ${e.from} -> ${e.to} (${e.event})`);
+    },
+    logStateChange: (n, e) => {
+      m("ConnectionStateMachine state changed", e.state);
+    }
+  }
+}).createMachine({
+  id: "connection",
+  initial: "idle",
+  context: {},
+  states: {
+    idle: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "idle"
+          /* IDLE */
+        }
+      },
+      on: {
+        START_CONNECT: {
+          target: "connecting",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "idle",
+              to: "connecting",
+              event: "START_CONNECT"
+              /* START_CONNECT */
+            }
+          }
+        }
+      }
+    },
+    connecting: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "connecting"
+          /* CONNECTING */
+        }
+      },
+      on: {
+        START_INIT_UA: {
+          target: "initializing",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connecting",
+              to: "initializing",
+              event: "START_INIT_UA"
+              /* START_INIT_UA */
+              // TODO: remove
+            }
+          }
+        },
+        UA_DISCONNECTED: {
+          target: "disconnected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connecting",
+              to: "disconnected",
+              event: "UA_DISCONNECTED"
+              /* UA_DISCONNECTED */
+            }
+          }
+        },
+        CONNECTION_FAILED: {
+          target: "failed",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connecting",
+              to: "failed",
+              event: "CONNECTION_FAILED"
+              /* CONNECTION_FAILED */
+            }
+          }
+        }
+      }
+    },
+    initializing: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "initializing"
+          /* INITIALIZING */
+        }
+      },
+      on: {
+        UA_CONNECTED: {
+          target: "connected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "initializing",
+              to: "connected",
+              event: "UA_CONNECTED"
+              /* UA_CONNECTED */
+            }
+          }
+        },
+        UA_REGISTERED: {
+          target: "registered",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "initializing",
+              to: "registered",
+              event: "UA_REGISTERED"
+              /* UA_REGISTERED */
+            }
+          }
+        },
+        UA_DISCONNECTED: {
+          target: "disconnected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "initializing",
+              to: "disconnected",
+              event: "UA_DISCONNECTED"
+              /* UA_DISCONNECTED */
+            }
+          }
+        },
+        CONNECTION_FAILED: {
+          target: "failed",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "initializing",
+              to: "failed",
+              event: "CONNECTION_FAILED"
+              /* CONNECTION_FAILED */
+            }
+          }
+        }
+      }
+    },
+    connected: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "connected"
+          /* CONNECTED */
+        }
+      },
+      on: {
+        UA_REGISTERED: {
+          target: "registered",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connected",
+              to: "registered",
+              event: "UA_REGISTERED"
+              /* UA_REGISTERED */
+            }
+          }
+        },
+        UA_DISCONNECTED: {
+          target: "disconnected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connected",
+              to: "disconnected",
+              event: "UA_DISCONNECTED"
+              /* UA_DISCONNECTED */
+            }
+          }
+        },
+        CONNECTION_FAILED: {
+          target: "failed",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "connected",
+              to: "failed",
+              event: "CONNECTION_FAILED"
+              /* CONNECTION_FAILED */
+            }
+          }
+        }
+      }
+    },
+    registered: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "registered"
+          /* REGISTERED */
+        }
+      },
+      on: {
+        UA_UNREGISTERED: {
+          target: "connected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "registered",
+              to: "connected",
+              event: "UA_UNREGISTERED"
+              /* UA_UNREGISTERED */
+            }
+          }
+        },
+        UA_DISCONNECTED: {
+          target: "disconnected",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "registered",
+              to: "disconnected",
+              event: "UA_DISCONNECTED"
+              /* UA_DISCONNECTED */
+            }
+          }
+        },
+        CONNECTION_FAILED: {
+          target: "failed",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "registered",
+              to: "failed",
+              event: "CONNECTION_FAILED"
+              /* CONNECTION_FAILED */
+            }
+          }
+        }
+      }
+    },
+    disconnected: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "disconnected"
+          /* DISCONNECTED */
+        }
+      },
+      on: {
+        RESET: {
+          target: "idle",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "disconnected",
+              to: "idle",
+              event: "RESET"
+              /* RESET */
+            }
+          }
+        },
+        START_CONNECT: {
+          target: "connecting",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "disconnected",
+              to: "connecting",
+              event: "START_CONNECT"
+              /* START_CONNECT */
+            }
+          }
+        }
+      }
+    },
+    failed: {
+      entry: {
+        type: "logStateChange",
+        params: {
+          state: "failed"
+          /* FAILED */
+        }
+      },
+      on: {
+        RESET: {
+          target: "idle",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "failed",
+              to: "idle",
+              event: "RESET"
+              /* RESET */
+            }
+          }
+        },
+        START_CONNECT: {
+          target: "connecting",
+          actions: {
+            type: "logTransition",
+            params: {
+              from: "failed",
+              to: "connecting",
+              event: "START_CONNECT"
+              /* START_CONNECT */
+            }
+          }
+        }
+      }
+    }
+  }
+});
+class Ie {
+  actor;
+  stateChangeListeners = /* @__PURE__ */ new Set();
+  events;
+  unsubscribeFromEvents;
+  actorSubscription;
+  constructor(e) {
+    this.events = e, this.actor = Z(Re), this.actorSubscription = this.actor.subscribe((t) => {
+      const s = t.value;
+      this.stateChangeListeners.forEach((i) => {
+        i(s);
+      });
+    }), this.actor.start(), this.subscribeToEvents();
+  }
+  get state() {
+    return this.actor.getSnapshot().value;
+  }
+  get isIdle() {
+    return this.hasState(
+      "idle"
+      /* IDLE */
+    );
+  }
+  get isConnecting() {
+    return this.hasState(
+      "connecting"
+      /* CONNECTING */
+    );
+  }
+  get isInitializing() {
+    return this.hasState(
+      "initializing"
+      /* INITIALIZING */
+    );
+  }
+  get isConnected() {
+    return this.hasState(
+      "connected"
+      /* CONNECTED */
+    );
+  }
+  get isRegistered() {
+    return this.hasState(
+      "registered"
+      /* REGISTERED */
+    );
+  }
+  get isDisconnected() {
+    return this.hasState(
+      "disconnected"
+      /* DISCONNECTED */
+    );
+  }
+  get isFailed() {
+    return this.hasState(
+      "failed"
+      /* FAILED */
+    );
+  }
+  get isPending() {
+    return this.isConnecting || this.isInitializing;
+  }
+  get isPendingConnect() {
+    return this.isConnecting;
+  }
+  get isPendingInitUa() {
+    return this.isInitializing;
+  }
+  get isActiveConnection() {
+    return this.isConnected || this.isRegistered;
+  }
+  // Публичные методы для уведомления о начале операций
+  startConnect() {
+    this.toStartConnect();
+  }
+  startInitUa() {
+    this.toStartInitUa();
+  }
+  reset() {
+    this.toIdle();
+  }
+  destroy() {
+    this.unsubscribeFromEvents?.(), this.actorSubscription?.unsubscribe(), this.actor.stop();
+  }
+  onStateChange(e) {
+    return this.stateChangeListeners.add(e), () => {
+      this.stateChangeListeners.delete(e);
+    };
+  }
+  canTransition(e) {
+    return this.actor.getSnapshot().can({ type: e });
+  }
+  getValidEvents() {
+    return Object.values(X).filter((e) => this.canTransition(e));
+  }
+  hasState(e) {
+    return this.actor.getSnapshot().matches(e);
+  }
+  sendEvent(e) {
+    const t = this.actor.getSnapshot(), s = { type: e };
+    if (!t.can(s)) {
+      m(
+        `Invalid transition: ${s.type} from ${this.state}. Event cannot be processed in current state.`
+      );
+      return;
+    }
+    this.actor.send(s);
+  }
+  toStartConnect = () => {
+    this.sendEvent(
+      "START_CONNECT"
+      /* START_CONNECT */
+    );
+  };
+  toStartInitUa = () => {
+    this.sendEvent(
+      "START_INIT_UA"
+      /* START_INIT_UA */
+    );
+  };
+  toConnected = () => {
+    this.sendEvent(
+      "UA_CONNECTED"
+      /* UA_CONNECTED */
+    );
+  };
+  toRegistered = () => {
+    this.sendEvent(
+      "UA_REGISTERED"
+      /* UA_REGISTERED */
+    );
+  };
+  toUnregistered = () => {
+    this.sendEvent(
+      "UA_UNREGISTERED"
+      /* UA_UNREGISTERED */
+    );
+  };
+  toDisconnected = () => {
+    this.sendEvent(
+      "UA_DISCONNECTED"
+      /* UA_DISCONNECTED */
+    );
+  };
+  toFailed = () => {
+    this.sendEvent(
+      "CONNECTION_FAILED"
+      /* CONNECTION_FAILED */
+    );
+  };
+  toIdle = () => {
+    this.sendEvent(
+      "RESET"
+      /* RESET */
+    );
+  };
+  subscribeToEvents() {
+    this.events.on("connected", this.toConnected), this.events.on("registered", this.toRegistered), this.events.on("unregistered", this.toUnregistered), this.events.on("disconnected", this.toDisconnected), this.events.on("registrationFailed", this.toFailed), this.unsubscribeFromEvents = () => {
+      this.events.off("connected", this.toConnected), this.events.off("registered", this.toRegistered), this.events.off("unregistered", this.toUnregistered), this.events.off("disconnected", this.toDisconnected), this.events.off("registrationFailed", this.toFailed);
+    };
+  }
+}
+class Me {
+  events;
+  getUaProtected;
+  constructor(e) {
+    this.events = e.events, this.getUaProtected = e.getUaProtected;
+  }
+  async register() {
+    const e = this.getUaProtected();
+    return new Promise((t, s) => {
+      e.on(u.REGISTERED, t), e.on(u.REGISTRATION_FAILED, s), e.register();
+    });
+  }
+  async unregister() {
+    const e = this.getUaProtected();
+    return new Promise((t) => {
+      e.on(u.UNREGISTERED, t), e.unregister();
+    });
+  }
+  async tryRegister() {
+    try {
+      await this.unregister();
+    } catch (e) {
+      m("tryRegister", e);
+    }
+    return this.register();
+  }
+  subscribeToStartEvents(e, t) {
+    const s = u.REGISTERED, i = [u.REGISTRATION_FAILED, u.DISCONNECTED];
+    return this.events.on(s, e), i.forEach((r) => {
+      this.events.on(r, t);
+    }), () => {
+      this.events.off(s, e), i.forEach((r) => {
+        this.events.off(r, t);
+      });
+    };
+  }
+}
+class pe {
+  uaFactory;
+  getUaProtected;
+  constructor(e) {
+    this.uaFactory = e.uaFactory, this.getUaProtected = e.getUaProtected;
+  }
+  /**
+   * Отправляет SIP OPTIONS запрос к указанному адресу
+   */
+  async sendOptions(e, t, s) {
+    const i = this.getUaProtected();
+    return new Promise((r, a) => {
+      try {
+        i.sendOptions(e, t, {
+          extraHeaders: s,
+          eventHandlers: {
+            succeeded: () => {
+              r();
+            },
+            failed: a
+          }
+        });
+      } catch (o) {
+        a(o);
+      }
+    });
+  }
+  /**
+   * Отправляет SIP OPTIONS запрос к собственному URI (ping)
+   */
+  async ping(e, t) {
+    const i = this.getUaProtected().configuration.uri;
+    return this.sendOptions(i, e, t);
+  }
+  /**
+   * Проверяет доступность телефонии, создавая временное соединение
+   */
+  async checkTelephony({
+    userAgent: e,
+    displayName: t,
+    sipServerUrl: s,
+    sipWebSocketServerURL: i,
+    remoteAddress: r,
+    extraHeaders: a
+  }) {
+    return new Promise((o, c) => {
+      const { configuration: T } = this.uaFactory.createConfiguration({
+        sipWebSocketServerURL: i,
+        displayName: t,
+        userAgent: e,
+        sipServerUrl: s
+      }), d = this.uaFactory.createUA({ ...T, remoteAddress: r, extraHeaders: a }), l = () => {
+        const S = new Error("Telephony is not available");
+        c(S);
+      };
+      d.once(u.DISCONNECTED, l);
+      const E = () => {
+        d.removeAllListeners(), d.once(u.DISCONNECTED, () => {
+          o();
+        }), d.stop();
+      };
+      d.once(u.CONNECTED, E), d.start();
+    });
+  }
+}
+const Pe = (n) => {
+  const e = [];
+  return n !== void 0 && n !== "" && e.push(`X-Vinteo-Remote: ${n}`), e;
+};
+class P {
+  JsSIP;
+  constructor(e) {
+    this.JsSIP = e;
+  }
+  static isRegisteredUA(e) {
+    return !!e && e.isRegistered();
+  }
+  static validateConfiguration({
+    register: e,
+    password: t,
+    user: s,
+    sipServerUrl: i,
+    sipWebSocketServerURL: r
+  }) {
+    if (!i)
+      throw new Error("sipServerUrl is required");
+    if (!r)
+      throw new Error("sipWebSocketServerURL is required");
+    if (e && (t === void 0 || t === ""))
+      throw new Error("password is required for authorized connection");
+    if (e && (s === void 0 || s === ""))
+      throw new Error("user is required for authorized connection");
+  }
+  static resolveAuthorizationUser(e, t) {
+    return e && t !== void 0 && t.trim() !== "" ? t.trim() : `${ie()}`;
+  }
+  static buildExtraHeaders(e, t) {
+    const s = e !== void 0 && e !== "" ? Pe(e) : [];
+    return t === void 0 ? s : [...s, ...t];
+  }
+  createConfiguration({
+    user: e,
+    password: t,
+    sipWebSocketServerURL: s,
+    displayName: i = "",
+    sipServerUrl: r,
+    register: a = !1,
+    sessionTimers: o = !1,
+    registerExpires: c = 300,
+    // 5 minutes in sec
+    connectionRecoveryMinInterval: T = 2,
+    connectionRecoveryMaxInterval: d = 6,
+    userAgent: l
+  }) {
+    P.validateConfiguration({
+      register: a,
+      password: t,
+      user: e,
+      sipServerUrl: r,
+      sipWebSocketServerURL: s
+    });
+    const E = P.resolveAuthorizationUser(a, e), S = ne(r), R = S(E), C = new this.JsSIP.WebSocketInterface(s);
+    return {
+      configuration: {
+        password: t,
+        register: a,
+        uri: R,
+        display_name: B(i),
+        user_agent: l,
+        sdpSemantics: "unified-plan",
+        sockets: [C],
+        session_timers: o,
+        register_expires: c,
+        connection_recovery_min_interval: T,
+        connection_recovery_max_interval: d
+      },
+      helpers: {
+        socket: C,
+        getSipServerUrl: S
+      }
+    };
+  }
+  createUA({ remoteAddress: e, extraHeaders: t, ...s }) {
+    const i = new this.JsSIP.UA(s), r = P.buildExtraHeaders(e, t);
+    return r.length > 0 && i.registrator().setExtraHeaders(r), i;
+  }
+  /**
+   * Создает UA с полным жизненным циклом - конфигурация + создание + настройка событий
+   */
+  createUAWithConfiguration(e, t) {
+    const { configuration: s, helpers: i } = this.createConfiguration(e), r = this.createUA({
+      ...s,
+      remoteAddress: e.remoteAddress,
+      extraHeaders: e.extraHeaders
+    });
+    return t.eachTriggers((a, o) => {
+      const c = Q.find((T) => T === o);
+      c && r.on(c, a);
+    }), { ua: r, helpers: i };
+  }
+}
+class me {
+  events;
+  ua;
+  socket;
+  uaFactory;
+  registrationManager;
+  stateMachine;
+  connectionFlow;
+  sipOperations;
+  configurationManager;
+  JsSIP;
+  constructor({ JsSIP: e }) {
+    this.JsSIP = e, this.events = new O(z), this.uaFactory = new P(e), this.registrationManager = new Me({
+      events: this.events,
+      getUaProtected: this.getUaProtected
+    }), this.stateMachine = new Ie(this.events), this.configurationManager = new ue({
+      getUa: this.getUa
+    }), this.sipOperations = new pe({
+      uaFactory: this.uaFactory,
+      getUaProtected: this.getUaProtected
+    }), this.connectionFlow = new _e({
+      JsSIP: this.JsSIP,
+      events: this.events,
+      uaFactory: this.uaFactory,
+      stateMachine: this.stateMachine,
+      registrationManager: this.registrationManager,
+      getUa: this.getUa,
+      getConnectionConfiguration: this.getConnectionConfiguration,
+      setConnectionConfiguration: (t) => {
+        this.configurationManager.set(t);
+      },
+      updateConnectionConfiguration: (t, s) => {
+        this.configurationManager.update(t, s);
+      },
+      setUa: (t) => {
+        this.ua = t;
+      },
+      setSipServerUrl: (t) => {
+        this.getSipServerUrl = t;
+      },
+      setSocket: (t) => {
+        this.socket = t;
+      }
+    });
+  }
+  get requested() {
+    return this.stateMachine.isPending;
+  }
+  get isPendingConnect() {
+    return this.stateMachine.isPendingConnect;
+  }
+  get isPendingInitUa() {
+    return this.stateMachine.isPendingInitUa;
+  }
+  get connectionState() {
+    return this.stateMachine.state;
+  }
+  get isRegistered() {
+    return P.isRegisteredUA(this.ua);
+  }
+  get isRegisterConfig() {
+    return this.configurationManager.isRegister();
+  }
+  connect = async (e, t) => this.connectionFlow.connect(e, t);
+  set = async ({ displayName: e }) => this.connectionFlow.set({ displayName: e });
+  disconnect = async () => this.connectionFlow.disconnect();
+  async register() {
+    return this.registrationManager.register();
+  }
+  async unregister() {
+    return this.registrationManager.unregister();
+  }
+  tryRegister = async () => this.registrationManager.tryRegister();
+  sendOptions = async (e, t, s) => this.sipOperations.sendOptions(e, t, s);
+  ping = async (e, t) => this.sipOperations.ping(e, t);
+  checkTelephony = async (e) => this.sipOperations.checkTelephony(e);
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  isConfigured() {
+    return this.configurationManager.isConfigured();
+  }
+  getConnectionConfiguration = () => this.configurationManager.get();
+  destroy() {
+    this.stateMachine.destroy();
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getSipServerUrl = (e) => e;
+  getUaProtected = () => {
+    if (!this.ua)
+      throw new Error("UA not initialized");
+    return this.ua;
+  };
+  getUa = () => this.ua;
+}
+var D = /* @__PURE__ */ ((n) => (n.INCOMING_CALL = "incomingCall", n.DECLINED_INCOMING_CALL = "declinedIncomingCall", n.TERMINATED_INCOMING_CALL = "terminatedIncomingCall", n.FAILED_INCOMING_CALL = "failedIncomingCall", n))(D || {}), $ = /* @__PURE__ */ ((n) => (n.LOCAL = "local", n.REMOTE = "remote", n.SYSTEM = "system", n))($ || {});
+const J = [
+  "incomingCall",
+  "declinedIncomingCall",
+  "terminatedIncomingCall",
+  "failedIncomingCall"
+], Oe = 486, fe = 487;
+class De {
+  events;
+  incomingRTCSession;
+  connectionManager;
+  constructor(e) {
+    this.connectionManager = e, this.events = new O(J), this.start();
+  }
+  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 isAvailableIncomingCall() {
+    return !!this.incomingRTCSession;
+  }
+  start() {
+    this.subscribe();
+  }
+  stop() {
+    this.unsubscribe(), this.removeIncomingSession();
+  }
+  getIncomingRTCSession = () => {
+    const { incomingRTCSession: e } = this;
+    if (!e)
+      throw new Error("No incomingRTCSession");
+    return e;
+  };
+  extractIncomingRTCSession = () => {
+    const e = this.getIncomingRTCSession();
+    return this.removeIncomingSession(), e;
+  };
+  async declineToIncomingCall({
+    statusCode: e = fe
+  } = {}) {
+    return new Promise((t, s) => {
+      try {
+        const i = this.getIncomingRTCSession(), r = this.remoteCallerData;
+        this.removeIncomingSession(), this.events.trigger(D.DECLINED_INCOMING_CALL, r), i.terminate({ status_code: e }), t();
+      } catch (i) {
+        s(i);
+      }
+    });
+  }
+  async busyIncomingCall() {
+    return this.declineToIncomingCall({ statusCode: Oe });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  subscribe() {
+    this.connectionManager.on("newRTCSession", this.handleNewRTCSession);
+  }
+  unsubscribe() {
+    this.connectionManager.off("newRTCSession", this.handleNewRTCSession);
+  }
+  handleNewRTCSession = ({
+    originator: e,
+    session: t
+  }) => {
+    e === $.REMOTE && this.setIncomingSession(t);
+  };
+  setIncomingSession(e) {
+    this.incomingRTCSession = e;
+    const t = this.remoteCallerData;
+    e.on("failed", (s) => {
+      this.removeIncomingSession(), s.originator === $.LOCAL ? this.events.trigger(D.TERMINATED_INCOMING_CALL, t) : this.events.trigger(D.FAILED_INCOMING_CALL, t);
+    }), this.events.trigger(D.INCOMING_CALL, t);
+  }
+  removeIncomingSession() {
+    delete this.incomingRTCSession;
+  }
+}
+const ve = z.map((n) => `connection:${n}`), ye = G.map((n) => `call:${n}`), Ue = q.map((n) => `api:${n}`), be = J.map((n) => `incoming-call:${n}`), we = Y.map((n) => `presentation:${n}`), Le = [
+  ...ve,
+  ...ye,
+  ...Ue,
+  ...be,
+  ...we
+];
+class xe {
+  events;
+  connectionManager;
+  callManager;
+  apiManager;
+  incomingCallManager;
+  presentationManager;
+  constructor({ JsSIP: e }) {
+    this.events = new O(Le), this.connectionManager = new me({ JsSIP: e }), this.callManager = new ge(), this.apiManager = new le({
+      connectionManager: this.connectionManager,
+      callManager: this.callManager
+    }), this.incomingCallManager = new De(this.connectionManager), this.presentationManager = new Ne({
+      callManager: this.callManager
+    }), this.subscribe();
+  }
+  get requestedConnection() {
+    return this.connectionManager.requested;
+  }
+  get isPendingConnect() {
+    return this.connectionManager.isPendingConnect;
+  }
+  get isPendingInitUa() {
+    return this.connectionManager.isPendingInitUa;
+  }
+  get connectionState() {
+    return this.connectionManager.connectionState;
+  }
+  get isRegistered() {
+    return this.connectionManager.isRegistered;
+  }
+  get isRegisterConfig() {
+    return this.connectionManager.isRegisterConfig;
+  }
+  get socket() {
+    return this.connectionManager.socket;
+  }
+  get requestedCall() {
+    return this.callManager.requested;
+  }
+  get connection() {
+    return this.callManager.connection;
+  }
+  get establishedRTCSession() {
+    return this.callManager.establishedRTCSession;
+  }
+  get isCallActive() {
+    return this.callManager.isCallActive;
+  }
+  get remoteCallerData() {
+    return this.incomingCallManager.remoteCallerData;
+  }
+  get isAvailableIncomingCall() {
+    return this.incomingCallManager.isAvailableIncomingCall;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  on(e, t) {
+    return this.events.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  once(e, t) {
+    return this.events.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRace(e, t) {
+    return this.events.onceRace(e, t);
+  }
+  async wait(e) {
+    return this.events.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  off(e, t) {
+    this.events.off(e, t);
+  }
+  connect = async (...e) => this.connectionManager.connect(...e);
+  set = async (...e) => this.connectionManager.set(...e);
+  disconnect = async () => this.connectionManager.disconnect();
+  register = async () => this.connectionManager.register();
+  unregister = async () => this.connectionManager.unregister();
+  tryRegister = async () => this.connectionManager.tryRegister();
+  sendOptions = async (e, t, s) => this.connectionManager.sendOptions(e, t, s);
+  ping = async (e, t) => this.connectionManager.ping(e, t);
+  checkTelephony = async (e) => this.connectionManager.checkTelephony(e);
+  isConfigured = () => this.connectionManager.isConfigured();
+  getConnectionConfiguration = () => this.connectionManager.getConnectionConfiguration();
+  getSipServerUrl = (e) => this.connectionManager.getSipServerUrl(e);
+  call = async (e) => this.callManager.startCall(
+    this.connectionManager.getUaProtected(),
+    this.getSipServerUrl,
+    e
+  );
+  hangUp = async () => this.callManager.endCall();
+  answerToIncomingCall = async (e) => this.callManager.answerToIncomingCall(
+    this.incomingCallManager.extractIncomingRTCSession,
+    e
+  );
+  declineToIncomingCall = async (...e) => this.incomingCallManager.declineToIncomingCall(...e);
+  getEstablishedRTCSession = () => this.callManager.getEstablishedRTCSession();
+  getCallConfiguration = () => this.callManager.getCallConfiguration();
+  getRemoteStreams = () => this.callManager.getRemoteStreams();
+  replaceMediaStream = async (...e) => this.callManager.replaceMediaStream(...e);
+  async startPresentation(e, t = {}) {
+    const { isP2P: s, callLimit: i, ...r } = t;
+    return this.presentationManager.startPresentation(
+      async () => {
+        s === !0 ? (await this.apiManager.sendMustStopPresentationP2P(), await this.apiManager.askPermissionToStartPresentationP2P()) : await this.apiManager.askPermissionToStartPresentation();
+      },
+      e,
+      r,
+      i === void 0 ? void 0 : { callLimit: i }
+    );
+  }
+  async stopPresentation(e = {}) {
+    const { isP2P: t } = e;
+    return this.presentationManager.stopPresentation(async () => {
+      t === !0 ? await this.apiManager.sendMustStopPresentationP2P() : await this.apiManager.sendStoppedPresentation();
+    });
+  }
+  async updatePresentation(e, t = {}) {
+    const { isP2P: s, ...i } = t;
+    return this.presentationManager.updatePresentation(
+      async () => {
+        s === !0 ? (await this.apiManager.sendMustStopPresentationP2P(), await this.apiManager.askPermissionToStartPresentationP2P()) : await this.apiManager.askPermissionToStartPresentation();
+      },
+      e,
+      i
+    );
+  }
+  async waitChannels(...e) {
+    return this.apiManager.waitChannels(...e);
+  }
+  async waitSyncMediaState(...e) {
+    return this.apiManager.waitSyncMediaState(...e);
+  }
+  async sendDTMF(...e) {
+    return this.apiManager.sendDTMF(...e);
+  }
+  async sendChannels(...e) {
+    return this.apiManager.sendChannels(...e);
+  }
+  async sendMediaState(...e) {
+    return this.apiManager.sendMediaState(...e);
+  }
+  async sendRefusalToTurnOn(...e) {
+    return this.apiManager.sendRefusalToTurnOn(...e);
+  }
+  async sendRefusalToTurnOnMic(...e) {
+    return this.apiManager.sendRefusalToTurnOnMic(...e);
+  }
+  async sendRefusalToTurnOnCam(...e) {
+    return this.apiManager.sendRefusalToTurnOnCam(...e);
+  }
+  async sendMustStopPresentationP2P(...e) {
+    return this.apiManager.sendMustStopPresentationP2P(...e);
+  }
+  async sendStoppedPresentationP2P(...e) {
+    return this.apiManager.sendStoppedPresentationP2P(...e);
+  }
+  async sendStoppedPresentation(...e) {
+    return this.apiManager.sendStoppedPresentation(...e);
+  }
+  async askPermissionToStartPresentationP2P(...e) {
+    return this.apiManager.askPermissionToStartPresentationP2P(...e);
+  }
+  async askPermissionToStartPresentation(...e) {
+    return this.apiManager.askPermissionToStartPresentation(...e);
+  }
+  async askPermissionToEnableCam(...e) {
+    return this.apiManager.askPermissionToEnableCam(...e);
+  }
+  subscribe() {
+    this.connectionManager.events.eachTriggers((e, t) => {
+      this.connectionManager.on(t, (s) => {
+        this.events.trigger(`connection:${t}`, s);
+      });
+    }), this.callManager.events.eachTriggers((e, t) => {
+      this.callManager.on(t, (s) => {
+        this.events.trigger(`call:${t}`, s);
+      });
+    }), this.apiManager.events.eachTriggers((e, t) => {
+      this.apiManager.on(t, (s) => {
+        this.events.trigger(`api:${t}`, s);
+      });
+    }), this.incomingCallManager.events.eachTriggers((e, t) => {
+      this.incomingCallManager.on(t, (s) => {
+        this.events.trigger(`incoming-call:${t}`, s);
+      });
+    }), this.presentationManager.events.eachTriggers((e, t) => {
+      this.presentationManager.on(t, (s) => {
+        this.events.trigger(`presentation:${t}`, s);
+      });
+    });
+  }
+}
+export {
+  x as E,
+  b as O,
+  xe as S,
+  f as a,
+  Se as b,
+  Ge as d,
+  He as e,
+  Be as h,
+  m as l
+};