@telegenta/webclient 3.0.0 → 3.1.1

package/dist/telegenta.js

@@ -168,10 +168,11 @@ class InvalidParameter extends Error {
 
 /**
  * Exception raised if trying to perform actions that require active session
+ * @property message - Error message
  */
 class NoActiveSession extends Error {
-    constructor() {
-        super();
+    constructor(message) {
+        super(message);
         this.name = 'NoActiveSession';
     }
 }
@@ -197,6 +198,16 @@ class NotAllowed extends Error {
     }
 }
 
+/**
+ * Exception raised if event service is not connected
+ */
+class EventServiceNotConnected extends Error {
+    constructor() {
+        super();
+        this.name = 'EventServiceNotConnected';
+    }
+}
+
 /*
  * TOOLBOX
  */
@@ -281,6 +292,43 @@ function browserIsEdge() {
     return (navigator.userAgent.indexOf("Edge") !== -1)
 }
 
+// SIP header names are RFC 3261 tokens
+const HEADER_NAME_RE = /^[A-Za-z0-9\-.!%*_+`'~]+$/;
+
+const HTML_ENTITIES = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '\r': '&#13;',
+    '\n': '&#10;',
+};
+
+// Build custom SIP header lines from a { name: value } map.
+// Names must be tokens - a bad one is always a programming error, so it throws.
+// Values are HTML encoded rather than rejected: that strips the CR/LF which
+// would otherwise let a value inject further headers, while still letting
+// punctuation through.
+function buildCustomHeaders(setHeader) {
+    if (!setHeader) {
+        return [];
+    }
+
+    if (typeof setHeader !== 'object' || Array.isArray(setHeader)) {
+        throw new TypeError(`Invalid setHeader argument: expected an object, got ${typeof setHeader}`);
+    }
+
+    return Object.entries(setHeader).map(([name, value]) => {
+        if (!HEADER_NAME_RE.test(name)) {
+            throw new TypeError(`Invalid SIP header name: "${name}"`);
+        }
+        // Single pass, so an encoded '&' is not encoded again.
+        const encoded = String(value).replace(/[&<>"'\r\n]/g, (c) => HTML_ENTITIES[c]);
+        return `${name}: ${encoded}`;
+    });
+}
+
 // Request timeout after 10 sec
 const REQUEST_TIMEOUT = 10000;
 
@@ -444,7 +492,7 @@ class Requestor extends EventEmitter {
                 resolve: resolve,
                 reject: reject,
                 timeoutObj: setTimeout(function () {
-                    self.log.warning(`Timeout on request ${r.id}, rejecting!`);
+                    self.log.info(`Timeout on request ${r.id}, rejecting!`);
                     self.removePendingRequest(r.id);
                     reject("Request timed out");
                 }, REQUEST_TIMEOUT),
@@ -512,7 +560,7 @@ class Requestor extends EventEmitter {
 // Keep alive in seconds
 const PING_INTERVAL = 50;
 
-const ES_DEFAULT_SERVER_URL = "wss://api.telegenta.com/es/";
+const ES_DEFAULT_SERVER_URL = 'wss://esvc.telegenta.com/';
 
 // Starting retry interval
 const RETRY_INTERVAL_START = 1 + Math.random();
@@ -550,7 +598,7 @@ class EventClient {
         this.log = logger ? logger : new LogHandler(LOGLVL.ERROR);
         this._requestor = new Requestor(this.log);
 
-        this._requestor.on("event", (request) => {
+        this._requestor.on('event', (request) => {
             this._handleIncomingEvent(request);
         });
     }
@@ -573,11 +621,11 @@ class EventClient {
 
     /**
      * Disconnect from event service and clear all active subscriptions
-     * @throws NoActiveSession if not connected
+     * @throws EventServiceNotConnected if not connected
      */
     disconnect() {
         if (this._socket.readyState !== 1) {
-            throw new NoActiveSession();
+            throw new EventServiceNotConnected();
         }
 
         this._activeSubscriptions = [];
@@ -602,26 +650,29 @@ class EventClient {
      * @param eventSpecification object Event parameters (please check docs for further description)
      * @param callback object Callback function (will be called when event is received)
      * @throws InvalidParameter
+     * @throws EventServiceNotConnected
      * @returns object Promise on subscription
      */
     subscribe(eventSpecification, callback) {
         if (!eventSpecification || !callback) {
-            throw new InvalidParameter("You must specify both event spec and callback function");
+            throw new InvalidParameter('You must specify both event spec and callback function');
         }
 
-        if (!eventSpecification.hasOwnProperty("event_name")) {
-            throw new InvalidParameter("Your event specification must contain event name");
+        if (!eventSpecification.hasOwnProperty('event_name')) {
+            throw new InvalidParameter('Your event specification must contain event name');
         }
 
         if (!this.isConnected()) {
-            throw new NoActiveSession();
+            throw new EventServiceNotConnected();
         }
 
         const self = this;
         return new Promise(function (resolve, reject) {
-            self._requestor.sendRequest(self._socket, "subscribe", eventSpecification).then(
+            self._requestor.sendRequest(self._socket, 'subscribe', eventSpecification).then(
                 function (subscriptionId) {
-                    self.log.debug(`Subscription to '${eventSpecification.event_name}' was successful, ID = ${subscriptionId}`);
+                    self.log.debug(
+                        `Subscription to '${eventSpecification.event_name}' was successful, ID = ${subscriptionId}`,
+                    );
                     self._activeSubscriptions.push(new EventSubscription(subscriptionId, eventSpecification, callback));
                     resolve(subscriptionId);
                 },
@@ -637,22 +688,23 @@ class EventClient {
      * Unsubscribe event messages
      * @param subscriptionId Object Event specification to unsubscribe (must match specification used on subscribe)
      * @throws InvalidParameter
+     * @throws EventServiceNotConnected
      * @returns object Promise on unsubscribe
      */
     unsubscribe(subscriptionId) {
         if (!subscriptionId) {
-            throw new InvalidParameter("You must specify subscription id");
+            throw new InvalidParameter('You must specify subscription id');
         }
 
         if (!this.isConnected()) {
-            throw new NoActiveSession();
+            throw new EventServiceNotConnected();
         }
 
-        this.log.info("Unsubscribe id: " + subscriptionId);
+        this.log.info('Unsubscribe id: ' + subscriptionId);
 
         const self = this;
         return new Promise(function (resolve, reject) {
-            self._requestor.sendRequest(self._socket, "unsubscribe", { id: subscriptionId }).then(
+            self._requestor.sendRequest(self._socket, 'unsubscribe', { id: subscriptionId }).then(
                 (data) => {
                     self.log.info(`Unsubscribe to '${subscriptionId}' was successful`);
                     self._removeSubscription(subscriptionId);
@@ -670,12 +722,12 @@ class EventClient {
      * Fire event message
      * @param type Event type to fire
      * @param payload Event payload
-     * @throws NoActiveSession
+     * @throws EventServiceNotConnected
      * @returns object Promise on event
      */
     fireEvent(type, payload) {
         if (!this.isConnected()) {
-            throw new NoActiveSession();
+            throw new EventServiceNotConnected();
         }
 
         return new Promise((resolve, reject) => {
@@ -708,20 +760,20 @@ class EventClient {
 
     // Connect to event service
     _connectServer() {
-        this.log.info("Connecting to event server: " + this._serverAddress);
+        this.log.info('Connecting to event server: ' + this._serverAddress);
 
         const self = this;
         return new Promise(function (resolve, reject) {
             if (self._socket) {
                 switch (self._socket.readyState) {
                     case 0:
-                        reject("Unable to connect, already connecting");
+                        reject('Unable to connect, already connecting');
                         return;
                     case 1:
-                        reject("Unable to connect, already connected");
+                        reject('Unable to connect, already connected');
                         return;
                     case 2:
-                        reject("Unable to connect, socket is still closing");
+                        reject('Unable to connect, socket is still closing');
                         return;
                 }
             }
@@ -730,8 +782,8 @@ class EventClient {
             let was_connected = false;
 
             // CONNECTION OPEN
-            self._socket.addEventListener("open", function (/*event*/) {
-                self.log.info("Successfully connected to event service");
+            self._socket.addEventListener('open', function (/*event*/) {
+                self.log.info('Successfully connected to event service');
 
                 was_connected = true;
                 // After successful connect we enable auto connect and reset reconnect timer
@@ -739,7 +791,7 @@ class EventClient {
                 self._reconnectRetrySeconds = RETRY_INTERVAL_START;
 
                 // Hook up event for incoming messages to requestor
-                self._socket.addEventListener("message", function (event) {
+                self._socket.addEventListener('message', function (event) {
                     self._requestor.receiveMessage(self._socket, event.data);
                 });
 
@@ -751,7 +803,7 @@ class EventClient {
                             // self.log.debug('Pong');
                         },
                         function (reason) {
-                            self.log.warning("Ping failed: " + reason);
+                            self.log.warning('Ping failed: ' + reason);
                             self._reconnectServer();
                         },
                     );
@@ -772,19 +824,19 @@ class EventClient {
             });
 
             // CONNECTION CLOSE
-            self._socket.addEventListener("close", function (/*event*/) {
-                self.log.info("Disconnected from event service");
+            self._socket.addEventListener('close', function (/*event*/) {
+                self.log.info('Disconnected from event service');
                 clearTimeout(self._pingTimerObj);
                 // We try to reconnect if possible
                 self._reconnectServer();
             });
 
             // CONNECTION ERROR
-            self._socket.addEventListener("error", function (error) {
-                self.log.error("Websocket connection error");
+            self._socket.addEventListener('error', function (error) {
+                self.log.error('Websocket connection error');
                 // Only reject promise if no connection was made (in that case promise is already resolved)
                 if (!was_connected) {
-                    reject("Unable to connect: " + error);
+                    reject('Unable to connect: ' + error);
                 }
             });
         });
@@ -798,10 +850,10 @@ class EventClient {
             setTimeout(function () {
                 self._connectServer().then(
                     function () {
-                        self.log.info("Reconnect attempt successful");
+                        self.log.info('Reconnect attempt successful');
                     },
                     function () {
-                        self.log.warning("Reconnect attempt failed");
+                        self.log.warning('Reconnect attempt failed');
                     },
                 );
                 if (self._reconnectRetrySeconds <= RETRY_MAX_BACKOFF) {
@@ -809,7 +861,7 @@ class EventClient {
                 }
             }, self._reconnectRetrySeconds * 1000);
         } else {
-            this.log.info("Auto reconnect disabled (disconnecting?)");
+            this.log.info('Auto reconnect disabled (disconnecting?)');
         }
     }
 
@@ -818,7 +870,9 @@ class EventClient {
         const subId = request.data.subscription_id;
         for (let sub of this._activeSubscriptions) {
             if (sub.id === subId) {
-                this.log.debug(`Received event for subcription id ${sub.id} payload: ` + JSON.stringify(request.data.payload));
+                this.log.debug(
+                    `Received event for subcription id ${sub.id} payload: ` + JSON.stringify(request.data.payload),
+                );
                 try {
                     sub.callback(request.data.payload);
                 } catch (e) {
@@ -1487,8 +1541,8 @@ function camelcaseKeys(input, options) {
 // 'use strict';
 
 const options = {
-    wssServer: "wss://api.telegenta.com/sip/",
-    eventServer: "wss://api.telegenta.com/es/",
+    wssServer: 'wss://api.telegenta.com/sip/',
+    eventServer: 'wss://esvc.telegenta.com/',
     provisionToken: null,
     authorizationUsername: null,
     password: null,
@@ -1521,9 +1575,9 @@ const DTMF_FREQUENCY_TABLE = {
     8: [1336, 852],
     9: [1477, 852],
     c: [1633, 852],
-    "*": [1209, 941],
+    '*': [1209, 941],
     0: [1336, 941],
-    "#": [1477, 941],
+    '#': [1477, 941],
     d: [1633, 941],
 };
 
@@ -1594,11 +1648,11 @@ class Phone extends EventEmitter {
         this._activeSessions = {};
 
         // Create remote audio element
-        this._remoteAudioElement = document.createElement("AUDIO");
+        this._remoteAudioElement = document.createElement('AUDIO');
         this._remoteAudioElement.autoplay = true;
 
         // Tone generator
-        this._toneAudioElement = document.createElement("AUDIO");
+        this._toneAudioElement = document.createElement('AUDIO');
         this._toneAudioElement.autoplay = true;
         this._toneTimer = null;
         this._repeatToneActive = false;
@@ -1613,9 +1667,9 @@ class Phone extends EventEmitter {
 
         // Handle jssip debug logs
         if (this.log.level === LOGLVL$1.DEBUG) {
-            JsSIP.debug.disable("JsSIP:*");
+            JsSIP.debug.disable('JsSIP:*');
         } else {
-            JsSIP.debug.disable("JsSIP:*");
+            JsSIP.debug.disable('JsSIP:*');
         }
     }
 
@@ -1627,7 +1681,7 @@ class Phone extends EventEmitter {
      *
      */
     prepareMedia() {
-        this.log.info("Get media permission");
+        this.log.info('Get media permission');
         const self = this;
         const constraints = { audio: true, video: false };
         return new Promise(function (resolve, reject) {
@@ -1635,13 +1689,13 @@ class Phone extends EventEmitter {
                 () => {
                     self._mediaPermission = true;
                     self._mediaPermissionError = false;
-                    self.log.info("Media permission granted");
+                    self.log.info('Media permission granted');
                     resolve();
                 },
                 (err) => {
                     self._mediaPermission = false;
                     self._mediaPermissionError = true;
-                    self.log.error("Denied media permission: " + err);
+                    self.log.error('Denied media permission: ' + err);
                     reject(err);
                 },
             );
@@ -1676,7 +1730,7 @@ class Phone extends EventEmitter {
         this._checkMediaPermission();
         // Check phone is not running already, if so stop it first
         if (this._isStarted) {
-            this.log.warning("Phone already started, stopping first");
+            this.log.warning('Phone already started, stopping first');
             this.stop();
         }
 
@@ -1691,29 +1745,29 @@ class Phone extends EventEmitter {
             try {
                 pt = JSON.parse(atob(this._options.provisionToken));
             } catch (err) {
-                throw new InvalidOptions("provisionToken", "Invalid token");
+                throw new InvalidOptions('provisionToken', 'Invalid token');
             }
 
-            this.log.info("Using provisioning token authorization");
+            this.log.info('Using provisioning token authorization');
             this._options.wssServer = pt.wss_server;
             this._options.eventServer = pt.event_server;
             this._options.authorizationUsername = pt.wss_username;
             this._options.password = pt.wss_password;
             this._options.callToken = pt.wss_token;
         } else {
-            this.log.info("Using manual specified credentials");
+            this.log.info('Using manual specified credentials');
 
             // Check auth info is provided
             if (!this._options.authorizationUsername) {
-                throw new InvalidOptions("authorizationUsername", "Missing username");
+                throw new InvalidOptions('authorizationUsername', 'Missing username');
             }
 
             if (!this._options.password) {
-                throw new InvalidOptions("password", "Missing password");
+                throw new InvalidOptions('password', 'Missing password');
             }
 
             if (!this._options.callToken) {
-                throw new InvalidOptions("callToken", "Missing call token");
+                throw new InvalidOptions('callToken', 'Missing call token');
             }
         }
 
@@ -1736,18 +1790,18 @@ class Phone extends EventEmitter {
                     if (this._options.useCallDataInfoEvent) {
                         // Subscribe to calldata_available events
                         let eventSpec = {
-                            event_name: "calldata_available",
+                            event_name: 'calldata_available',
                             call_token: this._options.callToken,
                         };
 
                         this._eventClient
                             .subscribe(eventSpec, (data) => {
                                 try {
-                                    this.log.debug("Received remote call data info");
+                                    this.log.debug('Received remote call data info');
                                     this.log.debug(data);
                                     this._fireCallDataInfoEvent(data);
                                 } catch (e) {
-                                    this.log.error("Event callback failed: " + e);
+                                    this.log.error('Event callback failed: ' + e);
                                 }
                             })
                             .then(
@@ -1770,10 +1824,10 @@ class Phone extends EventEmitter {
         try {
             wsSocket = new JsSIP.WebSocketInterface(this._options.wssServer);
         } catch (err) {
-            throw new UnableToConnect("Unable to connect phone websocket: " + err);
+            throw new UnableToConnect('Unable to connect phone websocket: ' + err);
         }
 
-        this.log.info("Starting phone");
+        this.log.info('Starting phone');
         this.log.debug(this._options);
 
         this._UA = new JsSIP.UA({
@@ -1782,15 +1836,15 @@ class Phone extends EventEmitter {
             password: this._options.password,
             register: this._options.register,
             display_name: this._options.authorizationUsername,
-            uri: this._options.authorizationUsername + "@telegenta.com",
+            uri: this._options.authorizationUsername + '@telegenta.com',
             session_timers: false,
         });
 
         // Setup remote media handler
         const self = this;
-        this._UA.on("newRTCSession", function (data) {
-            self.log.debug("New RTCSession");
-            if (data.originator === "remote") {
+        this._UA.on('newRTCSession', function (data) {
+            self.log.debug('New RTCSession');
+            if (data.originator === 'remote') {
                 // Create new session
                 const session = new Session(self);
 
@@ -1803,18 +1857,20 @@ class Phone extends EventEmitter {
                 // Check if we have other sessions and reject call if autoBusyIncoming is true
                 if (self._options.autoBusyIncoming) {
                     if (Object.keys(self._activeSessions).length > 0) {
-                        self.log.info(`Autorejecting incoming call ${session.uuid} because there is already active calls`);
-                        session.reject(486, "Busy");
+                        self.log.info(
+                            `Autorejecting incoming call ${session.uuid} because there is already active calls`,
+                        );
+                        session.reject(486, 'Busy');
                         return;
                     } else {
-                        self.log.debug("There are no other sessions, adding incoming call");
+                        self.log.debug('There are no other sessions, adding incoming call');
                     }
                 }
 
                 self._addSession(session);
 
                 // Set new session state
-                session._setSessionState("INCOMING");
+                session._setSessionState('INCOMING');
 
                 // Now fire incomingCall event
                 self._fireIncomingCallEvent(session);
@@ -1822,33 +1878,33 @@ class Phone extends EventEmitter {
         });
 
         // Setup connection state event subscriptions
-        this._UA.on("connecting", function (/* data */) {
-            self._setConnectionState("CONNECTING");
+        this._UA.on('connecting', function (/* data */) {
+            self._setConnectionState('CONNECTING');
         });
 
-        this._UA.on("connected", function (/* data */) {
-            self._setConnectionState("CONNECTED");
+        this._UA.on('connected', function (/* data */) {
+            self._setConnectionState('CONNECTED');
         });
 
-        this._UA.on("disconnected", function (/* data */) {
-            self._setConnectionState("DISCONNECTED");
+        this._UA.on('disconnected', function (/* data */) {
+            self._setConnectionState('DISCONNECTED');
         });
 
-        this._UA.on("registered", function (/* data */) {
-            self._setConnectionState("REGISTERED");
+        this._UA.on('registered', function (/* data */) {
+            self._setConnectionState('REGISTERED');
         });
 
-        this._UA.on("unregistered", function (/* data */) {
-            self._setConnectionState("UNREGISTERED");
+        this._UA.on('unregistered', function (/* data */) {
+            self._setConnectionState('UNREGISTERED');
         });
 
-        this._UA.on("registrationFailed", function (/* data */) {
-            self._setConnectionState("REGISTRATION_FAILED");
+        this._UA.on('registrationFailed', function (/* data */) {
+            self._setConnectionState('REGISTRATION_FAILED');
         });
 
         this._UA.start();
         this._isStarted = true;
-        this.log.info("Successfully started phone");
+        this.log.info('Successfully started phone');
     }
 
     /**
@@ -1858,7 +1914,7 @@ class Phone extends EventEmitter {
     stop() {
         // Check phone is started first
         if (!this._isStarted) {
-            throw new NotReady("Phone is not started");
+            throw new NotReady('Phone is not started');
         }
 
         // Make sure events are not firing anymore, we can't rely on GC.
@@ -1870,18 +1926,18 @@ class Phone extends EventEmitter {
 
         // Disconnect event client if needed
         if (!this._eventClient) {
-            this.log.debug("Event client not running, not stopping");
+            this.log.debug('Event client not running, not stopping');
             return;
         }
         try {
             this._eventClient.disconnect();
             delete this._eventClient;
         } catch (e) {
-            this.log.warning("Unable to disconnect event client");
+            this.log.warning('Unable to disconnect event client');
         }
 
         this._isStarted = false;
-        this.log.info("Phone client successfully stopped");
+        this.log.info('Phone client successfully stopped');
     }
 
     /**
@@ -1895,20 +1951,22 @@ class Phone extends EventEmitter {
      * @param {number} [params.answerCallTimeout=0] Hangup call with NO ANSWER if call is not picked up before specified interval (seconds). If 0, timeout is disabled.
      * @param {number} [params.maximumCallCost] Maximum call cost (in customer currency) allowed for call. The call will automatically be stopped when the specified cost has been reached. Setting this to 0 disables checking for maximum cost.
      * @param {string} [params.metaInfo] Add meta info to call, which will be available in server events and inside call complete webhook (max 256 chars)
+     * @param {object} [params.setHeader] Custom SIP headers to add to the INVITE, as {name: value}.
      * @return {Session} object for call
      * @throws NotReady - If phone is not ready to call
      * @throws NotAllowed - If there are calls currently connecting
+     * @throws InvalidParameter - If setHeader contains an invalid header name or container
      *
      */
     call(number, params = {}) {
         // Check phone is started first
         if (!this._isStarted) {
-            throw new NotReady("Phone is not started");
+            throw new NotReady('Phone is not started');
         }
 
         // Check we dont have any other connecting calls
         if (this._checkForConnectingCalls()) {
-            throw NotAllowed("Unable to make new calls while others are connecting");
+            throw new NotAllowed('Unable to make new calls while others are connecting');
         }
 
         // Hold other calls if needed
@@ -1922,15 +1980,16 @@ class Phone extends EventEmitter {
                 explicitCallerId: null,
                 explicitShortCallerId: null,
                 metaInfo: null,
+                setHeader: null,
                 _isListenCall: false,
             },
             params,
         );
 
         // Trim phone number to remove spaces and '()'
-        number = number.trim().replace(/ |\(|\)/g, "");
+        number = number.trim().replace(/ |\(|\)/g, '');
 
-        this.log.info("Calling number: " + number);
+        this.log.info('Calling number: ' + number);
 
         let session = new Session(this);
         session.newOutboundSession(number, callParams);
@@ -1946,12 +2005,12 @@ class Phone extends EventEmitter {
      * @throws NotAllowed - If there are calls currently connecting
      */
     listen(listenKey) {
-        const s = listenKey.split("@");
+        const s = listenKey.split('@');
         let callUUID = s[0];
-        let mediaSwitch = "sip:" + s[1];
+        let mediaSwitch = 'sip:' + s[1];
 
-        this.log.debug("Initiating listen to call with uuid " + callUUID + " on media switch " + mediaSwitch);
-        return this.call("listen-" + callUUID, {
+        this.log.debug('Initiating listen to call with uuid ' + callUUID + ' on media switch ' + mediaSwitch);
+        return this.call('listen-' + callUUID, {
             mediaSwitchURI: mediaSwitch,
             _isListenCall: true,
         });
@@ -2077,7 +2136,7 @@ class Phone extends EventEmitter {
 
     // Begin repeating tones
     _startRepeatTone(sequences) {
-        this.log.info("Repeating tone sequence started");
+        this.log.info('Repeating tone sequence started');
         this.log.debug(sequences);
         this._repeatToneSequence = sequences;
         this._repeatToneSequencePos = 0;
@@ -2107,7 +2166,7 @@ class Phone extends EventEmitter {
     // End repeating tones
     _endRepeatTone() {
         if (this._repeatToneActive) {
-            this.log.info("Repeating tone stopped");
+            this.log.info('Repeating tone stopped');
             this._repeatToneActive = false;
             this.stopTone();
         }
@@ -2118,7 +2177,7 @@ class Phone extends EventEmitter {
         // Create audio context
         const AudioContext = window.AudioContext || window.webkitAudioContext || false;
         if (!AudioContext) {
-            throw new NotAllowed("Audio API not supported by this browser");
+            throw new NotAllowed('Audio API not supported by this browser');
         }
 
         const ctx = new AudioContext();
@@ -2146,17 +2205,17 @@ class Phone extends EventEmitter {
      * @throws NotAllowed If there are connection calls
      */
     holdAllCalls() {
-        this.log.info("Holding all active sessions");
+        this.log.info('Holding all active sessions');
         // Check all session can be set on hold
         if (this._checkForConnectingCalls()) {
-            throw NotAllowed("A session is currently connecting");
+            throw new NotAllowed('A session is currently connecting');
         }
 
         // Iterate through all active calls and hold them
         for (let key in this._activeSessions) {
             if (this._activeSessions.hasOwnProperty(key)) {
                 let session = this._activeSessions[key];
-                if (session.state === "ACTIVE") {
+                if (session.state === 'ACTIVE') {
                     session.hold();
                 }
             }
@@ -2185,9 +2244,9 @@ class Phone extends EventEmitter {
 
         // Fire event
         try {
-            this.emit("sessionCreated", { session: session });
+            this.emit('sessionCreated', { session: session });
         } catch (e) {
-            this.log.error("Exception in sessionCreated event: " + e);
+            this.log.error('Exception in sessionCreated event: ' + e);
         }
     }
 
@@ -2203,9 +2262,9 @@ class Phone extends EventEmitter {
 
         // Fire event
         try {
-            this.emit("sessionRemoved", { session: session });
+            this.emit('sessionRemoved', { session: session });
         } catch (e) {
-            this.log.error("Exception in sessionRemoved event: " + e);
+            this.log.error('Exception in sessionRemoved event: ' + e);
         }
 
         delete this._activeSessions[session.__containerId];
@@ -2230,7 +2289,12 @@ class Phone extends EventEmitter {
         for (let key in this._activeSessions) {
             if (this._activeSessions.hasOwnProperty(key)) {
                 let session = this._activeSessions[key];
-                if (session.state === "INITIALIZING" || session.state === "CALLING" || session.state === "PROGRESS" || session.state === "INCOMING") {
+                if (
+                    session.state === 'INITIALIZING' ||
+                    session.state === 'CALLING' ||
+                    session.state === 'PROGRESS' ||
+                    session.state === 'INCOMING'
+                ) {
                     return true;
                 }
             }
@@ -2255,12 +2319,12 @@ class Phone extends EventEmitter {
          * @param {CONNECTION_STATE} state - The current connection state
          */
 
-        this.log.info("Connection state: " + state);
+        this.log.info('Connection state: ' + state);
         this._connectionState = state;
         try {
-            this.emit("connectionStateChange", { state: state });
+            this.emit('connectionStateChange', { state: state });
         } catch (e) {
-            this.log.error("Exception in connectionStateChange event: " + e);
+            this.log.error('Exception in connectionStateChange event: ' + e);
         }
     }
 
@@ -2271,9 +2335,9 @@ class Phone extends EventEmitter {
      */
     _fireIncomingCallEvent(session) {
         try {
-            this.emit("incomingCall", session);
+            this.emit('incomingCall', session);
         } catch (e) {
-            this.log.error("Exception in incomingCall event: " + e);
+            this.log.error('Exception in incomingCall event: ' + e);
         }
     }
 
@@ -2326,12 +2390,12 @@ class Phone extends EventEmitter {
 
         // Add some extra convenience fields
         e.durationStr = createDurationString(e.duration);
-        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : "";
-        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : "";
+        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : '';
+        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : '';
         try {
-            this.emit("callDataInfo", e);
+            this.emit('callDataInfo', e);
         } catch (e) {
-            this.log.error("Exception in callDataInfo event: " + e);
+            this.log.error('Exception in callDataInfo event: ' + e);
         }
     }
 
@@ -2412,33 +2476,37 @@ class Session extends EventEmitter {
         let options = {
             mediaConstraints: { audio: true, video: false },
             pcConfig: {
-                iceServers: [{ urls: ["stun:stun.l.google.com:19302"] }],
+                iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
             },
-            extraHeaders: ["X-Call-token: " + this._phone.options.callToken, "X-P-UUID: " + this._callUUID, "X-Max-cost: " + callParams.maximumCallCost],
+            extraHeaders: [
+                'X-Call-token: ' + this._phone.options.callToken,
+                'X-P-UUID: ' + this._callUUID,
+                'X-Max-cost: ' + callParams.maximumCallCost,
+            ],
         };
 
         // Append explicit caller id if needed
         if (callParams.explicitCallerId) {
-            options.extraHeaders.push("X-CID-Number-Id: " + callParams.explicitCallerId);
+            options.extraHeaders.push('X-CID-Number-Id: ' + callParams.explicitCallerId);
         }
 
         // Append explicit short cid if needed
         if (callParams.explicitShortCallerId) {
-            options.extraHeaders.push("X-Short-CID-Id: " + callParams.explicitShortCallerId);
+            options.extraHeaders.push('X-Short-CID-Id: ' + callParams.explicitShortCallerId);
         }
 
         // Append meta info
         if (callParams.metaInfo) {
-            options.extraHeaders.push("X-Meta-Info: " + encodeURI(callParams.metaInfo.toString().substr(0, 255)));
+            options.extraHeaders.push('X-Meta-Info: ' + encodeURI(callParams.metaInfo.toString().substr(0, 255)));
         }
 
         // Enable recording?
         if (callParams.record) {
             if (isNaN(callParams.record)) {
-                throw new InvalidParameter("Record parameter must be a number");
+                throw new InvalidParameter('Record parameter must be a number');
             }
             this.log.debug(`Recording enabled and kept for ${callParams.record} days`);
-            options.extraHeaders.push("X-Record: " + callParams.record);
+            options.extraHeaders.push('X-Record: ' + callParams.record);
             this._isRecording = true;
         } else {
             this._isRecording = false;
@@ -2449,8 +2517,8 @@ class Session extends EventEmitter {
 
         // Manually specified media switch
         if (callParams.mediaSwitchURI) {
-            this.log.debug("Requesting specific media switch " + callParams.mediaSwitchURI);
-            options.extraHeaders.push("X-RMS: " + callParams.mediaSwitchURI);
+            this.log.debug('Requesting specific media switch ' + callParams.mediaSwitchURI);
+            options.extraHeaders.push('X-RMS: ' + callParams.mediaSwitchURI);
         } else {
             // Request specific media switch to group calls on same server
             const otherSessions = this.getOtherSessions();
@@ -2458,24 +2526,41 @@ class Session extends EventEmitter {
             if (otherSessions.length > 0) {
                 if (otherSessions[0]._mediaSwitch) {
                     // There are existing active calls, append first media switch address found and request call grouping to this
-                    this.log.debug("Requesting call grouping on media switch " + otherSessions[0]._mediaSwitch);
-                    options.extraHeaders.push("X-RMS: sip:" + otherSessions[0]._mediaSwitch);
+                    this.log.debug('Requesting call grouping on media switch ' + otherSessions[0]._mediaSwitch);
+                    options.extraHeaders.push('X-RMS: sip:' + otherSessions[0]._mediaSwitch);
                 } else {
-                    this.log.warning("Other sessions exist but media switch address is invalid");
+                    this.log.warning('Other sessions exist but media switch address is invalid');
                 }
             } else {
-                this.log.debug("No other active calls, no media switch grouping requested");
+                this.log.debug('No other active calls, no media switch grouping requested');
+            }
+        }
+
+        // Custom headers last, so they cannot displace the built-in ones.
+        // Must be before _UA.call() below: jssip clones extraHeaders synchronously
+        // inside connect(), so anything pushed after that call never reaches the INVITE.
+        let customHeaders;
+        try {
+            customHeaders = buildCustomHeaders(callParams.setHeader);
+        } catch (error) {
+            if (error instanceof TypeError) {
+                throw new InvalidParameter(error.message);
             }
+            throw error;
+        }
+        for (const header of customHeaders) {
+            this.log.debug('Adding custom header: ' + header);
+            options.extraHeaders.push(header);
         }
 
         // Prepare invite uri
-        const uri = "sip:" + number + "@telegenta.com";
+        const uri = 'sip:' + number + '@telegenta.com';
 
         // Not start call and create sip session
         try {
             this._initWebRTCSession(this._phone._UA.call(uri, options));
         } catch (error) {
-            this.log.error("Error starting call:", error);
+            this.log.error('Error starting call:', error);
             return null;
         }
 
@@ -2486,16 +2571,16 @@ class Session extends EventEmitter {
 
     // Create new inbound session
     newInboundSession(newSessionRequest) {
-        this._callUUID = newSessionRequest.request.getHeader("X-P-UUID", 0);
-        this._destinationNumber = newSessionRequest.request.getHeader("X-DID", 0);
-        this._localNumberName = unescape(newSessionRequest.request.getHeader("X-DID-NAME", 0));
+        this._callUUID = newSessionRequest.request.getHeader('X-P-UUID', 0);
+        this._destinationNumber = newSessionRequest.request.getHeader('X-DID', 0);
+        this._localNumberName = unescape(newSessionRequest.request.getHeader('X-DID-NAME', 0));
         this._originName = newSessionRequest.request.from.display_name;
         this._originatingNumber = newSessionRequest.request.from.uri.user;
         this.log.info(`Incoming call from ${this._originatingNumber} [${this._callUUID}]`);
         this.log.debug(newSessionRequest);
 
         // Get media switch info
-        this._mediaSwitch = newSessionRequest.request.getHeader("X-MS");
+        this._mediaSwitch = newSessionRequest.request.getHeader('X-MS');
         this.log.debug(`Media switch handling call: ${this._mediaSwitch}`);
 
         this._initWebRTCSession(newSessionRequest.session);
@@ -2529,10 +2614,10 @@ class Session extends EventEmitter {
         const self = this;
 
         // ICE CANDIDATES
-        this._webRTCSession.on("icecandidate", function (event) {
+        this._webRTCSession.on('icecandidate', function (event) {
             const c = event.candidate;
             self.log.debug(`Got ICE candidate: ${c.candidate}`);
-            if (c.type === "srflx" && c.relatedAddress !== null && c.relatedPort !== null) {
+            if (c.type === 'srflx' && c.relatedAddress !== null && c.relatedPort !== null) {
                 self.log.info(`Accepting ICE candidate: ${c.candidate}`);
 
                 // Clear timer first
@@ -2555,24 +2640,24 @@ class Session extends EventEmitter {
             }
         });
 
-        this._webRTCSession.on("connecting", function (/* data */) {
+        this._webRTCSession.on('connecting', function (/* data */) {
             self._startDurationUpdateTimer();
             self._startRTCPStatsUpdateTimer();
-            self._setSessionState("INITIALIZING");
+            self._setSessionState('INITIALIZING');
         });
 
-        this._webRTCSession.on("sending", function (/* data */) {
+        this._webRTCSession.on('sending', function (/* data */) {
             // Play call initialized tone if needed
             if (self._phone.options.playCallInitializedTone) {
                 self._phone._startRepeatTone(ST_CALLINIT);
             }
 
-            self._setSessionState("CALLING");
+            self._setSessionState('CALLING');
         });
 
-        this._webRTCSession.on("progress", function (data) {
-            if (data.originator === "remote") {
-                self._setSessionState("PROGRESS", { code: data.response.status_code });
+        this._webRTCSession.on('progress', function (data) {
+            if (data.originator === 'remote') {
+                self._setSessionState('PROGRESS', { code: data.response.status_code });
                 self._phone._endRepeatTone();
 
                 // Ringback handling on 180 RINGING
@@ -2587,14 +2672,14 @@ class Session extends EventEmitter {
                         try {
                             self.hangup();
                         } catch (e) {
-                            self.log.info("No active session, ignoring answer call timeout");
+                            self.log.info('No active session, ignoring answer call timeout');
                         }
                     }, self._answerCallTimeout * 1000);
                 }
             }
         });
 
-        this._webRTCSession.on("accepted", function (data) {
+        this._webRTCSession.on('accepted', function (data) {
             // Always end ringsback
             self._phone._endRepeatTone();
 
@@ -2607,27 +2692,27 @@ class Session extends EventEmitter {
             }
 
             // Get initial recording state
-            if (data.originator === "remote") {
-                const recState = data.response.getHeader("X-Recording");
-                if (recState === "true") {
-                    self.log.debug("Call is being prerecorded");
+            if (data.originator === 'remote') {
+                const recState = data.response.getHeader('X-Recording');
+                if (recState === 'true') {
+                    self.log.debug('Call is being prerecorded');
                     // self._isRecording = true;
                     // self.emit('recordingStateChange', {state: true, error: null});
                 } else {
-                    self.log.debug("No call recording started yet");
+                    self.log.debug('No call recording started yet');
                 }
 
                 // Get media switch info
-                self._mediaSwitch = data.response.getHeader("X-MS");
+                self._mediaSwitch = data.response.getHeader('X-MS');
                 self.log.debug(`Media switch handling call: ${self._mediaSwitch}`);
             }
         });
 
-        this._webRTCSession.on("confirmed", function (/* data */) {
-            self._setSessionState("ACTIVE");
+        this._webRTCSession.on('confirmed', function (/* data */) {
+            self._setSessionState('ACTIVE');
         });
 
-        this._webRTCSession.on("ended", function (/* data */) {
+        this._webRTCSession.on('ended', function (/* data */) {
             // End any ringsbacks if needed
             self._phone._endRepeatTone();
 
@@ -2638,10 +2723,10 @@ class Session extends EventEmitter {
                 clearTimeout(self._answerCallTimer);
             }
 
-            self._setSessionState("TERMINATED");
+            self._setSessionState('TERMINATED');
         });
 
-        this._webRTCSession.on("failed", function (data) {
+        this._webRTCSession.on('failed', function (data) {
             // End any ringsbacks if needed
             self._phone._endRepeatTone();
 
@@ -2659,54 +2744,54 @@ class Session extends EventEmitter {
             if (data.message) {
                 m = `${data.message.status_code} ${data.message.reason_phrase}`;
             } else {
-                m = "";
+                m = '';
             }
 
-            self._setSessionState("FAILED", { cause: data.cause, message: m });
+            self._setSessionState('FAILED', { cause: data.cause, message: m });
         });
 
-        this._webRTCSession.on("dtmf", function (data) {
-            self.log.debug("Session DTMF", data);
+        this._webRTCSession.on('dtmf', function (data) {
+            self.log.debug('Session DTMF', data);
         });
 
-        this._webRTCSession.on("newInfo", function (data) {
-            self.log.debug("New session info", data);
+        this._webRTCSession.on('newInfo', function (data) {
+            self.log.debug('New session info', data);
         });
 
-        this._webRTCSession.on("hold", function (/* data */) {
+        this._webRTCSession.on('hold', function (/* data */) {
             self._isOnHold = true;
             self._fireHoldStateEvent();
-            self._setSessionState("ON_HOLD");
+            self._setSessionState('ON_HOLD');
         });
 
-        this._webRTCSession.on("unhold", function (/* data */) {
+        this._webRTCSession.on('unhold', function (/* data */) {
             self._isOnHold = false;
             self._fireHoldStateEvent();
-            self._setSessionState("ACTIVE");
+            self._setSessionState('ACTIVE');
         });
 
-        this._webRTCSession.on("muted", function (data) {
-            self.log.debug("Microphone muted", data);
+        this._webRTCSession.on('muted', function (data) {
+            self.log.debug('Microphone muted', data);
             self._isMuted = true;
             self._fireMuteStateEvent();
         });
 
-        this._webRTCSession.on("unmuted", function (data) {
-            self.log.debug("Microphone unmuted", data);
+        this._webRTCSession.on('unmuted', function (data) {
+            self.log.debug('Microphone unmuted', data);
             self._isMuted = false;
             self._fireMuteStateEvent();
         });
 
-        this._webRTCSession.on("reinvite", function (data) {
-            self.log.debug("Session reinvite", data);
+        this._webRTCSession.on('reinvite', function (data) {
+            self.log.debug('Session reinvite', data);
         });
 
-        this._webRTCSession.on("update", function (data) {
-            self.log.debug("Session update", data);
+        this._webRTCSession.on('update', function (data) {
+            self.log.debug('Session update', data);
         });
 
-        this._webRTCSession.on("getusermediafailed", function (data) {
-            self.log.error("Getusermedia failed", data);
+        this._webRTCSession.on('getusermediafailed', function (data) {
+            self.log.error('Getusermedia failed', data);
         });
 
         // If connection connect audio stream
@@ -2715,7 +2800,7 @@ class Session extends EventEmitter {
         }
 
         // DEBUG STUFF
-        this.log.debug("WebRTCSession object:");
+        this.log.debug('WebRTCSession object:');
         this.log.debug(this);
     }
 
@@ -2726,13 +2811,13 @@ class Session extends EventEmitter {
      */
     hangup(disposition = null) {
         if (!disposition) {
-            this.log.info("Hanging up call");
+            this.log.info('Hanging up call');
             this._webRTCSession.terminate();
         } else {
             this.log.info(`Hanging up call with disposition ${disposition}`);
             this._manualDisposition = disposition;
             this._webRTCSession.terminate({
-                extraHeaders: ["X-HDISP: " + disposition],
+                extraHeaders: ['X-HDISP: ' + disposition],
             });
         }
     }
@@ -2745,14 +2830,14 @@ class Session extends EventEmitter {
         let options = {
             mediaConstraints: { audio: true, video: false },
             pcConfig: {
-                iceServers: [{ urls: ["stun:stun.l.google.com:19302"] }],
+                iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
             },
-            extraHeaders: ["X-Call-token: " + this._phone.options.callToken],
+            extraHeaders: ['X-Call-token: ' + this._phone.options.callToken],
         };
 
         // Append meta info if needed
         if (metaInfo) {
-            options.extraHeaders.push("X-Meta-Info: " + encodeURI(metaInfo.toString().substr(0, 255)));
+            options.extraHeaders.push('X-Meta-Info: ' + encodeURI(metaInfo.toString().substr(0, 255)));
         }
 
         this._webRTCSession.answer(options);
@@ -2766,8 +2851,8 @@ class Session extends EventEmitter {
      * @param statusCode - SIP Status code
      * @param reasonPhrase - Reason phrase
      */
-    reject(statusCode = 603, reasonPhrase = "Rejected call") {
-        this.log.info("Rejecting call");
+    reject(statusCode = 603, reasonPhrase = 'Rejected call') {
+        this.log.info('Rejecting call');
         this._webRTCSession.terminate({
             status_code: statusCode,
             reason_phrase: reasonPhrase,
@@ -2808,7 +2893,7 @@ class Session extends EventEmitter {
 
     // Set destination number
     set destinationNumber(number) {
-        this.log.debug("Setting destination number to: " + number);
+        this.log.debug('Setting destination number to: ' + number);
         this._destinationNumber = number;
     }
 
@@ -2826,53 +2911,77 @@ class Session extends EventEmitter {
      */
     get direction() {
         if (this._isListenCall) {
-            this.log.debug("Call direction is LISTEN");
-            return "LISTEN";
-        } else if (this._webRTCSession.direction === "incoming") {
-            this.log.debug("Call direction is INBOUND");
-            return "INBOUND";
-        } else if (this._webRTCSession.direction === "outgoing") {
-            this.log.debug("Call direction is OUTBOUND");
-            return "OUTBOUND";
+            this.log.debug('Call direction is LISTEN');
+            return 'LISTEN';
+        } else if (this._webRTCSession.direction === 'incoming') {
+            this.log.debug('Call direction is INBOUND');
+            return 'INBOUND';
+        } else if (this._webRTCSession.direction === 'outgoing') {
+            this.log.debug('Call direction is OUTBOUND');
+            return 'OUTBOUND';
         } else {
-            this.log.error("Unknown call direction: " + this._webRTCSession.direction);
-            return "UNKNOWN";
+            this.log.error('Unknown call direction: ' + this._webRTCSession.direction);
+            return 'UNKNOWN';
         }
     }
 
+    /**
+     * Raw WebRTC statistics for this session's peer connection.
+     *
+     * Returns the browser's own `RTCStatsReport` untouched, so callers can read
+     * any statistic the browser exposes - RTP packet and byte counters, the
+     * DTLS/ICE transport state, codec and candidate-pair details.
+     *
+     * @returns {Promise<RTCStatsReport>} The peer connection's statistics
+     * @throws NoActiveSession - If the session has no established peer connection
+     * (thrown synchronously, before the promise is created)
+     *
+     * @example
+     * const report = await session.getRTCStats();
+     * for (const stat of report.values()) {
+     *   if (stat.type === 'inbound-rtp') console.log(stat.packetsReceived);
+     * }
+     */
+    getRTCStats() {
+        if (!this._webRTCSession || !this._webRTCSession.connection) {
+            throw new NoActiveSession('no peer connection for this session');
+        }
+        return this._webRTCSession.connection.getStats();
+    }
+
     // RECORDING
     /**
      * Start recording
      */
     startRecording() {
         const opt = {
-            extraHeaders: ["Record: on"],
+            extraHeaders: ['Record: on'],
         };
 
-        this.log.debug("Request start recording");
+        this.log.debug('Request start recording');
 
         const self = this;
-        this._webRTCSession.once("newInfo", (data) => {
-            if (data.originator === "local") {
-                data.info.on("succeeded", function (/* data */) {
-                    self.log.info("Recording started successfully");
+        this._webRTCSession.once('newInfo', (data) => {
+            if (data.originator === 'local') {
+                data.info.on('succeeded', function (/* data */) {
+                    self.log.info('Recording started successfully');
                     self._isRecording = true;
                     try {
-                        self.emit("recordingStateChange", { state: true, error: null });
+                        self.emit('recordingStateChange', { state: true, error: null });
                     } catch (e) {
-                        self.log.error("Exception in recordingStateChange event: " + e);
+                        self.log.error('Exception in recordingStateChange event: ' + e);
                     }
                 });
 
-                data.info.on("failed", function (data) {
+                data.info.on('failed', function (data) {
                     self._recordingError = data.response.reason_phrase;
-                    self.log.error("Recording start failed: " + self._recordingError);
+                    self.log.error('Recording start failed: ' + self._recordingError);
                     self._fireRecordingStateEvent();
                 });
             }
         });
 
-        this._webRTCSession.sendInfo("application/info", null, opt);
+        this._webRTCSession.sendInfo('application/info', null, opt);
     }
 
     /**
@@ -2880,35 +2989,35 @@ class Session extends EventEmitter {
      */
     stopRecording() {
         const opt = {
-            extraHeaders: ["Record: off"],
+            extraHeaders: ['Record: off'],
         };
 
-        this.log.debug("Request stop recording");
+        this.log.debug('Request stop recording');
 
         const self = this;
 
-        this._webRTCSession.once("newInfo", (data) => {
-            data.info.on("succeeded", function (/* data */) {
-                self.log.info("Recording stopped successfully");
+        this._webRTCSession.once('newInfo', (data) => {
+            data.info.on('succeeded', function (/* data */) {
+                self.log.info('Recording stopped successfully');
                 self._isRecording = false;
                 try {
-                    self.emit("recordingStateChange", { state: false, error: null });
+                    self.emit('recordingStateChange', { state: false, error: null });
                 } catch (e) {
-                    self.log.error("Exception in recordingStateChange event: " + e);
+                    self.log.error('Exception in recordingStateChange event: ' + e);
                 }
             });
 
-            data.info.on("failed", function (data) {
-                self.log.error("Recording stopped failed: " + data.response.reason_phrase);
+            data.info.on('failed', function (data) {
+                self.log.error('Recording stopped failed: ' + data.response.reason_phrase);
                 try {
-                    self.emit("recordingStateChange", { state: self._isRecording, error: data.response.reason_phrase });
+                    self.emit('recordingStateChange', { state: self._isRecording, error: data.response.reason_phrase });
                 } catch (e) {
-                    self.log.error("Exception in recordingStateChange event: " + e);
+                    self.log.error('Exception in recordingStateChange event: ' + e);
                 }
             });
         });
 
-        this._webRTCSession.sendInfo("application/info", null, opt);
+        this._webRTCSession.sendInfo('application/info', null, opt);
     }
 
     /**
@@ -2937,7 +3046,7 @@ class Session extends EventEmitter {
      * Mute microphone
      */
     muteMic() {
-        this.log.info("Mute microphone");
+        this.log.info('Mute microphone');
         this._webRTCSession.mute();
     }
 
@@ -2945,7 +3054,7 @@ class Session extends EventEmitter {
      * Unmute microphone
      */
     unmuteMic() {
-        this.log.info("Unmute microphone");
+        this.log.info('Unmute microphone');
         this._webRTCSession.unmute();
     }
 
@@ -2973,7 +3082,7 @@ class Session extends EventEmitter {
      * Hold call
      */
     hold() {
-        this.log.info("Hold call");
+        this.log.info('Hold call');
         this._webRTCSession.hold();
     }
 
@@ -2981,7 +3090,7 @@ class Session extends EventEmitter {
      * Unhold call
      */
     unhold() {
-        this.log.info("Uncall call");
+        this.log.info('Uncall call');
         this._phone.holdAllCalls();
         this._webRTCSession.unhold();
     }
@@ -3014,10 +3123,10 @@ class Session extends EventEmitter {
     sendDTMF(code, playLocal = true) {
         // Check for correct DTMF and get frequencies
         if (!(code in DTMF_FREQUENCY_TABLE)) {
-            throw new InvalidParameter("Invalid DTMF code");
+            throw new InvalidParameter('Invalid DTMF code');
         }
 
-        this.log.info("Sending DTMF: " + code);
+        this.log.info('Sending DTMF: ' + code);
         this._webRTCSession.sendDTMF(code);
 
         if (playLocal) {
@@ -3025,15 +3134,15 @@ class Session extends EventEmitter {
 
             // First mute microphone before playing DTMF
             if (this._isMuted) {
-                this.log.debug("Mic already muted, just sending DTMF");
+                this.log.debug('Mic already muted, just sending DTMF');
                 this._phone.playTone(500, f[0], f[1]);
             } else {
-                this.log.debug("Mute mic while sending DTMF");
+                this.log.debug('Mute mic while sending DTMF');
                 this._webRTCSession.mute();
 
                 const self = this;
                 this._phone.playTone(500, f[0], f[1], function () {
-                    self.log.debug("Unmute mic after DTMF");
+                    self.log.debug('Unmute mic after DTMF');
                     self._webRTCSession.unmute();
                 });
             }
@@ -3049,20 +3158,22 @@ class Session extends EventEmitter {
         this.log.info(`Transferring ${this.uuid} => ${dstSession.uuid}`);
 
         // Create ReferSubscriber event class
-        const referSubscriber = this._webRTCSession.refer(this._webRTCSession._request.ruri, { replaces: dstSession._webRTCSession });
+        const referSubscriber = this._webRTCSession.refer(this._webRTCSession._request.ruri, {
+            replaces: dstSession._webRTCSession,
+        });
 
         const self = this;
 
         // Setup some logging
-        referSubscriber.on("requestSucceeded", function () {
-            self.log.info("Transfer completed successfully");
+        referSubscriber.on('requestSucceeded', function () {
+            self.log.info('Transfer completed successfully');
         });
 
-        referSubscriber.on("requestFailed", function (cause) {
+        referSubscriber.on('requestFailed', function (cause) {
             self.log.error(`Transfer rejected: ${cause}`);
         });
 
-        referSubscriber.on("failed", function (cause) {
+        referSubscriber.on('failed', function (cause) {
             self.log.error(`Transfer failed: ${cause}`);
         });
     }
@@ -3080,14 +3191,14 @@ class Session extends EventEmitter {
     playback(media_file_id, hangup_after = false) {
         // Check event service is enabled first
         if (!this._phone._options.connectEventService) {
-            throw new NotAllowed("Event service not enabled");
+            throw new NotAllowed('Event service not enabled');
         }
 
         this.log.info(`Playback media file ${media_file_id} hangup after ${hangup_after}`);
 
-        const p = this._phone._eventClient.fireEvent("call_command", {
+        const p = this._phone._eventClient.fireEvent('call_command', {
             call_uuid: this.uuid,
-            call_command: "playback",
+            call_command: 'playback',
             media_file_id: media_file_id,
             hangup_after: hangup_after,
         });
@@ -3103,7 +3214,7 @@ class Session extends EventEmitter {
             // When playback starts set state to playback
             p.then(() => {
                 // Set session state
-                this._setSessionState("PLAYBACK");
+                this._setSessionState('PLAYBACK');
             });
         }
 
@@ -3119,12 +3230,12 @@ class Session extends EventEmitter {
      * @throws InvalidOptions - If invalid mode given
      */
     setWhisperMode(mode = 0) {
-        if (!this.direction === "LISTEN") {
-            throw new NotAllowed("Call is not correct type (listen)");
+        if (!this.direction === 'LISTEN') {
+            throw new NotAllowed('Call is not correct type (listen)');
         }
 
         if (mode < 0 || mode > 2) {
-            throw new InvalidOptions("Invalid mode");
+            throw new InvalidOptions('Invalid mode');
         }
 
         let t_dtmf_mode;
@@ -3182,13 +3293,13 @@ class Session extends EventEmitter {
                     duration: Date.now() - self._callBeginTime,
                     durationStr: createDurationString(Date.now() - self._callBeginTime),
                     activeDuration: activeDuration,
-                    activeDurationStr: activeDuration ? createDurationString(activeDuration) : "",
+                    activeDurationStr: activeDuration ? createDurationString(activeDuration) : '',
                 };
 
                 try {
-                    self.emit("callDurationUpdate", e);
+                    self.emit('callDurationUpdate', e);
                 } catch (e) {
-                    self.log.error("Exception in call duration update event: " + e);
+                    self.log.error('Exception in call duration update event: ' + e);
                 }
             }, 1000);
         }
@@ -3252,40 +3363,46 @@ class Session extends EventEmitter {
                     for (let report of data.values()) {
                         // this.log.debug(report);
                         switch (report.type) {
-                            case "outbound-rtp":
+                            case 'outbound-rtp':
                                 // this.log.debug('Got: outbound-rtp');
                                 // this.log.debug(report);
                                 // Packets
                                 totalReport.outboundPacketsSent = report.packetsSent;
-                                deltaReport.outboundPacketsSent = report.packetsSent - this._currentReport.outboundPacketsSent;
+                                deltaReport.outboundPacketsSent =
+                                    report.packetsSent - this._currentReport.outboundPacketsSent;
                                 // Bytes
                                 totalReport.outboundBytesSent = report.bytesSent;
-                                deltaReport.outboundBytesSent = report.bytesSent - this._currentReport.outboundBytesSent;
+                                deltaReport.outboundBytesSent =
+                                    report.bytesSent - this._currentReport.outboundBytesSent;
                                 break;
 
-                            case "inbound-rtp":
+                            case 'inbound-rtp':
                                 // this.log.debug('Got: inbound-rtp');
                                 // this.log.debug(report);
                                 // Packets
                                 totalReport.inboundPacketsReceived = report.packetsReceived;
-                                deltaReport.inboundPacketsReceived = report.packetsReceived - this._currentReport.inboundPacketsReceived;
+                                deltaReport.inboundPacketsReceived =
+                                    report.packetsReceived - this._currentReport.inboundPacketsReceived;
                                 // Bytes
                                 totalReport.inboundBytesReceived = report.bytesReceived;
-                                deltaReport.inboundBytesReceived = report.bytesReceived - this._currentReport.inboundBytesReceived;
+                                deltaReport.inboundBytesReceived =
+                                    report.bytesReceived - this._currentReport.inboundBytesReceived;
                                 // Loss
                                 totalReport.inboundPacketsLost = report.packetsLost;
-                                deltaReport.inboundPacketsLost = report.packetsLost - this._currentReport.inboundPacketsLost;
+                                deltaReport.inboundPacketsLost =
+                                    report.packetsLost - this._currentReport.inboundPacketsLost;
                                 // Jitter
                                 totalReport.inboundJitter = report.jitter * 1000;
                                 deltaReport.inboundJitter = report.jitter * 1000;
                                 break;
 
-                            case "remote-inbound-rtp":
+                            case 'remote-inbound-rtp':
                                 // this.log.debug('Got: remote-inbound-rtp');
                                 // this.log.debug(report);
                                 // Loss
                                 totalReport.outboundPacketsLost = report.packetsLost;
-                                deltaReport.outboundPacketsLost = report.packetsLost - this._currentReport.outboundPacketsLost;
+                                deltaReport.outboundPacketsLost =
+                                    report.packetsLost - this._currentReport.outboundPacketsLost;
                                 // Jitter
                                 totalReport.outboundJitter = report.jitter * 1000;
                                 deltaReport.outboundJitter = report.jitter * 1000;
@@ -3307,9 +3424,9 @@ class Session extends EventEmitter {
                         };
 
                         try {
-                            this.emit("callQualityReportUpdate", finalReport);
+                            this.emit('callQualityReportUpdate', finalReport);
                         } catch (e) {
-                            this.log.error("Exception in call quality report update event: " + e);
+                            this.log.error('Exception in call quality report update event: ' + e);
                         }
                     }
                 });
@@ -3333,27 +3450,28 @@ class Session extends EventEmitter {
         // this.log.debug(`R factor loss effect ${lossEffect} / latency effect ${latencyEffect}`);
 
         report.rFactor = Math.max(0, 100 - lossEffect - latencyEffect);
-        report.mos = 1 + 0.035 * report.rFactor + 0.000007 * report.rFactor * (report.rFactor - 60) * (100 - report.rFactor);
+        report.mos =
+            1 + 0.035 * report.rFactor + 0.000007 * report.rFactor * (report.rFactor - 60) * (100 - report.rFactor);
 
         // Quality string
         switch (true) {
             case report.rFactor < 50:
-                report.qualityString = "Bad";
+                report.qualityString = 'Bad';
                 break;
             case report.rFactor < 70:
-                report.qualityString = "Poor";
+                report.qualityString = 'Poor';
                 break;
             case report.rFactor < 80:
-                report.qualityString = "Fair";
+                report.qualityString = 'Fair';
                 break;
             case report.rFactor < 90:
-                report.qualityString = "Good";
+                report.qualityString = 'Good';
                 break;
             case report.rFactor <= 100:
-                report.qualityString = "Excellent";
+                report.qualityString = 'Excellent';
                 break;
             default:
-                report.qualityString = "Error";
+                report.qualityString = 'Error';
         }
 
         return report;
@@ -3387,7 +3505,7 @@ class Session extends EventEmitter {
          *
          */
 
-        this.log.debug("Session state: " + state);
+        this.log.debug('Session state: ' + state);
         if (info) {
             this.log.debug(info);
         }
@@ -3395,7 +3513,7 @@ class Session extends EventEmitter {
         this._sessionState = state;
         try {
             this.emit(
-                "sessionStateChange",
+                'sessionStateChange',
                 Object.assign(
                     {
                         state: state,
@@ -3405,51 +3523,51 @@ class Session extends EventEmitter {
                 ),
             );
         } catch (e) {
-            this.log.error("Exception in sessionStateChange event:" + e);
+            this.log.error('Exception in sessionStateChange event:' + e);
         }
 
         // Trigger callDataAvailable dummy event
-        if (state === "TERMINATED") {
-            this._callDisposition = this._manualDisposition || "NORMAL";
+        if (state === 'TERMINATED') {
+            this._callDisposition = this._manualDisposition || 'NORMAL';
             this._callFinished();
         }
 
-        if (state === "FAILED") {
-            if (info.cause === "Unavailable") {
-                this._callDisposition = "TEMP_UNAVAIL";
+        if (state === 'FAILED') {
+            if (info.cause === 'Unavailable') {
+                this._callDisposition = 'TEMP_UNAVAIL';
                 if (this._phone.options.playSignalTones) {
                     this._phone._startRepeatTone(ST_TEMP_UNAVAIL);
                 }
             }
 
-            if (info.cause === "Not Found") {
-                this._callDisposition = "INVALID_NUMBER";
+            if (info.cause === 'Not Found') {
+                this._callDisposition = 'INVALID_NUMBER';
                 if (this._phone.options.playSignalTones) {
                     this._phone._startRepeatTone(ST_INVALID_NUMBER);
                 }
             }
 
-            if (info.cause === "Canceled") {
-                this._callDisposition = this._manualDisposition || "NO_ANSWER";
+            if (info.cause === 'Canceled') {
+                this._callDisposition = this._manualDisposition || 'NO_ANSWER';
             }
 
-            if (info.cause === "Rejected") {
-                if (this.direction === "INBOUND") {
-                    this._callDisposition = "REJECTED";
+            if (info.cause === 'Rejected') {
+                if (this.direction === 'INBOUND') {
+                    this._callDisposition = 'REJECTED';
                 } else {
-                    this._callDisposition = "BARRED";
+                    this._callDisposition = 'BARRED';
                 }
             }
 
-            if (info.cause === "Busy") {
-                this._callDisposition = "BUSY";
+            if (info.cause === 'Busy') {
+                this._callDisposition = 'BUSY';
                 if (this._phone.options.playSignalTones) {
                     this._phone._startRepeatTone(ST_BUSY);
                 }
             }
 
             // If session is incoming and failed, we don't fire calldataAvailable event
-            if (this._webRTCSession.direction === "incoming") ;
+            if (this._webRTCSession.direction === 'incoming') ;
 
             this._callFinished();
         }
@@ -3477,7 +3595,7 @@ class Session extends EventEmitter {
      * @property {string} REJECTED Incoming call was rejected
      */
     _callFinished() {
-        this.log.info("Call finished");
+        this.log.info('Call finished');
 
         // Fire callEnded event
         this._fireCallEndedEvent();
@@ -3494,7 +3612,7 @@ class Session extends EventEmitter {
 
     // Set answer call timeout
     _setAnswerCallTimeout(timeout) {
-        this.log.debug("Setting answer call timeout to: " + timeout);
+        this.log.debug('Setting answer call timeout to: ' + timeout);
         this._answerCallTimeout = timeout;
     }
 
@@ -3506,9 +3624,9 @@ class Session extends EventEmitter {
          * @property {boolean} state - New recording state
          */
         try {
-            this.emit("recordingStateChange", { state: this._isRecording, error: this._recordingError });
+            this.emit('recordingStateChange', { state: this._isRecording, error: this._recordingError });
         } catch (e) {
-            this.log.error("Exception in recording state change event: " + e);
+            this.log.error('Exception in recording state change event: ' + e);
         }
     }
 
@@ -3520,9 +3638,9 @@ class Session extends EventEmitter {
          * @property {boolean} state - Mute state (true = muted / false = unmuted)
          */
         try {
-            this.emit("muteStateChange", { state: this._isMuted });
+            this.emit('muteStateChange', { state: this._isMuted });
         } catch (e) {
-            this.log.error("Exception in mute state change event: " + e);
+            this.log.error('Exception in mute state change event: ' + e);
         }
     }
 
@@ -3534,9 +3652,9 @@ class Session extends EventEmitter {
          * @property {boolean} state - New hold state
          */
         try {
-            this.emit("holdStateChange", { state: this._isOnHold });
+            this.emit('holdStateChange', { state: this._isOnHold });
         } catch (e) {
-            this.log.error("Exception in hold state change event: " + e);
+            this.log.error('Exception in hold state change event: ' + e);
         }
     }
 
@@ -3548,9 +3666,9 @@ class Session extends EventEmitter {
          * @property {boolean} mode - New whisper mode (0 = No whisper / 1 = Local only / 2 = Three way)
          */
         try {
-            this.emit("whisperModeChange", { mode: this._whisperMode });
+            this.emit('whisperModeChange', { mode: this._whisperMode });
         } catch (e) {
-            this.log.error("Exception in whisper mode change event: " + e);
+            this.log.error('Exception in whisper mode change event: ' + e);
         }
     }
 
@@ -3599,14 +3717,14 @@ class Session extends EventEmitter {
 
         // Add some extra convenience fields
         e.durationStr = createDurationString(e.duration);
-        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : "";
-        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : "";
+        e.answerDurationStr = e.answerDuration ? createDurationString(e.answerDuration) : '';
+        e.activeDurationStr = e.activeDuration ? createDurationString(e.activeDuration) : '';
         e.callQualityReport = this._currentReport;
 
         try {
-            this.emit("callEnded", e);
+            this.emit('callEnded', e);
         } catch (e) {
-            this.log.error("Exception in callEnded event: " + e);
+            this.log.error('Exception in callEnded event: ' + e);
         }
     }
 
@@ -3617,11 +3735,11 @@ class Session extends EventEmitter {
 
         const self = this;
         session.connection.ontrack = function (event) {
-            self.log.debug("Start media output (track):");
+            self.log.debug('Start media output (track):');
             self.log.debug(event);
             self._phone._remoteAudioElement.srcObject = event.streams[0];
         };
     }
 }
 
-export { EventClient, InvalidMediaDevice, InvalidOptions, InvalidParameter, LOGLVL$1 as LOGLVL, LogHandler, MediaNotPrepared, NoActiveSession, NotAllowed, NotReady, Phone, Request, Requestor, Session, UnableToConnect, browserIsChrome, browserIsEdge, browserIsFirefox, browserIsOpera, browserIsSafari, compareObjects, createDurationString, createUUID };
+export { EventClient, EventServiceNotConnected, InvalidMediaDevice, InvalidOptions, InvalidParameter, LOGLVL$1 as LOGLVL, LogHandler, MediaNotPrepared, NoActiveSession, NotAllowed, NotReady, Phone, Request, Requestor, Session, UnableToConnect, browserIsChrome, browserIsEdge, browserIsFirefox, browserIsOpera, browserIsSafari, buildCustomHeaders, compareObjects, createDurationString, createUUID };