sip-connector 14.0.0 → 14.1.0-alpha.0

package/dist/SipConnector-CK3GgjXE.js

@@ -0,0 +1,2492 @@
+import D from "events-constructor";
+import "@krivega/cancelable-promise";
+import W from "debug";
+import { hasCanceledError as ht, repeatedCallsAsync as G } from "repeated-calls";
+import { setup as lt, createActor as Ct } from "xstate";
+const Nt = "Connection Error", At = "Request Timeout", _t = "SIP Failure Code", ut = "Internal Error", It = "Busy", Rt = "Rejected", Mt = "Redirected", Ot = "Unavailable", pt = "Not Found", Pt = "Address Incomplete", mt = "Incompatible SDP", ft = "Missing SDP", Dt = "Authentication Error", vt = "Terminated", yt = "WebRTC Error", Ut = "Canceled", bt = "No Answer", wt = "Expires", Lt = "No ACK", Ft = "Dialog Error", $t = "User Denied Media Access", Wt = "Bad Media Description", kt = "RTP Timeout", yn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ADDRESS_INCOMPLETE: Pt,
+  AUTHENTICATION_ERROR: Dt,
+  BAD_MEDIA_DESCRIPTION: Wt,
+  BUSY: It,
+  BYE: vt,
+  CANCELED: Ut,
+  CONNECTION_ERROR: Nt,
+  DIALOG_ERROR: Ft,
+  EXPIRES: wt,
+  INCOMPATIBLE_SDP: mt,
+  INTERNAL_ERROR: ut,
+  MISSING_SDP: ft,
+  NOT_FOUND: pt,
+  NO_ACK: Lt,
+  NO_ANSWER: bt,
+  REDIRECTED: Mt,
+  REJECTED: Rt,
+  REQUEST_TIMEOUT: At,
+  RTP_TIMEOUT: kt,
+  SIP_FAILURE_CODE: _t,
+  UNAVAILABLE: Ot,
+  USER_DENIED_MEDIA_ACCESS: $t,
+  WEBRTC_ERROR: yt
+}, Symbol.toStringTag, { value: "Module" })), H = "incomingCall", B = "declinedIncomingCall", Y = "failedIncomingCall", q = "terminatedIncomingCall", k = "connecting", x = "connected", Q = "disconnected", z = "newRTCSession", J = "registered", X = "unregistered", j = "registrationFailed", K = "newMessage", Z = "sipEvent", ee = "availableSecondRemoteStream", te = "notAvailableSecondRemoteStream", ne = "mustStopPresentation", se = "shareState", ie = "enterRoom", re = "useLicense", ae = "peerconnection:confirmed", oe = "peerconnection:ontrack", ce = "channels", Te = "channels:notify", Ee = "ended:fromserver", ge = "main-cam-control", Se = "admin-stop-main-cam", de = "admin-start-main-cam", he = "admin-stop-mic", le = "admin-start-mic", Ce = "admin-force-sync-media-state", Ne = "participant:added-to-list-moderators", Ae = "participant:removed-from-list-moderators", _e = "participant:move-request-to-stream", ue = "participant:move-request-to-spectators", Ie = "participant:move-request-to-participants", Re = "participation:accepting-word-request", Me = "participation:cancelling-word-request", Oe = "webcast:started", pe = "webcast:stopped", Pe = "account:changed", me = "account:deleted", fe = "conference:participant-token-issued", De = "ended", ve = "sending", ye = "reinvite", Ue = "replaces", be = "refer", we = "progress", Le = "accepted", Fe = "confirmed", $e = "peerconnection", We = "failed", ke = "muted", Ve = "unmuted", Ge = "newDTMF", He = "newInfo", Be = "hold", Ye = "unhold", qe = "update", xe = "sdp", Qe = "icecandidate", ze = "getusermediafailed", Je = "peerconnection:createofferfailed", Xe = "peerconnection:createanswerfailed", je = "peerconnection:setlocaldescriptionfailed", Ke = "peerconnection:setremotedescriptionfailed", Ze = "presentation:start", et = "presentation:started", tt = "presentation:end", nt = "presentation:ended", st = "presentation:failed", Vt = "SPECTATOR", Gt = "PARTICIPANT", Ht = 1e6;
+var it = /* @__PURE__ */ ((n) => (n.LOCAL = "local", n.REMOTE = "remote", n.SYSTEM = "system", n))(it || {});
+const Un = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ACCEPTED: Le,
+  ACCOUNT_CHANGED: Pe,
+  ACCOUNT_DELETED: me,
+  ADMIN_FORCE_SYNC_MEDIA_STATE: Ce,
+  ADMIN_START_MAIN_CAM: de,
+  ADMIN_START_MIC: le,
+  ADMIN_STOP_MAIN_CAM: Se,
+  ADMIN_STOP_MIC: he,
+  AVAILABLE_SECOND_REMOTE_STREAM_EVENT: ee,
+  CHANNELS: ce,
+  CHANNELS_NOTIFY: Te,
+  CONFERENCE_PARTICIPANT_TOKEN_ISSUED: fe,
+  CONFIRMED: Fe,
+  CONNECTED: x,
+  CONNECTING: k,
+  DECLINED_INCOMING_CALL: B,
+  DISCONNECTED: Q,
+  ENDED: De,
+  ENDED_FROM_SERVER: Ee,
+  ENTER_ROOM: ie,
+  FAILED: We,
+  FAILED_INCOMING_CALL: Y,
+  GET_USER_MEDIA_FAILED: ze,
+  HOLD: Be,
+  ICE_CANDIDATE: Qe,
+  INCOMING_CALL: H,
+  MAIN_CAM_CONTROL: ge,
+  MUST_STOP_PRESENTATION_EVENT: ne,
+  MUTED: ke,
+  NEW_DTMF: Ge,
+  NEW_INFO: He,
+  NEW_MESSAGE: K,
+  NEW_RTC_SESSION: z,
+  NOT_AVAILABLE_SECOND_REMOTE_STREAM_EVENT: te,
+  ONE_MEGABIT_IN_BITS: Ht,
+  Originator: it,
+  PARTICIPANT: Gt,
+  PARTICIPANT_ADDED_TO_LIST_MODERATORS: Ne,
+  PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS: Ie,
+  PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS: ue,
+  PARTICIPANT_MOVE_REQUEST_TO_STREAM: _e,
+  PARTICIPANT_REMOVED_FROM_LIST_MODERATORS: Ae,
+  PARTICIPATION_ACCEPTING_WORD_REQUEST: Re,
+  PARTICIPATION_CANCELLING_WORD_REQUEST: Me,
+  PEER_CONNECTION: $e,
+  PEER_CONNECTION_CONFIRMED: ae,
+  PEER_CONNECTION_CREATE_ANSWER_FAILED: Xe,
+  PEER_CONNECTION_CREATE_OFFER_FAILED: Je,
+  PEER_CONNECTION_ONTRACK: oe,
+  PEER_CONNECTION_SET_LOCAL_DESCRIPTION_FAILED: je,
+  PEER_CONNECTION_SET_REMOTE_DESCRIPTION_FAILED: Ke,
+  PRESENTATION_END: tt,
+  PRESENTATION_ENDED: nt,
+  PRESENTATION_FAILED: st,
+  PRESENTATION_START: Ze,
+  PRESENTATION_STARTED: et,
+  PROGRESS: we,
+  REFER: be,
+  REGISTERED: J,
+  REGISTRATION_FAILED: j,
+  REINVITE: ye,
+  REPLACES: Ue,
+  SDP: xe,
+  SENDING: ve,
+  SHARE_STATE: se,
+  SIP_EVENT: Z,
+  SPECTATOR: Vt,
+  TERMINATED_INCOMING_CALL: q,
+  UNHOLD: Ye,
+  UNMUTED: Ve,
+  UNREGISTERED: X,
+  UPDATE: qe,
+  USE_LICENSE: re,
+  WEBCAST_STARTED: Oe,
+  WEBCAST_STOPPED: pe
+}, Symbol.toStringTag, { value: "Module" })), rt = [
+  H,
+  B,
+  q,
+  Y,
+  Re,
+  Me,
+  _e,
+  Te,
+  fe,
+  Pe,
+  me,
+  Oe,
+  pe,
+  Ne,
+  Ae
+], at = [
+  k,
+  x,
+  Q,
+  z,
+  J,
+  X,
+  j,
+  K,
+  Z
+], ot = [
+  ee,
+  te,
+  ne,
+  se,
+  ie,
+  re,
+  ae,
+  oe,
+  ce,
+  Ee,
+  ge,
+  de,
+  Se,
+  he,
+  le,
+  Ce,
+  ue,
+  Ie
+], ct = [
+  De,
+  k,
+  ve,
+  ye,
+  Ue,
+  be,
+  we,
+  Le,
+  Fe,
+  $e,
+  We,
+  ke,
+  Ve,
+  Ge,
+  He,
+  Be,
+  Ye,
+  qe,
+  xe,
+  Qe,
+  ze,
+  Je,
+  Xe,
+  je,
+  Ke,
+  Ze,
+  et,
+  tt,
+  nt,
+  st
+], Bt = [...at, ...rt], Yt = [
+  ...ct,
+  ...ot
+], bn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SESSION_EVENT_NAMES: Yt,
+  SESSION_JSSIP_EVENT_NAMES: ct,
+  SESSION_SYNTHETICS_EVENT_NAMES: ot,
+  UA_EVENT_NAMES: Bt,
+  UA_JSSIP_EVENT_NAMES: at,
+  UA_SYNTHETICS_EVENT_NAMES: rt
+}, Symbol.toStringTag, { value: "Module" })), V = "sip-connector", P = W(V), wn = () => {
+  W.enable(V);
+}, Ln = () => {
+  W.enable(`-${V}`);
+};
+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 || {}), U = /* @__PURE__ */ ((n) => (n.LOCAL = "local", n.REMOTE = "remote", n.SYSTEM = "system", n))(U || {});
+const Tt = [
+  "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"
+], qt = [
+  "peerconnection:confirmed",
+  "peerconnection:ontrack",
+  "ended:fromserver"
+], xt = [
+  ...Tt,
+  ...qt
+];
+function Qt(n) {
+  return (e) => `sip:${e}@${n}`;
+}
+const zt = (n, e) => () => Math.floor(Math.random() * (e - n)) + n, Et = (n) => n.trim().replaceAll(" ", "_"), Jt = zt(1e5, 99999999), Xt = (n) => n.some((t) => {
+  const { kind: s } = t;
+  return s === "video";
+}), jt = (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" && jt(o, s), o;
+};
+class Kt {
+  isPendingCall = !1;
+  isPendingAnswer = !1;
+  rtcSession;
+  remoteStreams = {};
+  events;
+  callConfiguration = {};
+  constructor(e) {
+    this.events = e;
+  }
+}
+var gt = /* @__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))(gt || {});
+class Zt {
+  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 en extends Kt {
+  remoteStreamsManager = new Zt();
+  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: S,
+    offerToReceiveAudio: l = !0,
+    offerToReceiveVideo: d = !0,
+    sendEncodings: h,
+    onAddedTransceiver: I
+  }) => (this.isPendingCall = !0, new Promise((C, O) => {
+    this.callConfiguration.number = s, this.callConfiguration.answer = !1, this.handleCall({ ontrack: a }).then(C).catch((b) => {
+      O(b);
+    }), this.rtcSession = e.call(t(s), {
+      extraHeaders: r,
+      mediaStream: v(i, {
+        directionVideo: c,
+        directionAudio: T,
+        contentHint: S
+      }),
+      directionVideo: c,
+      directionAudio: T,
+      pcConfig: {
+        iceServers: o
+      },
+      rtcOfferConstraints: {
+        offerToReceiveAudio: l,
+        offerToReceiveVideo: d
+      },
+      sendEncodings: h,
+      onAddedTransceiver: I
+    }), this.subscribeToSessionEvents(this.rtcSession);
+  }).finally(() => {
+    this.isPendingCall = !1;
+  }));
+  async endCall() {
+    const { rtcSession: e } = this;
+    if (e && !e.isEnded())
+      return e.terminateAsync({
+        cause: gt.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: S,
+    sendEncodings: l,
+    onAddedTransceiver: d
+  }) => (this.isPendingAnswer = !0, new Promise((h, I) => {
+    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(h).catch((b) => {
+        I(b);
+      });
+      const O = v(t, {
+        directionVideo: a,
+        directionAudio: o,
+        contentHint: S
+      });
+      C.answer({
+        extraHeaders: i,
+        directionVideo: a,
+        directionAudio: o,
+        mediaStream: O,
+        pcConfig: {
+          iceServers: r
+        },
+        rtcOfferConstraints: {
+          offerToReceiveAudio: c,
+          offerToReceiveVideo: T
+        },
+        sendEncodings: l,
+        onAddedTransceiver: d
+      });
+    } catch (C) {
+      I(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 Xt(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, S), this.events.on(N.CONFIRMED, l);
+    }, r = () => {
+      this.events.off(N.PEER_CONNECTION, S), 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 = (d) => {
+      r(), o(), s(d);
+    };
+    let T;
+    const S = ({ peerconnection: d }) => {
+      T = d;
+      const h = (I) => {
+        this.events.trigger(N.PEER_CONNECTION_ONTRACK, d), e && e(I);
+      };
+      d.addEventListener("track", h), this.disposers.add(() => {
+        d.removeEventListener("track", h);
+      });
+    }, 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 = Tt.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 === U.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 tn {
+  events;
+  strategy;
+  constructor(e) {
+    this.events = new D(xt), this.strategy = e ?? new en(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);
+}
+var R = /* @__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))(R || {});
+const nn = [
+  "presentation:start",
+  "presentation:started",
+  "presentation:end",
+  "presentation:ended",
+  "presentation:failed"
+], sn = 1, Fn = (n) => ht(n);
+class rn {
+  promisePendingStartPresentation;
+  promisePendingStopPresentation;
+  streamPresentationCurrent;
+  events;
+  cancelableSendPresentationWithRepeatedCalls;
+  callManager;
+  constructor({ callManager: e }) {
+    this.callManager = e, this.events = new D(nn), 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(R.FAILED_PRESENTATION, r), r;
+    }) : t && this.events.trigger(R.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(R.START_PRESENTATION, e);
+    }), this.callManager.on("presentation:started", (e) => {
+      this.events.trigger(R.STARTED_PRESENTATION, e);
+    }), this.callManager.on("presentation:end", (e) => {
+      this.events.trigger(R.END_PRESENTATION, e);
+    }), this.callManager.on("presentation:ended", (e) => {
+      this.events.trigger(R.ENDED_PRESENTATION, e);
+    }), this.callManager.on("presentation:failed", (e) => {
+      this.events.trigger(R.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: sn
+    }
+  }) {
+    const a = async () => this.sendPresentation(
+      e,
+      t,
+      s,
+      i
+    ), o = () => !!this.streamPresentationCurrent;
+    return this.cancelableSendPresentationWithRepeatedCalls = G({
+      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((S) => {
+      throw this.removeStreamPresentationCurrent(), this.events.trigger(R.FAILED_PRESENTATION, S), S;
+    });
+    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;
+  }
+}
+const an = "Error decline with 603", on = 1006, cn = (n) => typeof n == "object" && n !== null && "code" in n && n.code === on, Tn = (n) => n.message === an;
+var g = /* @__PURE__ */ ((n) => (n.CONTENT_TYPE_NAME = "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))(g || {}), y = /* @__PURE__ */ ((n) => (n.AVAILABLE_SECOND_REMOTE_STREAM = "YOUCANRECEIVECONTENT", n.NOT_AVAILABLE_SECOND_REMOTE_STREAM = "CONTENTEND", n.MUST_STOP_PRESENTATION = "YOUMUSTSTOPSENDCONTENT", n))(y || {}), w = /* @__PURE__ */ ((n) => (n.SPECTATOR = "SPECTATOR", n.PARTICIPANT = "PARTICIPANT", n))(w || {}), 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 || {}), u = /* @__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))(u || {}), m = /* @__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))(m || {}), 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 || {}), E = /* @__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.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))(E || {});
+const En = [
+  "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",
+  "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 _ = /* @__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))(_ || {});
+class gn {
+  events;
+  connectionManager;
+  callManager;
+  constructor({
+    connectionManager: e,
+    callManager: t
+  }) {
+    this.connectionManager = e, this.callManager = t, this.events = new D(En), this.subscribe();
+  }
+  async waitChannels() {
+    return this.wait(E.CHANNELS);
+  }
+  async waitSyncMediaState() {
+    return this.wait(E.ADMIN_FORCE_SYNC_MEDIA_STATE);
+  }
+  async sendDTMF(e) {
+    return new Promise((t, s) => {
+      const i = this.callManager.getEstablishedRTCSession();
+      if (!i) {
+        s(new Error("No rtcSession established"));
+        return;
+      }
+      this.callManager.once("newDTMF", ({ originator: r }) => {
+        r === U.LOCAL && t();
+      }), i.sendDTMF(e, {
+        duration: 120,
+        interToneGap: 600
+      });
+    });
+  }
+  async sendChannels({ inputChannels: e, outputChannels: t }) {
+    const s = this.callManager.getEstablishedRTCSession();
+    if (!s)
+      throw new Error("No rtcSession established");
+    const i = `${g.INPUT_CHANNELS}: ${e}`, r = `${g.OUTPUT_CHANNELS}: ${t}`, a = [
+      i,
+      r
+    ];
+    return s.sendInfo(u.CHANNELS, void 0, { extraHeaders: a });
+  }
+  async sendMediaState({ cam: e, mic: t }, s = {}) {
+    const i = this.callManager.getEstablishedRTCSession();
+    if (!i)
+      throw new Error("No rtcSession established");
+    const r = `${g.MEDIA_STATE}: currentstate`, a = `${g.MAIN_CAM_STATE}: ${Number(e)}`, o = `${g.MIC_STATE}: ${Number(t)}`, c = [
+      r,
+      a,
+      o
+    ];
+    return i.sendInfo(u.MEDIA_STATE, void 0, {
+      noTerminateWhenError: !0,
+      ...s,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOn(e, t = {}) {
+    const s = this.callManager.getEstablishedRTCSession();
+    if (!s)
+      throw new Error("No rtcSession established");
+    const a = e === "mic" ? 0 : 1, c = [`${g.MEDIA_TYPE}: ${a}`];
+    return s.sendInfo(u.REFUSAL, void 0, {
+      noTerminateWhenError: !0,
+      ...t,
+      extraHeaders: c
+    });
+  }
+  async sendRefusalToTurnOnMic(e = {}) {
+    if (!this.callManager.getEstablishedRTCSession())
+      throw new Error("No rtcSession established");
+    return this.sendRefusalToTurnOn("mic", { noTerminateWhenError: !0, ...e });
+  }
+  async sendRefusalToTurnOnCam(e = {}) {
+    if (!this.callManager.getEstablishedRTCSession())
+      throw new Error("No rtcSession established");
+    return this.sendRefusalToTurnOn("cam", { noTerminateWhenError: !0, ...e });
+  }
+  async sendMustStopPresentationP2P() {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(u.SHARE_STATE, void 0, {
+      extraHeaders: [g.MUST_STOP_PRESENTATION_P2P]
+    });
+  }
+  async sendStoppedPresentationP2P() {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(u.SHARE_STATE, void 0, {
+      extraHeaders: [g.STOP_PRESENTATION_P2P]
+    });
+  }
+  async sendStoppedPresentation() {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(u.SHARE_STATE, void 0, {
+      extraHeaders: [g.STOP_PRESENTATION]
+    });
+  }
+  async askPermissionToStartPresentationP2P() {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(u.SHARE_STATE, void 0, {
+      extraHeaders: [g.START_PRESENTATION_P2P]
+    });
+  }
+  async askPermissionToStartPresentation() {
+    const e = this.callManager.getEstablishedRTCSession();
+    if (!e)
+      throw new Error("No rtcSession established");
+    await e.sendInfo(u.SHARE_STATE, void 0, {
+      extraHeaders: [g.START_PRESENTATION]
+    });
+  }
+  async askPermissionToEnableCam(e = {}) {
+    const t = this.callManager.getEstablishedRTCSession();
+    if (!t)
+      throw new Error("No rtcSession established");
+    const s = [g.ENABLE_MAIN_CAM];
+    return t.sendInfo(u.MAIN_CAM, void 0, {
+      noTerminateWhenError: !0,
+      ...e,
+      extraHeaders: s
+    }).catch((i) => {
+      if (Tn(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);
+  }
+  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(g.NOTIFY);
+      if (t) {
+        const s = JSON.parse(t);
+        this.handleNotify(s);
+      }
+    } catch (t) {
+      P("error parse notify", t);
+    }
+  };
+  handleNotify = (e) => {
+    switch (e.cmd) {
+      case _.CHANNELS: {
+        const t = e;
+        this.triggerChannelsNotify(t);
+        break;
+      }
+      case _.WEBCAST_STARTED: {
+        const t = e;
+        this.triggerWebcastStartedNotify(t);
+        break;
+      }
+      case _.WEBCAST_STOPPED: {
+        const t = e;
+        this.triggerWebcastStoppedNotify(t);
+        break;
+      }
+      case _.ADDED_TO_LIST_MODERATORS: {
+        const t = e;
+        this.triggerAddedToListModeratorsNotify(t);
+        break;
+      }
+      case _.REMOVED_FROM_LIST_MODERATORS: {
+        const t = e;
+        this.triggerRemovedFromListModeratorsNotify(t);
+        break;
+      }
+      case _.ACCEPTING_WORD_REQUEST: {
+        const t = e;
+        this.triggerParticipationAcceptingWordRequest(t);
+        break;
+      }
+      case _.CANCELLING_WORD_REQUEST: {
+        const t = e;
+        this.triggerParticipationCancellingWordRequest(t);
+        break;
+      }
+      case _.MOVE_REQUEST_TO_STREAM: {
+        const t = e;
+        this.triggerParticipantMoveRequestToStream(t);
+        break;
+      }
+      case _.ACCOUNT_CHANGED: {
+        this.triggerAccountChangedNotify();
+        break;
+      }
+      case _.ACCOUNT_DELETED: {
+        this.triggerAccountDeletedNotify();
+        break;
+      }
+      case _.CONFERENCE_PARTICIPANT_TOKEN_ISSUED: {
+        const t = e;
+        this.triggerConferenceParticipantTokenIssued(t);
+        break;
+      }
+      default:
+        P("unknown cmd", e);
+    }
+  };
+  handleNewInfo = (e) => {
+    const { originator: t } = e;
+    if (t !== U.REMOTE)
+      return;
+    const { request: s } = e, i = s.getHeader(g.CONTENT_TYPE_NAME);
+    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(E.CHANNELS_NOTIFY, i);
+  };
+  triggerWebcastStartedNotify = ({
+    body: { conference: e, type: t }
+  }) => {
+    const s = {
+      conference: e,
+      type: t
+    };
+    this.events.trigger(E.WEBCAST_STARTED, s);
+  };
+  triggerWebcastStoppedNotify = ({
+    body: { conference: e, type: t }
+  }) => {
+    const s = {
+      conference: e,
+      type: t
+    };
+    this.events.trigger(E.WEBCAST_STOPPED, s);
+  };
+  triggerAddedToListModeratorsNotify = ({
+    conference: e
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(
+      E.PARTICIPANT_ADDED_TO_LIST_MODERATORS,
+      t
+    );
+  };
+  triggerRemovedFromListModeratorsNotify = ({
+    conference: e
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(
+      E.PARTICIPANT_REMOVED_FROM_LIST_MODERATORS,
+      t
+    );
+  };
+  triggerParticipationAcceptingWordRequest = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(E.PARTICIPATION_ACCEPTING_WORD_REQUEST, t);
+  };
+  triggerParticipationCancellingWordRequest = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(E.PARTICIPATION_CANCELLING_WORD_REQUEST, t);
+  };
+  triggerParticipantMoveRequestToStream = ({
+    body: { conference: e }
+  }) => {
+    const t = {
+      conference: e
+    };
+    this.events.trigger(E.PARTICIPANT_MOVE_REQUEST_TO_STREAM, t);
+  };
+  triggerAccountChangedNotify = () => {
+    this.events.trigger(E.ACCOUNT_CHANGED, void 0);
+  };
+  triggerAccountDeletedNotify = () => {
+    this.events.trigger(E.ACCOUNT_DELETED, void 0);
+  };
+  triggerConferenceParticipantTokenIssued = ({
+    body: { conference: e, participant: t, jwt: s }
+  }) => {
+    const i = {
+      conference: e,
+      participant: t,
+      jwt: s
+    };
+    this.events.trigger(
+      E.CONFERENCE_PARTICIPANT_TOKEN_ISSUED,
+      i
+    );
+  };
+  maybeTriggerChannels = (e) => {
+    const t = e.getHeader(g.INPUT_CHANNELS), s = e.getHeader(g.OUTPUT_CHANNELS);
+    if (t && s) {
+      const i = {
+        inputChannels: t,
+        outputChannels: s
+      };
+      this.events.trigger(E.CHANNELS, i);
+    }
+  };
+  triggerEnterRoom = (e) => {
+    const t = e.getHeader(g.CONTENT_ENTER_ROOM), s = e.getHeader(g.PARTICIPANT_NAME);
+    this.events.trigger(E.ENTER_ROOM, { room: t, participantName: s });
+  };
+  triggerShareState = (e) => {
+    const t = e.getHeader(g.CONTENT_SHARE_STATE);
+    if (t !== void 0)
+      switch (t) {
+        case y.AVAILABLE_SECOND_REMOTE_STREAM: {
+          this.events.trigger(E.AVAILABLE_SECOND_REMOTE_STREAM, void 0);
+          break;
+        }
+        case y.NOT_AVAILABLE_SECOND_REMOTE_STREAM: {
+          this.events.trigger(E.NOT_AVAILABLE_SECOND_REMOTE_STREAM, void 0);
+          break;
+        }
+        case y.MUST_STOP_PRESENTATION: {
+          this.events.trigger(E.MUST_STOP_PRESENTATION, void 0);
+          break;
+        }
+      }
+  };
+  maybeTriggerParticipantMoveRequest = (e) => {
+    const t = e.getHeader(g.CONTENT_PARTICIPANT_STATE);
+    t === w.SPECTATOR && this.events.trigger(E.PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS, void 0), t === w.PARTICIPANT && this.events.trigger(E.PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS, void 0);
+  };
+  triggerMainCamControl = (e) => {
+    const t = e.getHeader(g.MAIN_CAM), s = e.getHeader(g.MEDIA_SYNC), i = s === F.ADMIN_SYNC_FORCED;
+    if (t === m.ADMIN_START_MAIN_CAM) {
+      this.events.trigger(E.ADMIN_START_MAIN_CAM, { isSyncForced: i });
+      return;
+    }
+    if (t === m.ADMIN_STOP_MAIN_CAM) {
+      this.events.trigger(E.ADMIN_STOP_MAIN_CAM, { isSyncForced: i });
+      return;
+    }
+    (t === m.RESUME_MAIN_CAM || t === m.PAUSE_MAIN_CAM) && s !== void 0 && this.events.trigger(E.ADMIN_FORCE_SYNC_MEDIA_STATE, { isSyncForced: i });
+    const r = e.getHeader(g.MAIN_CAM_RESOLUTION);
+    this.events.trigger(E.MAIN_CAM_CONTROL, {
+      mainCam: t,
+      resolutionMainCam: r
+    });
+  };
+  triggerMicControl = (e) => {
+    const t = e.getHeader(g.MIC), i = e.getHeader(g.MEDIA_SYNC) === F.ADMIN_SYNC_FORCED;
+    t === L.ADMIN_START_MIC ? this.events.trigger(E.ADMIN_START_MIC, { isSyncForced: i }) : t === L.ADMIN_STOP_MIC && this.events.trigger(E.ADMIN_STOP_MIC, { isSyncForced: i });
+  };
+  triggerUseLicense = (e) => {
+    const t = e.getHeader(g.CONTENT_USE_LICENSE);
+    this.events.trigger(E.USE_LICENSE, t);
+  };
+}
+class Sn {
+  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 A = /* @__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))(A || {});
+const St = [
+  "connecting",
+  "connected",
+  "disconnected",
+  "newRTCSession",
+  "registered",
+  "unregistered",
+  "registrationFailed",
+  "newMessage",
+  "sipEvent"
+], dn = [...St], hn = 3;
+class ln {
+  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", Et(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(A.DISCONNECTED, () => {
+        s();
+      });
+    }), t = this.getUa();
+    return t ? t.stop() : this.events.trigger(A.DISCONNECTED, void 0), e.finally(() => {
+      this.setUa(void 0), this.stateMachine.reset();
+    });
+  };
+  cancelRequests() {
+    this.cancelConnectWithRepeatedCalls();
+  }
+  connectWithDuplicatedCalls = async (e, { callLimit: t = hn } = {}) => {
+    const s = async () => this.connectInner(e), i = (r) => {
+      const c = this.getUa()?.isConnected() === !0 && this.hasEqualConnectionConfiguration(e), T = r != null && !cn(r);
+      return c || T;
+    };
+    return this.stateMachine.startConnect(), this.cancelableConnectWithRepeatedCalls = G({
+      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: S,
+    displayName: l = "",
+    register: d = !1,
+    extraHeaders: h = []
+  }) => {
+    this.stateMachine.startInitUa(), this.setConnectionConfiguration({
+      sipServerUrl: s,
+      displayName: l,
+      register: d,
+      user: e,
+      password: t
+    }), this.getUa() && await this.disconnect();
+    const { ua: C, helpers: O } = this.uaFactory.createUAWithConfiguration(
+      {
+        user: e,
+        password: t,
+        sipServerUrl: s,
+        sipWebSocketServerURL: i,
+        displayName: l,
+        register: d,
+        sessionTimers: a,
+        registerExpires: o,
+        connectionRecoveryMinInterval: c,
+        connectionRecoveryMaxInterval: T,
+        userAgent: S,
+        remoteAddress: r,
+        extraHeaders: h
+      },
+      this.events
+    );
+    return this.setUa(C), this.setSipServerUrl(O.getSipServerUrl), this.setSocket(O.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 = A.CONNECTED, d = [A.DISCONNECTED];
+      return this.events.on(l, c), d.forEach((h) => {
+        this.events.on(h, T);
+      }), () => {
+        this.events.off(l, c), d.forEach((h) => {
+          this.events.off(h, T);
+        });
+      };
+    })(() => {
+      i?.(), e(s);
+    }, (c) => {
+      i?.(), t(c);
+    }), s.start();
+  });
+  cancelConnectWithRepeatedCalls() {
+    this.cancelableConnectWithRepeatedCalls?.cancel();
+  }
+}
+var dt = /* @__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))(dt || {});
+const Cn = lt({
+  types: {
+    context: {},
+    events: {}
+  },
+  actions: {
+    logTransition: (n, e) => {
+      P(`State transition: ${e.from} -> ${e.to} (${e.event})`);
+    },
+    logStateChange: (n, e) => {
+      P("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 Nn {
+  actor;
+  stateChangeListeners = /* @__PURE__ */ new Set();
+  events;
+  unsubscribeFromEvents;
+  actorSubscription;
+  constructor(e) {
+    this.events = e, this.actor = Ct(Cn), 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(dt).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)) {
+      P(
+        `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 An {
+  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(A.REGISTERED, t), e.on(A.REGISTRATION_FAILED, s), e.register();
+    });
+  }
+  async unregister() {
+    const e = this.getUaProtected();
+    return new Promise((t) => {
+      e.on(A.UNREGISTERED, t), e.unregister();
+    });
+  }
+  async tryRegister() {
+    try {
+      await this.unregister();
+    } catch (e) {
+      P("tryRegister", e);
+    }
+    return this.register();
+  }
+  subscribeToStartEvents(e, t) {
+    const s = A.REGISTERED, i = [A.REGISTRATION_FAILED, A.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 _n {
+  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
+      }), S = this.uaFactory.createUA({ ...T, remoteAddress: r, extraHeaders: a }), l = () => {
+        const h = new Error("Telephony is not available");
+        c(h);
+      };
+      S.once(A.DISCONNECTED, l);
+      const d = () => {
+        S.removeAllListeners(), S.once(A.DISCONNECTED, () => {
+          o();
+        }), S.stop();
+      };
+      S.once(A.CONNECTED, d), S.start();
+    });
+  }
+}
+const un = (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() : `${Jt()}`;
+  }
+  static buildExtraHeaders(e, t) {
+    const s = e !== void 0 && e !== "" ? un(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: S = 6,
+    userAgent: l
+  }) {
+    p.validateConfiguration({
+      register: a,
+      password: t,
+      user: e,
+      sipServerUrl: r,
+      sipWebSocketServerURL: s
+    });
+    const d = p.resolveAuthorizationUser(a, e), h = Qt(r), I = h(d), C = new this.JsSIP.WebSocketInterface(s);
+    return {
+      configuration: {
+        password: t,
+        register: a,
+        uri: I,
+        display_name: Et(i),
+        user_agent: l,
+        sdpSemantics: "unified-plan",
+        sockets: [C],
+        session_timers: o,
+        register_expires: c,
+        connection_recovery_min_interval: T,
+        connection_recovery_max_interval: S
+      },
+      helpers: {
+        socket: C,
+        getSipServerUrl: h
+      }
+    };
+  }
+  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 = St.find((T) => T === o);
+      c && r.on(c, a);
+    }), { ua: r, helpers: i };
+  }
+}
+class In {
+  events;
+  ua;
+  socket;
+  uaFactory;
+  registrationManager;
+  stateMachine;
+  connectionFlow;
+  sipOperations;
+  configurationManager;
+  JsSIP;
+  constructor({ JsSIP: e }) {
+    this.JsSIP = e, this.events = new D(dn), this.uaFactory = new p(e), this.registrationManager = new An({
+      events: this.events,
+      getUaProtected: this.getUaProtected
+    }), this.stateMachine = new Nn(this.events), this.configurationManager = new Sn({
+      getUa: this.getUa
+    }), this.sipOperations = new _n({
+      uaFactory: this.uaFactory,
+      getUaProtected: this.getUaProtected
+    }), this.connectionFlow = new ln({
+      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 f = /* @__PURE__ */ ((n) => (n.INCOMING_CALL = "incomingCall", n.DECLINED_INCOMING_CALL = "declinedIncomingCall", n.TERMINATED_INCOMING_CALL = "terminatedIncomingCall", n.FAILED_INCOMING_CALL = "failedIncomingCall", n))(f || {}), $ = /* @__PURE__ */ ((n) => (n.LOCAL = "local", n.REMOTE = "remote", n.SYSTEM = "system", n))($ || {});
+const Rn = [
+  "incomingCall",
+  "declinedIncomingCall",
+  "terminatedIncomingCall",
+  "failedIncomingCall"
+], Mn = 486, On = 487;
+class pn {
+  incomingRTCSession;
+  connectionManager;
+  events;
+  constructor(e) {
+    this.connectionManager = e, this.events = new D(Rn), 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 = On
+  } = {}) {
+    return new Promise((t, s) => {
+      try {
+        const i = this.getIncomingRTCSession(), r = this.remoteCallerData;
+        this.removeIncomingSession(), this.events.trigger(f.DECLINED_INCOMING_CALL, r), i.terminate({ status_code: e }), t();
+      } catch (i) {
+        s(i);
+      }
+    });
+  }
+  async busyIncomingCall() {
+    return this.declineToIncomingCall({ statusCode: Mn });
+  }
+  // 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(f.TERMINATED_INCOMING_CALL, t) : this.events.trigger(f.FAILED_INCOMING_CALL, t);
+    }), this.events.trigger(f.INCOMING_CALL, t);
+  }
+  removeIncomingSession() {
+    delete this.incomingRTCSession;
+  }
+}
+class $n {
+  connectionManager;
+  callManager;
+  apiManager;
+  incomingCallManager;
+  presentationManager;
+  constructor({ JsSIP: e }) {
+    this.connectionManager = new In({ JsSIP: e }), this.callManager = new tn(), this.apiManager = new gn({
+      connectionManager: this.connectionManager,
+      callManager: this.callManager
+    }), this.incomingCallManager = new pn(this.connectionManager), this.presentationManager = new rn({
+      callManager: this.callManager
+    });
+  }
+  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;
+  }
+  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);
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onConnection(e, t) {
+    return this.connectionManager.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceConnection(e, t) {
+    return this.connectionManager.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRaceConnection(e, t) {
+    return this.connectionManager.onceRace(e, t);
+  }
+  async waitConnection(e) {
+    return this.connectionManager.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  offConnection(e, t) {
+    this.connectionManager.off(e, t);
+  }
+  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);
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onCall(e, t) {
+    return this.callManager.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceCall(e, t) {
+    return this.callManager.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRaceCall(e, t) {
+    return this.callManager.onceRace(e, t);
+  }
+  async waitCall(e) {
+    return this.callManager.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  offIncomingCall(e, t) {
+    this.incomingCallManager.off(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onIncomingCall(e, t) {
+    return this.incomingCallManager.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceIncomingCall(e, t) {
+    return this.incomingCallManager.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRaceIncomingCall(e, t) {
+    return this.incomingCallManager.onceRace(e, t);
+  }
+  async waitIncomingCall(e) {
+    return this.incomingCallManager.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  offCall(e, t) {
+    this.callManager.off(e, t);
+  }
+  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);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onApi(e, t) {
+    return this.apiManager.on(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceApi(e, t) {
+    return this.apiManager.once(e, t);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  onceRaceApi(e, t) {
+    return this.apiManager.onceRace(e, t);
+  }
+  async waitApi(e) {
+    return this.apiManager.wait(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  offApi(e, t) {
+    this.apiManager.off(e, t);
+  }
+}
+export {
+  Wt as B,
+  gt as E,
+  pt as N,
+  it as O,
+  Rt as R,
+  $n as S,
+  at as U,
+  Un as a,
+  wn as b,
+  yn as c,
+  Ln as d,
+  bn as e,
+  Yt as f,
+  U as g,
+  Fn as h,
+  P as l
+};