fix(eslint): Add curly rule

.eslintrc.js

         'block-scoped-var': 0,
         'complexity': 0,
         'consistent-return': 0,
+        'curly': 2,
 
         'prefer-const': 2,
         'prefer-reflect': 0,

JitsiConference.js

  */
 JitsiConference.prototype._init = function (options) {
     if (!options)
-        options = {};
+        {options = {};}
 
     // Override connection and xmpp properties (Usefull if the connection
     // reloaded)
  */
 JitsiConference.prototype.join = function (password) {
     if (this.room)
-        this.room.join(password);
+        {this.room.join(password);}
 };
 
 /**
 
     this.rtc.closeAllDataChannels();
     if (this.statistics)
-        this.statistics.dispose();
+        {this.statistics.dispose();}
 
     // leave the conference
     if (this.room) {
  */
 JitsiConference.prototype.on = function (eventId, handler) {
     if (this.eventEmitter)
-        this.eventEmitter.on(eventId, handler);
+        {this.eventEmitter.on(eventId, handler);}
 };
 
 /**
  */
 JitsiConference.prototype.off = function (eventId, handler) {
     if (this.eventEmitter)
-        this.eventEmitter.removeListener(eventId, handler);
+        {this.eventEmitter.removeListener(eventId, handler);}
 };
 
 // Common aliases for event emitter
  */
  JitsiConference.prototype.addCommandListener = function (command, handler) {
     if (this.room)
-        this.room.addPresenceListener(command, handler);
+        {this.room.addPresenceListener(command, handler);}
  };
 
 /**
   */
  JitsiConference.prototype.removeCommandListener = function (command) {
     if (this.room)
-        this.room.removePresenceListener(command);
+        {this.room.removePresenceListener(command);}
  };
 
 /**
  */
 JitsiConference.prototype.sendTextMessage = function (message) {
     if (this.room)
-        this.room.sendMessage(message);
+        {this.room.sendMessage(message);}
 };
 
 /**
  **/
 JitsiConference.prototype.removeCommand = function (name) {
     if (this.room)
-        this.room.removeFromPresence(name);
+        {this.room.removeFromPresence(name);}
 };
 
 /**
     // FIXME: we assume we have only one screen sharing track
     // if we change this we need to fix this check
     if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP)
-        this.statistics.sendScreenSharingEvent(false);
+        {this.statistics.sendScreenSharingEvent(false);}
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
 };
     // FIXME: we assume we have only one screen sharing track
     // if we change this we need to fix this check
     if (newTrack.isVideoTrack() && newTrack.videoType === VideoType.DESKTOP)
-        this.statistics.sendScreenSharingEvent(true);
+        {this.statistics.sendScreenSharingEvent(true);}
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 };
 
     // there can be no participant in case the member that left is focus
     if (participant)
-        this.eventEmitter.emit(
-            JitsiConferenceEvents.USER_LEFT, id, participant);
+        {this.eventEmitter.emit(
+            JitsiConferenceEvents.USER_LEFT, id, participant);}
 };
 
 JitsiConference.prototype.onUserRoleChanged = function (jid, role) {
     }
 
     if (participant._displayName === displayName)
-        return;
+        {return;}
 
     participant._displayName = displayName;
     this.eventEmitter.emit(JitsiConferenceEvents.DISPLAY_NAME_CHANGED, id, displayName);
  */
 JitsiConference.prototype.isRecordingSupported = function () {
     if (this.room)
-        return this.room.isRecordingSupported();
+        {return this.room.isRecordingSupported();}
     return false;
 };
 
  */
 JitsiConference.prototype.toggleRecording = function (options) {
     if (this.room)
-        return this.room.toggleRecording(options, function (status, error) {
+        {return this.room.toggleRecording(options, function (status, error) {
             this.eventEmitter.emit(
                 JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
-        }.bind(this));
+        }.bind(this));}
     this.eventEmitter.emit(
         JitsiConferenceEvents.RECORDER_STATE_CHANGED, "error",
         new Error("The conference is not created yet!"));
  */
 JitsiConference.prototype.isSIPCallingSupported = function () {
     if (this.room)
-        return this.room.isSIPCallingSupported();
+        {return this.room.isSIPCallingSupported();}
     return false;
 };
 
  */
 JitsiConference.prototype.dial = function (number) {
     if (this.room)
-        return this.room.dial(number);
+        {return this.room.dial(number);}
     return new Promise(function(resolve, reject){
         reject(new Error("The conference is not created yet!"));});
 };
  */
 JitsiConference.prototype.hangup = function () {
     if (this.room)
-        return this.room.hangup();
+        {return this.room.hangup();}
     return new Promise(function(resolve, reject){
         reject(new Error("The conference is not created yet!"));});
 };
  */
 JitsiConference.prototype.getPhoneNumber = function () {
     if (this.room)
-        return this.room.getPhoneNumber();
+        {return this.room.getPhoneNumber();}
     return null;
 };
 
  */
 JitsiConference.prototype.getPhonePin = function () {
     if (this.room)
-        return this.room.getPhonePin();
+        {return this.room.getPhonePin();}
     return null;
 };
 

JitsiConferenceEventManager.js

     conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
         function (track) {
             if(!track.isLocal() || !conference.statistics)
-                return;
+                {return;}
             conference.statistics.sendMuteEvent(track.isMuted(),
                 track.getType());
         });
 JitsiConferenceEventManager.prototype.setupStatisticsListeners = function () {
     var conference = this.conference;
     if(!conference.statistics)
-        return;
+        {return;}
 
     conference.statistics.addAudioLevelListener(function (ssrc, level) {
         var resource = conference.rtc.getResourceBySSRC(ssrc);
         if (!resource)
-            return;
+            {return;}
 
         conference.rtc.setAudioLevel(resource, level);
     });
         conference.getLocalTracks(MediaType.AUDIO).forEach(function (track) {
             const ssrc = track.getSSRC();
             if (!ssrc || !stats.hasOwnProperty(ssrc))
-                return;
+                {return;}
 
             track._setByteSent(stats[ssrc]);
         });

JitsiConnection.js

             // and then there are no msgs, but we want to log only disconnects
             // when there is real error
             if(msg)
-                Statistics.analytics.sendEvent(
-                    'connection.disconnected.' + msg);
+                {Statistics.analytics.sendEvent(
+                    'connection.disconnected.' + msg);}
             Statistics.sendLog(
                 JSON.stringify({id: "connection.disconnected", msg: msg}));
         });
  */
 JitsiConnection.prototype.connect = function (options) {
     if(!options)
-        options = {};
+        {options = {};}
 
     this.xmpp.connect(options.id, options.password);
 };

JitsiMeetJS.js

 
 function getLowerResolution(resolution) {
     if(!Resolutions[resolution])
-        return null;
+        {return null;}
     var order = Resolutions[resolution].order;
     var res = null;
     var resName = null;
         }
 
         if(!window.connectionTimes)
-            window.connectionTimes = {};
+            {window.connectionTimes = {};}
         window.connectionTimes["obtainPermissions.start"] =
             window.performance.now();
 
                     "getUserMedia.success", options), {value: options});
 
                 if(!RTC.options.disableAudioLevels)
