twilio-video 2.34.0 → 2.35.0

package/es5/twilioconnection.js

@@ -1,50 +1,10 @@
 'use strict';
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var StateMachine = require('./statemachine');
-var _a = require('./util'), buildLogLevels = _a.buildLogLevels, makeUUID = _a.makeUUID;
-var Log = require('./util/log');
-var NetworkMonitor = require('./util/networkmonitor');
-var Timeout = require('./util/timeout');
-var nInstances = 0;
+const StateMachine = require('./statemachine');
+const { buildLogLevels, makeUUID } = require('./util');
+const Log = require('./util/log');
+const NetworkMonitor = require('./util/networkmonitor');
+const Timeout = require('./util/timeout');
+let nInstances = 0;
 /*
   TwilioConnection states
   -----------------------
@@ -64,47 +24,47 @@ var nInstances = 0;
   | waiting  | --------> |  open  | ---------------
   +----------+           +--------+
  */
-var states = {
+const states = {
     closed: [],
     connecting: ['closed', 'open', 'waiting'],
     early: ['closed', 'connecting'],
     open: ['closed'],
     waiting: ['closed', 'connecting', 'early', 'open']
 };
-var events = {
+const events = {
     closed: 'close',
     open: 'open',
     waiting: 'waiting'
 };
-var TCMP_VERSION = 2;
-var DEFAULT_MAX_CONSECUTIVE_MISSED_HEARTBEATS = 3;
-var DEFAULT_MAX_CONSECUTIVE_FAILED_HELLOS = 3;
-var DEFAULT_MAX_REQUESTED_HEARTBEAT_TIMEOUT = 5000;
-var DEFAULT_OPEN_TIMEOUT = 15000;
-var DEFAULT_WELCOME_TIMEOUT = 5000;
-var OUTGOING_HEARTBEAT_OFFSET = 200;
-var WS_CLOSE_NORMAL = 1000;
-var WS_CLOSE_WELCOME_TIMEOUT = 3000;
-var WS_CLOSE_HEARTBEATS_MISSED = 3001;
-var WS_CLOSE_HELLO_FAILED = 3002;
-var WS_CLOSE_SEND_FAILED = 3003;
-var WS_CLOSE_NETWORK_CHANGED = 3004;
-var WS_CLOSE_BUSY_WAIT = 3005;
-var WS_CLOSE_SERVER_BUSY = 3006;
-var WS_CLOSE_OPEN_TIMEOUT = 3007;
+const TCMP_VERSION = 2;
+const DEFAULT_MAX_CONSECUTIVE_MISSED_HEARTBEATS = 3;
+const DEFAULT_MAX_CONSECUTIVE_FAILED_HELLOS = 3;
+const DEFAULT_MAX_REQUESTED_HEARTBEAT_TIMEOUT = 5000;
+const DEFAULT_OPEN_TIMEOUT = 15000;
+const DEFAULT_WELCOME_TIMEOUT = 5000;
+const OUTGOING_HEARTBEAT_OFFSET = 200;
+const WS_CLOSE_NORMAL = 1000;
+const WS_CLOSE_WELCOME_TIMEOUT = 3000;
+const WS_CLOSE_HEARTBEATS_MISSED = 3001;
+const WS_CLOSE_HELLO_FAILED = 3002;
+const WS_CLOSE_SEND_FAILED = 3003;
+const WS_CLOSE_NETWORK_CHANGED = 3004;
+const WS_CLOSE_BUSY_WAIT = 3005;
+const WS_CLOSE_SERVER_BUSY = 3006;
+const WS_CLOSE_OPEN_TIMEOUT = 3007;
 // NOTE(joma): If you want to use close code 3008, please increment
 // the close code in test/integration/spec/docker/reconnection.js
 // line number 492.
-var toplevel = globalThis;
-var WebSocket = toplevel.WebSocket ? toplevel.WebSocket : require('ws');
-var CloseReason = {
+const toplevel = globalThis;
+const WebSocket = toplevel.WebSocket ? toplevel.WebSocket : require('ws');
+const CloseReason = {
     BUSY: 'busy',
     FAILED: 'failed',
     LOCAL: 'local',
     REMOTE: 'remote',
     TIMEOUT: 'timeout'
 };
-var wsCloseCodesToCloseReasons = new Map([
+const wsCloseCodesToCloseReasons = new Map([
     [WS_CLOSE_WELCOME_TIMEOUT, CloseReason.TIMEOUT],
     [WS_CLOSE_HEARTBEATS_MISSED, CloseReason.TIMEOUT],
     [WS_CLOSE_HELLO_FAILED, CloseReason.FAILED],
@@ -122,15 +82,14 @@ var wsCloseCodesToCloseReasons = new Map([
  * @fires TwilioConnection#open
  * @fires TwilioConnection#waiting
  */
-var TwilioConnection = /** @class */ (function (_super) {
-    __extends(TwilioConnection, _super);
+class TwilioConnection extends StateMachine {
     /**
      * Construct a {@link TwilioConnection}.
      * @param {string} serverUrl - TCMP server url
      * @param {TwilioConnectionOptions} options - {@link TwilioConnection} options
      */
-    function TwilioConnection(serverUrl, options) {
-        var _this = _super.call(this, 'early', states) || this;
+    constructor(serverUrl, options) {
+        super('early', states);
         options = Object.assign({
             helloBody: null,
             maxConsecutiveFailedHellos: DEFAULT_MAX_CONSECUTIVE_FAILED_HELLOS,
@@ -138,18 +97,18 @@ var TwilioConnection = /** @class */ (function (_super) {
             requestedHeartbeatTimeout: DEFAULT_MAX_REQUESTED_HEARTBEAT_TIMEOUT,
             openTimeout: DEFAULT_OPEN_TIMEOUT,
             welcomeTimeout: DEFAULT_WELCOME_TIMEOUT,
-            Log: Log,
-            WebSocket: WebSocket
+            Log,
+            WebSocket
         }, options);
-        var logLevels = buildLogLevels(options.logLevel);
-        var log = new options.Log('default', _this, logLevels, options.loggerName);
-        var networkMonitor = options.networkMonitor ? new NetworkMonitor(function () {
-            var type = networkMonitor.type;
-            var reason = "Network changed".concat(type ? " to ".concat(type) : '');
+        const logLevels = buildLogLevels(options.logLevel);
+        const log = new options.Log('default', this, logLevels, options.loggerName);
+        const networkMonitor = options.networkMonitor ? new NetworkMonitor(() => {
+            const { type } = networkMonitor;
+            const reason = `Network changed${type ? ` to ${type}` : ''}`;
             log.debug(reason);
-            _this._close({ code: WS_CLOSE_NETWORK_CHANGED, reason: reason });
+            this._close({ code: WS_CLOSE_NETWORK_CHANGED, reason });
         }) : null;
-        Object.defineProperties(_this, {
+        Object.defineProperties(this, {
             _busyWaitTimeout: {
                 value: null,
                 writable: true
@@ -208,43 +167,37 @@ var TwilioConnection = /** @class */ (function (_super) {
                 writable: true
             }
         });
-        var eventsToLevels = {
+        const eventsToLevels = {
             connecting: 'info',
             early: 'info',
             open: 'info',
             waiting: 'warning',
             closed: 'info'
         };
-        _this.on('stateChanged', function (state) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
+        this.on('stateChanged', (state, ...args) => {
             if (state in events) {
-                _this.emit.apply(_this, __spreadArray([events[state]], __read(args), false));
+                this.emit(events[state], ...args);
             }
-            var event = { name: state, group: 'signaling', level: eventsToLevels[_this.state] };
+            const event = { name: state, group: 'signaling', level: eventsToLevels[this.state] };
             if (state === 'closed') {
-                var _a = __read(args, 1), reason = _a[0];
-                event.payload = { reason: reason };
+                const [reason] = args;
+                event.payload = { reason };
                 event.level = reason === CloseReason.LOCAL ? 'info' : 'error';
             }
-            _this._eventObserver.emit('event', event);
+            this._eventObserver.emit('event', event);
         });
-        _this._eventObserver.emit('event', { name: _this.state, group: 'signaling', level: eventsToLevels[_this.state] });
-        _this._connect();
-        return _this;
+        this._eventObserver.emit('event', { name: this.state, group: 'signaling', level: eventsToLevels[this.state] });
+        this._connect();
+    }
+    toString() {
+        return `[TwilioConnection #${this._instanceId}: ${this._ws.url}]`;
     }
-    TwilioConnection.prototype.toString = function () {
-        return "[TwilioConnection #".concat(this._instanceId, ": ").concat(this._ws.url, "]");
-    };
     /**
      * Close the {@link TwilioConnection}.
      * @param {{code: number, reason: string}} event
      * @private
      */
-    TwilioConnection.prototype._close = function (_a) {
-        var code = _a.code, reason = _a.reason;
+    _close({ code, reason }) {
         if (this.state === 'closed') {
             return;
         }
@@ -267,127 +220,123 @@ var TwilioConnection = /** @class */ (function (_super) {
             this._busyWaitTimeout.clear();
         }
         this._messageQueue.splice(0);
-        var log = this._log;
+        const log = this._log;
         if (code === WS_CLOSE_NORMAL) {
             log.debug('Closed');
             this.transition('closed', null, [CloseReason.LOCAL]);
         }
         else {
-            log.warn("Closed: ".concat(code, " - ").concat(reason));
+            log.warn(`Closed: ${code} - ${reason}`);
             if (code !== WS_CLOSE_BUSY_WAIT) {
                 this.transition('closed', null, [
                     wsCloseCodesToCloseReasons.get(code) || CloseReason.REMOTE
                 ]);
             }
         }
-        var readyState = this._ws.readyState;
-        var WebSocket = this._options.WebSocket;
+        const { readyState } = this._ws;
+        const { WebSocket } = this._options;
         if (readyState !== WebSocket.CLOSING && readyState !== WebSocket.CLOSED) {
             this._ws.close(code, reason);
         }
-    };
+    }
     /**
      * Connect to the TCMP server.
      * @private
      */
-    TwilioConnection.prototype._connect = function () {
-        var _this = this;
-        var log = this._log;
+    _connect() {
+        const log = this._log;
         if (this.state === 'waiting') {
             this.transition('early');
         }
         else if (this.state !== 'early') {
-            log.warn("Unexpected state \"".concat(this.state, "\" for connecting to the")
+            log.warn(`Unexpected state "${this.state}" for connecting to the`
                 + ' TCMP server.');
             return;
         }
         this._ws = new this._options.WebSocket(this._serverUrl);
-        var ws = this._ws;
+        const ws = this._ws;
         log.debug('Created a new WebSocket:', ws);
-        ws.addEventListener('close', function (event) { return _this._close(event); });
-        var openTimeout = this._options.openTimeout;
+        ws.addEventListener('close', event => this._close(event));
+        const { openTimeout } = this._options;
         // Add a timeout for getting the onopen event on the WebSocket (15 sec). After that, attempt to reconnect only if this is not the first attempt.
-        this._openTimeout = new Timeout(function () {
-            var reason = "Failed to open in ".concat(openTimeout, " ms");
-            _this._close({ code: WS_CLOSE_OPEN_TIMEOUT, reason: reason });
+        this._openTimeout = new Timeout(() => {
+            const reason = `Failed to open in ${openTimeout} ms`;
+            this._close({ code: WS_CLOSE_OPEN_TIMEOUT, reason });
         }, openTimeout);
-        ws.addEventListener('open', function () {
+        ws.addEventListener('open', () => {
             log.debug('WebSocket opened:', ws);
-            _this._openTimeout.clear();
-            _this._startHandshake();
-            if (_this._networkMonitor) {
-                _this._networkMonitor.start();
+            this._openTimeout.clear();
+            this._startHandshake();
+            if (this._networkMonitor) {
+                this._networkMonitor.start();
             }
         });
-        ws.addEventListener('message', function (message) {
-            log.debug("Incoming: ".concat(message.data));
+        ws.addEventListener('message', message => {
+            log.debug(`Incoming: ${message.data}`);
             try {
                 message = JSON.parse(message.data);
             }
             catch (error) {
-                _this.emit('error', error);
+                this.emit('error', error);
                 return;
             }
             switch (message.type) {
                 case 'bad':
-                    _this._handleBad(message);
+                    this._handleBad(message);
                     break;
                 case 'busy':
-                    _this._handleBusy(message);
+                    this._handleBusy(message);
                     break;
                 case 'bye':
                     // Do nothing.
                     break;
                 case 'msg':
-                    _this._handleMessage(message);
+                    this._handleMessage(message);
                 // NOTE(mpatwardhan): Each incoming message should be treated as an incoming
                 // heartbeat intentionally falling through to 'heartbeat' case.
                 // eslint-disable-next-line no-fallthrough
                 case 'heartbeat':
-                    _this._handleHeartbeat();
+                    this._handleHeartbeat();
                     break;
                 case 'welcome':
-                    _this._handleWelcome(message);
+                    this._handleWelcome(message);
                     break;
                 default:
-                    _this._log.debug("Unknown message type: ".concat(message.type));
-                    _this.emit('error', new Error("Unknown message type: ".concat(message.type)));
+                    this._log.debug(`Unknown message type: ${message.type}`);
+                    this.emit('error', new Error(`Unknown message type: ${message.type}`));
                     break;
             }
         });
-    };
+    }
     /**
      * Handle an incoming "bad" message.
      * @param {{reason: string}} message
      * @private
      */
-    TwilioConnection.prototype._handleBad = function (_a) {
-        var reason = _a.reason;
-        var log = this._log;
+    _handleBad({ reason }) {
+        const log = this._log;
         if (!['connecting', 'open'].includes(this.state)) {
-            log.warn("Unexpected state \"".concat(this.state, "\" for handling a \"bad\" message")
+            log.warn(`Unexpected state "${this.state}" for handling a "bad" message`
                 + ' from the TCMP server.');
             return;
         }
         if (this.state === 'connecting') {
-            log.warn("Closing: ".concat(WS_CLOSE_HELLO_FAILED, " - ").concat(reason));
-            this._close({ code: WS_CLOSE_HELLO_FAILED, reason: reason });
+            log.warn(`Closing: ${WS_CLOSE_HELLO_FAILED} - ${reason}`);
+            this._close({ code: WS_CLOSE_HELLO_FAILED, reason });
             return;
         }
-        log.debug("Error: ".concat(reason));
+        log.debug(`Error: ${reason}`);
         this.emit('error', new Error(reason));
-    };
+    }
     /**
      * Handle an incoming "busy" message.
      * @param {{cookie: ?string, keepAlive: boolean, retryAfter: number}} message
      * @private
      */
-    TwilioConnection.prototype._handleBusy = function (_a) {
-        var _this = this;
-        var cookie = _a.cookie, keepAlive = _a.keepAlive, retryAfter = _a.retryAfter;
-        var log = this._log;
+    _handleBusy({ cookie, keepAlive, retryAfter }) {
+        const log = this._log;
         if (!['connecting', 'waiting'].includes(this.state)) {
-            log.warn("Unexpected state \"".concat(this.state, "\" for handling a \"busy\" message")
+            log.warn(`Unexpected state "${this.state}" for handling a "busy" message`
                 + ' from the TCMP server.');
             return;
         }
@@ -397,80 +346,77 @@ var TwilioConnection = /** @class */ (function (_super) {
         if (this._welcomeTimeout) {
             this._welcomeTimeout.clear();
         }
-        var reason = retryAfter < 0
+        const reason = retryAfter < 0
             ? 'Received terminal "busy" message'
-            : "Received \"busy\" message, retrying after ".concat(retryAfter, " ms");
+            : `Received "busy" message, retrying after ${retryAfter} ms`;
         if (retryAfter < 0) {
-            log.warn("Closing: ".concat(WS_CLOSE_SERVER_BUSY, " - ").concat(reason));
-            this._close({ code: WS_CLOSE_SERVER_BUSY, reason: reason });
+            log.warn(`Closing: ${WS_CLOSE_SERVER_BUSY} - ${reason}`);
+            this._close({ code: WS_CLOSE_SERVER_BUSY, reason });
             return;
         }
-        var maxConsecutiveFailedHellos = this._options.maxConsecutiveFailedHellos;
+        const { maxConsecutiveFailedHellos } = this._options;
         this._hellosLeft = maxConsecutiveFailedHellos;
         this._cookie = cookie || null;
         if (keepAlive) {
             log.warn(reason);
-            this._busyWaitTimeout = new Timeout(function () { return _this._startHandshake(); }, retryAfter);
+            this._busyWaitTimeout = new Timeout(() => this._startHandshake(), retryAfter);
         }
         else {
-            log.warn("Closing: ".concat(WS_CLOSE_BUSY_WAIT, " - ").concat(reason));
-            this._close({ code: WS_CLOSE_BUSY_WAIT, reason: reason });
-            this._busyWaitTimeout = new Timeout(function () { return _this._connect(); }, retryAfter);
+            log.warn(`Closing: ${WS_CLOSE_BUSY_WAIT} - ${reason}`);
+            this._close({ code: WS_CLOSE_BUSY_WAIT, reason });
+            this._busyWaitTimeout = new Timeout(() => this._connect(), retryAfter);
         }
         this.transition('waiting', null, [keepAlive, retryAfter]);
-    };
+    }
     /**
      * Handle an incoming "heartbeat" message.
      * @private
      */
-    TwilioConnection.prototype._handleHeartbeat = function () {
+    _handleHeartbeat() {
         if (this.state !== 'open') {
-            this._log.warn("Unexpected state \"".concat(this.state, "\" for handling a \"heartbeat\"")
+            this._log.warn(`Unexpected state "${this.state}" for handling a "heartbeat"`
                 + ' message from the TCMP server.');
             return;
         }
         this._heartbeatTimeout.reset();
-    };
+    }
     /**
      * Handle a missed "heartbeat" message.
      * @private
      */
-    TwilioConnection.prototype._handleHeartbeatTimeout = function () {
+    _handleHeartbeatTimeout() {
         if (this.state !== 'open') {
             return;
         }
-        var log = this._log;
-        var maxConsecutiveMissedHeartbeats = this._options.maxConsecutiveMissedHeartbeats;
-        log.debug("Consecutive heartbeats missed: ".concat(maxConsecutiveMissedHeartbeats));
-        var reason = "Missed ".concat(maxConsecutiveMissedHeartbeats, " \"heartbeat\" messages");
-        log.warn("Closing: ".concat(WS_CLOSE_HEARTBEATS_MISSED, " - ").concat(reason));
-        this._close({ code: WS_CLOSE_HEARTBEATS_MISSED, reason: reason });
-    };
+        const log = this._log;
+        const { maxConsecutiveMissedHeartbeats } = this._options;
+        log.debug(`Consecutive heartbeats missed: ${maxConsecutiveMissedHeartbeats}`);
+        const reason = `Missed ${maxConsecutiveMissedHeartbeats} "heartbeat" messages`;
+        log.warn(`Closing: ${WS_CLOSE_HEARTBEATS_MISSED} - ${reason}`);
+        this._close({ code: WS_CLOSE_HEARTBEATS_MISSED, reason });
+    }
     /**
      * Handle an incoming "msg" message.
      * @param {{body: object}} message
      * @private
      */
-    TwilioConnection.prototype._handleMessage = function (_a) {
-        var body = _a.body;
+    _handleMessage({ body }) {
         if (this.state !== 'open') {
-            this._log.warn("Unexpected state \"".concat(this.state, "\" for handling a \"msg\" message")
+            this._log.warn(`Unexpected state "${this.state}" for handling a "msg" message`
                 + ' from the TCMP server.');
             return;
         }
         this.emit('message', body);
-    };
+    }
     /**
      * Handle an incoming "welcome" message.
      * @param {{ negotiatedTimeout: number }} message
      * @private
      */
-    TwilioConnection.prototype._handleWelcome = function (_a) {
-        var _this = this;
-        var negotiatedTimeout = _a.negotiatedTimeout;
-        var log = this._log;
+    _handleWelcome({ negotiatedTimeout }) {
+        const log = this._log;
         if (!['connecting', 'waiting'].includes(this.state)) {
-            log.warn("Unexpected state \"".concat(this.state, "\" for handling a \"welcome\"")
+            log.warn(`Unexpected state "${this.state}" for handling a "welcome"`
                 + ' message from the TCMP server.');
             return;
         }
@@ -478,45 +424,45 @@ var TwilioConnection = /** @class */ (function (_super) {
             log.debug('Received "welcome" message, no need to retry connection.');
             this._busyWaitTimeout.clear();
         }
-        var maxConsecutiveMissedHeartbeats = this._options.maxConsecutiveMissedHeartbeats;
-        var heartbeatTimeout = negotiatedTimeout * maxConsecutiveMissedHeartbeats;
-        var outgoingHeartbeatTimeout = negotiatedTimeout - OUTGOING_HEARTBEAT_OFFSET;
+        const { maxConsecutiveMissedHeartbeats } = this._options;
+        const heartbeatTimeout = negotiatedTimeout * maxConsecutiveMissedHeartbeats;
+        const outgoingHeartbeatTimeout = negotiatedTimeout - OUTGOING_HEARTBEAT_OFFSET;
         this._welcomeTimeout.clear();
-        this._heartbeatTimeout = new Timeout(function () { return _this._handleHeartbeatTimeout(); }, heartbeatTimeout);
-        this._messageQueue.splice(0).forEach(function (message) { return _this._send(message); });
-        this._sendHeartbeatTimeout = new Timeout(function () { return _this._sendHeartbeat(); }, outgoingHeartbeatTimeout);
+        this._heartbeatTimeout = new Timeout(() => this._handleHeartbeatTimeout(), heartbeatTimeout);
+        this._messageQueue.splice(0).forEach(message => this._send(message));
+        this._sendHeartbeatTimeout = new Timeout(() => this._sendHeartbeat(), outgoingHeartbeatTimeout);
         this.transition('open');
-    };
+    }
     /**
      * Handle a missed "welcome" message.
      * @private
      */
-    TwilioConnection.prototype._handleWelcomeTimeout = function () {
+    _handleWelcomeTimeout() {
         if (this.state !== 'connecting') {
             return;
         }
-        var log = this._log;
+        const log = this._log;
         if (this._hellosLeft <= 0) {
-            var reason = 'All handshake attempts failed';
-            log.warn("Closing: ".concat(WS_CLOSE_WELCOME_TIMEOUT, " - ").concat(reason));
-            this._close({ code: WS_CLOSE_WELCOME_TIMEOUT, reason: reason });
+            const reason = 'All handshake attempts failed';
+            log.warn(`Closing: ${WS_CLOSE_WELCOME_TIMEOUT} - ${reason}`);
+            this._close({ code: WS_CLOSE_WELCOME_TIMEOUT, reason });
             return;
         }
-        var maxConsecutiveFailedHellos = this._options.maxConsecutiveFailedHellos;
-        log.warn("Handshake attempt ".concat(maxConsecutiveFailedHellos - this._hellosLeft, " failed"));
+        const { maxConsecutiveFailedHellos } = this._options;
+        log.warn(`Handshake attempt ${maxConsecutiveFailedHellos - this._hellosLeft} failed`);
         this._startHandshake();
-    };
+    }
     /**
      * Send a message to the TCMP server.
      * @param {*} message
      * @private
      */
-    TwilioConnection.prototype._send = function (message) {
-        var readyState = this._ws.readyState;
-        var WebSocket = this._options.WebSocket;
+    _send(message) {
+        const { readyState } = this._ws;
+        const { WebSocket } = this._options;
         if (readyState === WebSocket.OPEN) {
-            var data = JSON.stringify(message);
-            this._log.debug("Outgoing: ".concat(data));
+            const data = JSON.stringify(message);
+            this._log.debug(`Outgoing: ${data}`);
             try {
                 this._ws.send(data);
                 if (this._sendHeartbeatTimeout) {
@@ -525,31 +471,31 @@ var TwilioConnection = /** @class */ (function (_super) {
                 }
             }
             catch (error) {
-                var reason = 'Failed to send message';
-                this._log.warn("Closing: ".concat(WS_CLOSE_SEND_FAILED, " - ").concat(reason));
-                this._close({ code: WS_CLOSE_SEND_FAILED, reason: reason });
+                const reason = 'Failed to send message';
+                this._log.warn(`Closing: ${WS_CLOSE_SEND_FAILED} - ${reason}`);
+                this._close({ code: WS_CLOSE_SEND_FAILED, reason });
             }
         }
-    };
+    }
     /**
      * Send a "heartbeat" message.
      * @private
      */
-    TwilioConnection.prototype._sendHeartbeat = function () {
+    _sendHeartbeat() {
         if (this.state === 'closed') {
             return;
         }
         this._send({ type: 'heartbeat' });
-    };
+    }
     /**
      * Send a "hello" message.
      * @private
      */
-    TwilioConnection.prototype._sendHello = function () {
-        var _a = this._options, helloBody = _a.helloBody, timeout = _a.requestedHeartbeatTimeout;
-        var hello = {
+    _sendHello() {
+        const { helloBody, requestedHeartbeatTimeout: timeout } = this._options;
+        const hello = {
             id: makeUUID(),
-            timeout: timeout,
+            timeout,
             type: 'hello',
             version: TCMP_VERSION
         };
@@ -560,28 +506,26 @@ var TwilioConnection = /** @class */ (function (_super) {
             hello.body = helloBody;
         }
         this._send(hello);
-    };
+    }
     /**
      * Send or enqueue a message.
      * @param {*} message
      * @private
      */
-    TwilioConnection.prototype._sendOrEnqueue = function (message) {
-        var _this = this;
+    _sendOrEnqueue(message) {
         if (this.state === 'closed') {
             return;
         }
-        var sendOrEnqueue = this.state === 'open'
-            ? function (message) { return _this._send(message); }
-            : function (message) { return _this._messageQueue.push(message); };
+        const sendOrEnqueue = this.state === 'open'
+            ? message => this._send(message)
+            : message => this._messageQueue.push(message);
         sendOrEnqueue(message);
-    };
+    }
     /**
      * Start the TCMP handshake.
      * @private
      */
-    TwilioConnection.prototype._startHandshake = function () {
-        var _this = this;
+    _startHandshake() {
         if (['early', 'waiting'].includes(this.state)) {
             this.transition('connecting');
         }
@@ -590,30 +534,29 @@ var TwilioConnection = /** @class */ (function (_super) {
         }
         this._hellosLeft--;
         this._sendHello();
-        var welcomeTimeout = this._options.welcomeTimeout;
-        this._welcomeTimeout = new Timeout(function () { return _this._handleWelcomeTimeout(); }, welcomeTimeout);
-    };
+        const { welcomeTimeout } = this._options;
+        this._welcomeTimeout = new Timeout(() => this._handleWelcomeTimeout(), welcomeTimeout);
+    }
     /**
      * Close the {@link TwilioConnection}.
      * @returns {void}
      */
-    TwilioConnection.prototype.close = function () {
+    close() {
         if (this.state === 'closed') {
             return;
         }
         this._sendOrEnqueue({ type: 'bye' });
         this._close({ code: WS_CLOSE_NORMAL, reason: 'Normal' });
-    };
+    }
     /**
      * Send a "msg" message.
      * @param {*} body
      * @returns {void}
      */
-    TwilioConnection.prototype.sendMessage = function (body) {
-        this._sendOrEnqueue({ body: body, type: 'msg' });
-    };
-    return TwilioConnection;
-}(StateMachine));
+    sendMessage(body) {
+        this._sendOrEnqueue({ body, type: 'msg' });
+    }
+}
 /**
  * A unique string depicting the reason for the {@link TwilioConnection} being closed.
  * @enum {string}