sip-connector 14.0.0 → 14.1.0-alpha.0

package/dist/doMock.js

@@ -1,73 +1,66 @@
-var y = Object.defineProperty;
-var N = (o, t, e) => t in o ? y(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var r = (o, t, e) => N(o, typeof t != "symbol" ? t + "" : t, e);
-import { n as P, R as O, U as A, S as b } from "./SipConnector-Cc1z-VjV.js";
-import k from "@krivega/jssip/lib/NameAddrHeader";
+import { f as P, R as N, g as O, U as b, S as k } from "./SipConnector-CK3GgjXE.js";
+import A from "@krivega/jssip/lib/NameAddrHeader";
 import D from "@krivega/jssip/lib/URI";
 import { EventEmitter as L } from "node:events";
 import { IncomingRequest as W } from "@krivega/jssip/lib/SIPMessage";
-import { createAudioMediaStreamTrackMock as V, createVideoMediaStreamTrackMock as F } from "webrtc-mock";
-import v from "events-constructor";
-import { URI as E } from "@krivega/jssip";
-class I extends W {
+import { NameAddrHeader as V, URI as h, C as _ } from "@krivega/jssip";
+import { createAudioMediaStreamTrackMock as F, createVideoMediaStreamTrackMock as x } from "webrtc-mock";
+import R from "events-constructor";
+class w extends W {
+  headers;
   constructor(e) {
-    super();
-    r(this, "headers");
-    this.headers = new Headers(e);
+    super(), this.headers = new Headers(e);
   }
   getHeader(e) {
-    return this.headers.get(e) || "";
+    return this.headers.get(e) ?? "";
   }
 }
-class x {
-  // @ts-expect-error
-  constructor({ originator: t = "local", eventHandlers: e }) {
-    r(this, "originator");
-    r(this, "_connection");
-    r(this, "_events");
-    r(this, "_remote_identity");
-    r(this, "_mutedOptions", { audio: !1, video: !1 });
-    this.originator = t, this._events = new v(P), this.initEvents(e);
+class H {
+  originator;
+  connection;
+  events;
+  remote_identity;
+  mutedOptions = { audio: !1, video: !1 };
+  constructor({
+    originator: e = "local",
+    eventHandlers: t,
+    remoteIdentity: r
+  }) {
+    this.originator = e, this.events = new R(P), this.initEvents(t), this.remote_identity = r;
   }
-  // @ts-expect-error
-  get C() {
+  get contact() {
     throw new Error("Method not implemented.");
   }
-  // @ts-expect-error
-  get causes() {
+  get direction() {
     throw new Error("Method not implemented.");
   }
-  get id() {
+  get local_identity() {
     throw new Error("Method not implemented.");
   }
-  set data(t) {
+  get start_time() {
     throw new Error("Method not implemented.");
   }
-  get data() {
+  get end_time() {
     throw new Error("Method not implemented.");
   }
-  get connection() {
-    return this._connection;
-  }
-  get contact() {
+  get status() {
     throw new Error("Method not implemented.");
   }
-  get direction() {
+  // @ts-expect-error
+  get C() {
     throw new Error("Method not implemented.");
   }
-  get local_identity() {
+  // @ts-expect-error
+  get causes() {
     throw new Error("Method not implemented.");
   }
-  get remote_identity() {
-    return this._remote_identity;
-  }
-  get start_time() {
+  get id() {
     throw new Error("Method not implemented.");
   }
-  get end_time() {
+  get data() {
     throw new Error("Method not implemented.");
   }
-  get status() {
+  set data(e) {
     throw new Error("Method not implemented.");
   }
   isInProgress() {
@@ -79,104 +72,97 @@ class x {
   isReadyToReOffer() {
     throw new Error("Method not implemented.");
   }
-  answer(t) {
+  answer(e) {
     throw new Error("Method not implemented.");
   }
-  terminate(t) {
+  terminate(e) {
     throw new Error("Method not implemented.");
   }
-  async sendInfo(t, e, n) {
+  async sendInfo(e, t, r) {
     throw new Error("Method not implemented.");
   }
-  hold(t, e) {
+  hold(e, t) {
     throw new Error("Method not implemented.");
   }
-  unhold(t, e) {
+  unhold(e, t) {
     throw new Error("Method not implemented.");
   }
-  async renegotiate(t, e) {
+  async renegotiate(e, t) {
     throw new Error("Method not implemented.");
   }
   isOnHold() {
     throw new Error("Method not implemented.");
   }
-  mute(t) {
+  mute(e) {
     throw new Error("Method not implemented.");
   }
-  unmute(t) {
+  unmute(e) {
     throw new Error("Method not implemented.");
   }
   isMuted() {
     throw new Error("Method not implemented.");
   }
-  refer(t, e) {
+  refer(e, t) {
     throw new Error("Method not implemented.");
   }
   resetLocalMedia() {
     throw new Error("Method not implemented.");
   }
-  async replaceMediaStream(t, e) {
+  async replaceMediaStream(e, t) {
     throw new Error("Method not implemented.");
   }
-  addListener(t, e) {
+  addListener(e, t) {
     throw new Error("Method not implemented.");
   }
-  once(t, e) {
+  once(e, t) {
     throw new Error("Method not implemented.");
   }
-  removeListener(t, e) {
+  removeListener(e, t) {
     throw new Error("Method not implemented.");
   }
-  off(t, e) {
-    throw new Error("Method not implemented.");
+  off(e, t) {
+    return this.events.off(e, t), this;
   }
-  removeAllListeners(t) {
-    throw new Error("Method not implemented.");
+  removeAllListeners(e) {
+    return console.warn("Method not implemented. Event:", e), this;
   }
-  setMaxListeners(t) {
+  setMaxListeners(e) {
     throw new Error("Method not implemented.");
   }
   getMaxListeners() {
     throw new Error("Method not implemented.");
   }
-  listeners(t) {
+  listeners(e) {
     throw new Error("Method not implemented.");
   }
-  rawListeners(t) {
+  rawListeners(e) {
     throw new Error("Method not implemented.");
   }
-  emit(t, ...e) {
+  emit(e, ...t) {
     throw new Error("Method not implemented.");
   }
-  listenerCount(t) {
+  listenerCount(e) {
     throw new Error("Method not implemented.");
   }
-  prependListener(t, e) {
+  prependListener(e, t) {
     throw new Error("Method not implemented.");
   }
-  prependOnceListener(t, e) {
+  prependOnceListener(e, t) {
     throw new Error("Method not implemented.");
   }
   eventNames() {
     throw new Error("Method not implemented.");
   }
-  /**
-   * initEvents
-   *
-   * @param {Array} [eventHandlers=[] - ]  The event handlers
-   *
-   * @returns {undefined}
-   */
-  initEvents(t = []) {
-    Object.entries(t).forEach(([e, n]) => this.on(e, n));
+  initEvents(e) {
+    e && Object.entries(e).forEach(([t, r]) => this.on(t, r));
   }
   // @ts-expect-error
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
-  on(t, e) {
-    return this._events.on(t, e), this;
+  on(e, t) {
+    return this.events.on(e, t), this;
   }
-  trigger(t, e) {
-    this._events.trigger(t, e);
+  trigger(e, t) {
+    this.events.trigger(e, t);
   }
   /**
    * sendDTMF
@@ -188,103 +174,98 @@ class x {
   sendDTMF() {
     this.trigger("newDTMF", { originator: this.originator });
   }
-  async startPresentation(t) {
-    return t;
-  }
-  async updatePresentation(t) {
-    return t;
+  async startPresentation(e) {
+    return this.trigger("presentation:start", e), this.trigger("presentation:started", e), e;
   }
-  async stopPresentation(t) {
-    return t;
+  async stopPresentation(e) {
+    return this.trigger("presentation:end", e), this.trigger("presentation:ended", e), e;
   }
   isEstablished() {
     return !0;
   }
 }
-class U {
-  constructor({ track: t } = {}) {
-    r(this, "dtmf", null);
-    r(this, "track", null);
-    r(this, "transport", null);
-    r(this, "transform", null);
-    r(this, "_parameters", {
-      encodings: [{}],
-      transactionId: "0",
-      codecs: [],
-      headerExtensions: [],
-      rtcp: {}
-    });
-    r(this, "_parametersGets");
-    this.track = t ?? null;
+class j {
+  dtmf = null;
+  track = null;
+  transport = null;
+  transform = null;
+  parameters = {
+    encodings: [{}],
+    transactionId: "0",
+    codecs: [],
+    headerExtensions: [],
+    rtcp: {}
+  };
+  parametersGets;
+  constructor({ track: e } = {}) {
+    this.track = e ?? null;
   }
+  // eslint-disable-next-line class-methods-use-this
   async getStats() {
     throw new Error("Method not implemented.");
   }
-  async replaceTrack(t) {
-    this.track = t ?? null;
+  async replaceTrack(e) {
+    this.track = e ?? null;
   }
-  async setParameters(t) {
-    if (t !== this._parametersGets)
+  async setParameters(e) {
+    if (e !== this.parametersGets)
       throw new Error(
         "Failed to execute 'setParameters' on 'RTCRtpSender': Read-only field modified in setParameters()."
       );
-    const { transactionId: e } = this._parameters;
-    this._parameters = {
-      ...this._parameters,
-      ...t,
-      transactionId: `${Number(e) + 1}`
+    const { transactionId: t } = this.parameters;
+    this.parameters = {
+      ...this.parameters,
+      ...e,
+      transactionId: `${Number(t) + 1}`
     };
   }
   getParameters() {
-    return this._parametersGets = { ...this._parameters }, this._parametersGets;
+    return this.parametersGets = { ...this.parameters }, this.parametersGets;
   }
+  // eslint-disable-next-line class-methods-use-this
   setStreams() {
     throw new Error("Method not implemented.");
   }
 }
-class H {
-  constructor(t, e) {
-    r(this, "_senders", []);
-    r(this, "_receivers", []);
-    r(this, "canTrickleIceCandidates");
-    r(this, "connectionState");
-    r(this, "currentLocalDescription");
-    r(this, "currentRemoteDescription");
-    r(this, "iceConnectionState");
-    r(this, "iceGatheringState");
-    r(this, "idpErrorInfo");
-    r(this, "idpLoginUrl");
-    r(this, "localDescription");
-    r(this, "onconnectionstatechange");
-    r(this, "ondatachannel");
-    r(this, "onicecandidate");
-    r(this, "onicecandidateerror", null);
-    r(this, "oniceconnectionstatechange");
-    r(this, "onicegatheringstatechange");
-    r(this, "onnegotiationneeded");
-    r(this, "onsignalingstatechange");
-    r(this, "ontrack");
-    r(this, "peerIdentity");
-    r(this, "pendingLocalDescription");
-    r(this, "pendingRemoteDescription");
-    r(this, "remoteDescription");
-    r(this, "sctp", null);
-    r(this, "signalingState");
-    r(this, "getReceivers", () => this._receivers);
-    r(this, "getSenders", () => this._senders);
-    r(this, "addTrack", (t) => {
-      const e = new U({ track: t });
-      return this._senders.push(e), e;
-    });
-    this._receivers = e.map((n) => ({ track: n }));
+class z {
+  senders = [];
+  receivers = [];
+  canTrickleIceCandidates;
+  connectionState;
+  currentLocalDescription;
+  currentRemoteDescription;
+  iceConnectionState;
+  iceGatheringState;
+  idpErrorInfo;
+  idpLoginUrl;
+  localDescription;
+  onconnectionstatechange;
+  ondatachannel;
+  onicecandidate;
+  // eslint-disable-next-line unicorn/no-null
+  onicecandidateerror = null;
+  oniceconnectionstatechange;
+  onicegatheringstatechange;
+  onnegotiationneeded;
+  onsignalingstatechange;
+  ontrack;
+  peerIdentity = void 0;
+  pendingLocalDescription;
+  pendingRemoteDescription;
+  remoteDescription;
+  // eslint-disable-next-line unicorn/no-null
+  sctp = null;
+  signalingState;
+  constructor(e, t) {
+    this.receivers = t.map((r) => ({ track: r }));
   }
   getRemoteStreams() {
     throw new Error("Method not implemented.");
   }
-  async addIceCandidate(t) {
+  async addIceCandidate(e) {
     throw new Error("Method not implemented.");
   }
-  addTransceiver(t, e) {
+  addTransceiver(e, t) {
     throw new Error("Method not implemented.");
   }
   close() {
@@ -293,13 +274,13 @@ class H {
   restartIce() {
     throw new Error("Method not implemented.");
   }
-  async createAnswer(t, e) {
+  async createAnswer(e, t) {
     throw new Error("Method not implemented.");
   }
-  createDataChannel(t, e) {
+  createDataChannel(e, t) {
     throw new Error("Method not implemented.");
   }
-  async createOffer(t, e, n) {
+  async createOffer(e, t, r) {
     throw new Error("Method not implemented.");
   }
   getConfiguration() {
@@ -308,108 +289,144 @@ class H {
   async getIdentityAssertion() {
     throw new Error("Method not implemented.");
   }
-  async getStats(t) {
+  async getStats(e) {
     throw new Error("Method not implemented.");
   }
   getTransceivers() {
     throw new Error("Method not implemented.");
   }
-  removeTrack(t) {
+  removeTrack(e) {
     throw new Error("Method not implemented.");
   }
-  setConfiguration(t) {
+  setConfiguration(e) {
     throw new Error("Method not implemented.");
   }
-  async setLocalDescription(t) {
+  async setLocalDescription(e) {
     throw new Error("Method not implemented.");
   }
-  async setRemoteDescription(t) {
+  async setRemoteDescription(e) {
     throw new Error("Method not implemented.");
   }
-  addEventListener(t, e, n) {
-    throw new Error("Method not implemented.");
+  addEventListener(e, t, r) {
+    console.warn("Method not implemented. Type:", e);
   }
-  removeEventListener(t, e, n) {
-    throw new Error("Method not implemented.");
+  removeEventListener(e, t, r) {
+    console.warn("Method not implemented. Type:", e);
   }
-  dispatchEvent(t) {
+  dispatchEvent(e) {
     throw new Error("Method not implemented.");
   }
+  getReceivers = () => this.receivers;
+  getSenders = () => this.senders;
+  addTrack = (e) => {
+    const t = new j({ track: e });
+    return this.senders.push(t), t;
+  };
 }
-function z(o) {
-  const t = o.match(/(purgatory)|[\d.]+/g);
-  if (!t)
+function Y(n) {
+  const e = n.match(/(purgatory)|[\d.]+/g);
+  if (!e)
     throw new Error("wrong sip url");
-  return t[0];
+  return e[0];
 }
-const p = 400, Y = "777", q = (o) => o.getVideoTracks().length > 0, a = class a extends x {
+const p = 400, q = "777", J = (n) => n.getVideoTracks().length > 0;
+class i extends H {
+  static presentationError;
+  static startPresentationError;
+  static countStartPresentationError = Number.POSITIVE_INFINITY;
+  static countStartsPresentation = 0;
+  url;
+  status_code;
+  /**
+       * answer
+       *
+       * @param {Object} arg1               - The argument 1
+       * @param {Object} arg1.mediaStream   - The media stream
+       * @param {Array}  arg1.eventHandlers - The event handlers
+  
+   * @returns {undefined}
+       */
+  answer = jest.fn(({ mediaStream: e }) => {
+    if (this.originator !== "remote")
+      throw new Error("answer available only for remote sessions");
+    this.initPeerconnection(e), setTimeout(() => {
+      this.trigger("connecting"), setTimeout(() => {
+        this.trigger("accepted");
+      }, 100), setTimeout(() => {
+        this.trigger("confirmed");
+      }, 200);
+    }, p);
+  });
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  replaceMediaStream = jest.fn(async (e) => {
+  });
+  isEndedInner = !1;
   constructor({
     url: e = "",
-    mediaStream: n,
-    eventHandlers: i,
-    originator: d
+    mediaStream: t,
+    eventHandlers: r,
+    originator: s,
+    remoteIdentity: a = new V(
+      new h("sip", "caller1", "test1.com", 5060),
+      "Test Caller 1"
+    )
   }) {
-    super({ originator: d, eventHandlers: i });
-    r(this, "url");
-    r(this, "status_code");
-    r(this, "_isEnded", !1);
-    /**
-         * answer
-         *
-         * @param {Object} arg1               - The argument 1
-         * @param {Object} arg1.mediaStream   - The media stream
-         * @param {Array}  arg1.eventHandlers - The event handlers
-    
-     * @returns {undefined}
-         */
-    r(this, "answer", jest.fn(({ mediaStream: e }) => {
-      if (this.originator !== "remote")
-        throw new Error("answer available only for remote sessions");
-      this.initPeerconnection(e), setTimeout(() => {
-        this.trigger("connecting"), setTimeout(() => {
-          this.trigger("accepted");
-        }, 100), setTimeout(() => {
-          this.trigger("confirmed");
-        }, 200);
-      }, p);
-    }));
-    this.url = e, this.initPeerconnection(n);
-  }
-  static setStartPresentationError(e, { count: n = Number.POSITIVE_INFINITY } = {}) {
-    this.startPresentationError = e, this.countStartPresentationError = n;
+    super({ originator: s, eventHandlers: r, remoteIdentity: a }), this.url = e, this.initPeerconnection(t);
+  }
+  static setPresentationError(e) {
+    this.presentationError = e;
+  }
+  static resetPresentationError() {
+    this.presentationError = void 0;
+  }
+  static setStartPresentationError(e, { count: t = Number.POSITIVE_INFINITY } = {}) {
+    this.startPresentationError = e, this.countStartPresentationError = t;
   }
   static resetStartPresentationError() {
     this.startPresentationError = void 0, this.countStartPresentationError = Number.POSITIVE_INFINITY, this.countStartsPresentation = 0;
   }
-  async startPresentation(e) {
-    if (a.countStartsPresentation += 1, a.startPresentationError && a.countStartsPresentation < a.countStartPresentationError)
-      throw a.startPresentationError;
+  startPresentation = async (e) => {
+    if (i.countStartsPresentation += 1, i.presentationError)
+      throw this.trigger("presentation:start", e), this.trigger("presentation:failed", e), i.presentationError;
+    if (i.startPresentationError && i.countStartsPresentation < i.countStartPresentationError)
+      throw this.trigger("presentation:start", e), this.trigger("presentation:failed", e), i.startPresentationError;
     return super.startPresentation(e);
-  }
+  };
+  stopPresentation = async (e) => {
+    if (i.presentationError)
+      throw this.trigger("presentation:end", e), this.trigger("presentation:failed", e), i.presentationError;
+    return super.stopPresentation(e);
+  };
   initPeerconnection(e) {
     return e ? (this.createPeerconnection(e), !0) : !1;
   }
   createPeerconnection(e) {
-    const n = V();
-    n.id = "mainaudio1";
-    const i = [n];
-    if (q(e)) {
-      const h = F();
-      h.id = "mainvideo1", i.push(h);
+    const t = F();
+    t.id = "mainaudio1";
+    const r = [t];
+    if (J(e)) {
+      const a = x();
+      a.id = "mainvideo1", r.push(a);
     }
-    this._connection = new H(void 0, i), this._addStream(e), setTimeout(() => {
+    this.connection = new z(void 0, r), this.addStream(e), setTimeout(() => {
       this.trigger("peerconnection", { peerconnection: this.connection });
     }, p);
   }
   connect(e) {
-    const n = z(e);
+    const t = Y(e);
     setTimeout(() => {
-      this.url.includes(Y) ? this.trigger("failed", {
+      this.url.includes(q) ? this.trigger("failed", {
         originator: "remote",
         message: "IncomingResponse",
-        cause: O
+        cause: N
       }) : (this.trigger("connecting"), setTimeout(() => {
-        this.trigger("enterRoom", { room: n });
+        this.newInfo({
+          originator: O.REMOTE,
+          // @ts-expect-error
+          request: {
+            getHeader: (r) => r === "content-type" ? "application/vinteo.webrtc.roomname" : r === "x-webrtc-enter-room" ? t : r === "x-webrtc-participant-name" ? "Test Caller 1" : ""
+          }
+        });
       }, 100), setTimeout(() => {
         this.trigger("accepted");
       }, 200), setTimeout(() => {
@@ -417,153 +434,162 @@ const p = 400, Y = "777", q = (o) => o.getVideoTracks().length > 0, a = class a
       }, 300));
     }, p);
   }
-  terminate({ status_code: e } = {}) {
-    return this.status_code = e, this.trigger("ended", { status_code: e }), this._isEnded = !1, this;
+  terminate({ status_code: e, cause: t } = {}) {
+    return this.status_code = e, this.trigger("ended", { status_code: e, cause: t, originator: "local" }), this.isEndedInner = !1, this;
   }
-  async terminateAsync({ status_code: e } = {}) {
-    this.terminate({ status_code: e });
+  async terminateAsync({
+    status_code: e,
+    cause: t
+  } = {}) {
+    this.terminate({ status_code: e, cause: t });
   }
   terminateRemote({ status_code: e } = {}) {
     return this.status_code = e, this.trigger("ended", { status_code: e, originator: "remote" }), this;
   }
-  _addStream(e, n = "getTracks") {
-    e[n]().forEach((i) => this.connection.addTrack(i));
+  addStream(e, t = "getTracks") {
+    e[t]().forEach((r) => this.connection.addTrack(r));
   }
-  _forEachSenders(e) {
-    const n = this.connection.getSenders();
-    for (const i of n)
-      e(i);
-    return n;
+  forEachSenders(e) {
+    const t = this.connection.getSenders();
+    for (const r of t)
+      e(r);
+    return t;
   }
   /* eslint-disable no-param-reassign */
-  _toggleMuteAudio(e) {
-    this._forEachSenders(({ track: n }) => {
-      n && n.kind === "audio" && (n.enabled = !e);
+  toggleMuteAudio(e) {
+    this.forEachSenders(({ track: t }) => {
+      t && t.kind === "audio" && (t.enabled = !e);
     });
   }
   /* eslint-enable no-param-reassign */
   /* eslint-disable no-param-reassign */
-  _toggleMuteVideo(e) {
-    this._forEachSenders(({ track: n }) => {
-      n && n.kind === "video" && (n.enabled = !e);
+  toggleMuteVideo(e) {
+    this.forEachSenders(({ track: t }) => {
+      t && t.kind === "video" && (t.enabled = !e);
     });
   }
   mute(e) {
-    e.audio && (this._mutedOptions.audio = !0, this._toggleMuteAudio(this._mutedOptions.audio)), e.video && (this._mutedOptions.video = !0, this._toggleMuteVideo(this._mutedOptions.video)), this._onmute(e);
+    e.audio && (this.mutedOptions.audio = !0, this.toggleMuteAudio(this.mutedOptions.audio)), e.video && (this.mutedOptions.video = !0, this.toggleMuteVideo(this.mutedOptions.video)), this.onmute(e);
   }
   unmute(e) {
-    e.audio && (this._mutedOptions.audio = !1), e.video && (this._mutedOptions.video = !1), this.trigger("unmuted", e);
+    e.audio && (this.mutedOptions.audio = !1), e.video && (this.mutedOptions.video = !1), this.trigger("unmuted", e);
   }
   isMuted() {
-    return this._mutedOptions;
+    return this.mutedOptions;
   }
-  async replaceMediaStream(e) {
-    return e;
-  }
-  _onmute({ audio: e, video: n }) {
+  onmute({ audio: e, video: t }) {
     this.trigger("muted", {
       audio: e,
-      video: n
+      video: t
     });
   }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function, class-methods-use-this
   async sendInfo() {
   }
   isEnded() {
-    return this._isEnded;
+    return this.isEndedInner;
   }
   newInfo(e) {
     this.trigger("newInfo", e);
   }
   /* eslint-enable no-param-reassign */
-};
-r(a, "startPresentationError"), r(a, "countStartPresentationError", Number.POSITIVE_INFINITY), r(a, "countStartsPresentation", 0);
-let u = a;
-class G {
-  constructor() {
-    r(this, "extraHeaders", []);
-  }
-  setExtraHeaders(t) {
-    this.extraHeaders = t;
+}
+class $ {
+  extraHeaders = [];
+  setExtraHeaders(e) {
+    this.extraHeaders = e;
   }
+  // eslint-disable-next-line class-methods-use-this
   setExtraContactParams() {
   }
 }
-const c = "PASSWORD_CORRECT", T = "PASSWORD_CORRECT_2", j = "NAME_INCORRECT", m = 400, s = class s {
-  constructor(t) {
-    r(this, "_events");
-    r(this, "_startedTimeout");
-    r(this, "_stopedTimeout");
-    r(this, "session");
-    r(this, "_isRegistered");
-    r(this, "_isConnected");
-    r(this, "configuration");
-    r(this, "_registrator");
-    // @ts-expect-error
-    r(this, "call", jest.fn((t, e) => {
-      const { mediaStream: n, eventHandlers: i } = e;
-      return this.session = new u({ url: t, mediaStream: n, eventHandlers: i, originator: "local" }), this.session.connect(t), this.session;
-    }));
-    this._events = new v(A);
-    const [e, n] = t.uri.split(":"), [i, d] = n.split("@"), h = {
-      ...t,
-      uri: new E(e, i, d)
-    };
-    this.configuration = h, this._registrator = new G();
-  }
-  static setStartError(t, { count: e = Number.POSITIVE_INFINITY } = {}) {
-    this.startError = t, this.countStartError = e;
-  }
-  static resetStartError() {
-    this.startError = void 0, this.countStartError = Number.POSITIVE_INFINITY, this.countStarts = 0;
-  }
-  static setAvailableTelephony() {
-    this.isAvailableTelephony = !0;
-  }
-  static setNotAvailableTelephony() {
-    this.isAvailableTelephony = !1;
-  }
-  isConnected() {
-    return !!this._isConnected;
-  }
+const d = "PASSWORD_CORRECT", v = "PASSWORD_CORRECT_2", G = "NAME_INCORRECT", c = 400, g = {
+  url: "wss://sipServerUrl/webrtc/wss/",
+  sip_uri: "sip:sipServerUrl;transport=ws",
+  via_transport: "WSS"
+}, M = {
+  status_code: 200,
+  reason_phrase: "OK"
+}, T = {
+  status_code: 401,
+  reason_phrase: "Unauthorized"
+};
+class o {
+  static isAvailableTelephony = !0;
+  static startError;
+  static countStartError = Number.POSITIVE_INFINITY;
+  static countStarts = 0;
+  events;
+  registratorInner;
+  // @ts-expect-error – Jest создаёт функцию-замок.
+  call = jest.fn(
+    (e, t) => {
+      const { mediaStream: r, eventHandlers: s } = t;
+      return this.session = new i({ url: e, mediaStream: r, eventHandlers: s, originator: "local" }), this.session.connect(e), this.session;
+    }
+  );
+  sendOptions = jest.fn(
+    (e, t, r) => {
+      console.log("sendOptions", e, t, r);
+    }
+  );
   /**
-   * start
-   *
-   * @returns {undefined}
+   * start – имитирует запуск UA.
    */
-  start() {
-    if (s.countStarts += 1, s.startError && s.countStarts < s.countStartError) {
-      this.trigger("disconnected", s.startError);
+  start = jest.fn(() => {
+    if (o.countStarts += 1, o.startError && o.countStarts < o.countStartError) {
+      this.trigger("disconnected", o.startError);
       return;
     }
     this.register();
-  }
+  });
   /**
-   * stop
-   *
-   * @returns {undefined}
+   * stop – имитирует остановку UA.
    */
-  stop() {
-    this._startedTimeout && clearTimeout(this._startedTimeout), this._stopedTimeout && clearTimeout(this._stopedTimeout), this.unregister(), this.isStarted() ? this._stopedTimeout = setTimeout(() => {
-      this.trigger("disconnected", { error: new Error("stoped") });
-    }, m) : this.trigger("disconnected", { error: new Error("stoped") });
+  stop = jest.fn(() => {
+    this.startedTimeout && clearTimeout(this.startedTimeout), this.stopedTimeout && clearTimeout(this.stopedTimeout), this.unregister(), this.isStarted() ? this.stopedTimeout = setTimeout(() => {
+      this.trigger("disconnected", { error: !0, socket: g });
+    }, c) : this.trigger("disconnected", { error: !0, socket: g });
+  });
+  removeAllListeners = jest.fn(() => (this.events.removeEventHandlers(), this));
+  once = jest.fn((e, t) => (this.events.once(e, t), this));
+  startedTimeout;
+  stopedTimeout;
+  session;
+  isRegisteredInner;
+  isConnectedInner;
+  configuration;
+  constructor(e) {
+    this.events = new R(b);
+    const [t, r] = e.uri.split(":"), [s, a] = r.split("@"), l = {
+      ...e,
+      uri: new h(t, s, a)
+    };
+    this.configuration = l, this.registratorInner = new $();
   }
-  // @ts-expect-error
-  on(t, e) {
-    return this._events.on(t, e), this;
+  static setStartError(e, { count: t = Number.POSITIVE_INFINITY } = {}) {
+    o.startError = e, o.countStartError = t;
   }
-  // @ts-expect-error
-  once(t, e) {
-    return this._events.once(t, e), this;
+  static resetStartError() {
+    o.startError = void 0, o.countStartError = Number.POSITIVE_INFINITY, o.countStarts = 0;
   }
-  // @ts-expect-error
-  off(t, e) {
-    return this._events.off(t, e), this;
+  static setAvailableTelephony() {
+    o.isAvailableTelephony = !0;
+  }
+  static setNotAvailableTelephony() {
+    o.isAvailableTelephony = !1;
   }
-  removeAllListeners() {
-    return this._events.removeEventHandlers(), this;
+  static reset() {
+    o.resetStartError(), o.setAvailableTelephony();
   }
-  trigger(t, e) {
-    this._events.trigger(t, e);
+  on(e, t) {
+    return this.events.on(e, t), this;
+  }
+  off(e, t) {
+    return this.events.off(e, t), this;
+  }
+  trigger(e, t) {
+    this.events.trigger(e, t);
   }
   /**
    * terminateSessions
@@ -571,18 +597,10 @@ const c = "PASSWORD_CORRECT", T = "PASSWORD_CORRECT_2", j = "NAME_INCORRECT", m
    * @returns {undefined}
    */
   terminateSessions() {
-    this.session.terminate();
+    this.session?.terminate();
   }
-  /**
-   * set
-   *
-   * @param {string} key   - key
-   * @param {string} value - value
-   *
-   * @returns {boolean} true
-   */
-  set(t, e) {
-    return this.configuration[t] = e, !0;
+  set(e, t) {
+    return this.configuration[e] = t, !0;
   }
   /**
    * register
@@ -590,15 +608,15 @@ const c = "PASSWORD_CORRECT", T = "PASSWORD_CORRECT_2", j = "NAME_INCORRECT", m
    * @returns {undefined}
    */
   register() {
-    this._startedTimeout && clearTimeout(this._startedTimeout);
-    const { password: t, register: e, uri: n } = this.configuration;
-    e && n.user.includes(j) ? (this._isRegistered = !1, this._isConnected = !1, this._startedTimeout = setTimeout(() => {
-      this.trigger("registrationFailed", { response: null, cause: "Request Timeout" });
-    }, m)) : !this._isRegistered && e && (t === c || t === T) ? (this._isRegistered = !0, this._startedTimeout = setTimeout(() => {
-      this.trigger("registered");
-    }, m)) : e && t !== c && t !== T && (this._isRegistered = !1, this._isConnected = !1, this._startedTimeout = setTimeout(() => {
-      this.trigger("registrationFailed", { response: null, cause: "Wrong credentials" });
-    }, m)), s.isAvailableTelephony ? (this.trigger("connected"), this._isConnected = !0) : this.stop();
+    this.startedTimeout && clearTimeout(this.startedTimeout);
+    const { password: e, register: t, uri: r } = this.configuration;
+    t === !0 && r.user.includes(G) ? (this.isRegisteredInner = !1, this.isConnectedInner = !1, this.startedTimeout = setTimeout(() => {
+      this.trigger("registrationFailed", { response: T, cause: _.causes.REJECTED });
+    }, c)) : !this.isRegistered() && t === !0 && (e === d || e === v) ? (this.isRegisteredInner = !0, this.startedTimeout = setTimeout(() => {
+      this.trigger("registered", { response: M });
+    }, c)) : t === !0 && e !== d && e !== v && (this.isRegisteredInner = !1, this.isConnectedInner = !1, this.startedTimeout = setTimeout(() => {
+      this.trigger("registrationFailed", { response: T, cause: _.causes.REJECTED });
+    }, c)), o.isAvailableTelephony ? (this.trigger("connected", { socket: g }), this.isConnectedInner = !0) : this.stop();
   }
   /**
    * unregister
@@ -606,15 +624,13 @@ const c = "PASSWORD_CORRECT", T = "PASSWORD_CORRECT_2", j = "NAME_INCORRECT", m
    * @returns {undefined}
    */
   unregister() {
-    this._isRegistered = !1, this._isConnected = !1, this.trigger("unregistered");
+    this.isRegisteredInner = !1, this.isConnectedInner = !1, this.trigger("unregistered", { response: M });
   }
-  /**
-   * isRegistered
-   *
-   * @returns {boolean} isRegistered
-   */
   isRegistered() {
-    return !!this._isRegistered;
+    return this.isRegisteredInner === !0;
+  }
+  isConnected() {
+    return this.isConnectedInner === !0;
   }
   /**
    * isStarted
@@ -622,127 +638,131 @@ const c = "PASSWORD_CORRECT", T = "PASSWORD_CORRECT_2", j = "NAME_INCORRECT", m
    * @returns {boolean} isStarted
    */
   isStarted() {
-    return this.configuration && (this.configuration.register && !!this._isRegistered || !this.configuration.register && !!this._isConnected);
+    return this.configuration.register === !0 && this.isRegisteredInner === !0 || this.configuration.register !== !0 && this.isConnectedInner === !0;
   }
-  registrator() {
-    return this._registrator;
+  newSipEvent(e) {
+    this.trigger("sipEvent", e);
   }
-  newSipEvent(t) {
-    this.trigger("sipEvent", t);
+  registrator() {
+    return this.registratorInner;
   }
-};
-r(s, "isAvailableTelephony", !0), r(s, "startError"), r(s, "countStartError", Number.POSITIVE_INFINITY), r(s, "countStarts", 0);
-let _ = s;
-class B {
-  constructor(t) {
-    r(this, "url");
-    this.url = t;
+}
+class U {
+  url;
+  constructor(e) {
+    this.url = e;
   }
 }
-class $ extends L {
-  constructor(e, n) {
-    super();
-    r(this, "contentType");
-    r(this, "body");
-    this.contentType = e, this.body = n;
+class B extends L {
+  contentType;
+  body;
+  constructor(e, t) {
+    super(), this.contentType = e, this.body = t;
   }
 }
-const w = "remote", K = (o, t) => {
-  const e = new I(t), n = {
-    originator: w,
-    request: e,
-    info: new $("", "")
+const E = "remote", K = (n, e) => {
+  const t = new w(e), r = {
+    originator: E,
+    request: t,
+    info: new B("", "")
   };
-  o.newInfo(n);
-}, J = (o, t) => {
-  const n = { request: new I(t) };
-  o.newSipEvent(n);
-}, X = (o, {
-  incomingNumber: t = "1234",
-  displayName: e,
-  host: n
+  n.newInfo(r);
+}, X = (n, e) => {
+  const r = { event: "sipEvent", request: new w(e) };
+  n.newSipEvent(r);
+}, Q = (n, {
+  incomingNumber: e = "1234",
+  displayName: t,
+  host: r
 }) => {
-  const i = new u({ originator: w }), d = new D("sip", t, n);
-  i._remote_identity = new k(d, e), o.trigger("newRTCSession", { originator: w, session: i });
-}, Q = (o, t) => {
-  t ? o.trigger("failed", t) : o.trigger("failed", o);
-}, R = {
+  const s = new i({ originator: E, eventHandlers: {} }), a = new D("sip", e, r);
+  s.remote_identity = new A(a, t);
+  const l = new w([]);
+  n.trigger("newRTCSession", {
+    originator: E,
+    session: s,
+    request: l
+  });
+}, Z = (n, e) => {
+  e ? n.trigger("failed", e) : n.trigger("failed", n);
+}, C = {
   triggerNewInfo: K,
-  triggerNewSipEvent: J,
-  triggerIncomingSession: X,
-  triggerFailIncomingSession: Q,
-  WebSocketInterface: B,
-  UA: _,
+  triggerNewSipEvent: X,
+  triggerIncomingSession: Q,
+  triggerFailIncomingSession: Z,
+  WebSocketInterface: U,
+  UA: o,
   C: {
     INVITE: "INVITE"
   }
-}, f = "user", l = "displayName", S = "SIP_SERVER_URL", C = "SIP_WEB_SOCKET_SERVER_URL", Z = new R.WebSocketInterface(C), M = {
+}, f = "user", m = "displayName", S = "SIP_SERVER_URL", y = "SIP_WEB_SOCKET_SERVER_URL", ee = new C.WebSocketInterface(y), I = {
   userAgent: "Chrome",
   sipServerUrl: S,
-  sipWebSocketServerURL: C
+  sipWebSocketServerURL: y
 }, me = {
-  ...M
-}, ee = {
-  ...M,
+  ...I
+}, te = {
+  ...I,
   user: f,
-  password: c,
+  password: d,
   register: !0
 }, ue = {
-  ...ee,
-  displayName: l
+  ...te,
+  displayName: m
 }, le = {
-  ...M,
-  displayName: l,
+  ...I,
+  displayName: m,
   register: !1
-}, g = {
+}, u = {
   session_timers: !1,
-  sockets: [Z],
+  sockets: [ee],
   user_agent: "Chrome",
-  sdp_semantics: "unified-plan",
+  sdpSemantics: "unified-plan",
   register_expires: 300,
   connection_recovery_max_interval: 6,
   connection_recovery_min_interval: 2
-}, ge = {
-  ...g,
-  password: c,
-  uri: new E("sip", f, S),
+}, pe = {
+  ...u,
+  password: d,
+  uri: new h("sip", f, S),
   display_name: "",
   register: !0
-}, pe = {
-  ...g,
-  password: c,
-  uri: new E("sip", f, S),
-  display_name: l,
+}, ge = {
+  ...u,
+  password: d,
+  uri: new h("sip", f, S),
+  display_name: m,
   register: !0
-}, _e = {
-  ...g,
-  display_name: l,
+}, Ee = {
+  ...u,
+  display_name: m,
   register: !1
 }, we = {
-  ...g,
+  ...u,
   display_name: "",
   register: !1
-}, te = "10.10.10.10", Ee = [`X-Vinteo-Remote: ${te}`], fe = () => new b({
-  JsSIP: R
+}, re = "10.10.10.10", fe = [`X-Vinteo-Remote: ${re}`], Se = () => new k({
+  JsSIP: C
 });
 export {
-  Y as FAILED_CONFERENCE_NUMBER,
-  j as NAME_INCORRECT,
-  c as PASSWORD_CORRECT,
-  T as PASSWORD_CORRECT_2,
+  q as FAILED_CONFERENCE_NUMBER,
+  C as JsSIP,
+  G as NAME_INCORRECT,
+  d as PASSWORD_CORRECT,
+  v as PASSWORD_CORRECT_2,
   S as SIP_SERVER_URL,
-  C as SIP_WEB_SOCKET_SERVER_URL,
-  ee as dataForConnectionWithAuthorization,
+  y as SIP_WEB_SOCKET_SERVER_URL,
+  te as dataForConnectionWithAuthorization,
   ue as dataForConnectionWithAuthorizationWithDisplayName,
   le as dataForConnectionWithoutAuthorization,
   me as dataForConnectionWithoutAuthorizationWithoutDisplayName,
-  l as displayName,
-  fe as doMockSipConnector,
-  Ee as extraHeadersRemoteAddress,
-  te as remoteAddress,
-  ge as uaConfigurationWithAuthorization,
-  pe as uaConfigurationWithAuthorizationWithDisplayName,
-  _e as uaConfigurationWithoutAuthorization,
+  m as displayName,
+  Se as doMockSipConnector,
+  fe as extraHeadersRemoteAddress,
+  re as remoteAddress,
+  pe as uaConfigurationWithAuthorization,
+  ge as uaConfigurationWithAuthorizationWithDisplayName,
+  Ee as uaConfigurationWithoutAuthorization,
   we as uaConfigurationWithoutAuthorizationWithoutDisplayName,
   f as user
 };