[eslint] no-var

.eslintignore

 # not seem to be a reason why we will want to risk being inconsistent with our
 # remaining JavaScript source code.
 !.eslintrc.js
+
+# Source code written in ES5 which is not processed through Babel.
+connection_optimization/external_connect.js

.eslintrc.js

         'no-useless-computed-key': 2,
         'no-useless-constructor': 2,
         'no-useless-rename': 2,
+        'no-var': 2,
         'object-shorthand': [
             'error',
             'always',

JitsiConference.js

  */
 function JitsiConference(options) {
     if (!options.name || options.name.toLowerCase() !== options.name) {
-        var errmsg
+        const errmsg
             = 'Invalid conference name (no conference name passed or it '
                 + 'contains invalid characters like capital letters)!';
         logger.error(errmsg);
 JitsiConference.prototype.addTrack = function(track) {
     if (track.isVideoTrack()) {
         // Ensure there's exactly 1 local video track in the conference.
-        var localVideoTrack = this.rtc.getLocalVideoTrack();
+        const localVideoTrack = this.rtc.getLocalVideoTrack();
         if (localVideoTrack) {
             // Don't be excessively harsh and severe if the API client happens
             // to attempt to add the same local video track twice.
     if (newTrack.isAudioTrack() || (newTrack.isVideoTrack()
             && newTrack.videoType !== VideoType.DESKTOP)) {
         // Report active device to statistics
-        var devices = RTC.getCurrentlyAvailableMediaDevices();
-        var device = devices.find(function(d) {
+        const devices = RTC.getCurrentlyAvailableMediaDevices();
+        const device = devices.find(function(d) {
             return d.kind === newTrack.getTrack().kind + 'input'
                 && d.label === newTrack.getTrack().label;
         });
         return Promise.reject();
     }
 
-    var conference = this;
+    const conference = this;
     return new Promise(function(resolve, reject) {
         conference.room.lockRoom(password || '', function() {
             resolve();
  * @param {string} id id of the participant to kick
  */
 JitsiConference.prototype.kickParticipant = function(id) {
-    var participant = this.getParticipantById(id);
+    const participant = this.getParticipantById(id);
     if (!participant) {
         return;
     }
  * @param {string} id The id of the participant to mute.
  */
 JitsiConference.prototype.muteParticipant = function(id) {
-    var participant = this.getParticipantById(id);
+    const participant = this.getParticipantById(id);
     if (!participant) {
         return;
     }
  */
 JitsiConference.prototype.onMemberJoined
     = function(jid, nick, role, isHidden) {
-        var id = Strophe.getResourceFromJid(jid);
+        const id = Strophe.getResourceFromJid(jid);
         if (id === 'focus' || this.myUserId() === id) {
             return;
         }
-        var participant = new JitsiParticipant(jid, this, nick, isHidden);
+        const participant = new JitsiParticipant(jid, this, nick, isHidden);
         participant._role = role;
         this.participants[id] = participant;
         this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id, participant);
     };
 
 JitsiConference.prototype.onMemberLeft = function(jid) {
-    var id = Strophe.getResourceFromJid(jid);
+    const id = Strophe.getResourceFromJid(jid);
     if (id === 'focus' || this.myUserId() === id) {
         return;
     }
-    var participant = this.participants[id];
+    const participant = this.participants[id];
     delete this.participants[id];
 
-    var removedTracks = this.rtc.removeRemoteTracks(id);
+    const removedTracks = this.rtc.removeRemoteTracks(id);
 
     removedTracks.forEach(function(track) {
         this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
 };
 
 JitsiConference.prototype.onUserRoleChanged = function(jid, role) {
-    var id = Strophe.getResourceFromJid(jid);
-    var participant = this.getParticipantById(id);
+    const id = Strophe.getResourceFromJid(jid);
+    const participant = this.getParticipantById(id);
     if (!participant) {
         return;
     }
 };
 
 JitsiConference.prototype.onDisplayNameChanged = function(jid, displayName) {
-    var id = Strophe.getResourceFromJid(jid);
-    var participant = this.getParticipantById(id);
+    const id = Strophe.getResourceFromJid(jid);
+    const participant = this.getParticipantById(id);
     if (!participant) {
         return;
     }
 = function(jingleSession, jingleOffer, now) {
     if (!this.room.isFocus(jingleSession.peerjid)) {
         // Error cause this should never happen unless something is wrong!
-        var errmsg = 'Rejecting session-initiate from non-focus user: '
+        const errmsg = 'Rejecting session-initiate from non-focus user: '
                 + jingleSession.peerjid;
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         logger.error(errmsg);
         Statistics.sendEventToAll('session.restart');
     }
     // add info whether call is cross-region
-    var crossRegion = null;
+    let crossRegion = null;
     if (window.jitsiRegionInfo) {
         crossRegion = window.jitsiRegionInfo.CrossRegion;
     }
     // We want to re-register 'ssrcHandler' of our local tracks, so that they
     // will learn what their SSRC from the new PeerConnection which will be
     // created on incoming call event.
-    var self = this;
+    const self = this;
     this.getLocalTracks().forEach(function(localTrack) {
         // Reset SSRC as it will no longer be valid
         localTrack._setSSRC(null);
 };
 
 JitsiConference.prototype.updateDTMFSupport = function() {
-    var somebodySupportsDTMF = false;
-    var participants = this.getParticipants();
+    let somebodySupportsDTMF = false;
+    const participants = this.getParticipants();
 
     // check if at least 1 participant supports DTMF
-    for (var i = 0; i < participants.length; i += 1) {
+    for (let i = 0; i < participants.length; i += 1) {
         if (participants[i].supportsDTMF()) {
             somebodySupportsDTMF = true;
             break;
  * Get object with internal logs.
  */
 JitsiConference.prototype.getLogs = function() {
-    var data = this.xmpp.getJingleLog();
+    const data = this.xmpp.getJingleLog();
 
-    var metadata = {};
+    const metadata = {};
     metadata.time = new Date();
     metadata.url = window.location.href;
     metadata.ua = navigator.userAgent;
 
-    var log = this.xmpp.getXmppLog();
+    const log = this.xmpp.getXmppLog();
     if (log) {
         metadata.xmpp = log;
     }
  * @param container the container
  */
 JitsiConference.prototype._onTrackAttach = function(track, container) {
-    var ssrc = track.getSSRC();
+    const ssrc = track.getSSRC();
     if (!container.id || !ssrc) {
         return;
     }

JitsiConferenceEventManager.js

  * Setups event listeners related to conference.chatRoom
  */
 JitsiConferenceEventManager.prototype.setupChatRoomListeners = function() {
-    var conference = this.conference;
-    var chatRoom = conference.room;
+    const conference = this.conference;
+    const chatRoom = conference.room;
     this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
         this.conference.eventEmitter);
 
                 JitsiConferenceErrors.FOCUS_LEFT);
         });
 
-    var eventLogHandler = function(reason) {
+    const eventLogHandler = function(reason) {
         Statistics.sendEventToAll('conference.error.' + reason);
     };
     chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT,
         JitsiConferenceErrors.SETUP_FAILED);
 
     chatRoom.setParticipantPropertyListener(function(node, from) {
-        var participant = conference.getParticipantById(from);
+        const participant = conference.getParticipantById(from);
         if (!participant) {
             return;
         }
         if (conference.statistics && conference.isModerator()) {
             conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
                 function(status, error) {
-                    var logObject = {
+                    const logObject = {
                         id: 'recorder_status',
                         status
                     };
 
     chatRoom.addListener(XMPPEvents.MESSAGE_RECEIVED,
         function(jid, displayName, txt, myJid, ts) {
-            var id = Strophe.getResourceFromJid(jid);
+            const id = Strophe.getResourceFromJid(jid);
             conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED,
                 id, txt, ts);
         });
 
     chatRoom.addListener(XMPPEvents.PRESENCE_STATUS,
         function(jid, status) {
-            var id = Strophe.getResourceFromJid(jid);
-            var participant = conference.getParticipantById(id);
+            const id = Strophe.getResourceFromJid(jid);
+            const participant = conference.getParticipantById(id);
             if (!participant || participant._status === status) {
                 return;
             }
         });
 
     chatRoom.addPresenceListener('startmuted', function(data, from) {
-        var isModerator = false;
+        let isModerator = false;
         if (conference.myUserId() === from && conference.isModerator()) {
             isModerator = true;
         } else {
-            var participant = conference.getParticipantById(from);
+            const participant = conference.getParticipantById(from);
             if (participant && participant.isModerator()) {
                 isModerator = true;
             }
             return;
         }
 
-        var startAudioMuted = data.attributes.audio === 'true';
-        var startVideoMuted = data.attributes.video === 'true';
+        const startAudioMuted = data.attributes.audio === 'true';
+        const startVideoMuted = data.attributes.video === 'true';
 
-        var updated = false;
+        let updated = false;
 
         if (startAudioMuted !== conference.startMutedPolicy.audio) {
             conference.startMutedPolicy.audio = startAudioMuted;
     });
 
     chatRoom.addPresenceListener('devices', function(data, from) {
-        var isAudioAvailable = false;
-        var isVideoAvailable = false;
+        let isAudioAvailable = false;
+        let isVideoAvailable = false;
         data.children.forEach(function(config) {
             if (config.tagName === 'audio') {
                 isAudioAvailable = config.value === 'true';
             }
         });
 
-        var availableDevices;
+        let availableDevices;
         if (conference.myUserId() === from) {
             availableDevices = conference.availableDevices;
         } else {
-            var participant = conference.getParticipantById(from);
+            const participant = conference.getParticipantById(from);
             if (!participant) {
                 return;
             }
             availableDevices = participant._availableDevices;
         }
 
-        var updated = false;
+        let updated = false;
 
         if (availableDevices.audio !== isAudioAvailable) {
             updated = true;
         });
 
     rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, function() {
-        var now = window.performance.now();
+        const now = window.performance.now();
         logger.log('(TIME) data channel opened ', now);
         conference.room.connectionTimes['data.channel.opened'] = now;
         Statistics.analytics.sendEvent('conference.dataChannel.open',
  * Setups event listeners related to conference.xmpp
  */
 JitsiConferenceEventManager.prototype.setupXMPPListeners = function() {
-    var conference = this.conference;
+    const conference = this.conference;
     conference.xmpp.caps.addListener(XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
         from => {
             const participant = conference.getParticipantId(
  * Setups event listeners related to conference.statistics
  */
 JitsiConferenceEventManager.prototype.setupStatisticsListeners = function() {
-    var conference = this.conference;
+    const conference = this.conference;
     if(!conference.statistics) {
         return;
     }
 
     conference.statistics.addAudioLevelListener(function(ssrc, level) {
-        var resource = conference.rtc.getResourceBySSRC(ssrc);
+        const resource = conference.rtc.getResourceBySSRC(ssrc);
         if (!resource) {
             return;
         }
             JitsiConferenceEvents.BEFORE_STATISTICS_DISPOSED);
     });
     conference.statistics.addConnectionStatsListener(function(stats) {
-        var ssrc2resolution = stats.resolution;
+        const ssrc2resolution = stats.resolution;
 
-        var id2resolution = {};
+        const id2resolution = {};
 
         // preprocess resolutions: group by user id, skip incorrect
         // resolutions etc.
         Object.keys(ssrc2resolution).forEach(function(ssrc) {
-            var resolution = ssrc2resolution[ssrc];
+            const resolution = ssrc2resolution[ssrc];
 
             if (!resolution.width || !resolution.height
                 || resolution.width == -1 || resolution.height == -1) {
                 return;
             }
 
-            var id = conference.rtc.getResourceBySSRC(ssrc);
+            const id = conference.rtc.getResourceBySSRC(ssrc);
             if (!id) {
                 return;
             }
 
             // ssrc to resolution map for user id
-            var idResolutions = id2resolution[id] || {};
+            const idResolutions = id2resolution[id] || {};
             idResolutions[ssrc] = resolution;
 
             id2resolution[id] = idResolutions;

JitsiConnection.js

-var JitsiConference = require('./JitsiConference');
+const JitsiConference = require('./JitsiConference');
 import * as JitsiConnectionEvents from './JitsiConnectionEvents';
 import XMPP from './modules/xmpp/xmpp';
-var Statistics = require('./modules/statistics/statistics');
+const Statistics = require('./modules/statistics/statistics');
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
     // XMPP.disconnect. For example, the caller of JitsiConnection.disconnect
     // may optionally pass the event which triggered the disconnect in order to
     // provide the implementation with finer-grained context.
-    var x = this.xmpp;
+    const x = this.xmpp;
 
     x.disconnect(...arguments);
 };

JitsiMediaDevices.js

  * @param devices list of devices
  */
 function logOutputDevice(deviceID, devices) {
-    var device = devices.find(function(d) {
+    const device = devices.find(function(d) {
         return d.kind === 'audiooutput' && d.deviceId === deviceID;
     });
 
     }
 }
 
-var JitsiMediaDevices = {
+const JitsiMediaDevices = {
     /**
      * Executes callback with list of media devices connected.
      * @param {function} callback
      * @returns {boolean}
      */
     isDevicePermissionGranted(type) {
-        var permissions = RTC.getDeviceAvailability();
+        const permissions = RTC.getDeviceAvailability();
 
         switch(type) {
         case MediaType.VIDEO:
      */
     setAudioOutputDevice(deviceId) {
 
-        var availableDevices = RTC.getCurrentlyAvailableMediaDevices();
+        const availableDevices = RTC.getCurrentlyAvailableMediaDevices();
         if (availableDevices && availableDevices.length > 0) {
             // if we have devices info report device to stats
             // normally this will not happen on startup as this method is called

JitsiMeetJS.js

 
 // The amount of time to wait until firing
 // JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN event
-var USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
+const USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
 
 function getLowerResolution(resolution) {
     if(!Resolutions[resolution]) {
         return null;
     }
-    var order = Resolutions[resolution].order;
-    var res = null;
-    var resName = null;
+    const order = Resolutions[resolution].order;
+    let res = null;
+    let resName = null;
     Object.keys(Resolutions).forEach(resolution => {
         const value = Resolutions[resolution];
         if (!res || (res.order < value.order && value.order < order)) {
 /**
  * Namespace for the interface of Jitsi Meet Library.
  */
-var LibJitsiMeet = {
+const LibJitsiMeet = {
 
     version: '{#COMMIT_HASH#}',
 
      *     or a JitsiConferenceError if rejected.
      */
     createLocalTracks(options, firePermissionPromptIsShownEvent) {
-        var promiseFulfilled = false;
+        let promiseFulfilled = false;
 
         if (firePermissionPromptIsShownEvent === true) {
             window.setTimeout(function() {
                 if(!RTC.options.disableAudioLevels) {
                     for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
-                        var mStream = track.getOriginalStream();
+                        const mStream = track.getOriginalStream();
                         if(track.getType() === MediaType.AUDIO) {
                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                 }
 
                 // set real device ids
-                var currentlyAvailableMediaDevices
+                const currentlyAvailableMediaDevices
                     = RTC.getCurrentlyAvailableMediaDevices();
                 if (currentlyAvailableMediaDevices) {
                     for(let i = 0; i < tracks.length; i++) {

JitsiParticipant.js

      * @value the value to set.
      */
     setProperty(name, value) {
-        var oldValue = this._properties[name];
+        const oldValue = this._properties[name];
 
         if (value !== oldValue) {
             this._properties[name] = value;

JitsiRecorderErrors.js

  * Enumeration with the errors for the conference.
  * @type {{string: string}}
  */
-var JitsiRecorderErrors = {
+const JitsiRecorderErrors = {
     /**
      * Indicates that the recorder is currently unavailable.
      */

JitsiTrackError.js

                     + (this.gum.devices || []).join(', ');
             break;
         case 'ConstraintNotSatisfiedError':
-        case 'OverconstrainedError':
-            var constraintName = error.constraintName;
+        case 'OverconstrainedError': {
+            const constraintName = error.constraintName;
 
             if (options
                     && options.video
                         + error.constraintName;
             }
             break;
+        }
+
         default:
             this.name = JitsiTrackErrors.GENERAL;
             this.message

doc/example/example.js

 /* global $, JitsiMeetJS */
 
-var options = {
+const options = {
     hosts: {
         domain: 'jitsi-meet.example.com',
         muc: 'conference.jitsi-meet.example.com', // FIXME: use XEP-0030
     clientNode: 'http://jitsi.org/jitsimeet', // The name of client node advertised in XEP-0115 'c' stanza
 };
 
-var confOptions = {
+const confOptions = {
     openSctp: true
 };
 
-var isJoined = false;
+let connection = null;
+let isJoined = false;
+let room = null;
+
+let localTracks = [];
+const remoteTracks = {};
 
 /**
  * Handles local tracks.
  */
 function onLocalTracks(tracks) {
     localTracks = tracks;
-    for(var i = 0; i < localTracks.length; i++) {
+    for(let i = 0; i < localTracks.length; i++) {
         localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
             function(audioLevel) {
                 console.log('Audio Level local: ' + audioLevel);
     if(track.isLocal()) {
         return;
     }
-    var participant = track.getParticipantId();
+    const participant = track.getParticipantId();
     if(!remoteTracks[participant]) {
         remoteTracks[participant] = [];
     }
-    var idx = remoteTracks[participant].push(track);
+    const idx = remoteTracks[participant].push(track);
     track.addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
         function(audioLevel) {
             console.log('Audio Level remote: ' + audioLevel);
         function(deviceId) {
             console.log('track audio output device was changed to ' + deviceId);
         });
-    var id = participant + track.getType() + idx;
+    const id = participant + track.getType() + idx;
     if(track.getType() == 'video') {
         $('body').append('<video autoplay=\'1\' id=\'' + participant + 'video' + idx + '\' />');
     } else {
 function onConferenceJoined() {
     console.log('conference joined!');
     isJoined = true;
-    for(var i = 0; i < localTracks.length; i++) {
+    for(let i = 0; i < localTracks.length; i++) {
         room.addTrack(localTracks[i]);
     }
 }
     if(!remoteTracks[id]) {
         return;
     }
-    var tracks = remoteTracks[id];
-    for(var i = 0; i < tracks.length; i++) {
+    const tracks = remoteTracks[id];
+    for(let i = 0; i < tracks.length; i++) {
         tracks[i].detach($('#' + id + tracks[i].getType()));
     }
 }
 }
 
 function unload() {
-    for(var i = 0; i < localTracks.length; i++) {
+    for(let i = 0; i < localTracks.length; i++) {
         localTracks[i].stop();
     }
     room.leave();
     connection.disconnect();
 }
 
-var isVideo = true;
+let isVideo = true;
 function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if(localTracks[1]) {
 $(window).bind('unload', unload);
 
 // JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
-var initOptions = {
+const initOptions = {
     disableAudioLevels: true,
     // The ID of the jidesha extension for Chrome.
     desktopSharingChromeExtId: 'mbocklcggfhnbahlnepmldehdhpjfcjp',
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(function(devices) {
-        var audioOutputDevices = devices.filter(function(d) {
+        const audioOutputDevices = devices.filter(function(d) {
             return d.kind === 'audiooutput';
         });
 
         }
     });
 }
-
-var connection = null;
-var room = null;
-var localTracks = [];
-var remoteTracks = {};

modules/DTMF/JitsiDTMFManager.js

-var logger = require('jitsi-meet-logger').getLogger(__filename);
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 function JitsiDTMFManager(localAudio, peerConnection) {
-    var audioTrack = localAudio.getTrack();
+    const audioTrack = localAudio.getTrack();
     if (!audioTrack) {
         throw new Error('Failed to initialize DTMFSender: no audio track.');
     }

modules/RTC/DataChannels.js

 // cache datachannels to avoid garbage collection
 // https://code.google.com/p/chromium/issues/detail?id=405545
 
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var RTCEvents = require('../../service/RTC/RTCEvents');
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const RTCEvents = require('../../service/RTC/RTCEvents');
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
 /**
  * Binds "ondatachannel" event listener to given PeerConnection instance.
  * @param event the event info object.
  */
 DataChannels.prototype.onDataChannel = function(event) {
-    var dataChannel = event.channel;
-    var self = this;
+    const dataChannel = event.channel;
+    const self = this;
 
     dataChannel.onopen = function() {
         logger.info('Data channel opened by the Videobridge!', dataChannel);
     };
 
     dataChannel.onmessage = function(event) {
-        var data = event.data;
+        const data = event.data;
         // JSON
-        var obj;
+        let obj;
 
         try {
             obj = JSON.parse(data);
                 e);
         }
         if (('undefined' !== typeof obj) && (null !== obj)) {
-            var colibriClass = obj.colibriClass;
+            const colibriClass = obj.colibriClass;
 
             if ('DominantSpeakerEndpointChangeEvent' === colibriClass) {
                 // Endpoint ID from the Videobridge.
-                var dominantSpeakerEndpoint = obj.dominantSpeakerEndpoint;
+                const dominantSpeakerEndpoint = obj.dominantSpeakerEndpoint;
 
                 logger.info(
                     'Data channel new dominant speaker event: ',
                 self.eventEmitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED,
                   dominantSpeakerEndpoint);
             } else if ('InLastNChangeEvent' === colibriClass) {
-                var oldValue = obj.oldValue;
-                var newValue = obj.newValue;
+                let oldValue = obj.oldValue;
+                let newValue = obj.newValue;
 
                 // Make sure that oldValue and newValue are of type boolean.
-                var type;
+                let type;
 
                 if ((type = typeof oldValue) !== 'boolean') {
                     if (type === 'string') {
                 self.eventEmitter.emit(RTCEvents.LASTN_CHANGED, oldValue, newValue);
             } else if ('LastNEndpointsChangeEvent' === colibriClass) {
                 // The new/latest list of last-n endpoint IDs.
-                var lastNEndpoints = obj.lastNEndpoints;
+                const lastNEndpoints = obj.lastNEndpoints;
                 // The list of endpoint IDs which are entering the list of
                 // last-n at this time i.e. were not in the old list of last-n
                 // endpoint IDs.
-                var endpointsEnteringLastN = obj.endpointsEnteringLastN;
+                const endpointsEnteringLastN = obj.endpointsEnteringLastN;
 
                 logger.info(
                     'Data channel new last-n event: ',
                     RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
                     obj.msgPayload);
             } else if ('EndpointConnectivityStatusChangeEvent' === colibriClass) {
-                var endpoint = obj.endpoint;
-                var isActive = obj.active === 'true';
+                const endpoint = obj.endpoint;
+                const isActive = obj.active === 'true';
                 logger.info('Endpoint connection status changed: ' + endpoint
                            + ' active ? ' + isActive);
                 self.eventEmitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
 
     dataChannel.onclose = function() {
         logger.info('The Data Channel closed', dataChannel);
-        var idx = self._dataChannels.indexOf(dataChannel);
+        const idx = self._dataChannels.indexOf(dataChannel);
         if (idx > -1) {
             self._dataChannels = self._dataChannels.splice(idx, 1);
         }
 DataChannels.prototype._onXXXEndpointChanged = function(xxx, userResource) {
     // Derive the correct words from xxx such as selected and Selected, pinned
     // and Pinned.
-    var head = xxx.charAt(0);
-    var tail = xxx.substring(1);
-    var lower = head.toLowerCase() + tail;
-    var upper = head.toUpperCase() + tail;
+    const head = xxx.charAt(0);
+    const tail = xxx.substring(1);
+    const lower = head.toLowerCase() + tail;
+    const upper = head.toUpperCase() + tail;
     logger.log(
             'sending ' + lower
                 + ' endpoint changed notification to the bridge: ',
             userResource);
 
-    var jsonObject = {};
+    const jsonObject = {};
 
     jsonObject.colibriClass = upper + 'EndpointChangedEvent';
     jsonObject[lower + 'Endpoint']
 };
 
 DataChannels.prototype._some = function(callback, thisArg) {
-    var dataChannels = this._dataChannels;
+    const dataChannels = this._dataChannels;
 
     if (dataChannels && dataChannels.length !== 0) {
         if (thisArg) {

modules/RTC/JitsiLocalTrack.js

  */
 function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
                          deviceId, facingMode) {
-    var self = this;
+    const self = this;
 
     JitsiTrack.call(this,
         null /* RTC */, stream, track,
         return Promise.resolve();
     }
 
-    var promise = Promise.resolve();
-    var self = this;
+    let promise = Promise.resolve();
+    const self = this;
 
     // Local track can be used out of conference, so we need to handle that
     // case and mark that track should start muted or not when added to
             });
         } else {
             // This path is only for camera.
-            var streamOptions = {
+            const streamOptions = {
                 cameraDeviceId: this.getDeviceId(),
                 devices: [ MediaType.VIDEO ],
                 facingMode: this.getCameraFacingMode()
 
             promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
                 .then(function(streamsInfo) {
-                    var mediaType = self.getType();
-                    var streamInfo = streamsInfo.find(function(info) {
+                    const mediaType = self.getType();
+                    const streamInfo = streamsInfo.find(function(info) {
                         return info.mediaType === mediaType;
                     });
 
  * @returns {Promise}
  */
 JitsiLocalTrack.prototype.dispose = function() {
-    var self = this;
-    var promise = Promise.resolve();
+    const self = this;
+    let promise = Promise.resolve();
 
     if (this.conference) {
         promise = this.conference.removeTrack(this);
     // on "attach" call, but for local track we not always have the conference
     // before attaching. However this may result in duplicated events if they
     // have been triggered on "attach" already.
-    for(var i = 0; i < this.containers.length; i++) {
+    for(let i = 0; i < this.containers.length; i++) {
         this._maybeFireTrackAttached(this.containers[i]);
     }
 };
         // and https://bugzilla.mozilla.org/show_bug.cgi?id=1213517 for Firefox.
         // Even if a browser implements getSettings() already, it might still
         // not return anything for 'facingMode'.
-        var trackSettings;
+        let trackSettings;
 
         try {
             trackSettings = this.track.getSettings();

modules/RTC/JitsiRemoteTrack.js

 /* global */
 
-var JitsiTrack = require('./JitsiTrack');
+const JitsiTrack = require('./JitsiTrack');
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var RTCBrowserType = require('./RTCBrowserType');
-var RTCEvents = require('../../service/RTC/RTCEvents');
-var Statistics = require('../statistics/statistics');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const RTCBrowserType = require('./RTCBrowserType');
+const RTCEvents = require('../../service/RTC/RTCEvents');
+const Statistics = require('../statistics/statistics');
 
-var ttfmTrackerAudioAttached = false;
-var ttfmTrackerVideoAttached = false;
+let ttfmTrackerAudioAttached = false;
+let ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
 };
 
 JitsiRemoteTrack.prototype._playCallback = function() {
-    var type = this.isVideoTrack() ? 'video' : 'audio';
+    const type = this.isVideoTrack() ? 'video' : 'audio';
 
-    var now = window.performance.now();
+    const now = window.performance.now();
     console.log('(TIME) Render ' + type + ':\t', now);
     this.conference.getConnectionTimes()[type + '.render'] = now;
 
-    var ttfm = now
+    const ttfm = now
         - (this.conference.getConnectionTimes()['session.initiate']
         - this.conference.getConnectionTimes()['muc.joined'])
         - (window.connectionTimes['obtainPermissions.end']
         - window.connectionTimes['obtainPermissions.start']);
     this.conference.getConnectionTimes()[type + '.ttfm'] = ttfm;
     console.log('(TIME) TTFM ' + type + ':\t', ttfm);
-    var eventName = type + '.ttfm';
+    let eventName = type + '.ttfm';
     if(this.hasBeenMuted) {
         eventName += '.muted';
     }

modules/RTC/JitsiTrack.js

 /**
  * Maps our handler types to MediaStreamTrack properties.
  */
-var trackHandler2Prop = {
+const trackHandler2Prop = {
     'track_mute': 'onmute',// Not supported on FF
     'track_unmute': 'onunmute',
     'track_ended': 'onended'
  * to which 'onended' handling will be added.
  */
 function implementOnEndedHandling(jitsiTrack) {
-    var stream = jitsiTrack.getOriginalStream();
+    const stream = jitsiTrack.getOriginalStream();
 
     if(!stream) {
         return;
     }
 
-    var originalStop = stream.stop;
+    const originalStop = stream.stop;
     stream.stop = function() {
         originalStop.apply(stream);
         if (jitsiTrack.isActive()) {
  * JitsiTrack is currently attached.
  */
 JitsiTrack.prototype.detach = function(container) {
-    for (var cs = this.containers, i = cs.length - 1; i >= 0; --i) {
-        var c = cs[i];
+    for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
+        const c = cs[i];
         if (!container) {
             RTCUtils.attachMediaStream(c, null);
         }
  * no stream is attached.
  */
 JitsiTrack.prototype.getMSID = function() {
-    var streamId = this.getStreamId();
-    var trackId = this.getTrackId();
+    const streamId = this.getStreamId();
+    const trackId = this.getTrackId();
     return streamId && trackId ? streamId + ' ' + trackId : null;
 };
 
  * @returns {Promise}
  */
 JitsiTrack.prototype.setAudioOutput = function(audioOutputDeviceId) {
-    var self = this;
+    const self = this;
 
     if (!RTCUtils.isDeviceChangeAvailable('output')) {
         return Promise.reject(

modules/RTC/RTC.js

 const logger = getLogger(__filename);
 
 function createLocalTracks(tracksInfo, options) {
-    var newTracks = [];
-    var deviceId = null;
+    const newTracks = [];
+    let deviceId = null;
     tracksInfo.forEach(function(trackInfo) {
         if (trackInfo.mediaType === MediaType.AUDIO) {
             deviceId = options.micDeviceId;
         } else if (trackInfo.videoType === VideoType.CAMERA) {
             deviceId = options.cameraDeviceId;
         }
-        var localTrack
+        const localTrack
             = new JitsiLocalTrack(
                 trackInfo.stream,
                 trackInfo.track,
     static obtainAudioAndVideoPermissions(options) {
         return RTCUtils.obtainAudioAndVideoPermissions(options).then(
             function(tracksInfo) {
-                var tracks = createLocalTracks(tracksInfo, options);
+                const tracks = createLocalTracks(tracksInfo, options);
                 return !tracks.some(track =>
                     !track._isReceivingData()) ? tracks
                         : Promise.reject(new JitsiTrackError(
         if(!resource) {
             return;
         }
-        var audioTrack = this.getRemoteAudioTrack(resource);
+        const audioTrack = this.getRemoteAudioTrack(resource);
         if(audioTrack) {
             audioTrack.setAudioLevel(audioLevel);
         }
      * @param from {string} user id
      */
     handleRemoteTrackMute(type, isMuted, from) {
-        var track = this.getRemoteTrackByType(type, from);
+        const track = this.getRemoteTrackByType(type, from);
         if (track) {
             track.setMute(isMuted);
         }
      * @param from {string} user id
      */
     handleRemoteTrackVideoTypeChanged(value, from) {
-        var videoTrack = this.getRemoteVideoTrack(from);
+        const videoTrack = this.getRemoteVideoTrack(from);
         if (videoTrack) {
             videoTrack._setVideoType(value);
         }

modules/RTC/RTCBrowserType.js

-var logger = require('jitsi-meet-logger').getLogger(__filename);
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
-var currentBrowser;
+let currentBrowser;
 
-var browserVersion;
-
-var isAndroid;
-
-var RTCBrowserType = {
+const RTCBrowserType = {
 
     RTC_BROWSER_CHROME: 'rtc_browser.chrome',
 
      * @returns {string}
      */
     getBrowserName() {
-        var browser;
+        let browser;
         if (RTCBrowserType.isAndroid()) {
             browser = 'android';
         } else {
 function detectChrome() {
     if (navigator.webkitGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_CHROME;
-        var userAgent = navigator.userAgent.toLowerCase();
+        const userAgent = navigator.userAgent.toLowerCase();
         // We can assume that user agent is chrome, because it's
         // enforced when 'ext' streaming method is set
-        var ver = parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
+        const ver = parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
         logger.log('This appears to be Chrome, ver: ' + ver);
         return ver;
     }
 }
 
 function detectOpera() {
-    var userAgent = navigator.userAgent;
+    const userAgent = navigator.userAgent;
     if (userAgent.match(/Opera|OPR/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_OPERA;
-        var version = userAgent.match(/(Opera|OPR) ?\/?(\d+)\.?/)[2];
+        const version = userAgent.match(/(Opera|OPR) ?\/?(\d+)\.?/)[2];
         logger.info('This appears to be Opera, ver: ' + version);
         return version;
     }
 function detectFirefox() {
     if (navigator.mozGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_FIREFOX;
-        var version = parseInt(
+        const version = parseInt(
             navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1], 10);
         logger.log('This appears to be Firefox, ver: ' + version);
         return version;
 }
 
 function detectIE() {
-    var version;
-    var ua = window.navigator.userAgent;
+    let version;
+    const ua = window.navigator.userAgent;
 
-    var msie = ua.indexOf('MSIE ');
+    const msie = ua.indexOf('MSIE ');
     if (msie > 0) {
         // IE 10 or older => return version number
         version = parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
     }
 
-    var trident = ua.indexOf('Trident/');
+    const trident = ua.indexOf('Trident/');
     if (!version && trident > 0) {
         // IE 11 => return version number
-        var rv = ua.indexOf('rv:');
+        const rv = ua.indexOf('rv:');
         version = parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
     }
 
-    var edge = ua.indexOf('Edge/');
+    const edge = ua.indexOf('Edge/');
     if (!version && edge > 0) {
         // IE 12 => return version number
         version = parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
  * Detects Electron environment.
  */
 function detectElectron() {
-    var userAgent = navigator.userAgent;
+    const userAgent = navigator.userAgent;
     if (userAgent.match(/Electron/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_ELECTRON;
-        var version = userAgent.match(/Electron\/([\d.]+)/)[1];
+        const version = userAgent.match(/Electron\/([\d.]+)/)[1];
         logger.info('This appears to be Electron, ver: ' + version);
         return version;
     }
 }
 
 function detectNWJS() {
-    var userAgent = navigator.userAgent;
+    const userAgent = navigator.userAgent;
     if (userAgent.match(/JitsiMeetNW/)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_NWJS;
-        var version = userAgent.match(/JitsiMeetNW\/([\d.]+)/)[1];
+        const version = userAgent.match(/JitsiMeetNW\/([\d.]+)/)[1];
         logger.info('This appears to be JitsiMeetNW, ver: ' + version);
         return version;
     }
 }
 
 function detectReactNative() {
-    var match
+    const match
         = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
-    var version;
+    let version;
     // If we're remote debugging a React Native app, it may be treated as
     // Chrome. Check navigator.product as well and always return some version
     // even if we can't get the real one.
     if (match || navigator.product === 'ReactNative') {
         currentBrowser = RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
-        var name;
+        let name;
         if (match && match.length > 2) {
             name = match[1];
             version = match[2];
 }
 
 function detectBrowser() {
-    var version;
-    var detectors = [
+    let version;
+    const detectors = [
         detectReactNative,
         detectElectron,
         detectNWJS,
         detectSafari
     ];
     // Try all browser detectors
-    for (var i = 0; i < detectors.length; i++) {
+    for (let i = 0; i < detectors.length; i++) {
         version = detectors[i]();
         if (version) {
             return version;
     return 1;
 }
 
-browserVersion = detectBrowser();
-isAndroid = navigator.userAgent.indexOf('Android') != -1;
+const browserVersion = detectBrowser();
+const isAndroid = navigator.userAgent.indexOf('Android') != -1;
 
 module.exports = RTCBrowserType;

modules/RTC/RTCUIHelper.js

 /* global $ */
 
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var RTCBrowserType = require('./RTCBrowserType');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const RTCBrowserType = require('./RTCBrowserType');
 
-var RTCUIHelper = {
+const RTCUIHelper = {
 
     /**
      * Returns the name of 'video' element depending on the browser that we're
      *          container or undefined otherwise.
      */
     findVideoElement(containerElement) {
-        var videoElemName = RTCUIHelper.getVideoElementName();
+        const videoElemName = RTCUIHelper.getVideoElementName();
         if (!RTCBrowserType.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
         }
-        var matching = $(containerElement).find(
+        const matching = $(containerElement).find(
                 ' ' + videoElemName + '>param[value="video"]');
         if (matching.length) {
             if (matching.length > 1) {

modules/RTC/RTCUtils.js

         ? require('./adapter.screenshare')
         : undefined;
 
-var eventEmitter = new EventEmitter();
+const eventEmitter = new EventEmitter();
 
-var AVAILABLE_DEVICES_POLL_INTERVAL_TIME = 3000; // ms
+const AVAILABLE_DEVICES_POLL_INTERVAL_TIME = 3000; // ms
 
-var devices = {
+const devices = {
     audio: false,
     video: false
 };
 
 // Currently audio output device change is supported only in Chrome and
 // default output always has 'default' device ID
-var audioOutputDeviceId = 'default'; // default device
+let audioOutputDeviceId = 'default'; // default device
 // whether user has explicitly set a device to use
-var audioOutputChanged = false;
+let audioOutputChanged = false;
 // Disables Acoustic Echo Cancellation
-var disableAEC = false;
+let disableAEC = false;
 // Disables Noise Suppression
-var disableNS = false;
+let disableNS = false;
 
-var featureDetectionAudioEl = document.createElement('audio');
-var isAudioOutputDeviceChangeAvailable
+const featureDetectionAudioEl = document.createElement('audio');
+const isAudioOutputDeviceChangeAvailable
     = typeof featureDetectionAudioEl.setSinkId !== 'undefined';
 
-var currentlyAvailableMediaDevices;
+let currentlyAvailableMediaDevices;
 
-var rawEnumerateDevicesWithCallback = undefined;
+let rawEnumerateDevicesWithCallback = undefined;
 /**
  * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
  * ready. Otherwise it is too early to assume that the devices listing is not
 // 'devicechange' event can be found in spec -
 // http://w3c.github.io/mediacapture-main/#event-mediadevices-devicechange
 // TODO: check MS Edge
-var isDeviceChangeEventSupported = false;
+const isDeviceChangeEventSupported = false;
 
-var rtcReady = false;
+let rtcReady = false;
 
 function setResolutionConstraints(constraints, resolution) {
-    var isAndroid = RTCBrowserType.isAndroid();
+    const isAndroid = RTCBrowserType.isAndroid();
 
     if (Resolutions[resolution]) {
         constraints.video.mandatory.minWidth = Resolutions[resolution].width;
  * @param {bool} firefox_fake_device
  */
 function getConstraints(um, options) {
-    var constraints = {audio: false, video: false};
+    const constraints = {audio: false, video: false};
 
     // Don't mix new and old style settings for Chromium as this leads
     // to TypeError in new Chromium versions. @see
     // new style constraints when new versions of Chromium and Firefox will
     // have stable support of new constraints format. For more information
     // @see https://github.com/jitsi/lib-jitsi-meet/pull/136
-    var isNewStyleConstraintsSupported
+    const isNewStyleConstraintsSupported
         = RTCBrowserType.isFirefox()
         || RTCBrowserType.isReactNative()
         || RTCBrowserType.isTemasysPluginUsed();
             // TODO: Maybe use "exact" syntax if options.facingMode is defined,
             // but this probably needs to be decided when updating other
             // constraints, as we currently don't use "exact" syntax anywhere.
-            var facingMode = options.facingMode || CameraFacingMode.USER;
+            const facingMode = options.facingMode || CameraFacingMode.USER;
 
             if (isNewStyleConstraintsSupported) {
                 constraints.video.facingMode = facingMode;
             };
 
         } else {
-            var errmsg
+            const errmsg
                 = '\'screen\' WebRTC media source is supported only in Chrome'
                     + ' and with Temasys plugin';
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
  * @param stream the stream we received from calling getUserMedia.
  */
 function setAvailableDevices(um, stream) {
-    var audioTracksReceived = stream && !!stream.getAudioTracks().length;
-    var videoTracksReceived = stream && !!stream.getVideoTracks().length;
+    const audioTracksReceived = stream && !!stream.getAudioTracks().length;
+    const videoTracksReceived = stream && !!stream.getVideoTracks().length;
 
     if (um.indexOf('video') != -1) {
         devices.video = videoTracksReceived;
     fn && fn(...args);
 }
 
-var getUserMediaStatus = {
+const getUserMediaStatus = {
     initialized: false,
     callbacks: []
 };
  * @param {Object} source
  */
 function convertMediaStreamTrackSource(source) {
-    var kind = (source.kind || '').toLowerCase();
+    const kind = (source.kind || '').toLowerCase();
 
     return {
         facing: source.facing || null,
         return options.successCallback(options.streams || {});
     }
 
-    var device = options.devices.splice(0, 1);
-    var devices = [];
+    const device = options.devices.splice(0, 1);
+    const devices = [];
     devices.push(device);
     options.deviceGUM[device](function(stream) {
         options.streams = options.streams || {};
  * @returns {*[]} object that describes the new streams
  */
 function handleLocalStream(streams, resolution) {
-    var audioStream, desktopStream, res = [], videoStream;
+    let audioStream, desktopStream, videoStream;
+    const res = [];
 
     // XXX The function obtainAudioAndVideoPermissions has examined the type of
     // the browser, its capabilities, etc. and has taken the decision whether to
         // As mentioned above, certian types of browser (e.g. Chrome) support
         // (with a result which meets our requirements expressed bellow) calling
         // getUserMedia once for both audio and video.
-        var audioVideo = streams.audioVideo;
+        const audioVideo = streams.audioVideo;
         if (audioVideo) {
-            var audioTracks = audioVideo.getAudioTracks();
+            const audioTracks = audioVideo.getAudioTracks();
             if (audioTracks.length) {
                 // eslint-disable-next-line new-cap
                 audioStream = new webkitMediaStream();
-                for (var i = 0; i < audioTracks.length; i++) {
+                for (let i = 0; i < audioTracks.length; i++) {
                     audioStream.addTrack(audioTracks[i]);
                 }
             }
 
-            var videoTracks = audioVideo.getVideoTracks();
+            const videoTracks = audioVideo.getVideoTracks();
             if (videoTracks.length) {
                 // eslint-disable-next-line new-cap
                 videoStream = new webkitMediaStream();
-                for (var j = 0; j < videoTracks.length; j++) {
+                for (let j = 0; j < videoTracks.length; j++) {
                     videoStream.addTrack(videoTracks[j]);
                 }
             }
  */
 function wrapAttachMediaStream(origAttachMediaStream) {
     return function(element, stream) {
-        var res = origAttachMediaStream.apply(rtcUtils, arguments);
+        const res = origAttachMediaStream.apply(rtcUtils, arguments);
 
         if (stream
                 && rtcUtils.isDeviceChangeAvailable('output')
                 && audioOutputChanged) {
             element.setSinkId(rtcUtils.getAudioOutputDevice())
                 .catch(function(ex) {
-                    var err = new JitsiTrackError(ex, null, ['audiooutput']);
+                    const err = new JitsiTrackError(ex, null, ['audiooutput']);
 
                     GlobalOnErrorHandler.callUnhandledRejectionHandler(
                         {promise: this, reason: err});
  */
 function defaultSetVideoSrc(element, stream) {
     // srcObject
-    var srcObjectPropertyName = 'srcObject';
+    let srcObjectPropertyName = 'srcObject';
     if (!(srcObjectPropertyName in element)) {
         srcObjectPropertyName = 'mozSrcObject';
         if (!(srcObjectPropertyName in element)) {
     }
 
     // src
-    var src;
+    let src;
     if (stream) {
         src = stream.jitsiObjectURL;
         // Save the created URL for stream so we can reuse it and not keep
 
         return new Promise(function(resolve, reject) {
             if (RTCBrowserType.isFirefox()) {
-                var FFversion = RTCBrowserType.getFirefoxVersion();
+                const FFversion = RTCBrowserType.getFirefoxVersion();
                 if (FFversion < 40) {
                     rejectWithWebRTCNotSupported(
                         `Firefox version too old: ${FFversion}.`
                     return element;
                 });
                 this.getStreamID = function(stream) {
-                    var id = stream.id;
+                    let id = stream.id;
                     if (!id) {
-                        var tracks = stream.getVideoTracks();
+                        let tracks = stream.getVideoTracks();
                         if (!tracks || tracks.length === 0) {
                             tracks = stream.getAudioTracks();
                         }
                     || RTCBrowserType.isReactNative()) {
 
                 this.peerconnection = webkitRTCPeerConnection;
-                var getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
+                const getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
                 if (navigator.mediaDevices) {
                     this.getUserMedia = wrapGetUserMedia(getUserMedia);
                     this.enumerateDevices = wrapEnumerateDevices(
                     // React Native at the time of this writing returns a number
                     // for the id of MediaStream. Let's just say that a number
                     // contains no special characters.
-                    var id = stream.id;
+                    const id = stream.id;
                     // XXX The return statement is affected by automatic
                     // semicolon insertion (ASI). No line terminator is allowed
                     // between the return keyword and the expression.
 
                             // The container must be visible in order to play or
                             // attach the stream when Temasys plugin is in use
-                            var containerSel = $(element);
+                            const containerSel = $(element);
                             if (RTCBrowserType.isTemasysPluginUsed()
                                     && !containerSel.is(':visible')) {
                                 containerSel.show();
                             }
-                            var video = !!stream.getVideoTracks().length;
+                            const video = !!stream.getVideoTracks().length;
                             if (video && !$(element).is(':visible')) {
                                 throw new Error(
                                     'video element must be visible to attach'
     **/
     getUserMediaWithConstraints(um, success_callback, failure_callback, options) {
         options = options || {};
-        var constraints = getConstraints(um, options);
+        const constraints = getConstraints(um, options);
 
         logger.info('Get media constraints', constraints);
 
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
     obtainAudioAndVideoPermissions(options) {
-        var self = this;
+        const self = this;
 
         options = options || {};
-        var dsOptions = options.desktopSharingExtensionExternalInstallation;
+        const dsOptions = options.desktopSharingExtensionExternalInstallation;
         return new Promise(function(resolve, reject) {
-            var successCallback = function(stream) {
+            const successCallback = function(stream) {
                 resolve(handleLocalStream(stream, options.resolution));
             };
 
                     // NSNumber as) a MediaStream ID.
                     || RTCBrowserType.isReactNative()
                     || RTCBrowserType.isTemasysPluginUsed()) {
-                var GUM = function(device, s, e) {
+                const GUM = function(device, s, e) {
                     this.getUserMediaWithConstraints(device, s, e, options);
                 };
 
-                var deviceGUM = {
+                const deviceGUM = {
                     'audio': GUM.bind(self, ['audio']),
                     'video': GUM.bind(self, ['video'])
                 };
                     deviceGUM
                 });
             } else {
-                var hasDesktop = options.devices.indexOf('desktop') > -1;
+                const hasDesktop = options.devices.indexOf('desktop') > -1;
                 if (hasDesktop) {
                     options.devices.splice(options.devices.indexOf('desktop'), 1);
                 }
                     this.getUserMediaWithConstraints(
                         options.devices,
                         function(stream) {
-                            var audioDeviceRequested = options.devices.indexOf('audio') !== -1;
-                            var videoDeviceRequested = options.devices.indexOf('video') !== -1;
-                            var audioTracksReceived = !!stream.getAudioTracks().length;
-                            var videoTracksReceived = !!stream.getVideoTracks().length;
+                            const audioDeviceRequested = options.devices.indexOf('audio') !== -1;
+                            const videoDeviceRequested = options.devices.indexOf('video') !== -1;
+                            const audioTracksReceived = !!stream.getAudioTracks().length;
+                            const videoTracksReceived = !!stream.getVideoTracks().length;
 
                             if((audioDeviceRequested && !audioTracksReceived)
                                 || (videoDeviceRequested && !videoTracksReceived)) {
                                 // didn't get corresponding MediaStreamTrack in
                                 // response stream. We don't know the reason why
                                 // this happened, so reject with general error.
-                                var devices = [];
+                                const devices = [];
 
                                 if (audioDeviceRequested && !audioTracksReceived) {
                                     devices.push('audio');
         }
 
         // if we have done createObjectURL, lets clean it
-        var url = mediaStream.jitsiObjectURL;
+        const url = mediaStream.jitsiObjectURL;
         if (url) {
             delete mediaStream.jitsiObjectURL;
             (URL || webkitURL).revokeObjectURL(url);
      * @returns {MediaDeviceInfo} device.
      */
     getEventDataForActiveDevice(device) {
-        var devices = [];
-        var deviceData = {
+        const devices = [];
+        const deviceData = {
             'deviceId': device.deviceId,
             'kind':     device.kind,
             'label':    device.label,

modules/RTC/ScreenObtainer.js

 /* global chrome, $, alert */
 
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var RTCBrowserType = require('./RTCBrowserType');
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const RTCBrowserType = require('./RTCBrowserType');
 import JitsiTrackError from '../../JitsiTrackError';
 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 
  * Indicates whether the Chrome desktop sharing extension is installed.
  * @type {boolean}
  */
-var chromeExtInstalled = false;
+let chromeExtInstalled = false;
 
 /**
  * Indicates whether an update of the Chrome desktop sharing extension is
  * required.
  * @type {boolean}
  */
-var chromeExtUpdateRequired = false;
+let chromeExtUpdateRequired = false;
 
 /**
  * Whether the jidesha extension for firefox is installed for the domain on
  * which we are running. Null designates an unknown value.
  * @type {null}
  */
-var firefoxExtInstalled = null;
+let firefoxExtInstalled = null;
 
 /**
  * If set to true, detection of an installed firefox extension will be started
  * again the next time obtainScreenOnFirefox is called (e.g. next time the
  * user tries to enable screen sharing).
  */
-var reDetectFirefoxExtension = false;
+let reDetectFirefoxExtension = false;
 
-var gumFunction = null;
+let gumFunction = null;
 
 /**
  * The error returned by chrome when trying to start inline installation from
 /**
  * Handles obtaining a stream from a screen capture on different browsers.
  */
-var ScreenObtainer = {
+const ScreenObtainer = {
     obtainStream: null,
 
     /**
      * @param gum {Function} GUM method
      */
     init(options, gum) {
-        var obtainDesktopStream = null;
+        let obtainDesktopStream = null;
         this.options = options = options || {};
         gumFunction = gum;
 
                 window.JitsiMeetNW.obtainDesktopStream(
                     onSuccess,
                     (error, constraints) => {
-                        var jitsiError;
+                        let jitsiError;
                         // FIXME:
                         // This is very very durty fix for recognising that the
                         // user have clicked the cancel button from the Desktop
      * @param errorCallback
      */
     obtainScreenOnFirefox(options, callback, errorCallback) {
-        var extensionRequired = false;
+        let extensionRequired = false;
         const { desktopSharingFirefoxMaxVersionExtRequired } = this.options;
         if (desktopSharingFirefoxMaxVersionExtRequired === -1
             || (desktopSharingFirefoxMaxVersionExtRequired >= 0
  */
 function isUpdateRequired(minVersion, extVersion) {
     try {
-        var s1 = minVersion.split('.');
-        var s2 = extVersion.split('.');
+        const s1 = minVersion.split('.');
+        const s2 = extVersion.split('.');
 
-        var len = Math.max(s1.length, s2.length);
-        for (var i = 0; i < len; i++) {
-            var n1 = 0,
+        const len = Math.max(s1.length, s2.length);
+        for (let i = 0; i < len; i++) {
+            let n1 = 0,
                 n2 = 0;
 
             if (i < s1.length) {
                 return;
             }
             // Check installed extension version
-            var extVersion = response.version;
+            const extVersion = response.version;
             logger.log('Extension version is: ' + extVersion);
-            var updateRequired
+            const updateRequired
                 = isUpdateRequired(
                     options.desktopSharingChromeMinExtVersion,
                     extVersion);
         response => {
             if (!response) {
                 // possibly re-wraping error message to make code consistent
-                var lastError = chrome.runtime.lastError;
+                const lastError = chrome.runtime.lastError;
                 failCallback(lastError instanceof Error
                     ? lastError
                     : new JitsiTrackError(
         return;
     }
 
-    var img = document.createElement('img');
+    const img = document.createElement('img');
     img.onload = () => {
         logger.log('Detected firefox screen sharing extension.');
         firefoxExtInstalled = true;
     // "chrome://EXT_ID/content/DOMAIN.png"
     // Where EXT_ID is the ID of the extension with "@" replaced by ".", and
     // DOMAIN is a domain whitelisted by the extension.
-    var src = 'chrome://'
+    const src = 'chrome://'
         + options.desktopSharingFirefoxExtId.replace('@', '.')
         + '/content/' + document.location.hostname + '.png';
     img.setAttribute('src', src);

modules/RTC/TraceablePeerConnection.js

  */
 function TraceablePeerConnection(rtc, id, signalingLayer, ice_config,
                                  constraints, options) {
-    var self = this;
+    const self = this;
     /**
      * The parent instance of RTC service which created this
      * <tt>TracablePeerConnection</tt>.
      */
     this.signalingLayer = signalingLayer;
     this.options = options;
-    var RTCPeerConnectionType = null;
+    let RTCPeerConnectionType = null;
     if (RTCBrowserType.isFirefox()) {
         RTCPeerConnectionType = mozRTCPeerConnection;
     } else if (RTCBrowserType.isTemasysPluginUsed()) {
      * @type {number}
      */
     this.maxstats = 0;
-    var Interop = require('sdp-interop').Interop;
+    const Interop = require('sdp-interop').Interop;
     this.interop = new Interop();
-    var Simulcast = require('sdp-simulcast');
+    const Simulcast = require('sdp-simulcast');
     this.simulcast = new Simulcast({numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false});
     this.sdpConsistency = new SdpConsistency();
     if (!RTCBrowserType.isFirefox() && this.maxstats) {
         this.statsinterval = window.setInterval(function() {
             self.peerconnection.getStats(function(stats) {
-                var results = stats.result();
-                var now = new Date();
-                for (var i = 0; i < results.length; ++i) {
+                const results = stats.result();
+                const now = new Date();
+                for (let i = 0; i < results.length; ++i) {
                     results[i].names().forEach(function(name) {
-                        var id = results[i].id + '-' + name;
+                        const id = results[i].id + '-' + name;
                         if (!self.stats[id]) {
                             self.stats[id] = {
                                 startTime: now,
 /**
  * Returns a string representation of a SessionDescription object.
  */
-var dumpSDP = function(description) {
+const dumpSDP = function(description) {
     if (typeof description === 'undefined' || description == null) {
         return '';
     }
  * Takes a SessionDescription object and returns a "normalized" version.
  * Currently it only takes care of ordering the a=ssrc lines.
  */
-var normalizePlanB = function(desc) {
+const normalizePlanB = function(desc) {
     if (typeof desc !== 'object' || desc === null
         || typeof desc.sdp !== 'string') {
         logger.warn('An empty description was passed as an argument.');
         return desc;
     }
 
-    var transform = require('sdp-transform');
-    var session = transform.parse(desc.sdp);
+    const transform = require('sdp-transform');
+    const session = transform.parse(desc.sdp);
 
     if (typeof session !== 'undefined'
         && typeof session.media !== 'undefined' && Array.isArray(session.media)) {
             // the "a=ssrc:S1" lines, SRD fails.
             // So, put SSRC which appear as the first SSRC in an FID ssrc-group
             // first.
-            var firstSsrcs = [];
-            var newSsrcLines = [];
+            const firstSsrcs = [];
+            const newSsrcLines = [];
 
             if (typeof mLine.ssrcGroups !== 'undefined'
                 && Array.isArray(mLine.ssrcGroups)) {
             }
 
             if (Array.isArray(mLine.ssrcs)) {
-                var i;
+                let i;
                 for (i = 0; i < mLine.ssrcs.length; i++) {
                     if (typeof mLine.ssrcs[i] === 'object'
                         && typeof mLine.ssrcs[i].id !== 'undefined'
         });
     }
 
-    var resStr = transform.write(session);
+    const resStr = transform.write(session);
     return new RTCSessionDescription({
         type: desc.type,
         sdp: resStr
     });
 };
 
-var getters = {
+const getters = {
     signalingState() {
         return this.peerconnection.signalingState;
     },
         return this.peerconnection.iceConnectionState;
     },
     localDescription() {
-        var desc = this.peerconnection.localDescription;
+        let desc = this.peerconnection.localDescription;
 
         this.trace('getLocalDescription::preTransform', dumpSDP(desc));
 
         return desc;
     },
     remoteDescription() {
-        var desc = this.peerconnection.remoteDescription;
+        let desc = this.peerconnection.remoteDescription;
         this.trace('getRemoteDescription::preTransform', dumpSDP(desc));
 
         // if we're running on FF, transform to Plan B first.
             dumpSDP(description));
             }
 
-            var self = this;
+            const self = this;
             this.peerconnection.setLocalDescription(description,
         function() {
             self.trace('setLocalDescriptionOnSuccess');
                 description = normalizePlanB(description);
             }
 
-            var self = this;
+            const self = this;
             this.peerconnection.setRemoteDescription(description,
         function() {
             self.trace('setRemoteDescriptionOnSuccess');
  * @param {SDP} answer - the SDP to modify
  * @private
  */
-var _fixAnswerRFC4145Setup = function(offer, answer) {
+const _fixAnswerRFC4145Setup = function(offer, answer) {
     if (!RTCBrowserType.isChrome()) {
         // It looks like Firefox doesn't agree with the fix (at least in its
         // current implementation) because it effectively remains active even

modules/connectivity/ConnectionQuality.js

 import {getLogger} from 'jitsi-meet-logger';
 import RTCBrowserType from '../RTC/RTCBrowserType';
 
-var XMPPEvents = require('../../service/xmpp/XMPPEvents');
-var VideoType = require('../../service/RTC/VideoType');
-var Resolutions = require('../../service/RTC/Resolutions');
+const XMPPEvents = require('../../service/xmpp/XMPPEvents');
+const VideoType = require('../../service/RTC/VideoType');
+const Resolutions = require('../../service/RTC/Resolutions');
 
 const logger = getLogger(__filename);
 
 /**
  * The initial bitrate for video in kbps.
  */
-var startBitrate = 800;
+let startBitrate = 800;
 
 /**
  * Gets the expected bitrate (in kbps) in perfect network conditions.

modules/settings/Settings.js

         this.userId;
         this.callStatsUserName;
 
-        var localStorage = getLocalStorage();
+        const localStorage = getLocalStorage();
         if (localStorage) {
             this.userId
                 = localStorage.getItem('jitsiMeetId') || generateJitsiMeetId();
      * Save settings to localStorage if browser supports that.
      */
     save() {
-        var localStorage = getLocalStorage();
+        const localStorage = getLocalStorage();
         if (localStorage) {
             localStorage.setItem('jitsiMeetId', this.userId);
             localStorage.setItem('callStatsUserName', this.callStatsUserName);

modules/statistics/CallStats.js

 /* global $, Strophe, callstats */
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 import Settings from '../settings/Settings';
 
-var jsSHA = require('jssha');
-var io = require('socket.io-client');
+const jsSHA = require('jssha');
+const io = require('socket.io-client');
 
 /**
  * We define enumeration of wrtcFuncNames as we need them before
  * @const
  * @see http://www.callstats.io/api/#enumeration-of-wrtcfuncnames
  */
-var wrtcFuncNames = {
+const wrtcFuncNames = {
     createOffer:          'createOffer',
     createAnswer:         'createAnswer',
     setLocalDescription:  'setLocalDescription',
  * @const
  * @see http://www.callstats.io/api/#enumeration-of-fabricevent
  */
-var fabricEvent = {
+const fabricEvent = {
     fabricHold:'fabricHold',
     fabricResume:'fabricResume',
     audioMute:'audioMute',
     activeDeviceList:'activeDeviceList'
 };
 
-var callStats = null;
+let callStats = null;
 
 /**
  * The user id to report to callstats as destination.
         return;
     }
 
-    var ret = callStats.addNewFabric(this.peerconnection,
+    const ret = callStats.addNewFabric(this.peerconnection,
         DEFAULT_REMOTE_USER,
         callStats.fabricUsage.multiplex,
         this.confID,
         this.pcCallback.bind(this));
 
-    var fabricInitialized = ret.status === 'success';
+    const fabricInitialized = ret.status === 'success';
 
     if(!fabricInitialized) {
         CallStats.initializeFailed = true;
     if (CallStats.reportsQueue.length) {
         CallStats.reportsQueue.forEach(function(report) {
             if (report.type === reportType.ERROR) {
-                var error = report.data;
+                const error = report.data;
                 CallStats._reportError.call(this, error.type, error.error,
                     error.pc);
             } else if (report.type === reportType.EVENT
                 && fabricInitialized) {
                 // if we have and event to report and we failed to add fabric
                 // this event will not be reported anyway, returning an error
-                var eventData = report.data;
+                const eventData = report.data;
                 callStats.sendFabricEvent(
                     this.peerconnection,
                     eventData.event,
                     this.confID,
                     eventData.eventData);
             } else if (report.type === reportType.MST_WITH_USERID) {
-                var data = report.data;
+                const data = report.data;
                 callStats.associateMstWithUserID(
                     this.peerconnection,
                     data.callStatsId,
  * @param peerConnection {JingleSessionPC} the session object
  * @param options {object} credentials for callstats.
  */
-var CallStats = _try_catch(function(jingleSession, options) {
+const CallStats = _try_catch(function(jingleSession, options) {
     try{
         CallStats.feedbackEnabled = false;
         callStats = new callstats($, io, jsSHA); // eslint-disable-line new-cap
  * Type of pending reports, can be event or an error.
  * @type {{ERROR: string, EVENT: string}}
  */
-var reportType = {
+const reportType = {
     ERROR: 'error',
     EVENT: 'event',
     MST_WITH_USERID: 'mstWithUserID'

modules/statistics/LocalStatsCollector.js

  * Provides statistics for the local stream.
  */
 
-var RTCBrowserType = require('../RTC/RTCBrowserType');
+const RTCBrowserType = require('../RTC/RTCBrowserType');
 
 /**
  * Size of the webaudio analyzer buffer.
  * @type {number}
  */
-var WEBAUDIO_ANALYZER_FFT_SIZE = 2048;
+const WEBAUDIO_ANALYZER_FFT_SIZE = 2048;
 
 /**
  * Value of the webaudio analyzer smoothing time parameter.
  * @type {number}
  */
-var WEBAUDIO_ANALYZER_SMOOTING_TIME = 0.8;
+const WEBAUDIO_ANALYZER_SMOOTING_TIME = 0.8;
 
 window.AudioContext = window.AudioContext || window.webkitAudioContext;
 
-var context = null;
+let context = null;
 
 if(window.AudioContext) {
     context = new AudioContext();
  */
 function timeDomainDataToAudioLevel(samples) {
 
-    var maxVolume = 0;
+    let maxVolume = 0;
 
-    var length = samples.length;
+    const length = samples.length;
 
-    for (var i = 0; i < length; i++) {
+    for (let i = 0; i < length; i++) {
         if (maxVolume < samples[i]) {
             maxVolume = samples[i];
         }
  * @returns {Number} the audio level to be set
  */
 function animateLevel(newLevel, lastLevel) {
-    var value = 0;
-    var diff = lastLevel - newLevel;
+    let value = 0;
+    const diff = lastLevel - newLevel;
     if(diff > 0.2) {
         value = lastLevel - 0.2;
     } else if(diff < -0.4) {
         return;
     }
     context.resume();
-    var analyser = context.createAnalyser();
+    const analyser = context.createAnalyser();
     analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;
     analyser.fftSize = WEBAUDIO_ANALYZER_FFT_SIZE;
 
-    var source = context.createMediaStreamSource(this.stream);
+    const source = context.createMediaStreamSource(this.stream);
     source.connect(analyser);
 
 
-    var self = this;
+    const self = this;
 
     this.intervalId = setInterval(
         function() {
-            var array = new Uint8Array(analyser.frequencyBinCount);
+            const array = new Uint8Array(analyser.frequencyBinCount);
             analyser.getByteTimeDomainData(array);
-            var audioLevel = timeDomainDataToAudioLevel(array);
+            const audioLevel = timeDomainDataToAudioLevel(array);
             if (audioLevel != self.audioLevel) {
                 self.audioLevel = animateLevel(audioLevel, self.audioLevel);
                 self.callback(self.audioLevel);

modules/statistics/RTPStatsCollector.js

 /* global require */
 
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var RTCBrowserType = require('../RTC/RTCBrowserType');
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const RTCBrowserType = require('../RTC/RTCBrowserType');
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 /* Whether we support the browser we are running into for logging statistics */
-var browserSupported = RTCBrowserType.isChrome()
+const browserSupported = RTCBrowserType.isChrome()
         || RTCBrowserType.isOpera() || RTCBrowserType.isFirefox()
         || RTCBrowserType.isNWJS() || RTCBrowserType.isElectron();
 
  * The LibJitsiMeet browser-agnostic names of the browser-specific keys reported
  * by RTCPeerConnection#getStats mapped by RTCBrowserType.
  */
-var KEYS_BY_BROWSER_TYPE = {};
+const KEYS_BY_BROWSER_TYPE = {};
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
     'ssrc': 'ssrc',
     'packetsReceived': 'packetsReceived',
      * @private
      */
     this._browserType = RTCBrowserType.getBrowserType();
-    var keys = KEYS_BY_BROWSER_TYPE[this._browserType];
+    const keys = KEYS_BY_BROWSER_TYPE[this._browserType];
     if (!keys) {
         throw 'The browser type \'' + this._browserType + '\' isn\'t supported!';
     }
  * Starts stats updates.
  */
 StatsCollector.prototype.start = function(startAudioLevelStats) {
-    var self = this;
+    const self = this;
     if(startAudioLevelStats) {
         this.audioLevelsIntervalId = setInterval(
             function() {
                 // Interval updates
                 self.peerconnection.getStats(
                     function(report) {
-                        var results = null;
+                        let results = null;
                         if (!report || !report.result
                             || typeof report.result != 'function') {
                             results = report;
                 // Interval updates
                 self.peerconnection.getStats(
                     function(report) {
-                        var results = null;
+                        let results = null;
                         if (!report || !report.result
                             || typeof report.result != 'function') {
                             // firefox
     // Define the function which converts a LibJitsiMeet browser-asnostic name
     // to a browser-specific key of a report returned by
     // RTCPeerConnection#getStats.
-    var keyFromName = function(name) {
-        var key = keys[name];
+    const keyFromName = function(name) {
+        const key = keys[name];
         if (key) {
             return key;
         }
     // Define the function which retrieves the value from a specific report
     // returned by RTCPeerConnection#getStats associated with a given
     // browser-specific key.
-    var itemStatByKey;
+    let itemStatByKey;
     switch (this._browserType) {
     case RTCBrowserType.RTC_BROWSER_CHROME:
     case RTCBrowserType.RTC_BROWSER_OPERA:
         // Objective-C WebRTC API: RTCStatsReport has a values property of type
         // Array in which each element is a key-value pair.
         itemStatByKey = function(item, key) {
-            var value;
+            let value;
             item.values.some(function(pair) {
                 if (pair.hasOwnProperty(key)) {
                     value = pair[key];
         return;
     }
 
-    var getStatValue = this._getStatValue;
+    const getStatValue = this._getStatValue;
     function getNonNegativeStat(report, name) {
-        var value = getStatValue(report, name);
+        let value = getStatValue(report, name);
         if (typeof value !== 'number') {
             value = Number(value);
         }
 
         return Math.max(0, value);
     }
-    var byteSentStats = {};
+    const byteSentStats = {};
 
-    for (var idx in this.currentStatsReport) {
+    for (const idx in this.currentStatsReport) {
         if(!this.currentStatsReport.hasOwnProperty(idx)) {
             continue;
         }
-        var now = this.currentStatsReport[idx];
+        const now = this.currentStatsReport[idx];
         try {
-            var receiveBandwidth = getStatValue(now, 'receiveBandwidth');
-            var sendBandwidth = getStatValue(now, 'sendBandwidth');
+            const receiveBandwidth = getStatValue(now, 'receiveBandwidth');
+            const sendBandwidth = getStatValue(now, 'sendBandwidth');
             if (receiveBandwidth || sendBandwidth) {
                 this.conferenceStats.bandwidth = {
                     'download': Math.round(receiveBandwidth / 1000),
         } catch(e) {/* not supported*/}
 
         if(now.type == 'googCandidatePair') {
-            var active, ip, localip, type;
+            let active, ip, localip, type;
             try {
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, 'transportType');
                 continue;
             }
             // Save the address unless it has been saved already.
-            var conferenceStatsTransport = this.conferenceStats.transport;
+            const conferenceStatsTransport = this.conferenceStats.transport;
             if(!conferenceStatsTransport.some(
                     t =>
                         t.ip == ip && t.type == type && t.localip == localip)) {
                 continue;
             }
 
-            var local = this.currentStatsReport[now.localCandidateId];
-            var remote = this.currentStatsReport[now.remoteCandidateId];
+            const local = this.currentStatsReport[now.localCandidateId];
+            const remote = this.currentStatsReport[now.remoteCandidateId];
             this.conferenceStats.transport.push({
                 ip: remote.ipAddress + ':' + remote.portNumber,
                 type: local.transport,
             continue;
         }
 
-        var before = this.previousStatsReport[idx];
-        var ssrc = getStatValue(now, 'ssrc');
+        const before = this.previousStatsReport[idx];
+        const ssrc = getStatValue(now, 'ssrc');
         if (!before || !ssrc) {
             continue;
         }
 
-        var ssrcStats
+        const ssrcStats
           = this.ssrc2stats[ssrc] || (this.ssrc2stats[ssrc] = new SsrcStats());
 
-        var isDownloadStream = true;
-        var key = 'packetsReceived';
-        var packetsNow = getStatValue(now, key);
+        let isDownloadStream = true;
+        let key = 'packetsReceived';
+        let packetsNow = getStatValue(now, key);
         if (typeof packetsNow === 'undefined'
             || packetsNow === null || packetsNow === '') {
             isDownloadStream = false;
             packetsNow = 0;
         }
 
-        var packetsBefore = getNonNegativeStat(before, key);
-        var packetsDiff = Math.max(0, packetsNow - packetsBefore);
+        const packetsBefore = getNonNegativeStat(before, key);
+        const packetsDiff = Math.max(0, packetsNow - packetsBefore);
 
-        var packetsLostNow = getNonNegativeStat(now, 'packetsLost');
-        var packetsLostBefore = getNonNegativeStat(before, 'packetsLost');
-        var packetsLostDiff = Math.max(0, packetsLostNow - packetsLostBefore);
+        const packetsLostNow = getNonNegativeStat(now, 'packetsLost');
+        const packetsLostBefore = getNonNegativeStat(before, 'packetsLost');
+        const packetsLostDiff = Math.max(0, packetsLostNow - packetsLostBefore);
 
         ssrcStats.setLoss({
             packetsTotal: packetsDiff + packetsLostDiff,
             isDownloadStream
         });
 
-        var bytesReceivedNow = getNonNegativeStat(now, 'bytesReceived');
-        var bytesReceivedBefore = getNonNegativeStat(before, 'bytesReceived');
-        var bytesReceived = Math.max(0, bytesReceivedNow - bytesReceivedBefore);
+        const bytesReceivedNow = getNonNegativeStat(now, 'bytesReceived');
+        const bytesReceivedBefore = getNonNegativeStat(before, 'bytesReceived');
+        const bytesReceived = Math.max(0, bytesReceivedNow - bytesReceivedBefore);
 
-        var bytesSent = 0;
+        let bytesSent = 0;
 
         // TODO: clean this mess up!
-        var nowBytesTransmitted = getStatValue(now, 'bytesSent');
+        let nowBytesTransmitted = getStatValue(now, 'bytesSent');
         if(typeof nowBytesTransmitted === 'number'
             || typeof nowBytesTransmitted === 'string') {
             nowBytesTransmitted = Number(nowBytesTransmitted);
         }
         bytesSent = Math.max(0, bytesSent);
 
-        var timeMs = now.timestamp - before.timestamp;
-        var bitrateReceivedKbps = 0, bitrateSentKbps = 0;
+        const timeMs = now.timestamp - before.timestamp;
+        let bitrateReceivedKbps = 0, bitrateSentKbps = 0;
         if (timeMs > 0) {
             // TODO is there any reason to round here?
             bitrateReceivedKbps = Math.round((bytesReceived * 8) / timeMs);
             'upload': bitrateSentKbps
         });
 
-        var resolution = {height: null, width: null};
+        const resolution = {height: null, width: null};
         try {
-            var height, width;
+            let height, width;
             if ((height = getStatValue(now, 'googFrameHeightReceived'))
                 && (width = getStatValue(now, 'googFrameWidthReceived'))) {
                 resolution.height = height;
     }
 
     // process stats
-    var totalPackets = {
+    const totalPackets = {
         download: 0,
         upload: 0
     };
-    var lostPackets = {
+    const lostPackets = {
         download: 0,
         upload: 0
     };
-    var bitrateDownload = 0;
-    var bitrateUpload = 0;
-    var resolutions = {};
+    let bitrateDownload = 0;
+    let bitrateUpload = 0;
+    const resolutions = {};
     Object.keys(this.ssrc2stats).forEach(
         function(ssrc) {
-            var ssrcStats = this.ssrc2stats[ssrc];
+            const ssrcStats = this.ssrc2stats[ssrc];
             // process packet loss stats
-            var loss = ssrcStats.loss;
-            var type = loss.isDownloadStream ? 'download' : 'upload';
+            const loss = ssrcStats.loss;
+            const type = loss.isDownloadStream ? 'download' : 'upload';
             totalPackets[type] += loss.packetsTotal;
             lostPackets[type] += loss.packetsLost;
 
         return;
     }
 
-    var getStatValue = this._getStatValue;
+    const getStatValue = this._getStatValue;
 
-    for(var idx in this.currentAudioLevelsReport) {
+    for(const idx in this.currentAudioLevelsReport) {
         if(!this.currentAudioLevelsReport.hasOwnProperty(idx)) {
             continue;
         }
-        var now = this.currentAudioLevelsReport[idx];
+        const now = this.currentAudioLevelsReport[idx];
 
         if (now.type != 'ssrc') {
             continue;
         }
 
-        var before = this.baselineAudioLevelsReport[idx];
-        var ssrc = getStatValue(now, 'ssrc');
+        const before = this.baselineAudioLevelsReport[idx];
+        const ssrc = getStatValue(now, 'ssrc');
         if (!before) {
             logger.warn(ssrc + ' not enough data');
             continue;
         }
 
         // Audio level
+        let audioLevel;
+
         try {
-            var audioLevel
+            audioLevel
                 = getStatValue(now, 'audioInputLevel')
                     || getStatValue(now, 'audioOutputLevel');
         } catch(e) {/* not supported*/

modules/statistics/statistics.js

 /* global require */
 import analytics from './AnalyticsAdapter';
-var CallStats = require('./CallStats');
-var EventEmitter = require('events');
+const CallStats = require('./CallStats');
+const EventEmitter = require('events');
 import JitsiTrackError from '../../JitsiTrackError';
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var LocalStats = require('./LocalStatsCollector.js');
-var RTPStats = require('./RTPStatsCollector.js');
-var ScriptUtil = require('../util/ScriptUtil');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const LocalStats = require('./LocalStatsCollector.js');
+const RTPStats = require('./RTPStatsCollector.js');
+const ScriptUtil = require('../util/ScriptUtil');
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 /**
  * True if callstats API is loaded
  */
-var isCallstatsLoaded = false;
+let isCallstatsLoaded = false;
 
 // Since callstats.io is a third party, we cannot guarantee the quality of their
 // service. More specifically, their server may take noticeably long time to
  * @param {JitsiTrackError} error
  */
 function formatJitsiTrackErrorForCallStats(error) {
-    var err = new Error();
+    const err = new Error();
 
     // Just copy original stack from error
     err.stack = error.stack;
     if(!Statistics.audioLevelsEnabled) {
         return;
     }
-    var localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
+    const localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
         callback);
     this.localStats.push(localStats);
     localStats.start();
         return;
     }
 
-    for(var i = 0; i < Statistics.localStats.length; i++) {
+    for(let i = 0; i < Statistics.localStats.length; i++) {
         if(Statistics.localStats[i].stream === stream) {
-            var localStats = Statistics.localStats.splice(i, 1);
+            const localStats = Statistics.localStats.splice(i, 1);
             localStats[0].stop();
             break;
         }
  */
 Statistics.prototype.stopCallStats = function() {
     if(this.callStatsStarted) {
-        var index = Statistics.callsStatsInstances.indexOf(this.callstats);
+        const index = Statistics.callsStatsInstances.indexOf(this.callstats);
         if(index > -1) {
             Statistics.callsStatsInstances.splice(index, 1);
         }

modules/transcription/audioRecorder.js

 /* global MediaRecorder, MediaStream, webkitMediaStream */
 
-var RecordingResult = require('./recordingResult');
+const RecordingResult = require('./recordingResult');
 
 /**
  * Possible audio formats MIME types
  */
-var AUDIO_WEBM = 'audio/webm';    // Supported in chrome
-var AUDIO_OGG = 'audio/ogg';     // Supported in firefox
+const AUDIO_WEBM = 'audio/webm';    // Supported in chrome
+const AUDIO_OGG = 'audio/ogg';     // Supported in firefox
 
 /**
  * A TrackRecorder object holds all the information needed for recording a
  * single JitsiTrack (either remote or local)
  * @param track The JitsiTrack the object is going to hold
  */
-var TrackRecorder = function(track) {
+const TrackRecorder = function(track) {
     // The JitsiTrack holding the stream
     this.track = track;
     // The MediaRecorder recording the stream
  * @param track the JitsiTrack holding the audio MediaStream(s)
  */
 function instantiateTrackRecorder(track) {
-    var trackRecorder = new TrackRecorder(track);
+    const trackRecorder = new TrackRecorder(track);
     // Create a new stream which only holds the audio track
-    var originalStream = trackRecorder.track.getOriginalStream();
-    var stream = createEmptyStream();
+    const originalStream = trackRecorder.track.getOriginalStream();
+    const stream = createEmptyStream();
     originalStream.getAudioTracks().forEach(function(track) {
         stream.addTrack(track);
     });
  * @param jitsiConference the jitsiConference which this object
  * is going to record
  */
-var audioRecorder = function(jitsiConference) {
+const audioRecorder = function(jitsiConference) {
     // array of TrackRecorders, where each trackRecorder
     // holds the JitsiTrack, MediaRecorder and recorder data
     this.recorders = [];
 audioRecorder.prototype.addTrack = function(track) {
     if(track.isAudioTrack()) {
         // create the track recorder
-        var trackRecorder = instantiateTrackRecorder(track);
+        const trackRecorder = instantiateTrackRecorder(track);
         // push it to the local array of all recorders
         this.recorders.push(trackRecorder);
         // update the name of the trackRecorders
         return;
     }
 
-    var array = this.recorders;
-    var i;
+    const array = this.recorders;
+    let i;
     for(i = 0; i < array.length; i++) {
         if(array[i].track.getParticipantId() === track.getParticipantId()) {
-            var recorderToRemove = array[i];
+            const recorderToRemove = array[i];
             if(this.isRecording) {
                 stopRecorder(recorderToRemove);
             } else {
  * undefined value, the old value will also be kept.
  */
 audioRecorder.prototype.updateNames = function() {
-    var conference = this.jitsiConference;
+    const conference = this.jitsiConference;
     this.recorders.forEach(function(trackRecorder) {
         if(trackRecorder.track.isLocal()) {
             trackRecorder.name = 'the transcriber';
         } else {
-            var id = trackRecorder.track.getParticipantId();
-            var participant = conference.getParticipantById(id);
-            var newName = participant.getDisplayName();
+            const id = trackRecorder.track.getParticipantId();
+            const participant = conference.getParticipantById(id);
+            const newName = participant.getDisplayName();
             if(newName !== 'undefined') {
                 trackRecorder.name = newName;
             }
  * link hacking to download all recorded audio streams
  */
 audioRecorder.prototype.download = function() {
-    var t = this;
+    const t = this;
     this.recorders.forEach(function(trackRecorder) {
-        var blob = new Blob(trackRecorder.data, {type: t.fileType});
-        var url = URL.createObjectURL(blob);
-        var a = document.createElement('a');
+        const blob = new Blob(trackRecorder.data, {type: t.fileType});
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
         document.body.appendChild(a);
         a.style = 'display: none';
         a.href = url;
     // make sure the names are up to date before sending them off
     this.updateNames();
 
-    var array = [];
-    var t = this;
+    const array = [];
+    const t = this;
     this.recorders.forEach(function(recorder) {
         array.push(
             new RecordingResult(

modules/transcription/recordingResult.js

  * @param wordArray the recorder audio stream transcribed as an array of Word
  *                  objects
  */
-var RecordingResult = function(blob, name, startTime, wordArray) {
+const RecordingResult = function(blob, name, startTime, wordArray) {
     this.blob = blob;
     this.name = name;
     this.startTime = startTime;

modules/transcription/transcriber.js

-var AudioRecorder = require('./audioRecorder');
-var SphinxService = require(
+const AudioRecorder = require('./audioRecorder');
+const SphinxService = require(
     './transcriptionServices/SphinxTranscriptionService');
 
-var BEFORE_STATE = 'before';
-var RECORDING_STATE = 'recording';
-var TRANSCRIBING_STATE = 'transcribing';
-var FINISHED_STATE = 'finished';
+const BEFORE_STATE = 'before';
+const RECORDING_STATE = 'recording';
+const TRANSCRIBING_STATE = 'transcribing';
+const FINISHED_STATE = 'finished';
 
 // the amount of characters each line in the transcription will have
-var MAXIMUM_SENTENCE_LENGTH = 80;
+const MAXIMUM_SENTENCE_LENGTH = 80;
 
 /**
  * This is the main object for handing the Transcription. It interacts with
  * will be merged to create a transcript
  * @param {AudioRecorder} audioRecorder An audioRecorder recording a conference
  */
-var transcriber = function() {
+const transcriber = function() {
     // the object which can record all audio in the conference
     this.audioRecorder = new AudioRecorder();
     // this object can send the recorder audio to a speech-to-text service
     console.log('stopping recording and sending audio files');
     this.audioRecorder.stop();
     // and send all recorded audio the the transcription service
-    var t = this;
+    const t = this;
 
-    var callBack = blobCallBack.bind(this);
+    const callBack = blobCallBack.bind(this);
     this.audioRecorder.getRecordingResults().forEach(function(recordingResult) {
         t.transcriptionService.send(recordingResult, callBack);
         t.counter++;
  * @param {RecordingResult} answer a RecordingResult object with a defined
  * WordArray
  */
-var blobCallBack = function(answer) {
+const blobCallBack = function(answer) {
     console.log(
         'retrieved an answer from the transcription service. The answer has an'
             + ' array of length: ' + answer.wordArray.length);
     // first add the offset between the start of the transcription and
     // the start of the recording to all start and end times
     if(answer.wordArray.length > 0) {
-        var offset = answer.startTime.getUTCMilliseconds()
+        let offset = answer.startTime.getUTCMilliseconds()
             - this.startTime.getUTCMilliseconds();
         // transcriber time will always be earlier
         if (offset < 0) {
             offset = 0; // presume 0 if it somehow not earlier
         }
 
-        var array = '[';
+        let array = '[';
         answer.wordArray.forEach(function(wordObject) {
             wordObject.begin += offset;
             wordObject.end += offset;
     // previously placed word, while removing the selected word from its array
     // note: words can be skipped the skipped word's begin and end time somehow
     // end up between the closest word start and end time
-    var arrays = this.results;
+    const arrays = this.results;
     // arrays of Word objects
-    var potentialWords = []; // array of the first Word objects
+    const potentialWords = []; // array of the first Word objects
     // check if any arrays are already empty and remove them
     hasPopulatedArrays(arrays);
 
     });
 
     // keep adding words to transcription until all arrays are exhausted
-    var lowestWordArray;
-    var wordToAdd;
-    var foundSmaller;
+    let lowestWordArray;
+    let wordToAdd;
+    let foundSmaller;
     while(hasPopulatedArrays(arrays)) {
         // first select the lowest array;
         lowestWordArray = arrays[0];
  * @param {Array<Array>} twoDimensionalArray the array to check
  * @returns {boolean} true if any non-zero arrays inside, otherwise false
  */
-var hasPopulatedArrays = function(twoDimensionalArray) {
-    var i;
+const hasPopulatedArrays = function(twoDimensionalArray) {
+    let i;
     for(i = 0; i < twoDimensionalArray.length; i++) {
         if(twoDimensionalArray[i].length === 0) {
             twoDimensionalArray.splice(i, 1);
  * @param {Array<Word>} array the sorted array to push to
  * @param {Word} word the word to push into the array
  */
-var pushWordToSortedArray = function(array, word) {
+const pushWordToSortedArray = function(array, word) {
     if(array.length === 0) {
         array.push(word);
     } else{
             array.push(word);
             return;
         }
-        var i;
+        let i;
         for(i = 0; i < array.length; i++) {
             if(word.begin < array[i].begin) {
                 array.splice(i, 0, word);

modules/transcription/transcriberHolder.js

  * This is probably temporary until there is a better way to expose the
  * Transcriber in a conference
  */
-var transcriberHolder = {
+const transcriberHolder = {
     transcribers : [],
 
     add(transcriber) {

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

  * Abstract class representing an interface to implement a speech-to-text
  * service on.
  */
-var TranscriptionService = function() {
+const TranscriptionService = function() {
     throw new Error('TranscriptionService is abstract and cannot be'
         + 'created');
 };
  *        the answer as a WordArray
  */
 TranscriptionService.prototype.send = function send(recordingResult, callback) {
-    var t = this;
+    const t = this;
     this.sendRequest(recordingResult.blob, function(response) {
         if(!t.verify(response)) {
             console.log('the retrieved response from the server'

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

 /* global config */
 
-var TranscriptionService = require('./AbstractTranscriptionService');
-var Word = require('../word');
-var audioRecorder = require('./../audioRecorder');
+const TranscriptionService = require('./AbstractTranscriptionService');
+const Word = require('../word');
+const audioRecorder = require('./../audioRecorder');
 
 /**
  * Implements a TranscriptionService for a Sphinx4 http server
  */
-var SphinxService = function() {
+const SphinxService = function() {
     // set the correct url
     this.url = getURL();
 };
 SphinxService.prototype.sendRequest = function(audioFileBlob, callback) {
     console.log('sending an audio file  to ' + this.url);
     console.log('the audio file being sent: ' + audioFileBlob);
-    var request = new XMLHttpRequest();
+    const request = new XMLHttpRequest();
     request.onreadystatechange = function() {
         if(request.readyState === XMLHttpRequest.DONE
             && request.status === 200) {
  * @param response the JSON body retrieved from the Sphinx4 server
  */
 SphinxService.prototype.formatResponse = function(response) {
-    var result = JSON.parse(response).objects;
+    const result = JSON.parse(response).objects;
     // make sure to delete the session id object, which is always
     // the first value in the JSON array
     result.shift();
-    var array = [];
+    const array = [];
     result.forEach(function(word) {
         if(!word.filler) {
             array.push(new Word(word.word, word.start, word.end));
         return false;
     }
     // test if the string can be parsed into valid JSON
-    var json;
+    let json;
     try{
         json = JSON.parse(response);
     } catch (error) {
         return false;
     }
     // get the "objects" value and check for a session ID
-    var array = json.objects;
+    const array = json.objects;
     if(!(array[0] && array[0]['session-id'])) {
         return false;
     }
  * @returns {string} the URL to the sphinx4 server
  */
 function getURL() {
-    var message = 'config does not contain an url to a '
+    const message = 'config does not contain an url to a '
     + 'Sphinx4 https server';
     if(config.sphinxURL === undefined) {
         console.log(message);
     } else {
-        var toReturn = config.sphinxURL;
+        const toReturn = config.sphinxURL;
         if(toReturn.includes !== undefined && toReturn.includes('https://')) {
             return toReturn;
         }

modules/transcription/word.js

  * @param begin the time the word was started being uttered
  * @param end the time the word stopped being uttered
  */
-var Word = function(word, begin, end) {
+const Word = function(word, begin, end) {
     this.word = word;
     this.begin = begin;
     this.end = end;

modules/util/AuthUtil.js

-var AuthUtil = {
+const AuthUtil = {
     /**
      * Creates the URL pointing to JWT token authentication service. It is
      * formatted from the 'urlPattern' argument which can contain the following
      * constructed.
      */
     getTokenAuthUrl(urlPattern, roomName, roleUpgrade) {
-        var url = urlPattern;
+        const url = urlPattern;
         if (typeof url !== 'string') {
             return null;
         }

modules/util/EventEmitterForwarder.js

  */
 EventEmitterForwarder.prototype.forward = function() {
     // This line is only for fixing jshint errors.
-    var args = arguments;
-    var srcEvent = args[0];
+    const args = arguments;
+    const srcEvent = args[0];
     // This will be the "this" value for emit function.
     args[0] = this.dest;
     // Using bind.apply to pass the arguments as Array-like object ("arguments")

modules/util/GlobalOnErrorHandler.js

 /**
  * List with global error handlers that will be executed.
  */
-var handlers = [];
+const handlers = [];
 
 // If an old handler exists, also fire its events.
-var oldOnErrorHandler = window.onerror;
+const oldOnErrorHandler = window.onerror;
 
 /**
  * Custom error handler that calls the old global error handler and executes
 }
 
 // If an old handler exists, also fire its events.
-var oldOnUnhandledRejection = window.onunhandledrejection;
+const oldOnUnhandledRejection = window.onunhandledrejection;
 
 /**
  * Custom handler that calls the old global handler and executes all handlers
 window.onunhandledrejection = JitsiGlobalUnhandledRejection;
 
 
-var GlobalOnErrorHandler = {
+const GlobalOnErrorHandler = {
     /**
      * Adds new error handlers.
      * @param handler the new handler.
      * @param error the error to pass to the error handler
      */
     callErrorHandler(error) {
-        var errHandler = window.onerror;
+        const errHandler = window.onerror;
         if(!errHandler) {
             return;
         }
      * @param error the error to pass to the rejection handler.
      */
     callUnhandledRejectionHandler(error) {
-        var errHandler = window.onunhandledrejection;
+        const errHandler = window.onunhandledrejection;
         if(!errHandler) {
             return;
         }

modules/util/RandomUtil.js

-/**
 /**
  * @const
  */
-var ALPHANUM = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const ALPHANUM
+    = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
 /**
  * Hexadecimal digits.
  * @const
  */
-var HEX_DIGITS = '0123456789abcdef';
+const HEX_DIGITS = '0123456789abcdef';
 
 /**
  * Generates random int within the range [min, max]
  * @returns {string} random string of specified length
  */
 function randomAlphanumStr(length) {
-    var result = '';
+    let result = '';
 
-    for (var i = 0; i < length; i += 1) {
+    for (let i = 0; i < length; i += 1) {
         result += randomElement(ALPHANUM);
     }
 
 /**
  * Exported interface.
  */
-var RandomUtil = {
+const RandomUtil = {
     /**
      * Returns a random hex digit.
      * @returns {*}
      * @param len the length.
      */
     randomHexString(len) {
-        var ret = '';
+        let ret = '';
         while (len--) {
             ret += this.randomHexDigit();
         }

modules/util/ScriptUtil.js

-var currentExecutingScript = require('current-executing-script');
+const currentExecutingScript = require('current-executing-script');
 
 
 /**
  * Implements utility functions which facilitate the dealing with scripts such
  * as the download and execution of a JavaScript file.
  */
-var ScriptUtil = {
+const ScriptUtil = {
     /**
      * Loads a script from a specific source.
      *
      */
     loadScript(src, async, prepend, relativeURL,
                           loadCallback, errorCallback) {
-        var d = document;
-        var tagName = 'script';
-        var script = d.createElement(tagName);
-        var referenceNode = d.getElementsByTagName(tagName)[0];
+        const d = document;
+        const tagName = 'script';
+        const script = d.createElement(tagName);
+        const referenceNode = d.getElementsByTagName(tagName)[0];
 
         script.async = async;
 
         if (relativeURL) {
             // finds the src url of the current loaded script
             // and use it as base of the src supplied argument
-            var scriptEl = currentExecutingScript();
+            const scriptEl = currentExecutingScript();
             if(scriptEl) {
-                var scriptSrc = scriptEl.src;
-                var baseScriptSrc
+                const scriptSrc = scriptEl.src;
+                const baseScriptSrc
                     = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
                 if (scriptSrc && baseScriptSrc) {
                     src = baseScriptSrc + src;

modules/util/UsernameGenerator.js

-var RandomUtil = require('./RandomUtil');
+const RandomUtil = require('./RandomUtil');
 
 /**
  * from faker.js - Copyright (c) 2014-2015 Matthew Bergman & Marak Squires
  *
  * @const
  */
-var names = [
+const names = [
     'Aaliyah', 'Aaron', 'Abagail', 'Abbey', 'Abbie', 'Abbigail', 'Abby',
     'Abdiel', 'Abdul', 'Abdullah', 'Abe', 'Abel', 'Abelardo', 'Abigail',
     'Abigale', 'Abigayle', 'Abner', 'Abraham', 'Ada', 'Adah', 'Adalberto',
  * @returns {string} random username
  */
 function generateUsername() {
-    var name = RandomUtil.randomElement(names);
-    var suffix = RandomUtil.randomAlphanumStr(3);
+    const name = RandomUtil.randomElement(names);
+    const suffix = RandomUtil.randomAlphanumStr(3);
 
     return name + '-' + suffix;
 }

modules/version/ComponentsVersions.js

-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var Statistics = require('../statistics/statistics');
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const Statistics = require('../statistics/statistics');
 
 /**
  * The constant for the name of the focus component.
             return;
         }
 
-        var log = [];
+        const log = [];
         node.children.forEach(function(item) {
 
-            var componentName = item.attributes.name;
+            const componentName = item.attributes.name;
             if (componentName !== ComponentsVersions.FOCUS_COMPONENT
             && componentName !== ComponentsVersions.XMPP_SERVER_COMPONENT
             && componentName !== ComponentsVersions.VIDEOBRIDGE_COMPONENT) {
                 return;
             }
 
-            var version = item.value;
+            const version = item.value;
             if (this.versions[componentName] !== version) {
                 this.versions[componentName] = version;
                 logger.info('Got ' + componentName + ' version: ' + version);

modules/xmpp/ChatRoom.js

 
 const logger = getLogger(__filename);
 
-var parser = {
+const parser = {
     packet2JSON(packet, nodes) {
-        var self = this;
+        const self = this;
         $(packet).children().each(function() {
-            var tagName = $(this).prop('tagName');
+            const tagName = $(this).prop('tagName');
             const node = {
                 tagName
             };
             $($(this)[0].attributes).each(function(index, attr) {
                 node.attributes[ attr.name ] = attr.value;
             });
-            var text = Strophe.getText($(this)[0]);
+            const text = Strophe.getText($(this)[0]);
             if (text) {
                 node.value = text;
             }
  * @param nodeName the name of the node (videomuted, audiomuted, etc)
  */
 function filterNodeFromPresenceJSON(pres, nodeName) {
-    var res = [];
+    const res = [];
     for(let i = 0; i < pres.length; i++) {
         if(pres[i].tagName === nodeName) {
             res.push(pres[i]);
 
     join(password) {
         this.password = password;
-        var self = this;
+        const self = this;
         this.moderator.allocateConferenceFocus(function() {
             self.sendPresence(true);
         });
     }
 
     sendPresence(fromJoin) {
-        var to = this.presMap.to;
+        const to = this.presMap.to;
         if (!to || (!this.joined && !fromJoin)) {
             // Too early to send presence - not initialized
             return;
         }
 
-        var pres = $pres({to });
+        const pres = $pres({to });
 
         // xep-0045 defines: "including in the initial presence stanza an empty
         // <x/> element qualified by the 'http://jabber.org/protocol/muc' namespace"
      */
     doLeave() {
         logger.log('do leave', this.myroomjid);
-        var pres = $pres({to: this.myroomjid, type: 'unavailable' });
+        const pres = $pres({to: this.myroomjid, type: 'unavailable' });
         this.presMap.length = 0;
 
         // XXX Strophe is asynchronously sending by default. Unfortunately, that
     discoRoomInfo() {
       // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
 
-        var getInfo = $iq({type: 'get', to: this.roomjid})
+        const getInfo = $iq({type: 'get', to: this.roomjid})
         .c('query', {xmlns: Strophe.NS.DISCO_INFO});
 
         this.connection.sendIQ(getInfo, function(result) {
-            var locked = $(result).find('>query>feature[var="muc_passwordprotected"]')
+            const locked = $(result).find('>query>feature[var="muc_passwordprotected"]')
             .length === 1;
             if (locked != this.locked) {
                 this.eventEmitter.emit(XMPPEvents.MUC_LOCK_CHANGED, locked);
     createNonAnonymousRoom() {
         // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
 
-        var getForm = $iq({type: 'get', to: this.roomjid})
+        const getForm = $iq({type: 'get', to: this.roomjid})
             .c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'})
             .c('x', {xmlns: 'jabber:x:data', type: 'submit'});
 
-        var self = this;
+        const self = this;
 
         this.connection.sendIQ(getForm, function(form) {
 
             if (!$(form).find(
                     '>query>x[xmlns="jabber:x:data"]'
                     + '>field[var="muc#roomconfig_whois"]').length) {
-                var errmsg = 'non-anonymous rooms not supported';
+                const errmsg = 'non-anonymous rooms not supported';
                 GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
                 logger.error(errmsg);
                 return;
             }
 
-            var formSubmit = $iq({to: self.roomjid, type: 'set'})
+            const formSubmit = $iq({to: self.roomjid, type: 'set'})
                 .c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
 
             formSubmit.c('x', {xmlns: 'jabber:x:data', type: 'submit'});
     }
 
     onPresence(pres) {
-        var from = pres.getAttribute('from');
+        const from = pres.getAttribute('from');
         // Parse roles.
-        var member = {};
+        const member = {};
         member.show = $(pres).find('>show').text();
         member.status = $(pres).find('>status').text();
-        var mucUserItem
+        const mucUserItem
             = $(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item');
         member.affiliation = mucUserItem.attr('affiliation');
         member.role = mucUserItem.attr('role');
 
         // Focus recognition
-        var jid = mucUserItem.attr('jid');
+        const jid = mucUserItem.attr('jid');
         member.jid = jid;
         member.isFocus
             = jid && jid.indexOf(this.moderator.getFocusUserJid() + '/') === 0;
                     === jid.substring(jid.indexOf('@') + 1, jid.indexOf('/'));
 
         $(pres).find('>x').remove();
-        var nodes = [];
+        const nodes = [];
         parser.packet2JSON(pres, nodes);
         this.lastPresences[from] = nodes;
         let jibri = null;
         }
 
         if (from == this.myroomjid) {
-            var newRole = member.affiliation == 'owner' ? member.role : 'none';
+            const newRole = member.affiliation == 'owner' ? member.role : 'none';
             if (this.role !== newRole) {
                 this.role = newRole;
                 this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
             }
             if (!this.joined) {
                 this.joined = true;
-                var now = this.connectionTimes['muc.joined']
+                const now = this.connectionTimes['muc.joined']
                     = window.performance.now();
                 logger.log('(TIME) MUC joined:\t', now);
 
         } else {
             // Presence update for existing participant
             // Watch role change:
-            var memberOfThis = this.members[from];
+            const memberOfThis = this.members[from];
             if (memberOfThis.role != member.role) {
                 memberOfThis.role = member.role;
                 this.eventEmitter.emit(
             switch(node.tagName) {
             case 'nick':
                 if(!member.isFocus) {
-                    var displayName = this.xmpp.options.displayJids
+                    const displayName = this.xmpp.options.displayJids
                             ? Strophe.getResourceFromJid(from) : member.nick;
 
                     if (displayName && displayName.length > 0) {
             case 'jibri-recording-status':
                 jibri = node;
                 break;
-            case 'call-control':
-                var att = node.attributes;
+            case 'call-control': {
+                const att = node.attributes;
                 if(!att) {
                     break;
                 }
                 this.phonePin = att.pin || null;
                 this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
                 break;
+            }
             default:
                 this.processNode(node, from);
             }
 
         // Trigger status message update
         if (member.status) {
-            this.eventEmitter.emit(XMPPEvents.PRESENCE_STATUS, from, member.status);
+            this.eventEmitter.emit(
+                XMPPEvents.PRESENCE_STATUS,
+                from,
+                member.status);
         }
 
         if(jibri) {
         // make sure we catch all errors coming from any handler
         // otherwise we can remove the presence handler from strophe
         try {
-            var tagHandler = this.presHandlers[node.tagName];
+            let tagHandler = this.presHandlers[node.tagName];
             if (node.tagName.startsWith('jitsi_participant_')) {
                 tagHandler = this.participantPropertyListener;
             }
     }
 
     sendMessage(body, nickname) {
-        var msg = $msg({to: this.roomjid, type: 'groupchat'});
+        const msg = $msg({to: this.roomjid, type: 'groupchat'});
         msg.c('body', body).up();
         if (nickname) {
             msg.c('nick', {xmlns: 'http://jabber.org/protocol/nick'}).t(nickname).up().up();
     }
 
     setSubject(subject) {
-        var msg = $msg({to: this.roomjid, type: 'groupchat'});
+        const msg = $msg({to: this.roomjid, type: 'groupchat'});
         msg.c('subject', subject);
         this.connection.send(msg);
     }
         // room destroyed ?
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]'
             + '>destroy').length) {
-            var reason;
-            var reasonSelect = $(pres).find(
+            let reason;
+            const reasonSelect = $(pres).find(
                     '>x[xmlns="http://jabber.org/protocol/muc#user"]'
                     + '>destroy>reason');
             if (reasonSelect.length) {
         }
 
         // Status code 110 indicates that this notification is "self-presence".
-        var isSelfPresence = $(pres).find(
+        const isSelfPresence = $(pres).find(
                 '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="110"]'
             ).length !== 0;
-        var isKick = $(pres).find(
+        const isKick = $(pres).find(
                 '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="307"]'
             ).length !== 0;
         const membersKeys = Object.keys(this.members);
     }
 
     onMessage(msg, from) {
-        var nick
+        const nick
             = $(msg).find('>nick[xmlns="http://jabber.org/protocol/nick"]')
                 .text()
             || Strophe.getResourceFromJid(from);
 
-        var txt = $(msg).find('>body').text();
-        var type = msg.getAttribute('type');
+        const txt = $(msg).find('>body').text();
+        const type = msg.getAttribute('type');
         if (type == 'error') {
             this.eventEmitter.emit(XMPPEvents.CHAT_ERROR_RECEIVED,
                 $(msg).find('>text').text(), txt);
             return true;
         }
 
-        var subject = $(msg).find('>subject');
+        const subject = $(msg).find('>subject');
         if (subject.length) {
-            var subjectText = subject.text();
+            const subjectText = subject.text();
             if (subjectText || subjectText === '') {
                 this.eventEmitter.emit(XMPPEvents.SUBJECT_CHANGED, subjectText);
                 logger.log('Subject is changed to ' + subjectText);
         }
 
         // xep-0203 delay
-        var stamp = $(msg).find('>delay').attr('stamp');
+        let stamp = $(msg).find('>delay').attr('stamp');
 
         if (!stamp) {
             // or xep-0091 delay, UTC timestamp
 
             if (stamp) {
                 // the format is CCYYMMDDThh:mm:ss
-                var dateParts = stamp.match(/(\d{4})(\d{2})(\d{2}T\d{2}:\d{2}:\d{2})/);
+                const dateParts = stamp.match(/(\d{4})(\d{2})(\d{2}T\d{2}:\d{2}:\d{2})/);
                 stamp = dateParts[1] + '-' + dateParts[2] + '-' + dateParts[3] + 'Z';
             }
         }
             this.eventEmitter.emit(XMPPEvents.PASSWORD_REQUIRED);
         } else if ($(pres).find(
             '>error[type="cancel"]>not-allowed[xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]').length) {
-            var toDomain = Strophe.getDomainFromJid(pres.getAttribute('to'));
+            const toDomain = Strophe.getDomainFromJid(pres.getAttribute('to'));
             if (toDomain === this.xmpp.options.hosts.anonymousdomain) {
                 // enter the room by replying with 'not-authorized'. This would
                 // result in reconnection from authorized domain.
     }
 
     kick(jid) {
-        var kickIQ = $iq({to: this.roomjid, type: 'set'})
+        const kickIQ = $iq({to: this.roomjid, type: 'set'})
             .c('query', {xmlns: 'http://jabber.org/protocol/muc#admin'})
             .c('item', {nick: Strophe.getResourceFromJid(jid), role: 'none'})
             .c('reason').t('You have been kicked.').up().up().up();
 
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
-        var ob = this;
+        const ob = this;
         this.connection.sendIQ($iq({to: this.roomjid, type: 'get'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'}),
             function(res) {
                 if ($(res).find('>query>x[xmlns="jabber:x:data"]>field[var="muc#roomconfig_roomsecret"]').length) {
-                    var formsubmit = $iq({to: ob.roomjid, type: 'set'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
+                    const formsubmit = $iq({to: ob.roomjid, type: 'set'}).c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
                     formsubmit.c('x', {xmlns: 'jabber:x:data', type: 'submit'});
                     formsubmit.c('field', {'var': 'FORM_TYPE'}).c('value').t('http://jabber.org/protocol/muc#roomconfig').up().up();
                     formsubmit.c('field', {'var': 'muc#roomconfig_roomsecret'}).c('value').t(key).up().up();
     }
 
     removeFromPresence(key) {
-        var nodes = this.presMap.nodes.filter(function(node) {
+        const nodes = this.presMap.nodes.filter(function(node) {
             return key !== node.tagName;
         });
         this.presMap.nodes = nodes;
      * the MUC then <tt>null</tt> is returned.
      */
     isFocus(mucJid) {
-        var member = this.members[mucJid];
+        const member = this.members[mucJid];
         if (member) {
             return member.isFocus;
         }
      */
     muteParticipant(jid, mute) {
         logger.info('set mute', mute);
-        var iqToFocus = $iq(
+        const iqToFocus = $iq(
             {to: this.focusMucJid, type: 'set'})
             .c('mute', {
                 xmlns: 'http://jitsi.org/jitmeet/audio',
     }
 
     onMute(iq) {
-        var from = iq.getAttribute('from');
+        const from = iq.getAttribute('from');
         if (from !== this.focusMucJid) {
             logger.warn('Ignored mute from non focus peer');
             return false;
         }
-        var mute = $(iq).find('mute');
+        const mute = $(iq).find('mute');
         if (mute.length) {
-            var doMuteAudio = mute.text() === 'true';
+            const doMuteAudio = mute.text() === 'true';
             this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS, doMuteAudio);
         }
         return true;

modules/xmpp/SDP.js

 /* global $, APP */
 
-var SDPUtil = require('./SDPUtil');
+const SDPUtil = require('./SDPUtil');
 
 // SDP STUFF
 function SDP(sdp) {
-    var media = sdp.split('\r\nm=');
-    for (var i = 1, length = media.length; i < length; i++) {
-        var media_i = 'm=' + media[i];
+    const media = sdp.split('\r\nm=');
+    for (let i = 1, length = media.length; i < length; i++) {
+        let media_i = 'm=' + media[i];
         if (i != length - 1) {
             media_i += '\r\n';
         }
         media[i] = media_i;
     }
-    var session = media.shift() + '\r\n';
+    const session = media.shift() + '\r\n';
 
     this.media = media;
     this.raw = session + media.join('');
  * Returns map of MediaChannel mapped per channel idx.
  */
 SDP.prototype.getMediaSsrcMap = function() {
-    var self = this;
-    var media_ssrcs = {};
-    var tmp;
-    for (var mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
+    const self = this;
+    const media_ssrcs = {};
+    let tmp;
+    for (let mediaindex = 0; mediaindex < self.media.length; mediaindex++) {
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc:');
-        var mid = SDPUtil.parse_mid(SDPUtil.find_line(self.media[mediaindex], 'a=mid:'));
-        var media = {
+        const mid = SDPUtil.parse_mid(SDPUtil.find_line(self.media[mediaindex], 'a=mid:'));
+        const media = {
             mediaindex,
             mid,
             ssrcs: {},
         };
         media_ssrcs[mediaindex] = media;
         tmp.forEach(function(line) {
-            var linessrc = line.substring(7).split(' ')[0];
+            const linessrc = line.substring(7).split(' ')[0];
             // allocate new ChannelSsrc
             if(!media.ssrcs[linessrc]) {
                 media.ssrcs[linessrc] = {
         });
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc-group:');
         tmp.forEach(function(line) {
-            var idx = line.indexOf(' ');
-            var semantics = line.substr(0, idx).substr(13);
-            var ssrcs = line.substr(14 + semantics.length).split(' ');
+            const idx = line.indexOf(' ');
+            const semantics = line.substr(0, idx).substr(13);
+            const ssrcs = line.substr(14 + semantics.length).split(' ');
             if (ssrcs.length) {
                 media.ssrcGroups.push({
                     semantics,
  */
 SDP.prototype.containsSSRC = function(ssrc) {
     // FIXME this code is really strange - improve it if you can
-    var medias = this.getMediaSsrcMap();
-    var result = false;
+    const medias = this.getMediaSsrcMap();
+    let result = false;
     Object.keys(medias).forEach(function(mediaindex) {
         if (result) {
             return;
 
 // remove iSAC and CN from SDP
 SDP.prototype.mangle = function() {
-    var i, j, lines, mline, newdesc, rtpmap;
+    let i, j, lines, mline, newdesc, rtpmap;
     for (i = 0; i < this.media.length; i++) {
         lines = this.media[i].split('\r\n');
         lines.pop(); // remove empty last element
 
 // remove lines matching prefix from session section
 SDP.prototype.removeSessionLines = function(prefix) {
-    var self = this;
-    var lines = SDPUtil.find_lines(this.session, prefix);
+    const self = this;
+    const lines = SDPUtil.find_lines(this.session, prefix);
     lines.forEach(function(line) {
         self.session = self.session.replace(line + '\r\n', '');
     });
 // remove lines matching prefix from a media section specified by mediaindex
 // TODO: non-numeric mediaindex could match mid
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
-    var self = this;
-    var lines = SDPUtil.find_lines(this.media[mediaindex], prefix);
+    const self = this;
+    const lines = SDPUtil.find_lines(this.media[mediaindex], prefix);
     lines.forEach(function(line) {
         self.media[mediaindex] = self.media[mediaindex].replace(line + '\r\n', '');
     });
 
 // add content's to a jingle element
 SDP.prototype.toJingle = function(elem, thecreator) {
-    var i, j, k, lines, mline, rtpmap, ssrc, tmp;
+    let i, j, k, lines, mline, rtpmap, ssrc, tmp;
     // new bundle plan
     lines = SDPUtil.find_lines(this.session, 'a=group:');
     if (lines.length) {
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
-            var semantics = tmp.shift().substr(8);
+            const semantics = tmp.shift().substr(8);
             elem.c('group', {xmlns: 'urn:xmpp:jingle:apps:grouping:0', semantics});
             for (j = 0; j < tmp.length; j++) {
                 elem.c('content', {name: tmp[j]}).up();
               || mline.media === 'application')) {
             continue;
         }
-        var assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
+        const assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
         if (assrcline) {
             ssrc = assrcline.substring(7).split(' ')[0]; // take the first
         } else {
         }
 
         elem.c('content', {creator: thecreator, name: mline.media});
-        var amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
+        const amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
         if (amidline) {
             // prefer identifier from a=mid if present
-            var mid = SDPUtil.parse_mid(amidline);
+            const mid = SDPUtil.parse_mid(amidline);
             elem.attrs({ name: mid });
         }
 
                 rtpmap = SDPUtil.find_line(this.media[i], 'a=rtpmap:' + mline.fmt[j]);
                 elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
                 // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo value=bar/>
-                var afmtpline = SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]);
+                const afmtpline = SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]);
                 if (afmtpline) {
                     tmp = SDPUtil.parse_fmtp(afmtpline);
                     for (k = 0; k < tmp.length; k++) {
 
                 elem.up();
             }
-            var crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+            const crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
             if (crypto.length) {
                 elem.c('encryption', {required: 1});
                 crypto.forEach(function(line) {
                 // new style mapping
                 elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                 // FIXME: group by ssrc and support multiple different ssrcs
-                var ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
+                const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
                 if(ssrclines.length > 0) {
                     ssrclines.forEach(function(line) {
-                        var idx = line.indexOf(' ');
-                        var linessrc = line.substr(0, idx).substr(7);
+                        const idx = line.indexOf(' ');
+                        const linessrc = line.substr(0, idx).substr(7);
                         if (linessrc != ssrc) {
                             elem.up();
                             ssrc = linessrc;
                             elem.c('source', { ssrc, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         }
-                        var kv = line.substr(idx + 1);
+                        const kv = line.substr(idx + 1);
                         elem.c('parameter');
                         if (kv.indexOf(':') == -1) {
                             elem.attrs({ name: kv });
                         } else {
-                            var k = kv.split(':', 2)[0];
+                            const k = kv.split(':', 2)[0];
                             elem.attrs({ name: k });
 
-                            var v = kv.split(':', 2)[1];
+                            let v = kv.split(':', 2)[1];
                             v = SDPUtil.filter_special_chars(v);
                             elem.attrs({ value: v });
                         }
                 elem.up();
 
                 // XEP-0339 handle ssrc-group attributes
-                var ssrc_group_lines = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
+                const ssrc_group_lines = SDPUtil.find_lines(this.media[i], 'a=ssrc-group:');
                 ssrc_group_lines.forEach(function(line) {
-                    var idx = line.indexOf(' ');
-                    var semantics = line.substr(0, idx).substr(13);
-                    var ssrcs = line.substr(14 + semantics.length).split(' ');
+                    const idx = line.indexOf(' ');
+                    const semantics = line.substr(0, idx).substr(13);
+                    const ssrcs = line.substr(14 + semantics.length).split(' ');
                     if (ssrcs.length) {
                         elem.c('ssrc-group', { semantics, xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
                         ssrcs.forEach(function(ssrc) {
 };
 
 SDP.prototype.transportToJingle = function(mediaindex, elem) {
-    var fingerprints, sctpAttrs, sctpmap, tmp;
-    var self = this;
+    let tmp;
+    const self = this;
     elem.c('transport');
 
     // XEP-0343 DTLS/SCTP
-    sctpmap
+    const sctpmap
         = SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:', self.session);
     if (sctpmap) {
-        sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
+        const sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
         elem.c('sctpmap', {
             xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
             number: sctpAttrs[0], /* SCTP port */
         elem.up();
     }
     // XEP-0320
-    fingerprints = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
+    const fingerprints
+        = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
     fingerprints.forEach(function(line) {
         tmp = SDPUtil.parse_fingerprint(line);
         tmp.xmlns = 'urn:xmpp:jingle:apps:dtls:0';
         elem.attrs(tmp);
         // XEP-0176
         if (SDPUtil.find_line(this.media[mediaindex], 'a=candidate:', this.session)) { // add any a=candidate lines
-            var lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
+            const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
             lines.forEach(function(line) {
-                var candidate = SDPUtil.candidateToJingle(line);
+                const candidate = SDPUtil.candidateToJingle(line);
                 if (self.failICE) {
                     candidate.ip = '1.1.1.1';
                 }
-                var protocol = candidate
+                const protocol = candidate
                         && typeof candidate.protocol === 'string'
                     ? candidate.protocol.toLowerCase() : '';
                 if ((self.removeTcpCandidates
 };
 
 SDP.prototype.rtcpFbToJingle = function(mediaindex, elem, payloadtype) { // XEP-0293
-    var lines = SDPUtil.find_lines(this.media[mediaindex], 'a=rtcp-fb:' + payloadtype);
+    const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=rtcp-fb:' + payloadtype);
     lines.forEach(function(line) {
-        var tmp = SDPUtil.parse_rtcpfb(line);
+        const tmp = SDPUtil.parse_rtcpfb(line);
         if (tmp.type == 'trr-int') {
             elem.c('rtcp-fb-trr-int', {xmlns: 'urn:xmpp:jingle:apps:rtp:rtcp-fb:0', value: tmp.params[0]});
             elem.up();
 };
 
 SDP.prototype.rtcpFbFromJingle = function(elem, payloadtype) { // XEP-0293
-    var media = '';
-    var tmp = elem.find('>rtcp-fb-trr-int[xmlns="urn:xmpp:jingle:apps:rtp:rtcp-fb:0"]');
+    let media = '';
+    let tmp = elem.find('>rtcp-fb-trr-int[xmlns="urn:xmpp:jingle:apps:rtp:rtcp-fb:0"]');
     if (tmp.length) {
         media += 'a=rtcp-fb:' + '*' + ' ' + 'trr-int' + ' ';
         if (tmp.attr('value')) {
 
 // construct an SDP from a jingle stanza
 SDP.prototype.fromJingle = function(jingle) {
-    var self = this;
+    const self = this;
     this.raw = 'v=0\r\n'
         + 'o=- 1923518516 2 IN IP4 0.0.0.0\r\n'// FIXME
         + 's=-\r\n'
     // http://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-04#section-8
     if ($(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').length) {
         $(jingle).find('>group[xmlns="urn:xmpp:jingle:apps:grouping:0"]').each(function(idx, group) {
-            var contents = $(group).find('>content').map(function(idx, content) {
+            const contents = $(group).find('>content').map(function(idx, content) {
                 return content.getAttribute('name');
             }).get();
             if (contents.length > 0) {
 
     this.session = this.raw;
     jingle.find('>content').each(function() {
-        var m = self.jingle2media($(this));
+        const m = self.jingle2media($(this));
         self.media.push(m);
     });
 
 
 // translate a jingle content element into an an SDP media part
 SDP.prototype.jingle2media = function(content) {
-    var desc = content.find('description'),
-        media = '',
-        self = this,
-        tmp;
-    var sctp = content.find(
+    const desc = content.find('description');
+    let media = '';
+    const self = this;
+    const sctp = content.find(
         '>transport>sctpmap[xmlns="urn:xmpp:jingle:transports:dtls-sctp:1"]');
 
-    tmp = { media: desc.attr('media') };
+    let tmp = { media: desc.attr('media') };
     tmp.port = '1';
     if (content.attr('senders') == 'rejected') {
         // estos hack to reject an m-line.
         media += 'a=sctpmap:' + sctp.attr('number')
             + ' ' + sctp.attr('protocol');
 
-        var streamCount = sctp.attr('streams');
+        const streamCount = sctp.attr('streams');
         if (streamCount) {
             media += ' ' + streamCount + '\r\n';
         } else {
     });
 
     content.find('>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]>candidate').each(function() {
-        var protocol = this.getAttribute('protocol');
+        let protocol = this.getAttribute('protocol');
         protocol = typeof protocol === 'string' ? protocol.toLowerCase() : '';
 
         if ((self.removeTcpCandidates
 
     // XEP-0339 handle ssrc-group attributes
     content.find('description>ssrc-group[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]').each(function() {
-        var semantics = this.getAttribute('semantics');
-        var ssrcs = $(this).find('>source').map(function() {
+        const semantics = this.getAttribute('semantics');
+        const ssrcs = $(this).find('>source').map(function() {
             return this.getAttribute('ssrc');
         }).get();
 
 
     tmp = content.find('description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
     tmp.each(function() {
-        var ssrc = this.getAttribute('ssrc');
+        const ssrc = this.getAttribute('ssrc');
         $(this).find('>parameter').each(function() {
-            var name = this.getAttribute('name');
-            var value = this.getAttribute('value');
+            const name = this.getAttribute('name');
+            let value = this.getAttribute('value');
             value = SDPUtil.filter_special_chars(value);
             media += 'a=ssrc:' + ssrc + ' ' + name;
             if (value && value.length) {

modules/xmpp/SDPDiffer.js

-var SDPUtil = require('./SDPUtil');
+const SDPUtil = require('./SDPUtil');
 
 function SDPDiffer(mySDP, otherSDP) {
     this.mySDP = mySDP;
             return false;
         }
 
-        for (var i = 0, l = this.length; i < l; i++) {
+        for (let i = 0, l = this.length; i < l; i++) {
             // Check if we have nested arrays
             if (this[i] instanceof Array && array[i] instanceof Array) {
                 // recurse into the nested arrays
         return true;
     }
 
-    var myMedias = this.mySDP.getMediaSsrcMap();
-    var othersMedias = this.otherSDP.getMediaSsrcMap();
-    var newMedia = {};
+    const myMedias = this.mySDP.getMediaSsrcMap();
+    const othersMedias = this.otherSDP.getMediaSsrcMap();
+    const newMedia = {};
     Object.keys(othersMedias).forEach(function(othersMediaIdx) {
-        var myMedia = myMedias[othersMediaIdx];
-        var othersMedia = othersMedias[othersMediaIdx];
+        const myMedia = myMedias[othersMediaIdx];
+        const othersMedia = othersMedias[othersMediaIdx];
         if(!myMedia && othersMedia) {
             // Add whole channel
             newMedia[othersMediaIdx] = othersMedia;
         othersMedia.ssrcGroups.forEach(function(otherSsrcGroup) {
 
             // try to match the other ssrc-group with an ssrc-group of ours
-            var matched = false;
-            for (var i = 0; i < myMedia.ssrcGroups.length; i++) {
-                var mySsrcGroup = myMedia.ssrcGroups[i];
+            let matched = false;
+            for (let i = 0; i < myMedia.ssrcGroups.length; i++) {
+                const mySsrcGroup = myMedia.ssrcGroups[i];
                 if (otherSsrcGroup.semantics == mySsrcGroup.semantics
                     && arrayEquals.apply(otherSsrcGroup.ssrcs,
                                       [mySsrcGroup.ssrcs])) {
  * TODO: document!
  */
 SDPDiffer.prototype.toJingle = function(modify) {
-    var sdpMediaSsrcs = this.getNewMedia();
+    const sdpMediaSsrcs = this.getNewMedia();
 
-    var modified = false;
+    let modified = false;
     Object.keys(sdpMediaSsrcs).forEach(function(mediaindex) {
         modified = true;
-        var media = sdpMediaSsrcs[mediaindex];
+        const media = sdpMediaSsrcs[mediaindex];
         modify.c('content', {name: media.mid});
 
         modify.c('description',
         // different ssrcs correctly
         // generate sources from lines
         Object.keys(media.ssrcs).forEach(function(ssrcNum) {
-            var mediaSsrc = media.ssrcs[ssrcNum];
+            const mediaSsrc = media.ssrcs[ssrcNum];
             modify.c('source', { xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
             modify.attrs({ssrc: mediaSsrc.ssrc});
             // iterate over ssrc lines
             mediaSsrc.lines.forEach(function(line) {
-                var idx = line.indexOf(' ');
-                var kv = line.substr(idx + 1);
+                const idx = line.indexOf(' ');
+                const kv = line.substr(idx + 1);
                 modify.c('parameter');
                 if (kv.indexOf(':') == -1) {
                     modify.attrs({ name: kv });
                 } else {
-                    var nv = kv.split(':', 2);
-                    var name = nv[0];
-                    var value = SDPUtil.filter_special_chars(nv[1]);
+                    const nv = kv.split(':', 2);
+                    const name = nv[0];
+                    const value = SDPUtil.filter_special_chars(nv[1]);
                     modify.attrs({ name });
                     modify.attrs({ value });
                 }

modules/xmpp/SDPUtil.js

 import {getLogger} from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
 import RandomUtil from '../util/RandomUtil';
-var RTCBrowserType = require('../RTC/RTCBrowserType');
+const RTCBrowserType = require('../RTC/RTCBrowserType');
 
-var SDPUtil = {
+const SDPUtil = {
     filter_special_chars(text) {
         // XXX Neither one of the falsy values (e.g. null, undefined, false,
         // "", etc.) "contain" special chars.
         return text ? text.replace(/[\\\/\{,\}\+]/g, '') : text;
     },
     iceparams(mediadesc, sessiondesc) {
-        var data = null;
-        var pwd, ufrag;
+        let data = null;
+        let pwd, ufrag;
         if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
                 && (pwd = SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))) {
             data = {
         return line.substring(6);
     },
     parse_mline(line) {
-        var data = {},
-            parts = line.substring(2).split(' ');
+        const data = {};
+        const parts = line.substring(2).split(' ');
+
         data.media = parts.shift();
         data.port = parts.shift();
         data.proto = parts.shift();
         return 'm=' + mline.media + ' ' + mline.port + ' ' + mline.proto + ' ' + mline.fmt.join(' ');
     },
     parse_rtpmap(line) {
-        var data = {},
-            parts = line.substring(9).split(' ');
+        const data = {};
+        let parts = line.substring(9).split(' ');
+
         data.id = parts.shift();
         parts = parts[0].split('/');
         data.name = parts.shift();
      * @returns [SCTP port number, protocol, streams]
      */
     parse_sctpmap(line) {
-        var parts = line.substring(10).split(' ');
-        var sctpPort = parts[0];
-        var protocol = parts[1];
+        const parts = line.substring(10).split(' ');
+        const sctpPort = parts[0];
+        const protocol = parts[1];
         // Stream count is optional
-        var streamCount = parts.length > 2 ? parts[2] : null;
+        const streamCount = parts.length > 2 ? parts[2] : null;
         return [sctpPort, protocol, streamCount];// SCTP port
     },
     build_rtpmap(el) {
-        var line = 'a=rtpmap:' + el.getAttribute('id') + ' ' + el.getAttribute('name') + '/' + el.getAttribute('clockrate');
+        let line = 'a=rtpmap:' + el.getAttribute('id') + ' ' + el.getAttribute('name') + '/' + el.getAttribute('clockrate');
         if (el.getAttribute('channels') && el.getAttribute('channels') != '1') {
             line += '/' + el.getAttribute('channels');
         }
         return line;
     },
     parse_crypto(line) {
-        var data = {},
-            parts = line.substring(9).split(' ');
+        const data = {};
+        const parts = line.substring(9).split(' ');
+
         data.tag = parts.shift();
         data['crypto-suite'] = parts.shift();
         data['key-params'] = parts.shift();
         return data;
     },
     parse_fingerprint(line) { // RFC 4572
-        var data = {},
-            parts = line.substring(14).split(' ');
+        const data = {};
+        const parts = line.substring(14).split(' ');
+
         data.hash = parts.shift();
         data.fingerprint = parts.shift();
         // TODO assert that fingerprint satisfies 2UHEX *(":" 2UHEX) ?
         return data;
     },
     parse_fmtp(line) {
-        var data = [],
-            i,
-            key,
-            parts = line.split(' '),
-            value;
+        const data = [];
+        let parts = line.split(' ');
+
         parts.shift();
         parts = parts.join(' ').split(';');
-        for (i = 0; i < parts.length; i++) {
-            key = parts[i].split('=')[0];
+        for (let i = 0; i < parts.length; i++) {
+            let key = parts[i].split('=')[0];
             while (key.length && key[0] == ' ') {
                 key = key.substring(1);
             }
-            value = parts[i].split('=')[1];
+            const value = parts[i].split('=')[1];
             if (key && value) {
                 data.push({name: key, value});
             } else if (key) {
         return data;
     },
     parse_icecandidate(line) {
-        var candidate = {},
-            elems = line.split(' ');
+        const candidate = {};
+        const elems = line.split(' ');
+
         candidate.foundation = elems[0].substring(12);
         candidate.component = elems[1];
         candidate.protocol = elems[2].toLowerCase();
         // elems[6] => "typ"
         candidate.type = elems[7];
         candidate.generation = 0; // default value, may be overwritten below
-        for (var i = 8; i < elems.length; i += 2) {
+        for (let i = 8; i < elems.length; i += 2) {
             switch (elems[i]) {
             case 'raddr':
                 candidate['rel-addr'] = elems[i + 1];
         return candidate;
     },
     build_icecandidate(cand) {
-        var line = ['a=candidate:' + cand.foundation, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type].join(' ');
+        let line = ['a=candidate:' + cand.foundation, cand.component, cand.protocol, cand.priority, cand.ip, cand.port, 'typ', cand.type].join(' ');
         line += ' ';
         switch (cand.type) {
         case 'srflx':
         // proprietary mapping of a=ssrc lines
         // TODO: see "Jingle RTP Source Description" by Juberti and P. Thatcher on google docs
         // and parse according to that
-        var data = {},
-            lines = desc.split('\r\n');
-        for (var i = 0; i < lines.length; i++) {
+        const data = {};
+        const lines = desc.split('\r\n');
+
+        for (let i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, 7) == 'a=ssrc:') {
-                var idx = lines[i].indexOf(' ');
+                const idx = lines[i].indexOf(' ');
                 data[lines[i].substr(idx + 1).split(':', 2)[0]] = lines[i].substr(idx + 1).split(':', 2)[1];
             }
         }
         return data;
     },
     parse_rtcpfb(line) {
-        var parts = line.substr(10).split(' ');
-        var data = {};
+        const parts = line.substr(10).split(' ');
+        const data = {};
         data.pt = parts.shift();
         data.type = parts.shift();
         data.params = parts;
         return data;
     },
     parse_extmap(line) {
-        var parts = line.substr(9).split(' ');
-        var data = {};
+        const parts = line.substr(9).split(' ');
+        const data = {};
         data.value = parts.shift();
         if (data.value.indexOf('/') != -1) {
             data.direction = data.value.substr(data.value.indexOf('/') + 1);
         return data;
     },
     find_line(haystack, needle, sessionpart) {
-        var lines = haystack.split('\r\n');
-        for (var i = 0; i < lines.length; i++) {
+        let lines = haystack.split('\r\n');
+        for (let i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, needle.length) == needle) {
                 return lines[i];
             }
         }
         // search session part
         lines = sessionpart.split('\r\n');
-        for (var j = 0; j < lines.length; j++) {
+        for (let j = 0; j < lines.length; j++) {
             if (lines[j].substring(0, needle.length) == needle) {
                 return lines[j];
             }
         return false;
     },
     find_lines(haystack, needle, sessionpart) {
-        var lines = haystack.split('\r\n'),
-            needles = [];
-        for (var i = 0; i < lines.length; i++) {
+        let lines = haystack.split('\r\n');
+        const needles = [];
+
+        for (let i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, needle.length) == needle) {
                 needles.push(lines[i]);
             }
         }
         // search session part
         lines = sessionpart.split('\r\n');
-        for (var j = 0; j < lines.length; j++) {
+        for (let j = 0; j < lines.length; j++) {
             if (lines[j].substring(0, needle.length) == needle) {
                 needles.push(lines[j]);
             }
         if (line.substring(line.length - 2) == '\r\n') {// chomp it
             line = line.substring(0, line.length - 2);
         }
-        var candidate = {},
-            elems = line.split(' '),
-            i;
+        const candidate = {};
+        const elems = line.split(' ');
+
         if (elems[6] != 'typ') {
             logger.log('did not find typ in the right place');
             logger.log(line);
         candidate.type = elems[7];
 
         candidate.generation = '0'; // default, may be overwritten below
-        for (i = 8; i < elems.length; i += 2) {
+        for (let i = 8; i < elems.length; i += 2) {
             switch (elems[i]) {
             case 'raddr':
                 candidate['rel-addr'] = elems[i + 1];
         return candidate;
     },
     candidateFromJingle(cand) {
-        var line = 'a=candidate:';
+        let line = 'a=candidate:';
         line += cand.getAttribute('foundation');
         line += ' ';
         line += cand.getAttribute('component');
         line += ' ';
 
-        var protocol = cand.getAttribute('protocol');
+        let protocol = cand.getAttribute('protocol');
         // use tcp candidates for FF
         if (RTCBrowserType.isFirefox() && protocol.toLowerCase() == 'ssltcp') {
             protocol = 'tcp';

modules/xmpp/moderator.js

 /* global $, $iq, Promise, Strophe */
 
-var logger = require('jitsi-meet-logger').getLogger(__filename);
-var XMPPEvents = require('../../service/xmpp/XMPPEvents');
-var AuthenticationEvents
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+const XMPPEvents = require('../../service/xmpp/XMPPEvents');
+const AuthenticationEvents
     = require('../../service/authentication/AuthenticationEvents');
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 import Settings from '../settings/Settings';
 
 function createExpBackoffTimer(step) {
-    var count = 1;
+    let count = 1;
     return function(reset) {
         // Reset call
         if (reset) {
             return;
         }
         // Calculate next timeout
-        var timeout = Math.pow(2, count - 1);
+        const timeout = Math.pow(2, count - 1);
         count += 1;
         return timeout * step;
     };
 
 Moderator.prototype.onMucMemberLeft = function(jid) {
     logger.info('Someone left is it focus ? ' + jid);
-    var resource = Strophe.getResourceFromJid(jid);
+    const resource = Strophe.getResourceFromJid(jid);
     if (resource === 'focus') {
         logger.info(
             'Focus has left the room - leaving conference');
 
 Moderator.prototype.getFocusComponent = function() {
     // Get focus component address
-    var focusComponent = this.options.connection.hosts.focus;
+    let focusComponent = this.options.connection.hosts.focus;
     // If not specified use default:  'focus.domain'
     if (!focusComponent) {
         focusComponent = 'focus.' + this.options.connection.hosts.domain;
 
 Moderator.prototype.createConferenceIq = function() {
     // Generate create conference IQ
-    var elem = $iq({to: this.getFocusComponent(), type: 'set'});
+    const elem = $iq({to: this.getFocusComponent(), type: 'set'});
 
     // Session Id used for authentication
-    var sessionId = Settings.getSessionId();
-    var machineUID = Settings.getMachineId();
+    const sessionId = Settings.getSessionId();
+    const machineUID = Settings.getMachineId();
 
     logger.info(
             'Session ID: ' + sessionId + ' machine UID: ' + machineUID);
 
 
 Moderator.prototype.parseSessionId = function(resultIq) {
-    var sessionId = $(resultIq).find('conference').attr('session-id');
+    const sessionId = $(resultIq).find('conference').attr('session-id');
     if (sessionId) {
         logger.info('Received sessionId:  ' + sessionId);
         Settings.setSessionId(sessionId);
     this.setFocusUserJid(
         $(resultIq).find('conference').attr('focusjid'));
 
-    var authenticationEnabled
+    const authenticationEnabled
         = $(resultIq).find(
             '>conference>property'
             + '[name=\'authentication\'][value=\'true\']').length > 0;
         this.parseSessionId(resultIq);
     }
 
-    var authIdentity = $(resultIq).find('>conference').attr('identity');
+    const authIdentity = $(resultIq).find('>conference').attr('identity');
 
     this.eventEmitter.emit(AuthenticationEvents.IDENTITY_UPDATED,
         authenticationEnabled, authIdentity);
 Moderator.prototype._allocateConferenceFocusError = function(error, callback) {
     // If the session is invalid, remove and try again without session ID to get
     // a new one
-    var invalidSession = $(error).find('>error>session-invalid').length;
+    const invalidSession = $(error).find('>error>session-invalid').length;
     if (invalidSession) {
         logger.info('Session expired! - removing');
         Settings.clearSessionId();
         return;
     }
     // Check for error returned by the reservation system
-    var reservationErr = $(error).find('>error>reservation-error');
+    const reservationErr = $(error).find('>error>reservation-error');
     if (reservationErr.length) {
         // Trigger error event
-        var errorCode = reservationErr.attr('error-code');
-        var errorTextNode = $(error).find('>error>text');
-        var errorMsg;
+        const errorCode = reservationErr.attr('error-code');
+        const errorTextNode = $(error).find('>error>text');
+        let errorMsg;
         if (errorTextNode) {
             errorMsg = errorTextNode.text();
         }
     // Not authorized to create new room
     if ($(error).find('>error>not-authorized').length) {
         logger.warn('Unauthorized to start the conference', error);
-        var toDomain = Strophe.getDomainFromJid(error.getAttribute('to'));
+        const toDomain = Strophe.getDomainFromJid(error.getAttribute('to'));
         if (toDomain !== this.options.connection.hosts.anonymousdomain) {
             // FIXME "is external" should come either from the focus or
             // config.js
         this.eventEmitter.emit(XMPPEvents.AUTHENTICATION_REQUIRED);
         return;
     }
-    var waitMs = this.getNextErrorTimeout();
-    var errmsg = 'Focus error, retry after ' + waitMs;
+    const waitMs = this.getNextErrorTimeout();
+    const errmsg = 'Focus error, retry after ' + waitMs;
     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
     logger.error(errmsg, error);
     // Show message
-    var focusComponent = this.getFocusComponent();
-    var retrySec = waitMs / 1000;
+    const focusComponent = this.getFocusComponent();
+    const retrySec = waitMs / 1000;
     // FIXME: message is duplicated ? Do not show in case of session invalid
     // which means just a retry
     if (!invalidSession) {
         // Exec callback
         callback();
     } else {
-        var waitMs = this.getNextTimeout();
+        const waitMs = this.getNextTimeout();
         logger.info('Waiting for the focus... ' + waitMs);
         window.setTimeout(() => this.allocateConferenceFocus(callback),
             waitMs);
                 this.parseSessionId(result);
                 resolve();
             }, error => {
-                var code = $(error).find('>error').attr('code');
+                const code = $(error).find('>error').attr('code');
                 reject(error, code);
             }
         );
  * @param failureCb
  */
 Moderator.prototype._getLoginUrl = function(popup, urlCb, failureCb) {
-    var iq = $iq({to: this.getFocusComponent(), type: 'get'});
-    var attrs = {
+    const iq = $iq({to: this.getFocusComponent(), type: 'get'});
+    const attrs = {
         xmlns: 'http://jitsi.org/protocol/focus',
         room: this.roomName,
         'machine-uid': Settings.getMachineId()
     };
-    var str = 'auth url'; // for logger
+    let str = 'auth url'; // for logger
     if (popup) {
         attrs.popup = true;
         str = 'POPUP ' + str;
     this.connection.sendIQ(
         iq,
         function(result) {
-            var url = $(result).find('login-url').attr('url');
+            let url = $(result).find('login-url').attr('url');
             url = decodeURIComponent(url);
             if (url) {
                 logger.info('Got ' + str + ': ' + url);
 };
 
 Moderator.prototype.logout = function(callback) {
-    var iq = $iq({to: this.getFocusComponent(), type: 'set'});
-    var sessionId = Settings.getSessionId();
+    const iq = $iq({to: this.getFocusComponent(), type: 'set'});
+    const sessionId = Settings.getSessionId();
     if (!sessionId) {
         callback();
         return;
     this.connection.sendIQ(
         iq,
         function(result) {
-            var logoutUrl = $(result).find('logout').attr('logout-url');
+            let logoutUrl = $(result).find('logout').attr('logout-url');
             if (logoutUrl) {
                 logoutUrl = decodeURIComponent(logoutUrl);
             }
             callback(logoutUrl);
         }.bind(this),
         function(error) {
-            var errmsg = 'Logout error';
+            const errmsg = 'Logout error';
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg, error);
         }

modules/xmpp/recording.js

 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
-var XMPPEvents = require('../../service/xmpp/XMPPEvents');
-var JitsiRecorderErrors = require('../../JitsiRecorderErrors');
-var GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
+const XMPPEvents = require('../../service/xmpp/XMPPEvents');
+const JitsiRecorderErrors = require('../../JitsiRecorderErrors');
+const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
 
 function Recording(type, eventEmitter, connection, focusMucJid, jirecon,
 };
 
 Recording.prototype.handleJibriPresence = function(jibri) {
-    var attributes = jibri.attributes;
+    const attributes = jibri.attributes;
     if(!attributes) {
         return;
     }
 
-    var newState = attributes.status;
+    const newState = attributes.status;
     logger.log('Handle jibri presence : ', newState);
 
     if (newState === this.state) {
         options = options || {};
 
     // FIXME jibri does not accept IQ without 'url' attribute set ?
-        var iq = $iq({to: this.focusMucJid, type: 'set'})
+        const iq = $iq({to: this.focusMucJid, type: 'set'})
         .c('jibri', {
             'xmlns': 'http://jitsi.org/protocol/jibri',
             'action': state === Recording.status.ON
             errCallback(new Error('Invalid state!'));
         }
 
-        var iq = $iq({to: this.jirecon, type: 'set'})
+        const iq = $iq({to: this.jirecon, type: 'set'})
         .c('recording', {xmlns: 'http://jitsi.org/protocol/jirecon',
             action: state === Recording.status.ON
                 ? Recording.action.START
         }
 
         logger.log('Start recording');
-        var self = this;
+        const self = this;
         this.connection.sendIQ(
         iq,
         function(result) {
 // with the new recording state, according to the IQ.
 Recording.prototype.setRecordingColibri
 = function(state, callback, errCallback, options) {
-    var elem = $iq({to: this.focusMucJid, type: 'set'});
+    const elem = $iq({to: this.focusMucJid, type: 'set'});
     elem.c('conference', {
         xmlns: 'http://jitsi.org/protocol/colibri'
     });
     elem.c('recording', {state, token: options.token});
 
-    var self = this;
+    const self = this;
     this.connection.sendIQ(elem,
         function(result) {
             logger.log('Set recording "', state, '". Result:', result);
-            var recordingElem = $(result).find('>conference>recording');
-            var newState = recordingElem.attr('state');
+            const recordingElem = $(result).find('>conference>recording');
+            const newState = recordingElem.attr('state');
 
             self.state = newState;
             callback(newState);
 
             if (newState === 'pending') {
                 self.connection.addHandler(function(iq) {
-                    var state = $(iq).find('recording').attr('state');
+                    const state = $(iq).find('recording').attr('state');
                     if (state) {
                         self.state = newState;
                         callback(state);
     case Recording.types.JIBRI:
         this.setRecordingJibri(state, callback, errCallback, options);
         break;
-    default:
-        var errmsg = 'Unknown recording type!';
+    default: {
+        const errmsg = 'Unknown recording type!';
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         logger.error(errmsg);
-        return;
+        break;
+    }
     }
 };
 
  * @param statusChangeHandler {function} receives the new status as argument.
  */
 Recording.prototype.toggleRecording = function(options, statusChangeHandler) {
-    var oldState = this.state;
+    const oldState = this.state;
 
     // If the recorder is currently unavailable we throw an error.
     if (oldState === Recording.status.UNAVAILABLE
         return;
     }
 
-    var newState = oldState === Recording.status.AVAILABLE
+    const newState = oldState === Recording.status.AVAILABLE
                     || oldState === Recording.status.OFF
                     ? Recording.status.ON
                     : Recording.status.OFF;
 
-    var self = this;
+    const self = this;
     logger.log('Toggle recording (old state, new state): ', oldState, newState);
     this.setRecording(newState,
         function(state, url) {

modules/xmpp/xmpp.js

             logger.info('My Jabber ID: ' + this.connection.jid);
 
             // Schedule ping ?
-            var pingJid = this.connection.domain;
+            const pingJid = this.connection.domain;
             this.connection.ping.hasPingSupport(
                 pingJid,
                 function(hasPing) {

service/RTC/CameraFacingMode.js

  *
  * @enum {string}
  */
-var CameraFacingMode = {
+const CameraFacingMode = {
     /**
      * The mode which specifies the environment-facing camera.
      */

service/RTC/RTCEvents.js

-var RTCEvents = {
+const RTCEvents = {
     /**
      * Indicates error while create answer call.
      */

service/RTC/Resolutions.js

-var Resolutions = {
+const Resolutions = {
     '1080': {
         width: 1920,
         height: 1080,

service/RTC/StreamEventTypes.js

-var StreamEventTypes = {
+const StreamEventTypes = {
     EVENT_TYPE_LOCAL_CREATED: 'stream.local_created',
 
     EVENT_TYPE_LOCAL_CHANGED: 'stream.local_changed',

service/RTC/VideoType.js

  * Enumeration of the video types
  * @type {{CAMERA: string, DESKTOP: string}}
  */
-var VideoType = {
+const VideoType = {
     /**
      * The camera video type.
      */

service/authentication/AuthenticationEvents.js

-var AuthenticationEvents = {
+const AuthenticationEvents = {
     /**
      * Event callback arguments:
      * function(authenticationEnabled, userIdentity)

service/statistics/constants.js

-var Constants = {
+const Constants = {
     LOCAL_JID: 'local'
 };
 module.exports = Constants;

service/xmpp/XMPPEvents.js

-var XMPPEvents = {
+const XMPPEvents = {
     /**
      * Indicates error while adding ice candidate.
      */

webpack.config.js

 /* global __dirname */
 
-var child_process = require('child_process'); // eslint-disable-line camelcase
-var process = require('process');
-var webpack = require('webpack');
+const child_process = require('child_process'); // eslint-disable-line camelcase
+const process = require('process');
+const webpack = require('webpack');
 
-var minimize
+const minimize
     = process.argv.indexOf('-p') !== -1
         || process.argv.indexOf('--optimize-minimize') !== -1;
-var plugins = [];
+const plugins = [];
 
 if (minimize) {
     // While webpack will automatically insert UglifyJsPlugin when minimize is