twilio-video 2.34.0 → 2.35.0

package/es5/signaling/v2/peerconnection.js

@@ -1,66 +1,26 @@
 '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 DefaultBackoff = require('../../util/backoff');
-var _a = require('../../webrtc'), DefaultRTCIceCandidate = _a.RTCIceCandidate, DefaultRTCPeerConnection = _a.RTCPeerConnection, DefaultRTCSessionDescription = _a.RTCSessionDescription, getStatistics = _a.getStats;
-var util = require('../../webrtc/util');
-var _b = require('../../util/constants'), DEFAULT_ICE_GATHERING_TIMEOUT_MS = _b.DEFAULT_ICE_GATHERING_TIMEOUT_MS, DEFAULT_LOG_LEVEL = _b.DEFAULT_LOG_LEVEL, DEFAULT_SESSION_TIMEOUT_SEC = _b.DEFAULT_SESSION_TIMEOUT_SEC, iceRestartBackoffConfig = _b.iceRestartBackoffConfig;
-var _c = require('../../util/sdp'), addOrRewriteNewTrackIds = _c.addOrRewriteNewTrackIds, addOrRewriteTrackIds = _c.addOrRewriteTrackIds, createCodecMapForMediaSection = _c.createCodecMapForMediaSection, disableRtx = _c.disableRtx, enableDtxForOpus = _c.enableDtxForOpus, getMediaSections = _c.getMediaSections, removeUnreferencedCodecAttributes = _c.removeUnreferencedCodecAttributes, removeSSRCAttributes = _c.removeSSRCAttributes, revertSimulcast = _c.revertSimulcast, setCodecPreferences = _c.setCodecPreferences, setSimulcast = _c.setSimulcast;
-var DefaultTimeout = require('../../util/timeout');
-var _d = require('../../util/twilio-video-errors'), MediaClientLocalDescFailedError = _d.MediaClientLocalDescFailedError, MediaClientRemoteDescFailedError = _d.MediaClientRemoteDescFailedError;
-var _e = require('../../util'), buildLogLevels = _e.buildLogLevels, isChromeScreenShareTrack = _e.isChromeScreenShareTrack, oncePerTick = _e.oncePerTick, defer = _e.defer;
-var IceBox = require('./icebox');
-var DefaultIceConnectionMonitor = require('./iceconnectionmonitor.js');
-var DataTrackReceiver = require('../../data/receiver');
-var MediaTrackReceiver = require('../../media/track/receiver');
-var StateMachine = require('../../statemachine');
-var Log = require('../../util/log');
-var TrackMatcher = require('../../util/sdp/trackmatcher');
-var workaroundIssue8329 = require('../../util/sdp/issue8329');
-var telemetry = require('../../insights/telemetry');
-var guess = util.guessBrowser();
-var isChrome = guess === 'chrome';
-var isFirefox = guess === 'firefox';
-var isSafari = guess === 'safari';
-var nInstances = 0;
+const DefaultBackoff = require('../../util/backoff');
+const { RTCPeerConnection: DefaultRTCPeerConnection, getStats: getStatistics } = require('../../webrtc');
+const util = require('../../webrtc/util');
+const { DEFAULT_ICE_GATHERING_TIMEOUT_MS, DEFAULT_LOG_LEVEL, DEFAULT_SESSION_TIMEOUT_SEC, iceRestartBackoffConfig } = require('../../util/constants');
+const { addOrRewriteNewTrackIds, addOrRewriteTrackIds, createCodecMapForMediaSection, disableRtx, enableDtxForOpus, getMediaSections, removeUnreferencedCodecAttributes, removeSSRCAttributes, revertSimulcast, setCodecPreferences, setSimulcast } = require('../../util/sdp');
+const DefaultTimeout = require('../../util/timeout');
+const { MediaClientLocalDescFailedError, MediaClientRemoteDescFailedError } = require('../../util/twilio-video-errors');
+const { buildLogLevels, isChromeScreenShareTrack, oncePerTick, defer } = require('../../util');
+const IceBox = require('./icebox');
+const DefaultIceConnectionMonitor = require('./iceconnectionmonitor.js');
+const DataTrackReceiver = require('../../data/receiver');
+const MediaTrackReceiver = require('../../media/track/receiver');
+const StateMachine = require('../../statemachine');
+const Log = require('../../util/log');
+const TrackMatcher = require('../../util/sdp/trackmatcher');
+const workaroundIssue8329 = require('../../util/sdp/issue8329');
+const telemetry = require('../../insights/telemetry');
+const guess = util.guessBrowser();
+const isChrome = guess === 'chrome';
+const isFirefox = guess === 'firefox';
+const isSafari = guess === 'safari';
+let nInstances = 0;
 /*
 PeerConnectionV2 States
 -----------------------
@@ -81,7 +41,7 @@ PeerConnectionV2 States
   +----------+
 
 */