-                    for(let i = 0; i < tracks.length; i++) {
+                    {for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
                         var mStream = track.getOriginalStream();
                         if(track.getType() === MediaType.AUDIO){
                                     Statistics.stopLocalStats(mStream);
                                 });
                         }
-                    }
+                    }}
 
                 // set real device ids
                 var currentlyAvailableMediaDevices

doc/example/example.js

             localTracks[i].attach($("#localAudio" + i)[0]);
         }
         if(isJoined)
-            room.addTrack(localTracks[i]);
+            {room.addTrack(localTracks[i]);}
     }
 }
 
  */
 function onRemoteTrack(track) {
     if(track.isLocal())
-        return;
+        {return;}
     var participant = track.getParticipantId();
     if(!remoteTracks[participant])
-        remoteTracks[participant] = [];
+        {remoteTracks[participant] = [];}
     var idx = remoteTracks[participant].push(track);
     track.addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
         function (audioLevel) {
     console.log("conference joined!");
     isJoined = true;
     for(var i = 0; i < localTracks.length; i++)
-        room.addTrack(localTracks[i]);
+        {room.addTrack(localTracks[i]);}
 }
 
 function onUserLeft(id) {
     console.log("user left");
     if(!remoteTracks[id])
-        return;
+        {return;}
     var tracks = remoteTracks[id];
     for(var i = 0; i< tracks.length; i++)
-        tracks[i].detach($("#" + id + tracks[i].getType()));
+        {tracks[i].detach($("#" + id + tracks[i].getType()));}
 }
 
 /**
 
 function unload() {
     for(var i = 0; i < localTracks.length; i++)
-        localTracks[i].stop();
+        {localTracks[i].stop();}
     room.leave();
     connection.disconnect();
 }

modules/RTC/DataChannels.js

         logger.info("The Data Channel closed", dataChannel);
         var idx = self._dataChannels.indexOf(dataChannel);
         if (idx > -1)
-            self._dataChannels = self._dataChannels.splice(idx, 1);
+            {self._dataChannels = self._dataChannels.splice(idx, 1);}
     };
     this._dataChannels.push(dataChannel);
 };
 
     if (dataChannels && dataChannels.length !== 0) {
         if (thisArg)
-            return dataChannels.some(callback, thisArg);
+            {return dataChannels.some(callback, thisArg);}
         else
-            return dataChannels.some(callback);
+            {return dataChannels.some(callback);}
     } else {
         return false;
     }

modules/RTC/JitsiLocalTrack.js

         null /* RTC */, stream, track,
         function () {
             if(!this.dontFireRemoveEvent)
-                this.eventEmitter.emit(
-                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
+                {this.eventEmitter.emit(
+                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);}
             this.dontFireRemoveEvent = false;
         }.bind(this) /* inactiveHandler */,
         mediaType, videoType, null /* ssrc */);
     // FIXME: currently firefox is ignoring our constraints about resolutions
     // so we do not store it, to avoid wrong reporting of local track resolution
     if (RTCBrowserType.isFirefox())
-        this.resolution = null;
+        {this.resolution = null;}
 
     this.deviceId = deviceId;
     this.startMuted = false;
 JitsiLocalTrack.prototype._onNoDataFromSourceError = function () {
     this._clearNoDataFromSourceMuteResources();
     if(this._checkForCameraIssues())
-        this._fireNoDataFromSourceEvent();
+        {this._fireNoDataFromSourceEvent();}
 };
 
 /**
         this.videoType === VideoType.DESKTOP ||
         RTCBrowserType.isFirefox()) {
         if(this.track)
-            this.track.enabled = !mute;
+            {this.track.enabled = !mute;}
     } else {
         if(mute) {
             this.dontFireRemoveEvent = true;
                 facingMode: this.getCameraFacingMode()
             };
             if (this.resolution)
-                streamOptions.resolution = this.resolution;
+                {streamOptions.resolution = this.resolution;}
 
             promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
                 .then(function (streamsInfo) {
 JitsiLocalTrack.prototype.isMuted = function () {
     // this.stream will be null when we mute local video on Chrome
     if (!this.stream)
-        return true;
+        {return true;}
     if (this.isVideoTrack() && !this.isActive()) {
         return true;
     } else {
  */
 JitsiLocalTrack.prototype.getSSRC = function () {
     if(this.ssrc && this.ssrc.groups && this.ssrc.groups.length)
-        return this.ssrc.groups[0].ssrcs[0];
+        {return this.ssrc.groups[0].ssrcs[0];}
     else if(this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length)
-        return this.ssrc.ssrcs[0];
+        {return this.ssrc.ssrcs[0];}
     else
-        return null;
+        {return null;}
 };
 
 /**
 JitsiLocalTrack.prototype._checkForCameraIssues = function () {
     if(!this.isVideoTrack() || this.stopStreamInProgress ||
         this.videoType === VideoType.DESKTOP)
-        return false;
+        {return false;}
 
     return !this._isReceivingData();
 };
  */
 JitsiLocalTrack.prototype._isReceivingData = function () {
     if(!this.stream)
-        return false;
+        {return false;}
     // In older version of the spec there is no muted property and
     // readyState can have value muted. In the latest versions
     // readyState can have values "live" and "ended" and there is

modules/RTC/JitsiRemoteTrack.js

     this.hasBeenMuted = muted;
     // Bind 'onmute' and 'onunmute' event handlers
     if (this.rtc && this.track)
-        this._bindMuteHandlers();
+        {this._bindMuteHandlers();}
 }
 
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
  */
 JitsiRemoteTrack.prototype.setMute = function (value) {
     if(this.muted === value)
-        return;
+        {return;}
 
     if(value)
-        this.hasBeenMuted = true;
+        {this.hasBeenMuted = true;}
 
     // we can have a fake video stream
     if(this.stream)
-        this.stream.muted = value;
+        {this.stream.muted = value;}
 
     this.muted = value;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
  */
 JitsiRemoteTrack.prototype._setVideoType = function (type) {
     if(this.videoType === type)
-        return;
+        {return;}
     this.videoType = type;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
     console.log("(TIME) TTFM " + type + ":\t", ttfm);
     var eventName = type +'.ttfm';
     if(this.hasBeenMuted)
-        eventName += '.muted';
+        {eventName += '.muted';}
     Statistics.analytics.sendEvent(eventName, {value: ttfm});
 };
 
 JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
     if((ttfmTrackerAudioAttached && this.isAudioTrack())
         || (ttfmTrackerVideoAttached && this.isVideoTrack()))
-        return;
+        {return;}
 
     if (this.isAudioTrack())
-        ttfmTrackerAudioAttached = true;
+        {ttfmTrackerAudioAttached = true;}
     if (this.isVideoTrack())
-        ttfmTrackerVideoAttached = true;
+        {ttfmTrackerVideoAttached = true;}
 
     if (RTCBrowserType.isTemasysPluginUsed()) {
         // XXX Don't require Temasys unless it's to be used because it doesn't

modules/RTC/JitsiTrack.js

     var stream = jitsiTrack.getOriginalStream();
 
     if(!stream)
-        return;
+        {return;}
 
     var originalStop = stream.stop;
     stream.stop = function () {
 function addMediaStreamInactiveHandler(mediaStream, handler) {
     // Temasys will use onended
     if(typeof mediaStream.active !== "undefined")
-        mediaStream.oninactive = handler;
+        {mediaStream.oninactive = handler;}
     else
-        mediaStream.onended = handler;
+        {mediaStream.onended = handler;}
 }
 
 /**
 JitsiTrack.prototype._setHandler = function (type, handler) {
     this.handlers[type] = handler;
     if(!this.stream)
-        return;
+        {return;}
 
     if(type === "inactive") {
         if (RTCBrowserType.isFirefox()) {
  */
 JitsiTrack.prototype.getId = function () {
     if(this.stream)
-        return RTCUtils.getStreamID(this.stream);
+        {return RTCUtils.getStreamID(this.stream);}
     else
-        return null;
+        {return null;}
 };
 
 /**
  */
 JitsiTrack.prototype.isActive = function () {
     if(typeof this.stream.active !== "undefined")
-        return this.stream.active;
+        {return this.stream.active;}
     else
-        return true;
+        {return true;}
 };
 
 /**
  */
 JitsiTrack.prototype.on = function (eventId, handler) {
     if(this.eventEmitter)
-        this.eventEmitter.on(eventId, handler);
+        {this.eventEmitter.on(eventId, handler);}
 };
 
 /**
  */
 JitsiTrack.prototype.off = function (eventId, handler) {
     if(this.eventEmitter)
-        this.eventEmitter.removeListener(eventId, handler);
+        {this.eventEmitter.removeListener(eventId, handler);}
 };
 
 // Common aliases for event emitter

modules/RTC/RTC.js

         // cache the value if channel is missing, till we open it
         this.selectedEndpoint = id;
         if(this.dataChannels && this.dataChannelsOpen)
-            this.dataChannels.sendSelectedEndpointMessage(id);
+            {this.dataChannels.sendSelectedEndpointMessage(id);}
     }
 
     /**
 
     addLocalTrack (track) {
         if (!track)
-            throw new Error('track must not be null nor undefined');
+            {throw new Error('track must not be null nor undefined');}
 
         this.localTracks.push(track);
 
      */
     getRemoteTrackByType (type, resource) {
         if (this.remoteTracks[resource])
-            return this.remoteTracks[resource][type];
+            {return this.remoteTracks[resource][type];}
         else
-            return null;
+            {return null;}
     }
 
     /**
 
     setAudioLevel (resource, audioLevel) {
         if(!resource)
-            return;
+            {return;}
         var audioTrack = this.getRemoteAudioTrack(resource);
         if(audioTrack) {
             audioTrack.setAudioLevel(audioLevel);

modules/RTC/RTCBrowserType.js

     for (var i = 0; i < detectors.length; i++) {
         version = detectors[i]();
         if (version)
-            return version;
+            {return version;}
     }
     logger.warn("Browser type defaults to Safari ver 1");
     currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;

modules/RTC/RTCUtils.js

     }
 
     if (constraints.video.mandatory.minWidth)
-        constraints.video.mandatory.maxWidth =
-            constraints.video.mandatory.minWidth;
+        {constraints.video.mandatory.maxWidth =
+            constraints.video.mandatory.minWidth;}
     if (constraints.video.mandatory.minHeight)
-        constraints.video.mandatory.maxHeight =
-            constraints.video.mandatory.minHeight;
+        {constraints.video.mandatory.maxHeight =
+            constraints.video.mandatory.minHeight;}
 }
 
 /**
                     if (element) {
                         defaultSetVideoSrc(element, stream);
                         if (stream)
-                            element.play();
+                            {element.play();}
                     }
                     return element;
                 });
 
     _isDeviceListAvailable () {
         if (!rtcReady)
-            throw new Error("WebRTC not ready yet");
+            {throw new Error("WebRTC not ready yet");}
         var isEnumerateDevicesAvailable
             = navigator.mediaDevices && navigator.mediaDevices.enumerateDevices;
         if (isEnumerateDevicesAvailable) {

modules/RTC/ScreenObtainer.js

         gumFunction = gum;
 
         if (RTCBrowserType.isFirefox())
-            initFirefoxExtensionDetection(options);
+            {initFirefoxExtensionDetection(options);}
 
         if (RTCBrowserType.isNWJS()) {
             obtainDesktopStream = (options, onSuccess, onFailure) => {
             window.setTimeout(
                 () => {
                     if (firefoxExtInstalled === null)
-                        firefoxExtInstalled = false;
+                        {firefoxExtInstalled = false;}
                     this.obtainScreenOnFirefox(callback, errorCallback);
                 },
                 300);
                 n2 = 0;
 
             if (i < s1.length)
-                n1 = parseInt(s1[i]);
+                {n1 = parseInt(s1[i]);}
             if (i < s2.length)
-                n2 = parseInt(s2[i]);
+                {n2 = parseInt(s2[i]);}
 
             if (isNaN(n1) || isNaN(n2)) {
                 return true;
         return;
     }
     if (firefoxExtInstalled === false || firefoxExtInstalled === true)
-        return;
+        {return;}
     if (!options.desktopSharingFirefoxExtId) {
         firefoxExtInstalled = false;
         return;

modules/RTC/TraceablePeerConnection.js

 TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
     this.trace('addStream', stream ? stream.id : "null");
     if (stream)
-        this.peerconnection.addStream(stream);
+        {this.peerconnection.addStream(stream);}
     if (ssrcInfo && ssrcInfo.type === "addMuted") {
         this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrcs[0]);
         const simGroup
             || RTCBrowserType.isReactNative()) {
         // ignore for now...
         if(!errback)
-            errback = function () {};
+            {errback = function () {};}
         this.peerconnection.getStats(null, callback, errback);
     } else {
         this.peerconnection.getStats(callback);

modules/TalkMutedDetection.js

         // We are interested in the local audio stream only and if event is not
         // sent yet.
         if (!isLocal || !this.audioTrack || this._eventFired)
-            return;
+            {return;}
 
         if (this.audioTrack.isMuted() && audioLevel > 0.6) {
             this._eventFired = true;
      */
     _trackAdded(track) {
         if (this._isLocalAudioTrack(track))
-            this.audioTrack = track;
+            {this.audioTrack = track;}
     }
 
     /**
      */
     _trackMuteChanged(track) {
         if (this._isLocalAudioTrack(track) && track.isMuted())
-            this._eventFired = false;
+            {this._eventFired = false;}
     }
 }

modules/statistics/CallStats.js

 CallStats._checkInitialize = function () {
     if (CallStats.initialized || !CallStats.initializeFailed
         || !callStats || CallStats.initializeInProgress)
-        return;
+        {return;}
 
     // callstats object created, not initialized and it had previously failed,
     // and there is no init in progress, so lets try initialize it again
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
     if (callStats && err !== 'success')
-        logger.error("Monitoring status: "+ err + " msg: " + msg);
+        {logger.error("Monitoring status: "+ err + " msg: " + msg);}
 });
 
 /**

modules/statistics/LocalStatsCollector.js

 
     for (var i = 0; i < length; i++) {
         if (maxVolume < samples[i])
-            maxVolume = samples[i];
+            {maxVolume = samples[i];}
     }
 
     return parseFloat(((maxVolume - 127) / 128).toFixed(3));
 LocalStatsCollector.prototype.start = function () {
     if (!context ||
         RTCBrowserType.isTemasysPluginUsed())
-        return;
+        {return;}
     context.resume();
     var analyser = context.createAnalyser();
     analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;

modules/statistics/RTPStatsCollector.js

  */
 function calculatePacketLoss(lostPackets, totalPackets) {
     if(!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0)
-        return 0;
+        {return 0;}
     return Math.round((lostPackets/totalPackets)*100);
 }
 
     this._browserType = RTCBrowserType.getBrowserType();
     var keys = KEYS_BY_BROWSER_TYPE[this._browserType];
     if (!keys)
-        throw "The browser type '" + this._browserType + "' isn't supported!";
+        {throw "The browser type '" + this._browserType + "' isn't supported!";}
     /**
      * The function which is to be used to retrieve the value associated in a
      * report returned by RTCPeerConnection#getStats with a LibJitsiMeet
     var keyFromName = function (name) {
         var key = keys[name];
         if (key)
-            return key;
+            {return key;}
         else
-            throw "The property '" + name + "' isn't supported!";
+            {throw "The property '" + name + "' isn't supported!";}
     };
 
     // Define the function which retrieves the value from a specific report
             }
             catch(e){/*not supported*/}
             if(!ip || !type || !localip || active != "true")
