[eslint] prefer-const

.eslintrc.js

             { 'nestedBinaryExpressions': false }
         ],
 
+        'prefer-const': 2,
         'prefer-reflect': 0,
         'prefer-spread': 2,
         'require-yield': 2,

JitsiConference.js

 
     // leave the conference
     if (this.room) {
-        let room = this.room;
+        const room = this.room;
         this.room = null;
         return room.leave().catch(() => {
             // remove all participants because currently the conference won't

JitsiMeetJS.js

     var order = Resolutions[resolution].order;
     var res = null;
     var resName = null;
-    for(let i in Resolutions) {
+    for(const i in Resolutions) {
         var tmp = Resolutions[i];
         if (!res || (res.order < tmp.order && tmp.order < order)) {
             resName = i;

modules/RTC/JitsiLocalTrack.js

  */
 JitsiLocalTrack.prototype._initNoDataFromSourceHandlers = function () {
     if(this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
-        let _onNoDataFromSourceError
+        const _onNoDataFromSourceError
             = this._onNoDataFromSourceError.bind(this);
         this._setHandler("track_mute", () => {
             if(this._checkForCameraIssues()) {
-                let now = window.performance.now();
+                const now = window.performance.now();
                 this._noDataFromSourceTimeout
                     = setTimeout(_onNoDataFromSourceError, 3000);
                 this._setHandler("track_unmute", () => {
  */
 JitsiLocalTrack.prototype._fireNoDataFromSourceEvent = function () {
     this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
-    let eventName = this.getType() + ".no_data_from_source";
+    const eventName = this.getType() + ".no_data_from_source";
     Statistics.analytics.sendEvent(eventName);
-    let log = {name: eventName};
+    const log = {name: eventName};
     if (this.isAudioTrack()) {
         log.isReceivingData = this._isReceivingData();
     }
     // FIXME it's a shame that PeerConnection and ICE status does not belong
     // to the RTC module and it has to be accessed through
     // the conference(and through the XMPP chat room ???) instead
-    let iceConnectionState
+    const iceConnectionState
         = this.conference ? this.conference.getConnectionState() : null;
     if(this._testByteSent && "connected" === iceConnectionState) {
         setTimeout(function () {

modules/RTC/ScreenObtainer.js

     }
     return new Promise((resolve, reject) => {
         let currentRetries = retries;
-        let interval = window.setInterval(() => {
+        const interval = window.setInterval(() => {
             checkChromeExtInstalled( (installed) => {
                 if(installed) {
                     window.clearInterval(interval);

modules/RTC/TraceablePeerConnection.js

 
     // FIXME the length of ssrcLines[0] not verified, but it will fail
     // with global error handler anyway
-    let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
+    const trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
     const ownerEndpointId = this.signalingLayer.getSSRCOwner(trackSsrc);
 
     if (!ownerEndpointId) {
 
                 // Fix the setup attribute (see _fixAnswerRFC4145Setup for
                 //  details)
-                let remoteDescription = new SDP(this.remoteDescription.sdp);
-                let localDescription = new SDP(answer.sdp);
+                const remoteDescription = new SDP(this.remoteDescription.sdp);
+                const localDescription = new SDP(answer.sdp);
                 _fixAnswerRFC4145Setup(remoteDescription, localDescription);
                 answer.sdp = localDescription.raw;
 

modules/connectivity/ConnectionQuality.js

     } else {
         // See GetMaxDefaultVideoBitrateKbps in
         // media/engine/webrtcvideoengine2.cc from webrtc.org
-        let pixels = resolution.width * resolution.height;
+        const pixels = resolution.width * resolution.height;
         if (pixels <= 320 * 240) {
             target = 600;
         } else if (pixels <= 640 * 480) {
 
         // resolutionName is an index into Resolutions (where "720" is
         // "1280x720" and "960" is "960x720" ...).
-        let resolution = Resolutions[resolutionName];
+        const resolution = Resolutions[resolutionName];
 
         let quality = 100;
         let packetLoss;
             // Calculate a value based on the sending bitrate.
 
             // time since sending of video was enabled.
-            let millisSinceStart = window.performance.now()
+            const millisSinceStart = window.performance.now()
                     - Math.max(this._timeVideoUnmuted, this._timeIceConnected);
 
             // expected sending bitrate in perfect conditions
         // Make sure that the quality doesn't climb quickly
         if (this._lastConnectionQualityUpdate > 0)
         {
-            let maxIncreasePerSecond = 2;
-            let prevConnectionQuality = this._localStats.connectionQuality;
-            let diffSeconds
+            const maxIncreasePerSecond = 2;
+            const prevConnectionQuality = this._localStats.connectionQuality;
+            const diffSeconds
                 = (window.performance.now()
                     - this._lastConnectionQualityUpdate) / 1000;
             quality = Math.min(
      */
     _broadcastLocalStats() {
         // Send only the data that remote participants care about.
-        let data = {
+        const data = {
             bitrate: this._localStats.bitrate,
             packetLoss: this._localStats.packetLoss,
             connectionQuality: this._localStats.connectionQuality
         // TODO: It looks like the remote participants don't really "care"
         // about the resolution, and they look at their local rendered
         // resolution instead. Consider removing this.
-        let localVideoTrack
+        const localVideoTrack
             = this._conference.getLocalVideoTrack();
         if (localVideoTrack && localVideoTrack.resolution) {
             data.resolution = localVideoTrack.resolution;
      */
     _updateLocalStats(data) {
         let key;
-        let updateLocalConnectionQuality
+        const updateLocalConnectionQuality
             = !this._conference.isConnectionInterrupted();
-        let localVideoTrack
+        const localVideoTrack
             = this._conference.getLocalVideoTrack();
-        let videoType = localVideoTrack ? localVideoTrack.videoType : undefined;
-        let isMuted = localVideoTrack ? localVideoTrack.isMuted() : true;
-        let resolution = localVideoTrack ? localVideoTrack.resolution : null;
+        const videoType
+            = localVideoTrack ? localVideoTrack.videoType : undefined;
+        const isMuted = localVideoTrack ? localVideoTrack.isMuted() : true;
+        const resolution = localVideoTrack ? localVideoTrack.resolution : null;
 
         if (!isMuted) {
             this._maybeUpdateUnmuteTime();

modules/connectivity/ParticipantConnectionStatus.js

             isConnActiveByJvb = true;
         }
 
-        let isConnectionActive
+        const isConnectionActive
             = isConnActiveByJvb && (isVideoMuted || !isVideoTrackFrozen);
 
         logger.debug(

modules/settings/Settings.js

  * @returns {Storage} the local Storage object (if any)
  */
 function getLocalStorage() {
-    let global = typeof window == 'undefined' ? this : window;
+    const global = typeof window == 'undefined' ? this : window;
     return global.localStorage;
 }
 
  * @returns {string} random unique id
  */
 function generateJitsiMeetId() {
-    let jitsiMeetId = generateUniqueId();
+    const jitsiMeetId = generateUniqueId();
     logger.log("generated id", jitsiMeetId);
 
     return jitsiMeetId;
  * @returns {string} fake random username
  */
 function generateCallStatsUsername() {
-    let username = UsernameGenerator.generateUsername();
+    const username = UsernameGenerator.generateUsername();
     logger.log('generated callstats uid', username);
 
     return username;
      * @param {string} sessionId session id
      */
     setSessionId (sessionId) {
-        let localStorage = getLocalStorage();
+        const localStorage = getLocalStorage();
         if (localStorage) {
             if (sessionId) {
                 localStorage.setItem('sessionId', sessionId);
     getSessionId () {
         // We may update sessionId in localStorage from another JitsiConference
         // instance and that's why we should always re-read it.
-        let localStorage = getLocalStorage();
+        const localStorage = getLocalStorage();
         return localStorage ? localStorage.getItem('sessionId') : undefined;
     }
 }

modules/statistics/AnalyticsAdapter.js

      * @returns {Array} with the cached events.
      */
     drainCachedEvents() {
-        let eventCacheCopy = this.eventCache.slice();
+        const eventCacheCopy = this.eventCache.slice();
         this.eventCache = [];
         return eventCacheCopy;
     }
 
 }
 
-let cacheAnalytics = new CacheAnalytics();
+const cacheAnalytics = new CacheAnalytics();
 
 /**
  * This class will store and manage the handlers that are going to be used.
      * @param {Object} data can be any JSON object
      */
     sendEvent(action, data = {}) {
-        let modifiedData = Object.assign(
+        const modifiedData = Object.assign(
             {browserName: this.browserName}, this.permanentProperties, data);
         this.analyticsHandlers.forEach(
             analytics => analytics.sendEvent(action, modifiedData));

modules/xmpp/Caps.js

             room => this._addChatRoom(room));
         emuc.addListener(XMPPEvents.EMUC_ROOM_REMOVED,
             room => this._removeChatRoom(room));
-        for(let jid in emuc.rooms) {
+        for(const jid in emuc.rooms) {
             this._addChatRoom(this.emuc.rooms[jid]);
         }
 
      * @returns {Promise<Set<String>, Error>}
      */
     getFeatures(jid, timeout = 5000) {
-        let user
+        const user
             = jid in this.jidToVersion ? this.jidToVersion[jid] : null;
         if(!user || !(user.version in this.versionToCapabilities))
         {

modules/xmpp/ChatRoom.js

             mutedNode = filterNodeFromPresenceJSON(pres, "audiomuted");
         } else if (mediaType === MediaType.VIDEO) {
             mutedNode = filterNodeFromPresenceJSON(pres, "videomuted");
-            let videoTypeNode = filterNodeFromPresenceJSON(pres, "videoType");
+            const videoTypeNode = filterNodeFromPresenceJSON(pres, "videoType");
 
             if(videoTypeNode.length > 0) {
                 data.videoType = videoTypeNode[0]["value"];
      */
     leave () {
         return new Promise((resolve, reject) => {
-            let timeout = setTimeout(() => onMucLeft(true), 5000);
-            let eventEmitter = this.eventEmitter;
+            const timeout = setTimeout(() => onMucLeft(true), 5000);
+            const eventEmitter = this.eventEmitter;
             function onMucLeft(doReject = false) {
                 eventEmitter.removeListener(XMPPEvents.MUC_LEFT, onMucLeft);
                 clearTimeout(timeout);

modules/xmpp/JingleSessionPC.js

      *  be added to the remote SDP
      */
     _parseSsrcInfoFromSourceAdd(sourceAddElem, currentRemoteSdp) {
-        let addSsrcInfo = [];
+        const addSsrcInfo = [];
         $(sourceAddElem).each(function (idx, content) {
             const name = $(content).attr('name');
             let lines = '';
                     logger.debug("Renegotiate: creating answer");
                     this.peerconnection.createAnswer(
                         (answer) => {
-                            let localUfrag = JingleSessionPC.getUfrag(answer.sdp);
+                            const localUfrag = JingleSessionPC.getUfrag(answer.sdp);
                             if (localUfrag != this.localUfrag) {
                                 this.localUfrag = localUfrag;
                                 this.room.eventEmitter.emit(

modules/xmpp/RtxModifier.js

         logger.debug("Parsed primary video ssrcs ", primaryVideoSsrcs,
             " making sure all have rtx streams");
         for (const ssrc of primaryVideoSsrcs) {
-            let msid = videoMLine.getSSRCAttrValue(ssrc, "msid");
-            let cname = videoMLine.getSSRCAttrValue(ssrc, "cname");
+            const msid = videoMLine.getSSRCAttrValue(ssrc, "msid");
+            const cname = videoMLine.getSSRCAttrValue(ssrc, "cname");
             let correspondingRtxSsrc = this.correspondingRtxSsrcs.get(ssrc);
             if (correspondingRtxSsrc) {
                 logger.debug(
                     `No previously associated rtx ssrc for video ssrc ${ssrc}`);
                 // If there's one in the sdp already for it, we'll just set
                 //  that as the corresponding one
-                let previousAssociatedRtxStream = videoMLine.getRtxSSRC(ssrc);
+                const previousAssociatedRtxStream = videoMLine.getRtxSSRC(ssrc);
                 if (previousAssociatedRtxStream) {
                     logger.debug(
                         `Rtx stream ${previousAssociatedRtxStream} ` +

modules/xmpp/RtxModifier.spec.js

  * @returns {number} the number of video ssrcs in the given sdp
  */
 function numVideoSsrcs (parsedSdp) {
-  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  const videoMLine = parsedSdp.media.find(m => m.type === "video");
   return videoMLine.ssrcs
     .map(ssrcInfo => ssrcInfo.id)
     .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
  * @returns {number} the primary video ssrc in the given sdp
  */
 function getPrimaryVideoSsrc (parsedSdp) {
-  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  const videoMLine = parsedSdp.media.find(m => m.type === "video");
   return parseInt(SDPUtil.parsePrimaryVideoSsrc(videoMLine));
 }
 
  * @returns {list<number>} the primary video ssrcs in the given sdp
  */
 function getPrimaryVideoSsrcs (parsedSdp) {
-  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  const videoMLine = parsedSdp.media.find(m => m.type === "video");
   if (numVideoSsrcs(parsedSdp) === 1) {
     return [videoMLine.ssrcs[0].id];
   } else {
-    let simGroups = getVideoGroups(parsedSdp, "SIM");
+    const simGroups = getVideoGroups(parsedSdp, "SIM");
     if (simGroups.length > 1) {
       return;
     }
-    let simGroup = simGroups[0];
+    const simGroup = simGroups[0];
     return SDPUtil.parseGroupSsrcs(simGroup);
   }
 }
  *  that matched the passed semantics
  */
 function getVideoGroups (parsedSdp, groupSemantics) {
-  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  const videoMLine = parsedSdp.media.find(m => m.type === "video");
   videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
   return videoMLine.ssrcGroups
     .filter(g => g.semantics === groupSemantics);
         it ("should add a single rtx ssrc", function() {
           // Call rtxModifier.modifyRtxSsrcs with an sdp that contains a single video
           //  ssrc.  The returned sdp should have an rtx ssrc and an fid group.
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
-          let newSdp = transform.parse(newSdpStr);
-          let newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          const newSdp = transform.parse(newSdpStr);
+          const newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
           expect(newPrimaryVideoSsrc).toEqual(this.primaryVideoSsrc);
           // Should now have an rtx ssrc as well
           expect(numVideoSsrcs(newSdp)).toEqual(2);
           // Should now have an FID group
-          let fidGroups = getVideoGroups(newSdp, "FID");
+          const fidGroups = getVideoGroups(newSdp, "FID");
           expect(fidGroups.length).toEqual(1);
 
-          let fidGroup = fidGroups[0];
-          let fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+          const fidGroup = fidGroups[0];
+          const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
           expect(fidGroupPrimarySsrc).toEqual(this.primaryVideoSsrc);
         });
 
           let newSdp = transform.parse(newSdpStr);
 
           let fidGroup = getVideoGroups(newSdp, "FID")[0];
-          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
 
           // Now pass the original sdp through again 
           newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
           newSdp = transform.parse(newSdpStr);
           fidGroup = getVideoGroups(newSdp, "FID")[0];
-          let newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
           expect(newFidGroupRtxSsrc).toEqual(fidGroupRtxSsrc);
         });
 
           let newSdp = transform.parse(newSdpStr);
 
           let fidGroup = getVideoGroups(newSdp, "FID")[0];
-          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
           this.rtxModifier.clearSsrcCache();
 
           // Now pass the original sdp through again
           newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
           newSdp = transform.parse(newSdpStr);
           fidGroup = getVideoGroups(newSdp, "FID")[0];
-          let newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
           expect(newFidGroupRtxSsrc).not.toEqual(fidGroupRtxSsrc);
         });
 
           // Manually set an rtx ssrc mapping in the cache
           // Call modifyRtxSsrcs
           // -->The rtx ssrc used should be the one we set
-          let forcedRtxSsrc = 123456;
-          let ssrcCache = new Map();
+          const forcedRtxSsrc = 123456;
+          const ssrcCache = new Map();
           ssrcCache.set(this.primaryVideoSsrc, forcedRtxSsrc);
           this.rtxModifier.setSsrcCache(ssrcCache);
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
-          let newSdp = transform.parse(newSdpStr);
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          const newSdp = transform.parse(newSdpStr);
 
-          let fidGroup = getVideoGroups(newSdp, "FID")[0];
-          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          const fidGroup = getVideoGroups(newSdp, "FID")[0];
+          const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
           expect(fidGroupRtxSsrc).toEqual(forcedRtxSsrc);
         });
       });
         it ("should add rtx ssrcs for all of them", function() {
           // Call rtxModifier.modifyRtxSsrcs with an sdp that contains multiple video
           //  ssrcs.  The returned sdp should have an rtx ssrc and an fid group for all of them.
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
-          let newSdp = transform.parse(newSdpStr);
-          let newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          const newSdp = transform.parse(newSdpStr);
+          const newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
           expect(newPrimaryVideoSsrcs).toEqual(this.primaryVideoSsrcs);
           // Should now have rtx ssrcs as well
           expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
           // Should now have FID groups
-          let fidGroups = getVideoGroups(newSdp, "FID");
+          const fidGroups = getVideoGroups(newSdp, "FID");
           expect(fidGroups.length).toEqual(this.primaryVideoSsrcs.length);
           fidGroups.forEach(fidGroup => {
-            let fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+            const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
             expect(this.primaryVideoSsrcs.indexOf(fidGroupPrimarySsrc)).not.toEqual(-1);
           });
         });
           let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
           let newSdp = transform.parse(newSdpStr);
 
-          let rtxMapping = new Map();
+          const rtxMapping = new Map();
           let fidGroups = getVideoGroups(newSdp, "FID");
           // Save the first mapping that is made
           fidGroups.forEach(fidGroup => {
-            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
-            let fidGroupPrimarySsrc = fidSsrcs[0];
-            let fidGroupRtxSsrc = fidSsrcs[1];
+            const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            const fidGroupPrimarySsrc = fidSsrcs[0];
+            const fidGroupRtxSsrc = fidSsrcs[1];
             rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
           });
           // Now pass the original sdp through again and make sure we get the same mapping
           newSdp = transform.parse(newSdpStr);
           fidGroups = getVideoGroups(newSdp, "FID");
           fidGroups.forEach(fidGroup => {
-            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
-            let fidGroupPrimarySsrc = fidSsrcs[0];
-            let fidGroupRtxSsrc = fidSsrcs[1];
+            const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            const fidGroupPrimarySsrc = fidSsrcs[0];
+            const fidGroupRtxSsrc = fidSsrcs[1];
             expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
             expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
           });
           let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
           let newSdp = transform.parse(newSdpStr);
 
-          let rtxMapping = new Map();
+          const rtxMapping = new Map();
           let fidGroups = getVideoGroups(newSdp, "FID");
           // Save the first mapping that is made
           fidGroups.forEach(fidGroup => {
-            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
-            let fidGroupPrimarySsrc = fidSsrcs[0];
-            let fidGroupRtxSsrc = fidSsrcs[1];
+            const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            const fidGroupPrimarySsrc = fidSsrcs[0];
+            const fidGroupRtxSsrc = fidSsrcs[1];
             rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
           });
 
           newSdp = transform.parse(newSdpStr);
           fidGroups = getVideoGroups(newSdp, "FID");
           fidGroups.forEach(fidGroup => {
-            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
-            let fidGroupPrimarySsrc = fidSsrcs[0];
-            let fidGroupRtxSsrc = fidSsrcs[1];
+            const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            const fidGroupPrimarySsrc = fidSsrcs[0];
+            const fidGroupRtxSsrc = fidSsrcs[1];
             expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
             expect(rtxMapping.get(fidGroupPrimarySsrc)).not.toEqual(fidGroupRtxSsrc);
           });
           // Manually set an rtx ssrc mapping in the cache
           // Call modifyRtxSsrcs
           // -->The rtx ssrc used should be the one we set
-          let rtxMapping = new Map();
+          const rtxMapping = new Map();
           this.primaryVideoSsrcs.forEach(ssrc => {
             rtxMapping.set(ssrc, SDPUtil.generateSsrc());
           });
           this.rtxModifier.setSsrcCache(rtxMapping);
 
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
-          let newSdp = transform.parse(newSdpStr);
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          const newSdp = transform.parse(newSdpStr);
 
-          let fidGroups = getVideoGroups(newSdp, "FID");
+          const fidGroups = getVideoGroups(newSdp, "FID");
           fidGroups.forEach(fidGroup => {
-            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
-            let fidGroupPrimarySsrc = fidSsrcs[0];
-            let fidGroupRtxSsrc = fidSsrcs[1];
+            const fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            const fidGroupPrimarySsrc = fidSsrcs[0];
+            const fidGroupRtxSsrc = fidSsrcs[1];
             expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
             expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
           });
 
       describe ("(corner cases)", function() {
         it ("should handle a recvonly video mline", function() {
-          let sdp = SampleSdpStrings.plainVideoSdp;
-          let videoMLine = sdp.media.find(m => m.type === "video");
+          const sdp = SampleSdpStrings.plainVideoSdp;
+          const videoMLine = sdp.media.find(m => m.type === "video");
           videoMLine.direction = "recvonly";
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
           expect(newSdpStr).toEqual(this.transform.write(sdp));
         });
 
         it ("should handle an inactive video mline", function() {
-          let sdp = SampleSdpStrings.plainVideoSdp;
-          let videoMLine = sdp.media.find(m => m.type === "video");
+          const sdp = SampleSdpStrings.plainVideoSdp;
+          const videoMLine = sdp.media.find(m => m.type === "video");
           videoMLine.direction = "inactive";
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
           expect(newSdpStr).toEqual(this.transform.write(sdp));
         });
 
         it ("should handle a video mline with no video ssrcs", function() {
-          let sdp = SampleSdpStrings.plainVideoSdp;
-          let videoMLine = sdp.media.find(m => m.type === "video");
+          const sdp = SampleSdpStrings.plainVideoSdp;
+          const videoMLine = sdp.media.find(m => m.type === "video");
           videoMLine.ssrcs = [];
-          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
           expect(newSdpStr).toEqual(this.transform.write(sdp));
         });
       });

modules/xmpp/SDPUtil.js

      * @return {number} the primary video ssrc from the given m line
      */
     parsePrimaryVideoSsrc: function(videoMLine) {
-        let numSsrcs = videoMLine.ssrcs
+        const numSsrcs = videoMLine.ssrcs
             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
             .length;
-        let numGroups = (videoMLine.ssrcGroups && videoMLine.ssrcGroups.length) || 0;
+        const numGroups = (videoMLine.ssrcGroups && videoMLine.ssrcGroups.length) || 0;
         if (numSsrcs > 1 && numGroups === 0) {
             // Ambiguous, can't figure out the primary
             return;
         } else {
             if (numSsrcs === 2) {
                 // Can figure it out if there's an FID group
-                let fidGroup = videoMLine.ssrcGroups
+                const fidGroup = videoMLine.ssrcGroups
                     .find(group => group.semantics === "FID");
                 if (fidGroup) {
                     primarySsrc = fidGroup.ssrcs.split(" ")[0];
                 }
             } else if (numSsrcs >= 3) {
                 // Can figure it out if there's a sim group
-                let simGroup = videoMLine.ssrcGroups
+                const simGroup = videoMLine.ssrcGroups
                     .find(group => group.semantics === "SIM");
                 if (simGroup) {
                     primarySsrc = simGroup.ssrcs.split(" ")[0];
      */
     getSsrcAttribute: function (mLine, ssrc, attributeName) {
         for (let i = 0; i < mLine.ssrcs.length; ++i) {
-            let ssrcLine = mLine.ssrcs[i];
+            const ssrcLine = mLine.ssrcs[i];
             if (ssrcLine.id === ssrc &&
                 ssrcLine.attribute === attributeName) {
                 return ssrcLine.value;

modules/xmpp/SdpConsistency.js

                 logger.error("No SSRC found for the recvonly video stream!");
             }
         } else {
-            let newPrimarySsrc = videoMLine.getPrimaryVideoSsrc();
+            const newPrimarySsrc = videoMLine.getPrimaryVideoSsrc();
             if (!newPrimarySsrc) {
                 logger.info("Sdp-consistency couldn't parse new primary ssrc");
                 return sdpStr;
                     newPrimarySsrc, this.cachedPrimarySsrc);
                 for (const group of videoMLine.ssrcGroups) {
                     if (group.semantics === "FID") {
-                        let primarySsrc = parsePrimarySSRC(group);
-                        let rtxSsrc = parseSecondarySSRC(group);
+                        const primarySsrc = parsePrimarySSRC(group);
+                        const rtxSsrc = parseSecondarySSRC(group);
                         if (primarySsrc === newPrimarySsrc) {
                             group.ssrcs =
                                 this.cachedPrimarySsrc + " " +

modules/xmpp/strophe.jingle.js

                 .c('services', {xmlns: 'urn:xmpp:extdisco:1'})
                 .c('service', {host: 'turn.' + this.connection.domain}),
             res => {
-                let iceservers = [];
+                const iceservers = [];
                 $(res).find('>services>service').each((idx, el) => {
                     el = $(el);
-                    let dict = {};
+                    const dict = {};
                     const type = el.attr('type');
                     switch (type) {
                         case 'stun':

modules/xmpp/strophe.rayo.js

             this.connection.sendIQ(req, (result) => {
                 logger.info('Dial result ', result);
 
-                let resource = $(result).find('ref').attr('uri');
+                const resource = $(result).find('ref').attr('uri');
                 this.call_resource =
                     resource.substr('xmpp:'.length);
                 logger.info("Received call resource: " + this.call_resource);

modules/xmpp/xmpp.js

         // By default MUC nickname is the resource part of the JID
         let mucNickname = Strophe.getNodeFromJid(this.connection.jid);
         let roomjid = roomName  + "@" + this.options.hosts.muc + "/";
-        let cfgNickname
+        const cfgNickname
             = options.useNicks && options.nick ? options.nick : null;
 
         if (cfgNickname) {