-var states = {
+const states = {
     open: [
         'closed',
         'updating'
@@ -100,8 +60,7 @@ var states = {
  * @emits PeerConnectionV2#candidates
  * @emits PeerConnectionV2#description
  */
-var PeerConnectionV2 = /** @class */ (function (_super) {
-    __extends(PeerConnectionV2, _super);
+class PeerConnectionV2 extends StateMachine {
     /**
      * Construct a {@link PeerConnectionV2}.
      * @param {string} id
@@ -109,46 +68,46 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @param {PreferredCodecs} preferredCodecs
      * @param {object} [options]
      */
-    function PeerConnectionV2(id, encodingParameters, preferredCodecs, options) {
-        var _this = _super.call(this, 'open', states) || this;
+    constructor(id, encodingParameters, preferredCodecs, options) {
+        super('open', states);
         options = Object.assign({
             enableDscp: false,
             dummyAudioMediaStreamTrack: null,
-            isChromeScreenShareTrack: isChromeScreenShareTrack,
+            isChromeScreenShareTrack,
             iceServers: [],
             logLevel: DEFAULT_LOG_LEVEL,
             offerOptions: {},
-            revertSimulcast: revertSimulcast,
+            revertSimulcast,
             sessionTimeout: DEFAULT_SESSION_TIMEOUT_SEC * 1000,
-            setCodecPreferences: setCodecPreferences,
-            setSimulcast: setSimulcast,
+            setCodecPreferences,
+            setSimulcast,
             Backoff: DefaultBackoff,
             IceConnectionMonitor: DefaultIceConnectionMonitor,
-            RTCIceCandidate: DefaultRTCIceCandidate,
+            RTCIceCandidate,
             RTCPeerConnection: DefaultRTCPeerConnection,
-            RTCSessionDescription: DefaultRTCSessionDescription,
+            RTCSessionDescription,
             Timeout: DefaultTimeout
         }, options);
         // NOTE(lrivas): We intentionally include the options object for backward compatibility.
         // The ConnectOptions 'iceServers' and 'iceTransportPolicy' are part of the 'RTCConfiguration' interface and should be passed
         // as 'rtcConfiguration.iceServers' and 'rtcConfiguration.iceTransportPolicy' respectively.
-        var configuration = getConfiguration(Object.assign({}, options, options.rtcConfiguration));
-        var logLevels = buildLogLevels(options.logLevel);
-        var RTCPeerConnection = options.RTCPeerConnection;
+        const configuration = getConfiguration(Object.assign({}, options, options.rtcConfiguration));
+        const logLevels = buildLogLevels(options.logLevel);
+        const RTCPeerConnection = options.RTCPeerConnection;
         if (options.enableDscp === true) {
             options.chromeSpecificConstraints = options.chromeSpecificConstraints || {};
             options.chromeSpecificConstraints.optional = options.chromeSpecificConstraints.optional || [];
             options.chromeSpecificConstraints.optional.push({ googDscp: true });
         }
-        var log = options.log ? options.log.createLog('webrtc', _this) : new Log('webrtc', _this, logLevels, options.loggerName);
-        var peerConnection = new RTCPeerConnection(configuration, {
+        const log = options.log ? options.log.createLog('webrtc', this) : new Log('webrtc', this, logLevels, options.loggerName);
+        const peerConnection = new RTCPeerConnection(configuration, {
             chromeSpecificConstraints: options.chromeSpecificConstraints,
-            applyCodecPreferences: function (transceiver) { return _this._applyCodecPreferencesToTransceiver(transceiver); }
+            applyCodecPreferences: transceiver => this._applyCodecPreferencesToTransceiver(transceiver)
         });
         if (options.dummyAudioMediaStreamTrack) {
             peerConnection.addTrack(options.dummyAudioMediaStreamTrack);
         }
-        Object.defineProperties(_this, {
+        Object.defineProperties(this, {
             _appliedTrackIdsToAttributes: {
                 value: new Map(),
                 writable: true
@@ -185,7 +144,7 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                 writable: true
             },
             _iceGatheringTimeout: {
-                value: new options.Timeout(function () { return _this._handleIceGatheringTimeout(); }, DEFAULT_ICE_GATHERING_TIMEOUT_MS, false)
+                value: new options.Timeout(() => this._handleIceGatheringTimeout(), DEFAULT_ICE_GATHERING_TIMEOUT_MS, false)
             },
             _iceRestartBackoff: {
                 value: new options.Backoff(iceRestartBackoffConfig)
@@ -274,9 +233,9 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                 value: options.offerOptions
             },
             _onEncodingParametersChanged: {
-                value: oncePerTick(function () {
-                    if (!_this._needsAnswer) {
-                        updateEncodingParameters(_this);
+                value: oncePerTick(() => {
+                    if (!this._needsAnswer) {
+                        updateEncodingParameters(this);
                     }
                 })
             },
@@ -290,23 +249,17 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                 value: preferredCodecs.video
             },
             _shouldApplyDtx: {
-                value: preferredCodecs.audio.every(function (_a) {
-                    var codec = _a.codec;
-                    return codec !== 'opus';
-                })
-                    || preferredCodecs.audio.some(function (_a) {
-                        var codec = _a.codec, dtx = _a.dtx;
-                        return codec === 'opus' && dtx;
-                    })
+                value: preferredCodecs.audio.every(({ codec }) => codec !== 'opus')
+                    || preferredCodecs.audio.some(({ codec, dtx }) => codec === 'opus' && dtx)
             },
             _queuedDescription: {
                 writable: true,
                 value: null
             },
             _iceReconnectTimeout: {
-                value: new options.Timeout(function () {
+                value: new options.Timeout(() => {
                     log.debug('ICE reconnect timed out');
-                    _this.close();
+                    this.close();
                 }, options.sessionTimeout, false)
             },
             _recycledTransceivers: {
@@ -364,139 +317,117 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                 value: id
             }
         });
-        encodingParameters.on('changed', _this._onEncodingParametersChanged);
-        telemetry.pc.signalingState(_this.id, peerConnection.signalingState);
-        telemetry.pc.iceGatheringState(_this.id, peerConnection.iceGatheringState);
-        telemetry.pc.iceConnectionState(_this.id, peerConnection.iceConnectionState);
-        telemetry.pc.connectionState(_this.id, _this.connectionState);
-        peerConnection.addEventListener('connectionstatechange', _this._handleConnectionStateChange.bind(_this));
-        peerConnection.addEventListener('datachannel', _this._handleDataChannelEvent.bind(_this));
-        peerConnection.addEventListener('icecandidate', _this._handleIceCandidateEvent.bind(_this));
-        peerConnection.addEventListener('iceconnectionstatechange', _this._handleIceConnectionStateChange.bind(_this));
-        peerConnection.addEventListener('icegatheringstatechange', _this._handleIceGatheringStateChange.bind(_this));
-        peerConnection.addEventListener('signalingstatechange', _this._handleSignalingStateChange.bind(_this));
-        peerConnection.addEventListener('track', _this._handleTrackEvent.bind(_this));
-        var self = _this;
-        _this.on('stateChanged', function stateChanged(state) {
+        encodingParameters.on('changed', this._onEncodingParametersChanged);
+        telemetry.pc.signalingState(this.id, peerConnection.signalingState);
+        telemetry.pc.iceGatheringState(this.id, peerConnection.iceGatheringState);
+        telemetry.pc.iceConnectionState(this.id, peerConnection.iceConnectionState);
+        telemetry.pc.connectionState(this.id, this.connectionState);
+        peerConnection.addEventListener('connectionstatechange', this._handleConnectionStateChange.bind(this));
+        peerConnection.addEventListener('datachannel', this._handleDataChannelEvent.bind(this));
+        peerConnection.addEventListener('icecandidate', this._handleIceCandidateEvent.bind(this));
+        peerConnection.addEventListener('iceconnectionstatechange', this._handleIceConnectionStateChange.bind(this));
+        peerConnection.addEventListener('icegatheringstatechange', this._handleIceGatheringStateChange.bind(this));
+        peerConnection.addEventListener('signalingstatechange', this._handleSignalingStateChange.bind(this));
+        peerConnection.addEventListener('track', this._handleTrackEvent.bind(this));
+        const self = this;
+        this.on('stateChanged', function stateChanged(state) {
             if (state !== 'closed') {
                 return;
             }
             self.removeListener('stateChanged', stateChanged);
-            self._dataChannels.forEach(function (dataChannel, dataTrackSender) {
+            self._dataChannels.forEach((dataChannel, dataTrackSender) => {
                 self.removeDataTrackSender(dataTrackSender);
             });
         });
-        return _this;
     }
-    PeerConnectionV2.prototype.toString = function () {
-        return "[PeerConnectionV2 #".concat(this._instanceId, ": ").concat(this.id, "]");
-    };
-    PeerConnectionV2.prototype.setEffectiveAdaptiveSimulcast = function (effectiveAdaptiveSimulcast) {
+    toString() {
+        return `[PeerConnectionV2 #${this._instanceId}: ${this.id}]`;
+    }
+    setEffectiveAdaptiveSimulcast(effectiveAdaptiveSimulcast) {
         this._log.debug('Setting setEffectiveAdaptiveSimulcast: ', effectiveAdaptiveSimulcast);
         // clear adaptive simulcast from codec preferences if it was set.
-        this._preferredVideoCodecs.forEach(function (cs) {
+        this._preferredVideoCodecs.forEach(cs => {
             if ('adaptiveSimulcast' in cs) {
                 cs.adaptiveSimulcast = effectiveAdaptiveSimulcast;
             }
         });
-    };
-    Object.defineProperty(PeerConnectionV2.prototype, "_shouldApplySimulcast", {
-        get: function () {
-            if (!isChrome && !isSafari) {
-                return false;
-            }
-            // adaptiveSimulcast is set to false after connected message is received if other party does not support it.
-            var simulcast = this._preferredVideoCodecs.some(function (cs) {
-                return cs.codec.toLowerCase() === 'vp8' && cs.simulcast && cs.adaptiveSimulcast !== false;
-            });
-            return simulcast;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PeerConnectionV2.prototype, "connectionState", {
-        /**
-         * The {@link PeerConnectionV2}'s underlying RTCPeerConnection's RTCPeerConnectionState
-         * if supported by the browser, its RTCIceConnectionState otherwise.
-         * @property {RTCPeerConnectionState}
-         */
-        get: function () {
-            return this.iceConnectionState === 'failed'
-                ? 'failed' : (this._peerConnection.connectionState || this.iceConnectionState);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PeerConnectionV2.prototype, "iceConnectionState", {
-        /**
-         * The {@link PeerConnectionV2}'s underlying RTCPeerConnection's
-         * RTCIceConnectionState.
-         * @property {RTCIceConnectionState}
-         */
-        get: function () {
-            return ((this._isIceConnectionInactive && this._peerConnection.iceConnectionState === 'disconnected') || this._iceGatheringFailed)
-                ? 'failed' : this._peerConnection.iceConnectionState;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PeerConnectionV2.prototype, "isApplicationSectionNegotiated", {
-        /**
-         * Whether the {@link PeerConnectionV2} has negotiated or is in the process
-         * of negotiating the application m= section.
-         * @returns {boolean}
-         */
-        get: function () {
-            if (this._peerConnection.signalingState !== 'closed') {
-                // accessing .localDescription in 'closed' state causes it throw exceptions.
-                return this._peerConnection.localDescription
-                    ? getMediaSections(this._peerConnection.localDescription.sdp, 'application').length > 0
-                    : false;
-            }
-            return true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PeerConnectionV2.prototype, "_isAdaptiveSimulcastEnabled", {
-        /**
-         * Whether adaptive simulcast is enabled.
-         * @returns {boolean}
-         */
-        get: function () {
-            var adaptiveSimulcastEntry = this._preferredVideoCodecs.find(function (cs) { return 'adaptiveSimulcast' in cs; });
-            return adaptiveSimulcastEntry && adaptiveSimulcastEntry.adaptiveSimulcast === true;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    get _shouldApplySimulcast() {
+        if (!isChrome && !isSafari) {
+            return false;
+        }
+        // adaptiveSimulcast is set to false after connected message is received if other party does not support it.
+        const simulcast = this._preferredVideoCodecs.some(cs => {
+            return cs.codec.toLowerCase() === 'vp8' && cs.simulcast && cs.adaptiveSimulcast !== false;
+        });
+        return simulcast;
+    }
+    /**
+     * The {@link PeerConnectionV2}'s underlying RTCPeerConnection's RTCPeerConnectionState
+     * if supported by the browser, its RTCIceConnectionState otherwise.
+     * @property {RTCPeerConnectionState}
+     */
+    get connectionState() {
+        return this.iceConnectionState === 'failed'
+            ? 'failed' : (this._peerConnection.connectionState || this.iceConnectionState);
+    }
+    /**
+     * The {@link PeerConnectionV2}'s underlying RTCPeerConnection's
+     * RTCIceConnectionState.
+     * @property {RTCIceConnectionState}
+     */
+    get iceConnectionState() {
+        return ((this._isIceConnectionInactive && this._peerConnection.iceConnectionState === 'disconnected') || this._iceGatheringFailed)
+            ? 'failed' : this._peerConnection.iceConnectionState;
+    }
+    /**
+     * Whether the {@link PeerConnectionV2} has negotiated or is in the process
+     * of negotiating the application m= section.
+     * @returns {boolean}
+     */
+    get isApplicationSectionNegotiated() {
+        if (this._peerConnection.signalingState !== 'closed') {
+            // accessing .localDescription in 'closed' state causes it throw exceptions.
+            return this._peerConnection.localDescription
+                ? getMediaSections(this._peerConnection.localDescription.sdp, 'application').length > 0
+                : false;
+        }
+        return true;
+    }
+    /**
+     * Whether adaptive simulcast is enabled.
+     * @returns {boolean}
+     */
+    get _isAdaptiveSimulcastEnabled() {
+        const adaptiveSimulcastEntry = this._preferredVideoCodecs.find(cs => 'adaptiveSimulcast' in cs);
+        return adaptiveSimulcastEntry && adaptiveSimulcastEntry.adaptiveSimulcast === true;
+    }
     /**
      * @param {MediaStreamTrack} track
      * @param {Array<RTCRtpEncodingParameters>} encodings
      * @param {boolean} trackReplaced
      * @returns {boolean} true if encodings were updated.
      */
-    PeerConnectionV2.prototype._maybeUpdateEncodings = function (track, encodings, trackReplaced) {
-        if (trackReplaced === void 0) { trackReplaced = false; }
+    _maybeUpdateEncodings(track, encodings, trackReplaced = false) {
         if (track.kind !== 'video' || track.readyState === 'ended') {
             return false;
         }
         // NOTE(mmalavalli): There is no guarantee that CanvasCaptureMediaStreamTracks will always have "width" and "height"
         // in their settings. So, we don't update the encodings if they are not present.
         // Chromium bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1367082
-        var _a = track.getSettings(), height = _a.height, width = _a.width;
+        const { height, width } = track.getSettings();
         if (typeof height !== 'number' || typeof width !== 'number') {
             return false;
         }
         // Note(mpatwardhan): always configure encodings for safari.
         // for chrome only when adaptive simulcast enabled.
-        var browser = util.guessBrowser();
+        const browser = util.guessBrowser();
         if (browser === 'safari' || (browser === 'chrome' && this._isAdaptiveSimulcastEnabled)) {
             this._updateEncodings(track, encodings, trackReplaced);
             return true;
         }
         return false;
-    };
+    }
     /**
      * Configures with default encodings depending on track type and resolution.
      * Default configuration sets some encodings to disabled, and for others set scaleResolutionDownBy
@@ -506,14 +437,14 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @param {Array<RTCRtpEncodingParameters>} encodings
      * @param {boolean} trackReplaced
      */
-    PeerConnectionV2.prototype._updateEncodings = function (track, encodings, trackReplaced) {
+    _updateEncodings(track, encodings, trackReplaced) {
         if (this._isChromeScreenShareTrack(track)) {
-            var screenShareActiveLayerConfig_1 = [
+            const screenShareActiveLayerConfig = [
                 { scaleResolutionDownBy: 1 },
                 { scaleResolutionDownBy: 1 }
             ];
-            encodings.forEach(function (encoding, i) {
-                var activeLayerConfig = screenShareActiveLayerConfig_1[i];
+            encodings.forEach((encoding, i) => {
+                const activeLayerConfig = screenShareActiveLayerConfig[i];
                 if (activeLayerConfig) {
                     encoding.scaleResolutionDownBy = activeLayerConfig.scaleResolutionDownBy;
                     if (trackReplaced) {
@@ -527,21 +458,21 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             });
         }
         else {
-            var _a = track.getSettings(), width = _a.width, height = _a.height;
+            const { width, height } = track.getSettings();
             // NOTE(mpatwardhan): for non-screen share tracks
             // enable layers depending on track resolutions
-            var pixelsToMaxActiveLayers = [
+            const pixelsToMaxActiveLayers = [
                 { pixels: 960 * 540, maxActiveLayers: 3 },
                 { pixels: 480 * 270, maxActiveLayers: 2 },
                 { pixels: 0, maxActiveLayers: 1 }
             ];
-            var trackPixels_1 = width * height;
-            var activeLayersInfo = pixelsToMaxActiveLayers.find(function (layer) { return trackPixels_1 >= layer.pixels; });
-            var activeLayers_1 = Math.min(encodings.length, activeLayersInfo.maxActiveLayers);
-            encodings.forEach(function (encoding, i) {
-                var enabled = i < activeLayers_1;
+            const trackPixels = width * height;
+            const activeLayersInfo = pixelsToMaxActiveLayers.find(layer => trackPixels >= layer.pixels);
+            const activeLayers = Math.min(encodings.length, activeLayersInfo.maxActiveLayers);
+            encodings.forEach((encoding, i) => {
+                const enabled = i < activeLayers;
                 if (enabled) {
-                    encoding.scaleResolutionDownBy = 1 << (activeLayers_1 - i - 1);
+                    encoding.scaleResolutionDownBy = 1 << (activeLayers - i - 1);
                     if (trackReplaced) {
                         encoding.active = true;
                     }
@@ -552,24 +483,20 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                 }
             });
         }
-        this._log.debug('_updateEncodings:', encodings.map(function (_a, i) {
-            var active = _a.active, scaleResolutionDownBy = _a.scaleResolutionDownBy;
-            return "[".concat(i, ": ").concat(active, ", ").concat(scaleResolutionDownBy || 0, "]");
-        }).join(', '));
-    };
+        this._log.debug('_updateEncodings:', encodings.map(({ active, scaleResolutionDownBy }, i) => `[${i}: ${active}, ${scaleResolutionDownBy || 0}]`).join(', '));
+    }
     /**
      * Add an ICE candidate to the {@link PeerConnectionV2}.
      * @private
      * @param {object} candidate
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._addIceCandidate = function (candidate) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            telemetry.pc.iceCandidate(_this.id, candidate, true);
-            candidate = new _this._RTCIceCandidate(candidate);
-            return _this._peerConnection.addIceCandidate(candidate);
-        }).catch(function (error) {
+    _addIceCandidate(candidate) {
+        return Promise.resolve().then(() => {
+            telemetry.pc.iceCandidate(this.id, candidate, true);
+            candidate = new this._RTCIceCandidate(candidate);
+            return this._peerConnection.addIceCandidate(candidate);
+        }).catch(error => {
             // NOTE(mmalavalli): Firefox 68+ now generates an RTCIceCandidate with an
             // empty candidate string to signal end-of-candidates, followed by a null
             // candidate. As of now, Chrome and Safari reject this RTCIceCandidate. Since
@@ -578,45 +505,45 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             //
             // Chrome bug: https://bugs.chromium.org/p/chromium/issues/detail?id=978582
             //
-            _this._log.warn("Failed to add RTCIceCandidate ".concat(candidate ? "\"".concat(candidate.candidate, "\"") : 'null', ": ")
+            this._log.warn(`Failed to add RTCIceCandidate ${candidate ? `"${candidate.candidate}"` : 'null'}: `
                 + error.message);
         });
-    };
+    }
     /**
      * Add ICE candidates to the {@link PeerConnectionV2}.
      * @private
      * @param {Array<object>} candidates
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._addIceCandidates = function (candidates) {
-        return Promise.all(candidates.map(this._addIceCandidate, this)).then(function () { });
-    };
+    _addIceCandidates(candidates) {
+        return Promise.all(candidates.map(this._addIceCandidate, this)).then(() => { });
+    }
     /**
      * Apply codec preferences to a transceiver.
      * @private
      * @param {RTCRtpTransceiver} transceiver
      * @returns {void}
      */
-    PeerConnectionV2.prototype._applyCodecPreferencesToTransceiver = function (transceiver) {
+    _applyCodecPreferencesToTransceiver(transceiver) {
         if (!transceiver || !transceiver.receiver || !transceiver.receiver.track) {
             return;
         }
-        var kind = transceiver.receiver.track.kind;
-        var preferredCodecs = kind === 'audio'
+        const kind = transceiver.receiver.track.kind;
+        const preferredCodecs = kind === 'audio'
             ? this._preferredAudioCodecs
             : this._preferredVideoCodecs;
         if (!preferredCodecs || preferredCodecs.length === 0) {
             return;
         }
         try {
-            var availableCodecs = RTCRtpReceiver.getCapabilities(kind).codecs;
-            var sortedCodecs = this._sortCodecsByPreference(availableCodecs, preferredCodecs);
+            const availableCodecs = RTCRtpReceiver.getCapabilities(kind).codecs;
+            const sortedCodecs = this._sortCodecsByPreference(availableCodecs, preferredCodecs);
             transceiver.setCodecPreferences(sortedCodecs);
         }
         catch (error) {
             this._log.warn('Failed to apply codec preferences:', error);
         }
-    };
+    }
     /**
      * Sort codecs by preference.
      * @private
@@ -624,15 +551,13 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @param {Array} preferredCodecs
      * @returns {Array}
      */
-    PeerConnectionV2.prototype._sortCodecsByPreference = function (availableCodecs, preferredCodecs) {
-        var preferred = [];
-        var remaining = [];
-        var preferredNames = preferredCodecs.map(function (c) {
-            return (typeof c === 'string' ? c : c.codec).toLowerCase();
-        });
-        availableCodecs.forEach(function (codec) {
-            var codecName = codec.mimeType.split('/')[1].toLowerCase();
-            var index = preferredNames.indexOf(codecName);
+    _sortCodecsByPreference(availableCodecs, preferredCodecs) {
+        const preferred = [];
+        const remaining = [];
+        const preferredNames = preferredCodecs.map(c => (typeof c === 'string' ? c : c.codec).toLowerCase());
+        availableCodecs.forEach(codec => {
+            const codecName = codec.mimeType.split('/')[1].toLowerCase();
+            const index = preferredNames.indexOf(codecName);
             if (index >= 0) {
                 if (!preferred[index]) {
                     preferred[index] = [];
@@ -644,7 +569,7 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             }
         });
         return preferred.flat().concat(remaining);
-    };
+    }
     /**
      * Add a new RTCRtpTransceiver or update an existing RTCRtpTransceiver for the
      * given MediaStreamTrack.
@@ -652,68 +577,66 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @param {MediaStreamTrack} track
      * @returns {RTCRtpTransceiver}
      */
-    PeerConnectionV2.prototype._addOrUpdateTransceiver = function (track) {
-        var _this = this;
-        var transceiver = takeRecycledTransceiver(this, track.kind);
+    _addOrUpdateTransceiver(track) {
+        const transceiver = takeRecycledTransceiver(this, track.kind);
         if (transceiver && transceiver.sender) {
-            var oldTrackId = transceiver.sender.track ? transceiver.sender.track.id : null;
+            const oldTrackId = transceiver.sender.track ? transceiver.sender.track.id : null;
             if (oldTrackId) {
-                this._log.warn("Reusing transceiver: ".concat(transceiver.mid, "] ").concat(oldTrackId, " => ").concat(track.id));
+                this._log.warn(`Reusing transceiver: ${transceiver.mid}] ${oldTrackId} => ${track.id}`);
             }
             // NOTE(mpatwardhan):remember this transceiver while we replace track.
             // we recycle transceivers that are not in use after 'negotiationCompleted', but we want to prevent
             // this one from getting recycled while replaceTrack is pending.
-            this._replaceTrackPromises.set(transceiver, transceiver.sender.replaceTrack(track).then(function () {
+            this._replaceTrackPromises.set(transceiver, transceiver.sender.replaceTrack(track).then(() => {
                 transceiver.direction = 'sendrecv';
-            }, function () {
+            }, () => {
                 // Do nothing.
-            }).finally(function () {
-                _this._replaceTrackPromises.delete(transceiver);
+            }).finally(() => {
+                this._replaceTrackPromises.delete(transceiver);
             }));
             return transceiver;
         }
         // NOTE(lrivas): The second argument {} is optional in the specification but required by the Citrix VDI implementations.
-        var newTransceiver = this._peerConnection.addTransceiver(track, {});
+        const newTransceiver = this._peerConnection.addTransceiver(track, {});
         this._applyCodecPreferencesToTransceiver(newTransceiver);
         return newTransceiver;
-    };
+    }
     /**
      * Check the {@link IceBox}.
      * @private
      * @param {RTCSessionDescriptionInit} description
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._checkIceBox = function (description) {
-        var ufrag = getUfrag(description);
+    _checkIceBox(description) {
+        const ufrag = getUfrag(description);
         if (!ufrag) {
             return Promise.resolve();
         }
-        var candidates = this._remoteCandidates.setUfrag(ufrag);
+        const candidates = this._remoteCandidates.setUfrag(ufrag);
         return this._addIceCandidates(candidates);
-    };
+    }
     /**
      * Create an answer and set it on the {@link PeerConnectionV2}.
      * @private
      * @param {RTCSessionDescriptionInit} offer
      * @returns {Promise<boolean>}
      */
-    PeerConnectionV2.prototype._answer = function (offer) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            if (!_this._negotiationRole) {
-                _this._negotiationRole = 'answerer';
+    _answer(offer) {
+        return Promise.resolve().then(() => {
+            if (!this._negotiationRole) {
+                this._negotiationRole = 'answerer';
             }
-            return _this._setRemoteDescription(offer);
-        }).catch(function () {
+            return this._setRemoteDescription(offer);
+        }).catch(() => {
             throw new MediaClientRemoteDescFailedError();
-        }).then(function () {
-            return _this._peerConnection.createAnswer();
-        }).then(function (answer) {
+        }).then(() => {
+            return this._peerConnection.createAnswer();
+        }).then(answer => {
             if (isFirefox) {
                 // NOTE(mmalavalli): We work around Chromium bug 1106157 by disabling
                 // RTX in Firefox 79+. For more details about the bug, please go here:
                 // https://bugs.chromium.org/p/chromium/issues/detail?id=1106157
-                answer = new _this._RTCSessionDescription({
+                answer = new this._RTCSessionDescription({
                     sdp: disableRtx(answer.sdp),
                     type: answer.type
                 });
@@ -726,47 +649,47 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             // and PSA: https://groups.google.com/forum/#!searchin/discuss-webrtc/PSA%7Csort:date/discuss-webrtc/jcZO-Wj0Wus/k2XvPCvoAwAJ
             // We are not referencing those attributes, but this changes goes ahead and removes them to see if it works.
             // this also helps reduce bytes on wires
-            var updatedSdp = removeSSRCAttributes(answer.sdp, ['mslabel', 'label']);
-            if (_this._shouldApplySimulcast) {
-                var sdpWithoutSimulcast = updatedSdp;
-                updatedSdp = _this._setSimulcast(sdpWithoutSimulcast, _this._trackIdsToAttributes);
+            let updatedSdp = removeSSRCAttributes(answer.sdp, ['mslabel', 'label']);
+            if (this._shouldApplySimulcast) {
+                let sdpWithoutSimulcast = updatedSdp;
+                updatedSdp = this._setSimulcast(sdpWithoutSimulcast, this._trackIdsToAttributes);
                 // NOTE(syerrapragada): VMS does not support H264 simulcast. So,
                 // unset simulcast for sections in local offer where corresponding
                 // sections in answer doesn't have vp8 as preferred codec and reapply offer.
-                updatedSdp = _this._revertSimulcast(updatedSdp, sdpWithoutSimulcast, offer.sdp);
+                updatedSdp = this._revertSimulcast(updatedSdp, sdpWithoutSimulcast, offer.sdp);
             }
             // NOTE(mmalavalli): Work around Chromium bug 1074421.
             // https://bugs.chromium.org/p/chromium/issues/detail?id=1074421
             updatedSdp = updatedSdp.replace(/42e015/g, '42e01f');
-            return _this._setLocalDescription({
+            return this._setLocalDescription({
                 type: answer.type,
                 sdp: updatedSdp
             });
-        }).then(function () {
-            return _this._checkIceBox(offer);
-        }).then(function () {
-            return _this._queuedDescription
-                && _this._updateDescription(_this._queuedDescription);
-        }).then(function () {
-            _this._queuedDescription = null;
-            return _this._maybeReoffer(_this._peerConnection.localDescription);
-        }).catch(function (error) {
-            var errorToThrow = error instanceof MediaClientRemoteDescFailedError ? error : new MediaClientLocalDescFailedError();
-            _this._publishMediaWarning({
+        }).then(() => {
+            return this._checkIceBox(offer);
+        }).then(() => {
+            return this._queuedDescription
+                && this._updateDescription(this._queuedDescription);
+        }).then(() => {
+            this._queuedDescription = null;
+            return this._maybeReoffer(this._peerConnection.localDescription);
+        }).catch(error => {
+            const errorToThrow = error instanceof MediaClientRemoteDescFailedError ? error : new MediaClientLocalDescFailedError();
+            this._publishMediaWarning({
                 message: 'Failed to _answer',
                 code: errorToThrow.code,
-                error: error
+                error
             });
             throw errorToThrow;
         });
-    };
+    }
     /**
      * Close the underlying RTCPeerConnection. Returns false if the
      * RTCPeerConnection was already closed.
      * @private
      * @returns {boolean}
      */
-    PeerConnectionV2.prototype._close = function () {
+    _close() {
         this._iceConnectionMonitor.stop();
         if (this._peerConnection.signalingState !== 'closed') {
             this._peerConnection.close();
@@ -783,71 +706,68 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             return true;
         }
         return false;
-    };
+    }
     /**
      * Handle a "connectionstatechange" event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleConnectionStateChange = function () {
+    _handleConnectionStateChange() {
         telemetry.pc.connectionState(this.id, this.connectionState);
         this.emit('connectionStateChanged');
-    };
+    }
     /**
      * Handle a "datachannel" event.
      * @private
      * @param {RTCDataChannelEvent} event
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleDataChannelEvent = function (event) {
-        var _this = this;
-        var dataChannel = event.channel;
-        var dataTrackReceiver = new DataTrackReceiver(dataChannel);
+    _handleDataChannelEvent(event) {
+        const dataChannel = event.channel;
+        const dataTrackReceiver = new DataTrackReceiver(dataChannel);
         this._dataTrackReceivers.add(dataTrackReceiver);
-        dataChannel.addEventListener('close', function () {
-            _this._dataTrackReceivers.delete(dataTrackReceiver);
+        dataChannel.addEventListener('close', () => {
+            this._dataTrackReceivers.delete(dataTrackReceiver);
         });
         this.emit('trackAdded', dataTrackReceiver);
-    };
+    }
     /**
      * Handle a glare scenario on the {@link PeerConnectionV2}.
      * @private
      * @param {RTCSessionDescriptionInit} offer
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._handleGlare = function (offer) {
-        var _this = this;
+    _handleGlare(offer) {
         this._log.debug('Glare detected; rolling back');
         if (this._isRestartingIce) {
             this._log.debug('An ICE restart was in progress; we\'ll need to restart ICE again after rolling back');
             this._isRestartingIce = false;
             this._shouldRestartIce = true;
         }
-        return Promise.resolve().then(function () {
-            _this._trackIdsToAttributes = new Map(_this._appliedTrackIdsToAttributes);
-            return _this._setLocalDescription({ type: 'rollback' });
-        }).then(function () {
-            _this._needsAnswer = false;
-            return _this._answer(offer);
-        }).then(function (didReoffer) {
-            return didReoffer ? Promise.resolve() : _this._offer();
+        return Promise.resolve().then(() => {
+            this._trackIdsToAttributes = new Map(this._appliedTrackIdsToAttributes);
+            return this._setLocalDescription({ type: 'rollback' });
+        }).then(() => {
+            this._needsAnswer = false;
+            return this._answer(offer);
+        }).then(didReoffer => {
+            return didReoffer ? Promise.resolve() : this._offer();
         });
-    };
-    PeerConnectionV2.prototype._publishMediaWarning = function (_a) {
-        var message = _a.message, code = _a.code, error = _a.error, sdp = _a.sdp;
+    }
+    _publishMediaWarning({ message, code, error, sdp }) {
         this._eventObserver.emit('event', { level: 'warning', name: 'error', group: 'media', payload: {
-                message: message,
-                code: code,
-                context: JSON.stringify({ error: error.message, sdp: sdp })
+                message,
+                code,
+                context: JSON.stringify({ error: error.message, sdp })
             } });
-    };
+    }
     /**
      * Handle an ICE candidate event.
      * @private
      * @param {Event} event
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleIceCandidateEvent = function (event) {
+    _handleIceCandidateEvent(event) {
         if (event.candidate) {
             this._log.debug('Clearing ICE gathering timeout');
             this._didGenerateLocalCandidates = true;
@@ -855,7 +775,7 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             this._localCandidates.push(event.candidate);
             telemetry.pc.iceCandidate(this.id, event.candidate);
         }
-        var peerConnectionState = {
+        const peerConnectionState = {
             ice: {
                 candidates: this._isIceLite ? [] : this._localCandidates.slice(),
                 ufrag: this._localUfrag
@@ -869,18 +789,17 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             peerConnectionState.ice.revision = this._localCandidatesRevision++;
             this.emit('candidates', peerConnectionState);
         }
-    };
+    }
     /**
      * Handle an ICE connection state change event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleIceConnectionStateChange = function () {
-        var _this = this;
-        var iceConnectionState = this._peerConnection.iceConnectionState;
-        var isIceConnectedOrComplete = ['connected', 'completed'].includes(iceConnectionState);
-        var log = this._log;
-        log.debug("ICE connection state is \"".concat(iceConnectionState, "\""));
+    _handleIceConnectionStateChange() {
+        const { iceConnectionState } = this._peerConnection;
+        const isIceConnectedOrComplete = ['connected', 'completed'].includes(iceConnectionState);
+        const log = this._log;
+        log.debug(`ICE connection state is "${iceConnectionState}"`);
         telemetry.pc.iceConnectionState(this.id, iceConnectionState);
         if (isIceConnectedOrComplete) {
             this._iceReconnectTimeout.clear();
@@ -898,16 +817,16 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         // start monitor media when connected, and continue to monitor while state is complete-disconnected-connected.
         if (iceConnectionState === 'connected') {
             this._isIceConnectionInactive = false;
-            this._iceConnectionMonitor.start(function () {
+            this._iceConnectionMonitor.start(() => {
                 // note: iceConnection monitor waits for iceConnectionState=disconnected for
                 // detecting inactivity. Its possible that it may know about disconnected before _handleIceConnectionStateChange
-                _this._iceConnectionMonitor.stop();
-                if (!_this._shouldRestartIce && !_this._isRestartingIce) {
+                this._iceConnectionMonitor.stop();
+                if (!this._shouldRestartIce && !this._isRestartingIce) {
                     log.warn('ICE Connection Monitor detected inactivity');
-                    _this._isIceConnectionInactive = true;
-                    _this._initiateIceRestartBackoff();
-                    _this.emit('iceConnectionStateChanged');
-                    _this.emit('connectionStateChanged');
+                    this._isIceConnectionInactive = true;
+                    this._initiateIceRestartBackoff();
+                    this.emit('iceConnectionStateChanged');
+                    this.emit('connectionStateChanged');
                 }
             });
         }
@@ -917,217 +836,214 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         }
         this._lastIceConnectionState = iceConnectionState;
         this.emit('iceConnectionStateChanged');
-    };
+    }
     /**
      * Handle ICE gathering timeout.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleIceGatheringTimeout = function () {
+    _handleIceGatheringTimeout() {
         this._log.warn('ICE failed to gather any local candidates');
         this._iceGatheringFailed = true;
         this._initiateIceRestartBackoff();
         this.emit('iceConnectionStateChanged');
         this.emit('connectionStateChanged');
-    };
+    }
     /**
      * Handle an ICE gathering state change event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleIceGatheringStateChange = function () {
-        var iceGatheringState = this._peerConnection.iceGatheringState;
+    _handleIceGatheringStateChange() {
+        const { iceGatheringState } = this._peerConnection;
         telemetry.pc.iceGatheringState(this.id, iceGatheringState);
-        var log = this._log;
-        log.debug("ICE gathering state is \"".concat(iceGatheringState, "\""));
+        const log = this._log;
+        log.debug(`ICE gathering state is "${iceGatheringState}"`);
         // NOTE(mmalavalli): Start the ICE gathering timeout only if the RTCPeerConnection
         // has started gathering candidates for the first time since the initial offer/answer
         // or an offer/answer with ICE restart.
-        var _a = this._iceGatheringTimeout, delay = _a.delay, isSet = _a.isSet;
+        const { delay, isSet } = this._iceGatheringTimeout;
         if (iceGatheringState === 'gathering' && !this._didGenerateLocalCandidates && !isSet) {
-            log.debug("Starting ICE gathering timeout: ".concat(delay));
+            log.debug(`Starting ICE gathering timeout: ${delay}`);
             this._iceGatheringFailed = false;
             this._iceGatheringTimeout.start();
         }
-    };
+    }
     /**
      * Handle a signaling state change event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleSignalingStateChange = function () {
+    _handleSignalingStateChange() {
         telemetry.pc.signalingState(this.id, this._peerConnection.signalingState);
         if (this._peerConnection.signalingState === 'stable') {
             this._appliedTrackIdsToAttributes = new Map(this._trackIdsToAttributes);
         }
-    };
+    }
     /**
      * Handle a DTLS transport state change event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleDtlsTransportStateChange = function () {
-        var transport = this._dtlsTransport;
+    _handleDtlsTransportStateChange() {
+        const transport = this._dtlsTransport;
         if (transport) {
-            this._log.debug("DTLS transport state is \"".concat(transport.state, "\""));
+            this._log.debug(`DTLS transport state is "${transport.state}"`);
             telemetry.pc.dtlsTransportState(this.id, transport.state);
         }
-    };
+    }
     /**
      * Handle a selected candidate pair change event.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleSelectedCandidatePairChange = function () {
+    _handleSelectedCandidatePairChange() {
         var _a;
-        var iceTransport = (_a = this._dtlsTransport) === null || _a === void 0 ? void 0 : _a.iceTransport;
+        const iceTransport = (_a = this._dtlsTransport) === null || _a === void 0 ? void 0 : _a.iceTransport;
         if (iceTransport && typeof iceTransport.getSelectedCandidatePair === 'function') {
-            var pair = iceTransport.getSelectedCandidatePair();
+            const pair = iceTransport.getSelectedCandidatePair();
             if (pair) {
                 telemetry.pc.selectedCandidatePair(this.id, pair);
             }
         }
-    };
+    }
     /**
      * Handle a track event.
      * @private
      * @param {RTCTrackEvent} event
      * @returns {void}
      */
-    PeerConnectionV2.prototype._handleTrackEvent = function (event) {
-        var _this = this;
-        var sdp = this._peerConnection.remoteDescription
+    _handleTrackEvent(event) {
+        const sdp = this._peerConnection.remoteDescription
             ? this._peerConnection.remoteDescription.sdp
             : null;
         this._trackMatcher = this._trackMatcher || new TrackMatcher();
         this._trackMatcher.update(sdp);
-        var mediaStreamTrack = event.track;
-        var signaledTrackId = this._trackMatcher.match(event) || mediaStreamTrack.id;
-        var mediaTrackReceiver = new MediaTrackReceiver(signaledTrackId, mediaStreamTrack);
+        const mediaStreamTrack = event.track;
+        const signaledTrackId = this._trackMatcher.match(event) || mediaStreamTrack.id;
+        const mediaTrackReceiver = new MediaTrackReceiver(signaledTrackId, mediaStreamTrack);
         // NOTE(mmalavalli): "ended" is not fired on the remote MediaStreamTrack when
         // the remote peer removes a track. So, when this MediaStreamTrack is re-used
         // for a different track due to the remote peer calling RTCRtpSender.replaceTrack(),
         // we delete the previous MediaTrackReceiver that owned this MediaStreamTrack
         // before adding the new MediaTrackReceiver.
-        this._mediaTrackReceivers.forEach(function (trackReceiver) {
+        this._mediaTrackReceivers.forEach(trackReceiver => {
             if (trackReceiver.track.id === mediaTrackReceiver.track.id) {
-                _this._mediaTrackReceivers.delete(trackReceiver);
+                this._mediaTrackReceivers.delete(trackReceiver);
             }
         });
         this._mediaTrackReceivers.add(mediaTrackReceiver);
         if (mediaStreamTrack.addEventListener) {
-            mediaStreamTrack.addEventListener('ended', function () { return _this._mediaTrackReceivers.delete(mediaTrackReceiver); });
+            mediaStreamTrack.addEventListener('ended', () => this._mediaTrackReceivers.delete(mediaTrackReceiver));
         }
         else {
-            mediaStreamTrack.onended = function () { return _this._mediaTrackReceivers.delete(mediaTrackReceiver); };
+            mediaStreamTrack.onended = () => this._mediaTrackReceivers.delete(mediaTrackReceiver);
         }
         this.emit('trackAdded', mediaTrackReceiver);
-    };
+    }
     /**
      * Initiate ICE Restart.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._initiateIceRestart = function () {
+    _initiateIceRestart() {
         if (this._peerConnection.signalingState === 'closed') {
             return;
         }
-        var log = this._log;
+        const log = this._log;
         log.warn('Attempting to restart ICE');
         this._didGenerateLocalCandidates = false;
         this._isIceRestartBackoffInProgress = false;
         this._shouldRestartIce = true;
-        var _a = this._iceReconnectTimeout, delay = _a.delay, isSet = _a.isSet;
+        const { delay, isSet } = this._iceReconnectTimeout;
         if (!isSet) {
-            log.debug("Starting ICE reconnect timeout: ".concat(delay));
+            log.debug(`Starting ICE reconnect timeout: ${delay}`);
             this._iceReconnectTimeout.start();
         }
-        this.offer().catch(function (ex) {
-            log.error("offer failed in _initiateIceRestart with: ".concat(ex.message));
+        this.offer().catch(ex => {
+            log.error(`offer failed in _initiateIceRestart with: ${ex.message}`);
         });
-    };
+    }
     /**
      * Schedule an ICE Restart.
      * @private
      * @returns {void}
      */
-    PeerConnectionV2.prototype._initiateIceRestartBackoff = function () {
-        var _this = this;
+    _initiateIceRestartBackoff() {
         if (this._peerConnection.signalingState === 'closed' || this._isIceRestartBackoffInProgress) {
             return;
         }
         this._log.warn('An ICE restart has been scheduled');
         this._isIceRestartBackoffInProgress = true;
-        this._iceRestartBackoff.backoff(function () { return _this._initiateIceRestart(); });
-    };
+        this._iceRestartBackoff.backoff(() => this._initiateIceRestart());
+    }
     /**
      * Conditionally re-offer.
      * @private
      * @param {?RTCSessionDescriptionInit} localDescription
      * @returns {Promise<boolean>}
      */
-    PeerConnectionV2.prototype._maybeReoffer = function (localDescription) {
-        var shouldReoffer = this._shouldOffer;
+    _maybeReoffer(localDescription) {
+        let shouldReoffer = this._shouldOffer;
         if (localDescription && localDescription.sdp) {
             // NOTE(mmalavalli): If the local RTCSessionDescription has fewer audio and/or
             // video send* m= lines than the corresponding RTCRtpSenders with non-null
             // MediaStreamTracks, it means that the newly added RTCRtpSenders require
             // renegotiation.
-            var senders_1 = this._peerConnection.getSenders().filter(function (sender) { return sender.track; });
-            shouldReoffer = ['audio', 'video'].reduce(function (shouldOffer, kind) {
-                var mediaSections = getMediaSections(localDescription.sdp, kind, '(sendrecv|sendonly)');
-                var sendersOfKind = senders_1.filter(isSenderOfKind.bind(null, kind));
+            const senders = this._peerConnection.getSenders().filter(sender => sender.track);
+            shouldReoffer = ['audio', 'video'].reduce((shouldOffer, kind) => {
+                const mediaSections = getMediaSections(localDescription.sdp, kind, '(sendrecv|sendonly)');
+                const sendersOfKind = senders.filter(isSenderOfKind.bind(null, kind));
                 return shouldOffer || (mediaSections.length < sendersOfKind.length);
             }, shouldReoffer);
             // NOTE(mroberts): We also need to re-offer if we have a DataTrack to share
             // but no m= application section.
-            var hasDataTrack = this._dataChannels.size > 0;
-            var hasApplicationMediaSection = getMediaSections(localDescription.sdp, 'application').length > 0;
-            var needsApplicationMediaSection = hasDataTrack && !hasApplicationMediaSection;
+            const hasDataTrack = this._dataChannels.size > 0;
+            const hasApplicationMediaSection = getMediaSections(localDescription.sdp, 'application').length > 0;
+            const needsApplicationMediaSection = hasDataTrack && !hasApplicationMediaSection;
             shouldReoffer = shouldReoffer || needsApplicationMediaSection;
         }
-        var promise = shouldReoffer ? this._offer() : Promise.resolve();
-        return promise.then(function () { return shouldReoffer; });
-    };
+        const promise = shouldReoffer ? this._offer() : Promise.resolve();
+        return promise.then(() => shouldReoffer);
+    }
     /**
      * Create an offer and set it on the {@link PeerConnectionV2}.
      * @private
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._offer = function () {
-        var _this = this;
-        var offerOptions = Object.assign({}, this._offerOptions);
+    _offer() {
+        const offerOptions = Object.assign({}, this._offerOptions);
         this._needsAnswer = true;
         if (this._shouldRestartIce) {
             this._shouldRestartIce = false;
             this._isRestartingIce = true;
             offerOptions.iceRestart = true;
         }
-        return Promise.all(this._replaceTrackPromises.values()).then(function () {
-            var transceivers = _this._peerConnection.getTransceivers();
-            transceivers.forEach(function (transceiver) { return _this._applyCodecPreferencesToTransceiver(transceiver); });
-            return _this._peerConnection.createOffer(offerOptions);
-        }).catch(function (error) {
-            var errorToThrow = new MediaClientLocalDescFailedError();
-            _this._publishMediaWarning({
+        return Promise.all(this._replaceTrackPromises.values()).then(() => {
+            const transceivers = this._peerConnection.getTransceivers();
+            transceivers.forEach(transceiver => this._applyCodecPreferencesToTransceiver(transceiver));
+            return this._peerConnection.createOffer(offerOptions);
+        }).catch(error => {
+            const errorToThrow = new MediaClientLocalDescFailedError();
+            this._publishMediaWarning({
                 message: 'Failed to create offer',
                 code: errorToThrow.code,
-                error: error
+                error
             });
             throw errorToThrow;
-        }).then(function (offer) {
+        }).then(offer => {
             if (isFirefox) {
                 // NOTE(mmalavalli): We work around Chromium bug 1106157 by disabling
                 // RTX in Firefox 79+. For more details about the bug, please go here:
                 // https://bugs.chromium.org/p/chromium/issues/detail?id=1106157
-                var sdp = disableRtx(offer.sdp);
+                let sdp = disableRtx(offer.sdp);
                 // NOTE(lrivas): Work around Firefox bug where setCodecPreferences leaves
                 // unreferenced codec attributes (fmtp, rtpmap, rtcp-fb) for payload types not
                 // present in the m= line. For more details about the bug, please go here:
                 // https://bugzilla.mozilla.org/show_bug.cgi?id=1909443
                 sdp = removeUnreferencedCodecAttributes(sdp);
-                offer = new _this._RTCSessionDescription({
-                    sdp: sdp,
+                offer = new this._RTCSessionDescription({
+                    sdp,
                     type: offer.type
                 });
             }
@@ -1139,24 +1055,24 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             // and PSA: https://groups.google.com/forum/#!searchin/discuss-webrtc/PSA%7Csort:date/discuss-webrtc/jcZO-Wj0Wus/k2XvPCvoAwAJ
             // Looks like we are not referencing those attributes, but this changes goes ahead and removes them to see if it works.
             // this also helps reduce bytes on wires
-            var updatedSdp = removeSSRCAttributes(offer.sdp, ['mslabel', 'label']);
-            _this._shouldOffer = false;
-            if (!_this._negotiationRole) {
-                _this._negotiationRole = 'offerer';
+            let updatedSdp = removeSSRCAttributes(offer.sdp, ['mslabel', 'label']);
+            this._shouldOffer = false;
+            if (!this._negotiationRole) {
+                this._negotiationRole = 'offerer';
             }
-            if (_this._shouldApplySimulcast) {
-                _this._localDescriptionWithoutSimulcast = {
+            if (this._shouldApplySimulcast) {
+                this._localDescriptionWithoutSimulcast = {
                     type: 'offer',
                     sdp: updatedSdp
                 };
-                updatedSdp = _this._setSimulcast(updatedSdp, _this._trackIdsToAttributes);
+                updatedSdp = this._setSimulcast(updatedSdp, this._trackIdsToAttributes);
             }
-            return _this._setLocalDescription({
+            return this._setLocalDescription({
                 type: 'offer',
                 sdp: updatedSdp
             });
         });
-    };
+    }
     /**
      * Get the MediaTrackSender ID of the given MediaStreamTrack ID.
      * Since a MediaTrackSender's underlying MediaStreamTrack can be
@@ -1165,134 +1081,109 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @param {Track.ID} id
      * @returns {Track.ID}
      */
-    PeerConnectionV2.prototype._getMediaTrackSenderId = function (trackId) {
-        var mediaTrackSender = Array.from(this._rtpSenders.keys()).find(function (_a) {
-            var id = _a.track.id;
-            return id === trackId;
-        });
+    _getMediaTrackSenderId(trackId) {
+        const mediaTrackSender = Array.from(this._rtpSenders.keys()).find(({ track: { id } }) => id === trackId);
         return mediaTrackSender ? mediaTrackSender.id : trackId;
-    };
+    }
     /**
      * Add or rewrite local MediaStreamTrack IDs in the given RTCSessionDescription.
      * @private
      * @param {RTCSessionDescription} description
      * @return {RTCSessionDescription}
      */
-    PeerConnectionV2.prototype._addOrRewriteLocalTrackIds = function (description) {
-        var _this = this;
-        var transceivers = this._peerConnection.getTransceivers();
-        var activeTransceivers = transceivers.filter(function (_a) {
-            var sender = _a.sender, stopped = _a.stopped;
-            return !stopped && sender && sender.track;
-        });
+    _addOrRewriteLocalTrackIds(description) {
+        const transceivers = this._peerConnection.getTransceivers();
+        const activeTransceivers = transceivers.filter(({ sender, stopped }) => !stopped && sender && sender.track);
         // NOTE(mmalavalli): There is no guarantee that MediaStreamTrack IDs will be present in
         // SDPs, and even if they are, there is no guarantee that they will be the same as the
         // actual MediaStreamTrack IDs. So, we add or re-write the actual MediaStreamTrack IDs
         // to the assigned m= sections here.
-        var assignedTransceivers = activeTransceivers.filter(function (_a) {
-            var mid = _a.mid;
-            return mid;
-        });
-        var midsToTrackIds = new Map(assignedTransceivers.map(function (_a) {
-            var mid = _a.mid, sender = _a.sender;
-            return [mid, _this._getMediaTrackSenderId(sender.track.id)];
-        }));
-        var sdp1 = addOrRewriteTrackIds(description.sdp, midsToTrackIds);
+        const assignedTransceivers = activeTransceivers.filter(({ mid }) => mid);
+        const midsToTrackIds = new Map(assignedTransceivers.map(({ mid, sender }) => [mid, this._getMediaTrackSenderId(sender.track.id)]));
+        const sdp1 = addOrRewriteTrackIds(description.sdp, midsToTrackIds);
         // NOTE(mmalavalli): Chrome and Safari do not apply the offer until they get an answer.
         // So, we add or re-write the actual MediaStreamTrack IDs to the unassigned m= sections here.
-        var unassignedTransceivers = activeTransceivers.filter(function (_a) {
-            var mid = _a.mid;
-            return !mid;
-        });
-        var newTrackIdsByKind = new Map(['audio', 'video'].map(function (kind) { return [
+        const unassignedTransceivers = activeTransceivers.filter(({ mid }) => !mid);
+        const newTrackIdsByKind = new Map(['audio', 'video'].map(kind => [
             kind,
-            unassignedTransceivers.filter(function (_a) {
-                var sender = _a.sender;
-                return sender.track.kind === kind;
-            }).map(function (_a) {
-                var sender = _a.sender;
-                return _this._getMediaTrackSenderId(sender.track.id);
-            })
-        ]; }));
-        var sdp2 = addOrRewriteNewTrackIds(sdp1, midsToTrackIds, newTrackIdsByKind);
+            unassignedTransceivers.filter(({ sender }) => sender.track.kind === kind).map(({ sender }) => this._getMediaTrackSenderId(sender.track.id))
+        ]));
+        const sdp2 = addOrRewriteNewTrackIds(sdp1, midsToTrackIds, newTrackIdsByKind);
         return new this._RTCSessionDescription({
             sdp: sdp2,
             type: description.type
         });
-    };
+    }
     /**
      * Rollback and apply the given offer.
      * @private
      * @param {RTCSessionDescriptionInit} offer
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._rollbackAndApplyOffer = function (offer) {
-        var _this = this;
-        return this._setLocalDescription({ type: 'rollback' }).then(function () { return _this._setLocalDescription(offer); });
-    };
+    _rollbackAndApplyOffer(offer) {
+        return this._setLocalDescription({ type: 'rollback' }).then(() => this._setLocalDescription(offer));
+    }
     /**
      * Set a local description on the {@link PeerConnectionV2}.
      * @private
      * @param {RTCSessionDescription|RTCSessionDescriptionInit} description
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._setLocalDescription = function (description) {
-        var _this = this;
+    _setLocalDescription(description) {
         if (description.type !== 'rollback' && this._shouldApplyDtx) {
             description = new this._RTCSessionDescription({
                 sdp: enableDtxForOpus(description.sdp),
                 type: description.type
             });
         }
-        return this._peerConnection.setLocalDescription(description).catch(function (error) {
-            _this._log.warn("Calling setLocalDescription with an RTCSessionDescription of type \"".concat(description.type, "\" failed with the error \"").concat(error.message, "\"."), error);
-            var errorToThrow = new MediaClientLocalDescFailedError();
-            var publishWarning = {
-                message: "Calling setLocalDescription with an RTCSessionDescription of type \"".concat(description.type, "\" failed"),
+        return this._peerConnection.setLocalDescription(description).catch(error => {
+            this._log.warn(`Calling setLocalDescription with an RTCSessionDescription of type "${description.type}" failed with the error "${error.message}".`, error);
+            const errorToThrow = new MediaClientLocalDescFailedError();
+            const publishWarning = {
+                message: `Calling setLocalDescription with an RTCSessionDescription of type "${description.type}" failed`,
                 code: errorToThrow.code,
-                error: error
+                error
             };
             if (description.sdp) {
-                _this._log.warn("The SDP was ".concat(description.sdp));
+                this._log.warn(`The SDP was ${description.sdp}`);
                 publishWarning.sdp = description.sdp;
             }
-            _this._publishMediaWarning(publishWarning);
+            this._publishMediaWarning(publishWarning);
             throw errorToThrow;
-        }).then(function () {
+        }).then(() => {
             if (description.type !== 'rollback') {
-                _this._localDescription = _this._addOrRewriteLocalTrackIds(description);
+                this._localDescription = this._addOrRewriteLocalTrackIds(description);
                 // NOTE(mmalavalli): In order for this feature to be backward compatible with older
                 // SDK versions which to not support opus DTX, we append "usedtx=1" to the local SDP
                 // only while applying it. We will not send it over the wire to prevent inadvertent
                 // enabling of opus DTX in older SDKs. Newer SDKs will append "usedtx=1" by themselves
                 // if the developer has requested opus DTX to be enabled. (JSDK-3063)
-                if (_this._shouldApplyDtx) {
-                    _this._localDescription = new _this._RTCSessionDescription({
-                        sdp: enableDtxForOpus(_this._localDescription.sdp, []),
-                        type: _this._localDescription.type
+                if (this._shouldApplyDtx) {
+                    this._localDescription = new this._RTCSessionDescription({
+                        sdp: enableDtxForOpus(this._localDescription.sdp, []),
+                        type: this._localDescription.type
                     });
                 }
-                _this._localCandidates = [];
+                this._localCandidates = [];
                 if (description.type === 'offer') {
-                    _this._descriptionRevision++;
+                    this._descriptionRevision++;
                 }
                 else if (description.type === 'answer') {
-                    _this._lastStableDescriptionRevision = _this._descriptionRevision;
-                    negotiationCompleted(_this);
+                    this._lastStableDescriptionRevision = this._descriptionRevision;
+                    negotiationCompleted(this);
                 }
-                _this._localUfrag = getUfrag(description);
-                _this.emit('description', _this.getState());
+                this._localUfrag = getUfrag(description);
+                this.emit('description', this.getState());
             }
         });
-    };
+    }
     /**
      * Set a remote RTCSessionDescription on the {@link PeerConnectionV2}.
      * @private
      * @param {RTCSessionDescriptionInit} description
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._setRemoteDescription = function (description) {
-        var _this = this;
+    _setRemoteDescription(description) {
         if (description.sdp) {
             description.sdp = this._setCodecPreferences(description.sdp, this._preferredAudioCodecs, this._preferredVideoCodecs);
             if (this._shouldApplyDtx) {
@@ -1316,48 +1207,47 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         }
         description = new this._RTCSessionDescription(description);
         // eslint-disable-next-line consistent-return
-        return Promise.resolve().then(function () {
+        return Promise.resolve().then(() => {
             // NOTE(syerrapragada): VMS does not support H264 simulcast. So,
             // unset simulcast for sections in local offer where corresponding
             // sections in answer doesn't have vp8 as preferred codec and reapply offer.
-            if (description.type === 'answer' && _this._localDescriptionWithoutSimulcast) {
+            if (description.type === 'answer' && this._localDescriptionWithoutSimulcast) {
                 // NOTE(mpatwardhan):if we were using adaptive simulcast, and if its not supported by server
                 // revert simulcast even for vp8.
-                var adaptiveSimulcastEntry = _this._preferredVideoCodecs.find(function (cs) { return 'adaptiveSimulcast' in cs; });
-                var revertForAll = !!adaptiveSimulcastEntry && adaptiveSimulcastEntry.adaptiveSimulcast === false;
-                var sdpWithoutSimulcastForNonVP8MediaSections = _this._revertSimulcast(_this._localDescription.sdp, _this._localDescriptionWithoutSimulcast.sdp, description.sdp, revertForAll);
-                _this._localDescriptionWithoutSimulcast = null;
-                if (sdpWithoutSimulcastForNonVP8MediaSections !== _this._localDescription.sdp) {
-                    return _this._rollbackAndApplyOffer({
-                        type: _this._localDescription.type,
+                const adaptiveSimulcastEntry = this._preferredVideoCodecs.find(cs => 'adaptiveSimulcast' in cs);
+                const revertForAll = !!adaptiveSimulcastEntry && adaptiveSimulcastEntry.adaptiveSimulcast === false;
+                const sdpWithoutSimulcastForNonVP8MediaSections = this._revertSimulcast(this._localDescription.sdp, this._localDescriptionWithoutSimulcast.sdp, description.sdp, revertForAll);
+                this._localDescriptionWithoutSimulcast = null;
+                if (sdpWithoutSimulcastForNonVP8MediaSections !== this._localDescription.sdp) {
+                    return this._rollbackAndApplyOffer({
+                        type: this._localDescription.type,
                         sdp: sdpWithoutSimulcastForNonVP8MediaSections
                     });
                 }
             }
-        }).then(function () { return _this._peerConnection.setRemoteDescription(description); }).then(function () {
+        }).then(() => this._peerConnection.setRemoteDescription(description)).then(() => {
             if (description.type === 'answer') {
-                if (_this._isRestartingIce) {
-                    _this._log.debug('An ICE restart was in-progress and is now completed');
-                    _this._isRestartingIce = false;
+                if (this._isRestartingIce) {
+                    this._log.debug('An ICE restart was in-progress and is now completed');
+                    this._isRestartingIce = false;
                 }
-                negotiationCompleted(_this);
+                negotiationCompleted(this);
             }
-        }, function (error) {
-            _this._log.warn("Calling setRemoteDescription with an RTCSessionDescription of type \"".concat(description.type, "\" failed with the error \"").concat(error.message, "\"."), error);
+        }, error => {
+            this._log.warn(`Calling setRemoteDescription with an RTCSessionDescription of type "${description.type}" failed with the error "${error.message}".`, error);
             if (description.sdp) {
-                _this._log.warn("The SDP was ".concat(description.sdp));
+                this._log.warn(`The SDP was ${description.sdp}`);
             }
             throw error;
         });
-    };
+    }
     /**
      * Update the {@link PeerConnectionV2}'s description.
      * @private
      * @param {RTCSessionDescriptionInit} description
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._updateDescription = function (description) {
-        var _this = this;
+    _updateDescription(description) {
         switch (description.type) {
             case 'answer':
             case 'pranswer':
@@ -1401,56 +1291,56 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
                     return this._handleGlare(description);
                 }
                 this._descriptionRevision = description.revision;
-                return this._answer(description).then(function () { });
+                return this._answer(description).then(() => { });
             default:
             // Do nothing.
         }
         // Handle answer or pranswer.
-        var revision = description.revision;
-        return Promise.resolve().then(function () {
-            return _this._setRemoteDescription(description);
-        }).catch(function (error) {
-            var errorToThrow = new MediaClientRemoteDescFailedError();
-            _this._publishMediaWarning({
-                message: "Calling setRemoteDescription with an RTCSessionDescription of type \"".concat(description.type, "\" failed"),
+        const revision = description.revision;
+        return Promise.resolve().then(() => {
+            return this._setRemoteDescription(description);
+        }).catch(error => {
+            const errorToThrow = new MediaClientRemoteDescFailedError();
+            this._publishMediaWarning({
+                message: `Calling setRemoteDescription with an RTCSessionDescription of type "${description.type}" failed`,
                 code: errorToThrow.code,
-                error: error,
+                error,
                 sdp: description.sdp
             });
             throw errorToThrow;
-        }).then(function () {
-            _this._lastStableDescriptionRevision = revision;
-            _this._needsAnswer = false;
-            return _this._checkIceBox(description);
-        }).then(function () {
-            return _this._queuedDescription
-                && _this._updateDescription(_this._queuedDescription);
-        }).then(function () {
-            _this._queuedDescription = null;
-            return _this._maybeReoffer(_this._peerConnection.localDescription).then(function () { });
+        }).then(() => {
+            this._lastStableDescriptionRevision = revision;
+            this._needsAnswer = false;
+            return this._checkIceBox(description);
+        }).then(() => {
+            return this._queuedDescription
+                && this._updateDescription(this._queuedDescription);
+        }).then(() => {
+            this._queuedDescription = null;
+            return this._maybeReoffer(this._peerConnection.localDescription).then(() => { });
         });
-    };
+    }
     /**
      * Update the {@link PeerConnectionV2}'s ICE candidates.
      * @private
      * @param {object} iceState
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype._updateIce = function (iceState) {
-        var candidates = this._remoteCandidates.update(iceState);
+    _updateIce(iceState) {
+        const candidates = this._remoteCandidates.update(iceState);
         return this._addIceCandidates(candidates);
-    };
+    }
     /**
      * Add a {@link DataTrackSender} to the {@link PeerConnectionV2}.
      * @param {DataTrackSender} dataTrackSender
      * @returns {void}
      */
-    PeerConnectionV2.prototype.addDataTrackSender = function (dataTrackSender) {
+    addDataTrackSender(dataTrackSender) {
         if (this._dataChannels.has(dataTrackSender)) {
             return;
         }
         try {
-            var dataChannelDict = {
+            const dataChannelDict = {
                 ordered: dataTrackSender.ordered
             };
             if (dataTrackSender.maxPacketLifeTime !== null) {
@@ -1459,26 +1349,24 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             if (dataTrackSender.maxRetransmits !== null) {
                 dataChannelDict.maxRetransmits = dataTrackSender.maxRetransmits;
             }
-            var dataChannel = this._peerConnection.createDataChannel(dataTrackSender.id, dataChannelDict);
+            const dataChannel = this._peerConnection.createDataChannel(dataTrackSender.id, dataChannelDict);
             dataTrackSender.addDataChannel(dataChannel);
             this._dataChannels.set(dataTrackSender, dataChannel);
         }
         catch (error) {
-            this._log.warn("Error creating an RTCDataChannel for DataTrack \"".concat(dataTrackSender.id, "\": ").concat(error.message));
+            this._log.warn(`Error creating an RTCDataChannel for DataTrack "${dataTrackSender.id}": ${error.message}`);
         }
-    };
-    PeerConnectionV2.prototype._handleQueuedPublisherHints = function () {
-        var _this = this;
+    }
+    _handleQueuedPublisherHints() {
         if (this._peerConnection.signalingState === 'stable') {
-            this._mediaTrackSenderToPublisherHints.forEach(function (_a, mediaTrackSender) {
-                var deferred = _a.deferred, encodings = _a.encodings;
-                _this._mediaTrackSenderToPublisherHints.delete(mediaTrackSender);
-                _this._setPublisherHint(mediaTrackSender, encodings)
-                    .then(function (result) { return deferred.resolve(result); })
-                    .catch(function (error) { return deferred.reject(error); });
+            this._mediaTrackSenderToPublisherHints.forEach(({ deferred, encodings }, mediaTrackSender) => {
+                this._mediaTrackSenderToPublisherHints.delete(mediaTrackSender);
+                this._setPublisherHint(mediaTrackSender, encodings)
+                    .then(result => deferred.resolve(result))
+                    .catch(error => deferred.reject(error));
             });
         }
-    };
+    }
     /**
      * updates encodings for simulcast layers of given sender.
      * @param {RTCRtpSender} sender
@@ -1486,18 +1374,17 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
      * @returns {Promise<string>} string indicating result of the operation. can be one of
      *  "OK", "INVALID_HINT", "COULD_NOT_APPLY_HINT", "UNKNOWN_TRACK"
      */
-    PeerConnectionV2.prototype._setPublisherHint = function (mediaTrackSender, encodings) {
-        var _this = this;
+    _setPublisherHint(mediaTrackSender, encodings) {
         if (isFirefox) {
             return Promise.resolve('COULD_NOT_APPLY_HINT');
         }
         if (this._mediaTrackSenderToPublisherHints.has(mediaTrackSender)) {
             // skip any stale hint associated with the mediaTrackSender.
-            var queuedHint = this._mediaTrackSenderToPublisherHints.get(mediaTrackSender);
+            const queuedHint = this._mediaTrackSenderToPublisherHints.get(mediaTrackSender);
             queuedHint.deferred.resolve('REQUEST_SKIPPED');
             this._mediaTrackSenderToPublisherHints.delete(mediaTrackSender);
         }
-        var sender = this._rtpSenders.get(mediaTrackSender);
+        const sender = this._rtpSenders.get(mediaTrackSender);
         if (!sender) {
             this._log.warn('Could not apply publisher hint because RTCRtpSender was not found');
             return Promise.resolve('UNKNOWN_TRACK');
@@ -1509,20 +1396,19 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         if (this._peerConnection.signalingState !== 'stable') {
             // enqueue this hint to be applied when pc becomes stable.
             this._log.debug('Queuing up publisher hint because signalingState:', this._peerConnection.signalingState);
-            var deferred = defer();
-            this._mediaTrackSenderToPublisherHints.set(mediaTrackSender, { deferred: deferred, encodings: encodings });
+            const deferred = defer();
+            this._mediaTrackSenderToPublisherHints.set(mediaTrackSender, { deferred, encodings });
             return deferred.promise;
         }
-        var parameters = sender.getParameters();
+        const parameters = sender.getParameters();
         if (encodings !== null) {
-            encodings.forEach(function (_a) {
-                var enabled = _a.enabled, layerIndex = _a.layer_index;
+            encodings.forEach(({ enabled, layer_index: layerIndex }) => {
                 if (parameters.encodings.length > layerIndex) {
-                    _this._log.debug("layer:".concat(layerIndex, ", active:").concat(parameters.encodings[layerIndex].active, " => ").concat(enabled));
+                    this._log.debug(`layer:${layerIndex}, active:${parameters.encodings[layerIndex].active} => ${enabled}`);
                     parameters.encodings[layerIndex].active = enabled;
                 }
                 else {
-                    _this._log.warn("invalid layer:".concat(layerIndex, ", active:").concat(enabled));
+                    this._log.warn(`invalid layer:${layerIndex}, active:${enabled}`);
                 }
             });
         }
@@ -1531,51 +1417,50 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         // When encodings===null (that is we are asked to reset encodings for replaceTrack)
         // along with disabling encodings, clear active flag for encodings that should not be disabled
         this._maybeUpdateEncodings(sender.track, parameters.encodings, encodings === null /* trackReplaced */);
-        return sender.setParameters(parameters).then(function () { return 'OK'; }).catch(function (error) {
-            _this._log.error('Failed to apply publisher hints:', error);
+        return sender.setParameters(parameters).then(() => 'OK').catch(error => {
+            this._log.error('Failed to apply publisher hints:', error);
             return 'COULD_NOT_APPLY_HINT';
         });
-    };
+    }
     /**
      * Add the {@link MediaTrackSender} to the {@link PeerConnectionV2}.
      * @param {MediaTrackSender} mediaTrackSender
      * @returns {void}
      */
-    PeerConnectionV2.prototype.addMediaTrackSender = function (mediaTrackSender) {
-        var _this = this;
+    addMediaTrackSender(mediaTrackSender) {
         if (this._peerConnection.signalingState === 'closed' || this._rtpSenders.has(mediaTrackSender)) {
             return;
         }
-        var transceiver = this._addOrUpdateTransceiver(mediaTrackSender.track);
-        var sender = transceiver.sender;
-        mediaTrackSender.addSender(sender, function (encodings) { return _this._setPublisherHint(mediaTrackSender, encodings); });
+        const transceiver = this._addOrUpdateTransceiver(mediaTrackSender.track);
+        const { sender } = transceiver;
+        mediaTrackSender.addSender(sender, encodings => this._setPublisherHint(mediaTrackSender, encodings));
         this._rtpNewSenders.add(sender);
         this._rtpSenders.set(mediaTrackSender, sender);
-    };
+    }
     /**
      * Close the {@link PeerConnectionV2}.
      * @returns {void}
      */
-    PeerConnectionV2.prototype.close = function () {
+    close() {
         if (this._close()) {
             this._descriptionRevision++;
             this._localDescription = { type: 'close' };
             this.emit('description', this.getState());
         }
-    };
+    }
     /**
      * Get the {@link DataTrackReceiver}s and the {@link MediaTrackReceiver}s on the
      * {@link PeerConnectionV2}.
      * @returns {Array<DataTrackReceiver|MediaTrackReceiver>} trackReceivers
      */
-    PeerConnectionV2.prototype.getTrackReceivers = function () {
+    getTrackReceivers() {
         return Array.from(this._dataTrackReceivers).concat(Array.from(this._mediaTrackReceivers));
-    };
+    }
     /**
      * Get the {@link PeerConnectionV2}'s state (specifically, its description).
      * @returns {?object}
      */
-    PeerConnectionV2.prototype.getState = function () {
+    getState() {
         if (!this._localDescription) {
             return null;
         }
@@ -1583,8 +1468,8 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         // answer, and this method is called for sending a "sync" message while the next remote offer is being processed,
         // we need to send the most recent stable description revision instead of the current description revision,
         // which is supposed to be for the next local answer.
-        var localDescriptionRevision = this._localDescription.type === 'answer' ? this._lastStableDescriptionRevision : this._descriptionRevision;
-        var localDescription = {
+        const localDescriptionRevision = this._localDescription.type === 'answer' ? this._lastStableDescriptionRevision : this._descriptionRevision;
+        const localDescription = {
             type: this._localDescription.type,
             revision: localDescriptionRevision
         };
@@ -1595,48 +1480,47 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
             description: localDescription,
             id: this.id
         };
-    };
+    }
     /**
      * Create an offer and set it on the {@link PeerConnectionV2}.
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype.offer = function () {
-        var _this = this;
+    offer() {
         if (this._needsAnswer || this._isRestartingIce) {
             this._shouldOffer = true;
             return Promise.resolve();
         }
-        return this.bracket('offering', function (key) {
-            _this.transition('updating', key);
-            var promise = _this._needsAnswer || _this._isRestartingIce ? Promise.resolve() : _this._offer();
-            return promise.then(function () {
-                _this.tryTransition('open', key);
-            }, function (error) {
-                _this.tryTransition('open', key);
+        return this.bracket('offering', key => {
+            this.transition('updating', key);
+            const promise = this._needsAnswer || this._isRestartingIce ? Promise.resolve() : this._offer();
+            return promise.then(() => {
+                this.tryTransition('open', key);
+            }, error => {
+                this.tryTransition('open', key);
                 throw error;
             });
         });
-    };
+    }
     /**
      * Remove a {@link DataTrackSender} from the {@link PeerConnectionV2}.
      * @param {DataTrackSender} dataTrackSender
      * @returns {void}
      */
-    PeerConnectionV2.prototype.removeDataTrackSender = function (dataTrackSender) {
-        var dataChannel = this._dataChannels.get(dataTrackSender);
+    removeDataTrackSender(dataTrackSender) {
+        const dataChannel = this._dataChannels.get(dataTrackSender);
         if (dataChannel) {
             dataTrackSender.removeDataChannel(dataChannel);
             this._dataChannels.delete(dataTrackSender);
             dataChannel.close();
         }
-    };
+    }
     /**
      * Remove the {@link MediaTrackSender} from the {@link PeerConnectionV2}.
      * @param {MediaTrackSender} mediaTrackSender
      * @returns {void}
      */
-    PeerConnectionV2.prototype.removeMediaTrackSender = function (mediaTrackSender) {
-        var sender = this._rtpSenders.get(mediaTrackSender);
+    removeMediaTrackSender(mediaTrackSender) {
+        const sender = this._rtpSenders.get(mediaTrackSender);
         if (!sender) {
             return;
         }
@@ -1646,85 +1530,83 @@ var PeerConnectionV2 = /** @class */ (function (_super) {
         mediaTrackSender.removeSender(sender);
         // clean up any pending publisher hints associated with this mediaTrackSender.
         if (this._mediaTrackSenderToPublisherHints.has(mediaTrackSender)) {
-            var queuedHint = this._mediaTrackSenderToPublisherHints.get(mediaTrackSender);
+            const queuedHint = this._mediaTrackSenderToPublisherHints.get(mediaTrackSender);
             queuedHint.deferred.resolve('UNKNOWN_TRACK');
             this._mediaTrackSenderToPublisherHints.delete(mediaTrackSender);
         }
         this._rtpNewSenders.delete(sender);
         this._rtpSenders.delete(mediaTrackSender);
-    };
+    }
     /**
      * Set the RTCConfiguration on the underlying RTCPeerConnection.
      * @param {RTCConfiguration} configuration
      * @returns {void}
      */
-    PeerConnectionV2.prototype.setConfiguration = function (configuration) {
+    setConfiguration(configuration) {
         if (typeof this._peerConnection.setConfiguration === 'function') {
             this._peerConnection.setConfiguration(getConfiguration(configuration));
         }
-    };
+    }
     /**
      * Set the ICE reconnect timeout period.
      * @param {number} period - Period in milliseconds.
      * @returns {this}
      */
-    PeerConnectionV2.prototype.setIceReconnectTimeout = function (period) {
+    setIceReconnectTimeout(period) {
         this._iceReconnectTimeout.setDelay(period);
         this._log.debug('Updated ICE reconnection timeout period:', this._iceReconnectTimeout.delay);
         return this;
-    };
+    }
     /**
      * Update the {@link PeerConnectionV2}.
      * @param {object} peerConnectionState
      * @returns {Promise<void>}
      */
-    PeerConnectionV2.prototype.update = function (peerConnectionState) {
-        var _this = this;
-        return this.bracket('updating', function (key) {
-            if (_this.state === 'closed') {
+    update(peerConnectionState) {
+        return this.bracket('updating', key => {
+            if (this.state === 'closed') {
                 return Promise.resolve();
             }
-            _this.transition('updating', key);
-            var updates = [];
+            this.transition('updating', key);
+            const updates = [];
             if (peerConnectionState.ice) {
-                updates.push(_this._updateIce(peerConnectionState.ice));
+                updates.push(this._updateIce(peerConnectionState.ice));
             }
             if (peerConnectionState.description) {
-                updates.push(_this._updateDescription(peerConnectionState.description));
+                updates.push(this._updateDescription(peerConnectionState.description));
             }
-            return Promise.all(updates).then(function () {
-                _this.tryTransition('open', key);
-            }, function (error) {
-                _this.tryTransition('open', key);
+            return Promise.all(updates).then(() => {
+                this.tryTransition('open', key);
+            }, error => {
+                this.tryTransition('open', key);
                 throw error;
             });
         });
-    };
+    }
     /**
      * Get the {@link PeerConnectionV2}'s media statistics.
      * @returns {Promise<StandardizedStatsResponse>}
      */
-    PeerConnectionV2.prototype.getStats = function () {
-        var _this = this;
-        return getStatistics(this._peerConnection, { log: this._log }).then(function (response) { return rewriteTrackIds(_this, response); });
-    };
-    return PeerConnectionV2;
-}(StateMachine));
+    getStats() {
+        return getStatistics(this._peerConnection, { log: this._log }).then(response => rewriteTrackIds(this, response));
+    }
+}
 function rewriteLocalTrackId(pcv2, stats) {
-    var trackId = pcv2._getMediaTrackSenderId(stats.trackId);
-    return Object.assign(stats, { trackId: trackId });
+    const trackId = pcv2._getMediaTrackSenderId(stats.trackId);
+    return Object.assign(stats, { trackId });
 }
 function rewriteTrackId(pcv2, stats) {
-    var receiver = __spreadArray([], __read(pcv2._mediaTrackReceivers), false).find(function (receiver) { return receiver.track.id === stats.trackId; });
-    var trackId = receiver ? receiver.id : null;
-    return Object.assign(stats, { trackId: trackId });
+    const receiver = [...pcv2._mediaTrackReceivers]
+        .find(receiver => receiver.track.id === stats.trackId);
+    const trackId = receiver ? receiver.id : null;
+    return Object.assign(stats, { trackId });
 }
 function rewriteTrackIds(pcv2, response) {
     return Object.assign(response, {
-        remoteAudioTrackStats: response.remoteAudioTrackStats.map(function (stats) { return rewriteTrackId(pcv2, stats); }),
-        remoteVideoTrackStats: response.remoteVideoTrackStats.map(function (stats) { return rewriteTrackId(pcv2, stats); }),
-        localAudioTrackStats: response.localAudioTrackStats.map(function (stats) { return rewriteLocalTrackId(pcv2, stats); }),
-        localVideoTrackStats: response.localVideoTrackStats.map(function (stats) { return rewriteLocalTrackId(pcv2, stats); }),
+        remoteAudioTrackStats: response.remoteAudioTrackStats.map(stats => rewriteTrackId(pcv2, stats)),
+        remoteVideoTrackStats: response.remoteVideoTrackStats.map(stats => rewriteTrackId(pcv2, stats)),
+        localAudioTrackStats: response.localAudioTrackStats.map(stats => rewriteLocalTrackId(pcv2, stats)),
+        localVideoTrackStats: response.localVideoTrackStats.map(stats => rewriteLocalTrackId(pcv2, stats)),
     });
 }
 /**
@@ -1747,7 +1629,7 @@ function rewriteTrackIds(pcv2, response) {
  */
 function getUfrag(description) {
     if (description.sdp) {
-        var match = description.sdp.match(/^a=ice-ufrag:([a-zA-Z0-9+/]+)/m);
+        const match = description.sdp.match(/^a=ice-ufrag:([a-zA-Z0-9+/]+)/m);
         if (match) {
             return match[1];
         }
@@ -1762,8 +1644,7 @@ function getUfrag(description) {
  * @param {RTCConfiguration} [configuration={}] - Optional RTCConfiguration object
  * @returns {RTCConfiguration}
  */
-function getConfiguration(configuration) {
-    if (configuration === void 0) { configuration = {}; }
+function getConfiguration(configuration = {}) {
     return Object.assign({
         bundlePolicy: 'max-bundle',
         rtcpMuxPolicy: 'require'
@@ -1778,7 +1659,7 @@ function getConfiguration(configuration) {
  * @return {boolean}
  */
 function isSenderOfKind(kind, sender) {
-    var track = sender.track;
+    const track = sender.track;
     return track && track.kind === kind && track.readyState !== 'ended';
 }
 /**
@@ -1807,23 +1688,17 @@ function shouldRecycleTransceiver(transceiver, pcv2) {
  * @returns {?RTCRtpTransceiver}
  */
 function takeRecycledTransceiver(pcv2, kind) {
-    var preferredCodecs = {
-        audio: pcv2._preferredAudioCodecs.map(function (_a) {
-            var codec = _a.codec;
-            return codec.toLowerCase();
-        }),
-        video: pcv2._preferredVideoCodecs.map(function (_a) {
-            var codec = _a.codec;
-            return codec.toLowerCase();
-        })
+    const preferredCodecs = {
+        audio: pcv2._preferredAudioCodecs.map(({ codec }) => codec.toLowerCase()),
+        video: pcv2._preferredVideoCodecs.map(({ codec }) => codec.toLowerCase())
     }[kind];
-    var recycledTransceivers = pcv2._recycledTransceivers[kind];
-    var localCodec = preferredCodecs.find(function (codec) { return pcv2._localCodecs.has(codec); });
+    const recycledTransceivers = pcv2._recycledTransceivers[kind];
+    const localCodec = preferredCodecs.find(codec => pcv2._localCodecs.has(codec));
     if (!localCodec) {
         return recycledTransceivers.shift();
     }
-    var transceiver = recycledTransceivers.find(function (transceiver) {
-        var remoteCodecMap = pcv2._remoteCodecMaps.get(transceiver.mid);
+    const transceiver = recycledTransceivers.find(transceiver => {
+        const remoteCodecMap = pcv2._remoteCodecMaps.get(transceiver.mid);
         return remoteCodecMap && remoteCodecMap.has(localCodec);
     });
     if (transceiver) {
@@ -1837,13 +1712,13 @@ function takeRecycledTransceiver(pcv2, kind) {
  * @returns {void}
  */
 function updateLocalCodecs(pcv2) {
-    var description = pcv2._peerConnection.localDescription;
+    const description = pcv2._peerConnection.localDescription;
     if (!description || !description.sdp) {
         return;
     }
-    getMediaSections(description.sdp).forEach(function (section) {
-        var codecMap = createCodecMapForMediaSection(section);
-        codecMap.forEach(function (pts, codec) { return pcv2._localCodecs.add(codec); });
+    getMediaSections(description.sdp).forEach(section => {
+        const codecMap = createCodecMapForMediaSection(section);
+        codecMap.forEach((pts, codec) => pcv2._localCodecs.add(codec));
     });
 }
 /**
@@ -1852,17 +1727,17 @@ function updateLocalCodecs(pcv2) {
  * @returns {void}
  */
 function updateRemoteCodecMaps(pcv2) {
-    var description = pcv2._peerConnection.remoteDescription;
+    const description = pcv2._peerConnection.remoteDescription;
     if (!description || !description.sdp) {
         return;
     }
-    getMediaSections(description.sdp).forEach(function (section) {
-        var matched = section.match(/^a=mid:(.+)$/m);
+    getMediaSections(description.sdp).forEach(section => {
+        const matched = section.match(/^a=mid:(.+)$/m);
         if (!matched || !matched[1]) {
             return;
         }
-        var mid = matched[1];
-        var codecMap = createCodecMapForMediaSection(section);
+        const mid = matched[1];
+        const codecMap = createCodecMapForMediaSection(section);
         pcv2._remoteCodecMaps.set(mid, codecMap);
     });
 }
@@ -1873,9 +1748,9 @@ function updateRemoteCodecMaps(pcv2) {
 function updateRecycledTransceivers(pcv2) {
     pcv2._recycledTransceivers.audio = [];
     pcv2._recycledTransceivers.video = [];
-    pcv2._peerConnection.getTransceivers().forEach(function (transceiver) {
+    pcv2._peerConnection.getTransceivers().forEach(transceiver => {
         if (shouldRecycleTransceiver(transceiver, pcv2)) {
-            var track = transceiver.receiver.track;
+            const track = transceiver.receiver.track;
             pcv2._recycledTransceivers[track.kind].push(transceiver);
         }
     });
@@ -1887,8 +1762,8 @@ function updateRecycledTransceivers(pcv2) {
  */
 function updateDtlsTransport(pcv2) {
     var _a;
-    var senders = pcv2._peerConnection.getSenders();
-    var transport = (_a = senders.find(function (sender) { return sender.transport; })) === null || _a === void 0 ? void 0 : _a.transport;
+    const senders = pcv2._peerConnection.getSenders();
+    const transport = (_a = senders.find(sender => sender.transport)) === null || _a === void 0 ? void 0 : _a.transport;
     if (transport && !pcv2._dtlsTransport) {
         pcv2._dtlsTransport = transport;
         transport.addEventListener('statechange', pcv2._handleDtlsTransportStateChange.bind(pcv2));
@@ -1897,7 +1772,7 @@ function updateDtlsTransport(pcv2) {
         }
         if (transport.iceTransport && typeof transport.iceTransport.getSelectedCandidatePair === 'function') {
             transport.iceTransport.addEventListener('selectedcandidatepairchange', pcv2._handleSelectedCandidatePairChange.bind(pcv2));
-            var pair = transport.iceTransport.getSelectedCandidatePair();
+            const pair = transport.iceTransport.getSelectedCandidatePair();
             if (pair) {
                 pcv2._handleSelectedCandidatePairChange();
             }
@@ -1914,7 +1789,7 @@ function negotiationCompleted(pcv2) {
     updateLocalCodecs(pcv2);
     updateRemoteCodecMaps(pcv2);
     updateDtlsTransport(pcv2);
-    updateEncodingParameters(pcv2).then(function () {
+    updateEncodingParameters(pcv2).then(() => {
         // if there any any publisher hints queued, apply them now.
         pcv2._handleQueuedPublisherHints();
     });
@@ -1925,22 +1800,22 @@ function negotiationCompleted(pcv2) {
  * @returns {void}
  */
 function updateEncodingParameters(pcv2) {
-    var _a = pcv2._encodingParameters, maxAudioBitrate = _a.maxAudioBitrate, maxVideoBitrate = _a.maxVideoBitrate;
-    var maxBitrates = new Map([
+    const { maxAudioBitrate, maxVideoBitrate } = pcv2._encodingParameters;
+    const maxBitrates = new Map([
         ['audio', maxAudioBitrate],
         ['video', maxVideoBitrate]
     ]);
-    var promises = [];
-    pcv2._peerConnection.getSenders().filter(function (sender) { return sender.track; }).forEach(function (sender) {
-        var maxBitrate = maxBitrates.get(sender.track.kind);
-        var params = sender.getParameters();
+    const promises = [];
+    pcv2._peerConnection.getSenders().filter(sender => sender.track).forEach(sender => {
+        const maxBitrate = maxBitrates.get(sender.track.kind);
+        const params = sender.getParameters();
         if (maxBitrate === null || maxBitrate === 0) {
             removeMaxBitrate(params);
         }
         else if (pcv2._isChromeScreenShareTrack(sender.track)) {
             // NOTE(mpatwardhan): Sometimes (JSDK-2557) chrome does not send any bytes on screen track if MaxBitRate is set on it via setParameters,
             // To workaround this issue we will not apply maxBitrate if the track appears to be a screen share track created by chrome
-            pcv2._log.warn("Not setting maxBitrate for ".concat(sender.track.kind, " Track ").concat(sender.track.id, " because it appears to be screen share track: ").concat(sender.track.label));
+            pcv2._log.warn(`Not setting maxBitrate for ${sender.track.kind} Track ${sender.track.id} because it appears to be screen share track: ${sender.track.label}`);
         }
         else {
             setMaxBitrate(params, maxBitrate);
@@ -1970,11 +1845,11 @@ function updateEncodingParameters(pcv2) {
             }
         }
         // when a sender is reused, delete any active encodings set by server.
-        var trackReplaced = pcv2._rtpNewSenders.has(sender);
+        const trackReplaced = pcv2._rtpNewSenders.has(sender);
         pcv2._maybeUpdateEncodings(sender.track, params.encodings, trackReplaced);
         pcv2._rtpNewSenders.delete(sender);
-        var promise = sender.setParameters(params).catch(function (error) {
-            pcv2._log.warn("Error while setting encodings parameters for ".concat(sender.track.kind, " Track ").concat(sender.track.id, ": ").concat(error.message || error.name));
+        const promise = sender.setParameters(params).catch(error => {
+            pcv2._log.warn(`Error while setting encodings parameters for ${sender.track.kind} Track ${sender.track.id}: ${error.message || error.name}`);
         });
         promises.push(promise);
     });
@@ -1987,7 +1862,7 @@ function updateEncodingParameters(pcv2) {
  */
 function removeMaxBitrate(params) {
     if (Array.isArray(params.encodings)) {
-        params.encodings.forEach(function (encoding) { return delete encoding.maxBitrate; });
+        params.encodings.forEach(encoding => delete encoding.maxBitrate);
     }
 }
 /**
@@ -1998,10 +1873,10 @@ function removeMaxBitrate(params) {
  */
 function setMaxBitrate(params, maxBitrate) {
     if (isFirefox) {
-        params.encodings = [{ maxBitrate: maxBitrate }];
+        params.encodings = [{ maxBitrate }];
     }
     else {
-        params.encodings.forEach(function (encoding) {
+        params.encodings.forEach(encoding => {
             encoding.maxBitrate = maxBitrate;
         });
     }