-                continue;
+                {continue;}
             // Save the address unless it has been saved already.
             var conferenceStatsTransport = this.conferenceStats.transport;
             if(!conferenceStatsTransport.some(function (t) { return (
 
         if(now.type == "candidatepair") {
             if(now.state == "succeeded")
-                continue;
+                {continue;}
 
             var local = this.currentStatsReport[now.localCandidateId];
             var remote = this.currentStatsReport[now.remoteCandidateId];
             }
         }
         if (!packetsNow || packetsNow < 0)
-            packetsNow = 0;
+            {packetsNow = 0;}
 
         var packetsBefore = getNonNegativeStat(before, key);
         var packetsDiff = Math.max(0, packetsNow - packetsBefore);
         var now = this.currentAudioLevelsReport[idx];
 
         if (now.type != 'ssrc')
-            continue;
+            {continue;}
 
         var before = this.baselineAudioLevelsReport[idx];
         var ssrc = getStatValue(now, 'ssrc');
 
         if (!ssrc) {
             if ((Date.now() - now.timestamp) < 3000)
-                logger.warn("No ssrc: ");
+                {logger.warn("No ssrc: ");}
             continue;
         }
 

modules/statistics/statistics.js

             // requests to any third parties.
             && (Statistics.disableThirdPartyRequests !== true);
     if(this.callStatsIntegrationEnabled)
-        loadCallStatsAPI(this.options.callStatsCustomScriptUrl);
+        {loadCallStatsAPI(this.options.callStatsCustomScriptUrl);}
     this.callStats = null;
     // Flag indicates whether or not the CallStats have been started for this
     // Statistics instance
 
 Statistics.startLocalStats = function (stream, callback) {
     if(!Statistics.audioLevelsEnabled)
-        return;
+        {return;}
     var localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
         callback);
     this.localStats.push(localStats);
 
 Statistics.prototype.addAudioLevelListener = function(listener) {
     if(!Statistics.audioLevelsEnabled)
-        return;
+        {return;}
     this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
 Statistics.prototype.removeAudioLevelListener = function(listener) {
     if(!Statistics.audioLevelsEnabled)
-        return;
+        {return;}
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
     this.stopCallStats();
     this.stopRemoteStats();
     if(this.eventEmitter)
-        this.eventEmitter.removeAllListeners();
+        {this.eventEmitter.removeAllListeners();}
 };
 
 Statistics.stopLocalStats = function (stream) {
     if(!Statistics.audioLevelsEnabled)
-        return;
+        {return;}
 
     for(var i = 0; i < Statistics.localStats.length; i++)
-        if(Statistics.localStats[i].stream === stream){
+        {if(Statistics.localStats[i].stream === stream){
             var localStats = Statistics.localStats.splice(i, 1);
             localStats[0].stop();
             break;
-        }
+        }}
 };
 
 Statistics.prototype.stopRemoteStats = function () {
     if(this.callStatsStarted) {
         var index = Statistics.callsStatsInstances.indexOf(this.callstats);
         if(index > -1)
-            Statistics.callsStatsInstances.splice(index, 1);
+            {Statistics.callsStatsInstances.splice(index, 1);}
         // The next line is commented because we need to be able to send
         // feedback even after the conference has been destroyed.
         // this.callstats = null;
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function (pc) {
     if(this.callstats)
-        this.callstats.sendIceConnectionFailedEvent(pc, this.callstats);
+        {this.callstats.sendIceConnectionFailedEvent(pc, this.callstats);}
     Statistics.analytics.sendEvent('connection.ice_failed');
 };
 
  */
 Statistics.prototype.sendMuteEvent = function (muted, type) {
     if(this.callstats)
-        CallStats.sendMuteEvent(muted, type, this.callstats);
+        {CallStats.sendMuteEvent(muted, type, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendScreenSharingEvent = function (start) {
     if(this.callstats)
-        CallStats.sendScreenSharingEvent(start, this.callstats);
+        {CallStats.sendScreenSharingEvent(start, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendDominantSpeakerEvent = function () {
     if(this.callstats)
-        CallStats.sendDominantSpeakerEvent(this.callstats);
+        {CallStats.sendDominantSpeakerEvent(this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendCreateOfferFailed = function (e, pc) {
     if(this.callstats)
-        CallStats.sendCreateOfferFailed(e, pc, this.callstats);
+        {CallStats.sendCreateOfferFailed(e, pc, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendCreateAnswerFailed = function (e, pc) {
     if(this.callstats)
-        CallStats.sendCreateAnswerFailed(e, pc, this.callstats);
+        {CallStats.sendCreateAnswerFailed(e, pc, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendSetLocalDescFailed = function (e, pc) {
     if(this.callstats)
-        CallStats.sendSetLocalDescFailed(e, pc, this.callstats);
+        {CallStats.sendSetLocalDescFailed(e, pc, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendSetRemoteDescFailed = function (e, pc) {
     if(this.callstats)
-        CallStats.sendSetRemoteDescFailed(e, pc, this.callstats);
+        {CallStats.sendSetRemoteDescFailed(e, pc, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendAddIceCandidateFailed = function (e, pc) {
     if(this.callstats)
-        CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
+        {CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);}
 };
 
 /**
  */
 Statistics.prototype.sendFeedback = function(overall, detailed) {
     if(this.callstats)
-        this.callstats.sendFeedback(overall, detailed);
+        {this.callstats.sendFeedback(overall, detailed);}
     Statistics.analytics.sendEvent("feedback.rating",
         {value: overall, detailed: detailed});
 };

modules/util/EventEmitterForwarder.js

 function EventEmitterForwarder (src, dest) {
     if (!src || !dest || typeof src.addListener !== "function" ||
         typeof dest.emit !== "function")
-        throw new Error("Invalid arguments passed to EventEmitterForwarder");
+        {throw new Error("Invalid arguments passed to EventEmitterForwarder");}
     this.src = src;
     this.dest = dest;
 }

modules/util/GlobalOnErrorHandler.js

         handler(message, source, lineno, colno, error);
     });
     if (oldOnErrorHandler)
-        oldOnErrorHandler(message, source, lineno, colno, error);
+        {oldOnErrorHandler(message, source, lineno, colno, error);}
 }
 
 // If an old handler exists, also fire its events.
         handler(null, null, null, null, event.reason);
     });
     if(oldOnUnhandledRejection)
-        oldOnUnhandledRejection(event);
+        {oldOnUnhandledRejection(event);}
 }
 
 // Setting the custom error handlers.
     callErrorHandler: function (error) {
         var errHandler = window.onerror;
         if(!errHandler)
-            return;
+            {return;}
         errHandler(null, null, null, null, error);
     },
     /**
     callUnhandledRejectionHandler: function (error) {
         var errHandler = window.onunhandledrejection;
         if(!errHandler)
-            return;
+            {return;}
         errHandler(error);
     }
 };

modules/util/ScriptUtil.js

                 var baseScriptSrc
                     = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
                 if (scriptSrc && baseScriptSrc)
-                    src = baseScriptSrc + src;
+                    {src = baseScriptSrc + src;}
             }
         }
 
         if (loadCallback)
-            script.onload = loadCallback;
+            {script.onload = loadCallback;}
         if (errorCallback)
-            script.onerror = errorCallback;
+            {script.onerror = errorCallback;}
 
         script.src = src;
         if (prepend) {

modules/version/ComponentsVersions.js

 
     // logs versions to stats
     if (log.length > 0)
-        Statistics.sendLog(JSON.stringify(log));
+        {Statistics.sendLog(JSON.stringify(log));}
 };
 
 /**

modules/xmpp/ChatRoom.js

             }
             packet.c(node.tagName, node.attributes);
             if(node.value)
-                packet.t(node.value);
+                {packet.t(node.value);}
             if(node.children)
-                this.json2packet(node.children, packet);
+                {this.json2packet(node.children, packet);}
             packet.up();
         }
         // packet.up();
 function filterNodeFromPresenceJSON(pres, nodeName){
     var res = [];
     for(let i = 0; i < pres.length; i++)
-        if(pres[i].tagName === nodeName)
-            res.push(pres[i]);
+        {if(pres[i].tagName === nodeName)
+            {res.push(pres[i]);}}
 
     return res;
 }
 
                 // set correct initial state of locked
                 if (this.password)
-                    this.locked = true;
+                    {this.locked = true;}
 
                 this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
             }
 
             // store the new display name
             if(member.displayName)
-                memberOfThis.displayName = member.displayName;
+                {memberOfThis.displayName = member.displayName;}
         }
 
         // after we had fired member or room joined events, lets fire events
                 case "call-control":
                     var att = node.attributes;
                     if(!att)
-                        break;
+                        {break;}
                     this.phoneNumber = att.phone || null;
                     this.phonePin = att.pin || null;
                     this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
         {
             this.lastJibri = jibri;
             if(this.recording)
-                this.recording.handleJibriPresence(jibri);
+                {this.recording.handleJibriPresence(jibri);}
         }
     }
 
                 this.eventEmitter, this.connection, this.focusMucJid,
                 this.options.jirecon, this.roomjid);
             if(this.lastJibri)
-                this.recording.handleJibriPresence(this.lastJibri);
+                {this.recording.handleJibriPresence(this.lastJibri);}
         }
         logger.info("Ignore focus: " + from + ", real JID: " + mucJid);
     }
         delete this.lastPresences[jid];
 
         if(skipEvents)
-            return;
+            {return;}
 
         this.eventEmitter.emit(XMPPEvents.MUC_MEMBER_LEFT, jid);
 
             // we fire muc_left only if this is not a kick,
             // kick has both statuses 110 and 307.
             if (!isKick)
-                this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
+                {this.eventEmitter.emit(XMPPEvents.MUC_LEFT);}
         }
 
         if (isKick && this.myroomjid === from) {
     setVideoMute (mute, callback) {
         this.sendVideoInfoPresence(mute);
         if(callback)
-            callback(mute);
+            {callback(mute);}
     }
 
     setAudioMute (mute, callback) {
             this.sendPresence();
         }
         if(callback)
-            callback();
+            {callback();}
     }
 
     addVideoInfoToPresence (mute) {
     sendVideoInfoPresence (mute) {
         this.addVideoInfoToPresence(mute);
         if(!this.connection)
-            return;
+            {return;}
         this.sendPresence();
     }
 
      */
     isRecordingSupported () {
         if(this.recording)
-            return this.recording.isSupported();
+            {return this.recording.isSupported();}
         return false;
     }
 
      */
     toggleRecording (options, statusChangeHandler) {
         if(this.recording)
-            return this.recording.toggleRecording(options, statusChangeHandler);
+            {return this.recording.toggleRecording(options, statusChangeHandler);}
 
         return statusChangeHandler("error",
             new Error("The conference is not created yet!"));
      */
     isSIPCallingSupported () {
         if(this.moderator)
-            return this.moderator.isSipGatewayEnabled();
+            {return this.moderator.isSipGatewayEnabled();}
         return false;
     }
 

modules/xmpp/JingleSessionPC.js

                     protocol = protocol.toLowerCase();
                     if (protocol === 'tcp' || protocol === 'ssltcp') {
                         if (this.webrtcIceTcpDisable)
-                            return;
+                            {return;}
                     } else if (protocol == 'udp') {
                         if (this.webrtcIceUdpDisable)
-                            return;
+                            {return;}
                     }
                 }
             }
         // "closed" instead.
         // I suppose at some point this will be moved to onconnectionstatechange
         this.peerconnection.onsignalingstatechange = () => {
-            if (!this.peerconnection) return;
+            if (!this.peerconnection) {return;}
             if (this.peerconnection.signalingState === 'stable') {
                 this.wasstable = true;
             } else if (
          * the value of RTCPeerConnection.iceConnectionState changes.
          */
         this.peerconnection.oniceconnectionstatechange = () => {
-            if (!this.peerconnection) return;
+            if (!this.peerconnection) {return;}
             const now = window.performance.now();
             this.room.connectionTimes["ice.state." +
             this.peerconnection.iceConnectionState] = now;
                     break;
                 case 'disconnected':
                     if (this.closed)
-                        break;
+                        {break;}
                     this.isreconnect = true;
                     // Informs interested parties that the connection has been
                     // interrupted.
                     if (this.wasstable)
-                        this.room.eventEmitter.emit(
-                            XMPPEvents.CONNECTION_INTERRUPTED);
+                        {this.room.eventEmitter.emit(
+                            XMPPEvents.CONNECTION_INTERRUPTED);}
                     break;
                 case 'failed':
                     this.room.eventEmitter.emit(
                 if (this.drip_container.length === 0) {
                     // start 20ms callout
                     setTimeout(() => {
-                        if (this.drip_container.length === 0) return;
+                        if (this.drip_container.length === 0) {return;}
                         this.sendIceCandidates(this.drip_container);
                         this.drip_container = [];
                     }, 20);
                 $(this).find('>parameter').each(function () {
                     lines += 'a=ssrc:' + ssrc + ' ' + $(this).attr('name');
                     if ($(this).attr('value') && $(this).attr('value').length)
-                        lines += ':' + $(this).attr('value');
+                        {lines += ':' + $(this).attr('value');}
                     lines += '\r\n';
                 });
             });
             currentRemoteSdp.media.forEach(function(media, idx) {
                 if (!SDPUtil.find_line(media, 'a=mid:' + name))
-                    return;
+                    {return;}
                 if (!addSsrcInfo[idx]) {
                     addSsrcInfo[idx] = '';
                 }
             });
             currentRemoteSdp.media.forEach(function(media, idx) {
                 if (!SDPUtil.find_line(media, 'a=mid:' + name))
-                    return;
+                    {return;}
                 if (!removeSsrcInfo[idx]) {
                     removeSsrcInfo[idx] = '';
                 }
                 error.code = errorElSel.attr('code');
                 const errorReasonSel = $(errResponse).find('error :first');
                 if (errorReasonSel.length)
-                    error.reason = errorReasonSel[0].tagName;
+                    {error.reason = errorReasonSel[0].tagName;}
             }
 
             if (!errResponse) {
                 const desc = $(jingle.tree()).find(">jingle>content[name=\"" +
                     ssrcObj.mtype + "\"]>description");
                 if (!desc || !desc.length)
-                    return;
+                    {return;}
                 ssrcObj.ssrcs.forEach(function (ssrc) {
                     const sourceNode = desc.find(">source[ssrc=\"" +
                         ssrc + "\"]");
         let ssrcs = this.modifiedSSRCs["mute"];
         this.modifiedSSRCs["mute"] = [];
         if (ssrcs && ssrcs.length)
-            ssrcs.forEach(function (ssrcObj) {
+            {ssrcs.forEach(function (ssrcObj) {
                 ssrcObj.ssrcs.forEach(function (ssrc) {
                     const sourceNode
                         = $(jingle.tree()).find(">jingle>content[name=\"" +
                             group.ssrcs[0] + "\"])");
                     groupNode.remove();
                 });
-            });
+            });}
 
         ssrcs = this.modifiedSSRCs["remove"];
         this.modifiedSSRCs["remove"] = [];
         if (ssrcs && ssrcs.length)
-            ssrcs.forEach(function (ssrcObj) {
+            {ssrcs.forEach(function (ssrcObj) {
                 const desc
                     = JingleSessionPC.createDescriptionNode(
                         jingle, ssrcObj.mtype);
                             "</ssrc-group>");
                     }
                 });
-            });
+            });}
     }
 
     /**

modules/xmpp/SDP.js

     var result = false;
     Object.keys(medias).forEach(function (mediaindex) {
         if (result)
-            return;
+            {return;}
         if (medias[mediaindex].ssrcs[ssrc]) {
             result = true;
         }
         lines.pop(); // remove empty last element
         mline = SDPUtil.parse_mline(lines.shift());
         if (mline.media != 'audio')
-            continue;
+            {continue;}
         newdesc = '';
         mline.fmt.length = 0;
         for (j = 0; j < lines.length; j++) {
             if (lines[j].substr(0, 9) == 'a=rtpmap:') {
                 rtpmap = SDPUtil.parse_rtpmap(lines[j]);
                 if (rtpmap.name == 'CN' || rtpmap.name == 'ISAC')
-                    continue;
+                    {continue;}
                 mline.fmt.push(rtpmap.id);
             }
             newdesc += lines[j] + '\r\n';
             });
         // Optional stream count attribute
         if (sctpAttrs.length > 2)
-            elem.attrs({ streams: sctpAttrs[2]});
+            {elem.attrs({ streams: sctpAttrs[2]});}
         elem.up();
     }
     // XEP-0320
 
         var streamCount = sctp.attr('streams');
         if (streamCount)
-            media += ' ' + streamCount + '\r\n';
+            {media += ' ' + streamCount + '\r\n';}
         else
-            media += '\r\n';
+            {media += '\r\n';}
     }
 
     media += 'c=IN IP4 0.0.0.0\r\n';
     if (!sctp.length)
-        media += 'a=rtcp:1 IN IP4 0.0.0.0\r\n';
+        {media += 'a=rtcp:1 IN IP4 0.0.0.0\r\n';}
     tmp = content.find('>transport[xmlns="urn:xmpp:jingle:transports:ice-udp:1"]');
     if (tmp.length) {
         if (tmp.attr('ufrag')) {
             value = SDPUtil.filter_special_chars(value);
             media += 'a=ssrc:' + ssrc + ' ' + name;
             if (value && value.length)
-                media += ':' + value;
+                {media += ':' + value;}
             media += '\r\n';
         });
     });

modules/xmpp/SDPDiffer.js

     function arrayEquals(array) {
         // if the other array is a falsy value, return
         if (!array)
-            return false;
+            {return false;}
 
         // compare lengths - can save a lot of time
         if (this.length != array.length)
-            return false;
+            {return false;}
 
         for (var 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
                 if (!this[i].equals(array[i]))
-                    return false;
+                    {return false;}
             }
             else if (this[i] != array[i]) {
                 // Warning - two different object instances will never be

modules/xmpp/SDPUtil.js

             needles = [];
         for (var i = 0; i < lines.length; i++) {
             if (lines[i].substring(0, needle.length) == needle)
-                needles.push(lines[i]);
+                {needles.push(lines[i]);}
         }
         if (needles.length || !sessionpart) {
             return needles;
             return null;
         }
         if (line.substring(line.length - 2) == '\r\n') // chomp it
-            line = line.substring(0, line.length - 2);
+            {line = line.substring(0, line.length - 2);}
         var candidate = {},
             elems = line.split(' '),
             i;

modules/xmpp/recording.js

 Recording.prototype.handleJibriPresence = function (jibri) {
     var attributes = jibri.attributes;
     if(!attributes)
-        return;
+        {return;}
 
     var newState = attributes.status;
     logger.log("Handle jibri presence : ", newState);
 
     if (newState === this.state)
-        return;
+        {return;}
 
     if (newState === "undefined") {
         this.state = Recording.status.UNAVAILABLE;
         if (!this.state
             || this.state === "undefined"
             || this.state === Recording.status.UNAVAILABLE)
-            this.state = Recording.status.AVAILABLE;
+            {this.state = Recording.status.AVAILABLE;}
         else
-            this.state = Recording.status.OFF;
+            {this.state = Recording.status.OFF;}
     }
     else {
         this.state = newState;
     // If the recorder is currently unavailable we throw an error.
     if (oldState === Recording.status.UNAVAILABLE
         || oldState === Recording.status.FAILED)
-        statusChangeHandler(Recording.status.FAILED,
-                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
+        {statusChangeHandler(Recording.status.FAILED,
+                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);}
     else if (oldState === Recording.status.BUSY)
-        statusChangeHandler(Recording.status.BUSY,
-                            JitsiRecorderErrors.RECORDER_BUSY);
+        {statusChangeHandler(Recording.status.BUSY,
+                            JitsiRecorderErrors.RECORDER_BUSY);}
 
     // If we're about to turn ON the recording we need either a streamId or
     // an authentication token depending on the recording type. If we don't

modules/xmpp/strophe.emuc.js

 
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         if(!room)
-            return;
+            {return;}
 
         // Parse status.
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]' +
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         if(!room)
-            return;
+            {return;}
 
         room.onPresenceUnavailable(pres, from);
         return true;
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         if(!room)
-            return;
+            {return;}
 
         room.onPresenceError(pres, from);
         return true;
         const from = msg.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         if(!room)
-            return;
+            {return;}
 
         room.onMessage(msg, from);
         return true;
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         if(!room)
-            return;
+            {return;}
 
         room.onMute(iq);
         return true;

modules/xmpp/xmpp.js

                 pingJid,
                 function (hasPing) {
                     if (hasPing)
-                        this.connection.ping.startInterval(pingJid);
+                        {this.connection.ping.startInterval(pingJid);}
                     else
-                        logger.warn("Ping NOT supported by " + pingJid);
+                        {logger.warn("Ping NOT supported by " + pingJid);}
                 }.bind(this));
 
             if (password)
-                this.authenticatedUser = true;
+                {this.authenticatedUser = true;}
             if (this.connection && this.connection.connected &&
                 Strophe.getResourceFromJid(this.connection.jid)) {
                 // .connected is true while connecting?