[eslint] space-before-blocks

.eslintrc.js

         'padded-blocks': 0,
         'quote-props': 0,
         'semi': [ 'error', 'always' ],
+        'space-before-blocks': 2,
         'space-before-function-paren': [ 'error', 'never' ],
         'space-in-parens': [ 'error', 'never' ],
         'space-infix-ops': 2,

JitsiConference.js

  * @param name the display name to set
  */
 JitsiConference.prototype.setDisplayName = function(name) {
-    if (this.room){
+    if (this.room) {
         // remove previously set nickname
         this.room.removeFromPresence("nick");
 
  * Get a transcriber object for all current participants in this conference
  * @return {Transcriber} the transcriber object
  */
-JitsiConference.prototype.getTranscriber = function(){
-    if (this.transcriber === undefined){
+JitsiConference.prototype.getTranscriber = function() {
+    if (this.transcriber === undefined) {
         this.transcriber = new Transcriber();
         // add all existing local audio tracks to the transcriber
         const localAudioTracks = this.getLocalTracks(MediaType.AUDIO);
         }
         // and all remote audio tracks
         const remoteAudioTracks = this.rtc.getRemoteTracks(MediaType.AUDIO);
-        for (const remoteTrack of remoteAudioTracks){
+        for (const remoteTrack of remoteAudioTracks) {
             this.transcriber.addTrack(remoteTrack);
         }
     }
     // Add track to JitsiParticipant.
     participant._tracks.push(track);
 
-    if (this.transcriber){
+    if (this.transcriber) {
         this.transcriber.addTrack(track);
     }
 
                 this.eventEmitter.emit(
                     JitsiConferenceEvents.TRACK_REMOVED, removedTrack);
 
-                if (this.transcriber){
+                if (this.transcriber) {
                     this.transcriber.removeTrack(removedTrack);
                 }
 
     if (this.room) {
         return this.room.dial(number);
     }
-    return new Promise(function(resolve, reject){
+    return new Promise(function(resolve, reject) {
         reject(new Error("The conference is not created yet!"));
     });
 };
     if (this.room) {
         return this.room.hangup();
     }
-    return new Promise(function(resolve, reject){
+    return new Promise(function(resolve, reject) {
         reject(new Error("The conference is not created yet!"));
     });
 };
  * @param detailedFeedback detailed feedback from the user. Not yet used
  */
 JitsiConference.prototype.sendFeedback =
-function(overallFeedback, detailedFeedback){
+function(overallFeedback, detailedFeedback) {
     this.statistics.sendFeedback(overallFeedback, detailedFeedback);
 };
 

JitsiConferenceEventManager.js

 
             this.conference.connectionIsInterrupted = false;
 
-            for (key in chatRoom.connectionTimes){
+            for (key in chatRoom.connectionTimes) {
                 value = chatRoom.connectionTimes[key];
                 Statistics.analytics.sendEvent('conference.' + key,
                     {value});
             }
-            for (key in chatRoom.xmpp.connectionTimes){
+            for (key in chatRoom.xmpp.connectionTimes) {
                 value = chatRoom.xmpp.connectionTimes[key];
                 Statistics.analytics.sendEvent('xmpp.' + key,
                     {value});
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
     chatRoom.addListener(XMPPEvents.BRIDGE_DOWN,
-        function(){
+        function() {
             Statistics.analytics.sendEvent('conference.bridgeDown');
         });
 

JitsiMeetJS.js

                     for(let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
                         var mStream = track.getOriginalStream();
-                        if(track.getType() === MediaType.AUDIO){
+                        if(track.getType() === MediaType.AUDIO) {
                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                             track.addEventListener(
                                 JitsiTrackEvents.LOCAL_TRACK_STOPPED,
-                                function(){
+                                function() {
                                     Statistics.stopLocalStats(mStream);
                                 });
                         }

doc/example/example.js

  * Handles local tracks.
  * @param tracks Array with JitsiTrack objects
  */
-function onLocalTracks(tracks){
+function onLocalTracks(tracks) {
     localTracks = tracks;
     for(var i = 0; i < localTracks.length; i++) {
         localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_AUDIO_LEVEL_CHANGED,
 /**
  * That function is called when connection is established successfully
  */
-function onConnectionSuccess(){
+function onConnectionSuccess() {
     room = connection.initJitsiConference("conference", confOptions);
     room.on(JitsiMeetJS.events.conference.TRACK_ADDED, onRemoteTrack);
     room.on(JitsiMeetJS.events.conference.TRACK_REMOVED, function(track) {
         console.log("track removed!!!" + track);
     });
     room.on(JitsiMeetJS.events.conference.CONFERENCE_JOINED, onConferenceJoined);
-    room.on(JitsiMeetJS.events.conference.USER_JOINED, function(id){
+    room.on(JitsiMeetJS.events.conference.USER_JOINED, function(id) {
         console.log("user join");remoteTracks[id] = [];
     });
     room.on(JitsiMeetJS.events.conference.USER_LEFT, onUserLeft);
         console.log(userID + " - " + displayName);
     });
     room.on(JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
-      function(userID, audioLevel){
+      function(userID, audioLevel) {
           console.log(userID + " - " + audioLevel);
       });
     room.on(JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED, function() {
 /**
  * This function is called when we disconnect.
  */
-function disconnect(){
+function disconnect() {
     console.log("disconnect!");
     connection.removeEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);
     connection.removeEventListener(JitsiMeetJS.events.connection.CONNECTION_FAILED, onConnectionFailed);
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
 };
-JitsiMeetJS.init(initOptions).then(function(){
+JitsiMeetJS.init(initOptions).then(function() {
     connection = new JitsiMeetJS.JitsiConnection(null, null, options);
 
     connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);

modules/RTC/DataChannels.js

  * Closes all currently opened data channels.
  */
 DataChannels.prototype.closeAllChannels = function() {
-    this._dataChannels.forEach(function(dc){
+    this._dataChannels.forEach(function(dc) {
         // the DC will be removed from the array on 'onclose' event
         dc.close();
     });

modules/RTC/JitsiLocalTrack.js

     var self = this;
     var promise = Promise.resolve();
 
-    if (this.conference){
+    if (this.conference) {
         promise = this.conference.removeTrack(this);
     }
 
         = this.conference ? this.conference.getConnectionState() : null;
     if(this._testByteSent && "connected" === iceConnectionState) {
         setTimeout(function() {
-            if(this._bytesSent <= 0){
+            if(this._bytesSent <= 0) {
                 // we are not receiving anything from the microphone
                 this._fireNoDataFromSourceEvent();
             }

modules/RTC/JitsiTrack.js

  * @param ssrc the SSRC of this track if known
  */
 function JitsiTrack(conference, stream, track, streamInactiveHandler, trackMediaType,
-                    videoType, ssrc){
+                    videoType, ssrc) {
     /**
      * Array with the HTML elements that are displaying the streams.
      * @type {Array}

modules/RTC/RTC.js

 function createLocalTracks(tracksInfo, options) {
     var newTracks = [];
     var deviceId = null;
-    tracksInfo.forEach(function(trackInfo){
+    tracksInfo.forEach(function(trackInfo) {
         if (trackInfo.mediaType === MediaType.AUDIO) {
             deviceId = options.micDeviceId;
-        } else if (trackInfo.videoType === VideoType.CAMERA){
+        } else if (trackInfo.videoType === VideoType.CAMERA) {
             deviceId = options.cameraDeviceId;
         }
         var localTrack
      */
     setAudioMute(value) {
         const mutePromises = [];
-        this.getLocalTracks(MediaType.AUDIO).forEach(function(audioTrack){
+        this.getLocalTracks(MediaType.AUDIO).forEach(function(audioTrack) {
             // this is a Promise
             mutePromises.push(value ? audioTrack.mute() : audioTrack.unmute());
         });

modules/RTC/RTCUtils.js

 
             options.devices = options.devices || ['audio', 'video'];
             if(!screenObtainer.isSupported()
-                && options.devices.indexOf("desktop") !== -1){
+                && options.devices.indexOf("desktop") !== -1) {
                 reject(new Error("Desktop sharing is not supported!"));
             }
             if (RTCBrowserType.isFirefox()
                     "video": GUM.bind(self, ["video"])
                 };
 
-                if(screenObtainer.isSupported()){
+                if(screenObtainer.isSupported()) {
                     deviceGUM["desktop"] = screenObtainer.obtainStream.bind(
                         screenObtainer,
                         dsOptions);

modules/RTC/ScreenObtainer.js

         } else if (RTCBrowserType.isFirefox()) {
             if (options.desktopSharingFirefoxDisabled) {
                 obtainDesktopStream = null;
-            } else if (window.location.protocol === "http:"){
+            } else if (window.location.protocol === "http:") {
                 logger.log("Screen sharing is not supported over HTTP. " +
                     "Use of HTTPS is required.");
                 obtainDesktopStream = null;
  * @param options supports "desktopSharingChromeExtId"
  * @returns {string}
  */
-function getWebStoreInstallUrl(options){
+function getWebStoreInstallUrl(options) {
     return "https://chrome.google.com/webstore/detail/" +
         options.desktopSharingChromeExtId;
 }
  * website of published extension.
  * @param options supports "desktopSharingChromeExtId"
  */
-function initInlineInstalls(options){
+function initInlineInstalls(options) {
     if($("link[rel=chrome-webstore-item]").length === 0) {
         $("head").append("<link rel=\"chrome-webstore-item\">");
     }

modules/RTC/TraceablePeerConnection.js

 
     const remoteSDP = new SDP(this.remoteDescription.sdp);
     const mediaLines = remoteSDP.media.filter(
-        function(mediaLines){
+        function(mediaLines) {
             return mediaLines.startsWith("m=" + mediaType);
         });
     if (!mediaLines.length) {
 
             if (Array.isArray(mLine.ssrcs)) {
                 var i;
-                for (i = 0; i < mLine.ssrcs.length; i++){
+                for (i = 0; i < mLine.ssrcs.length; i++) {
                     if (typeof mLine.ssrcs[i] === 'object'
                         && typeof mLine.ssrcs[i].id !== 'undefined'
                         && firstSsrcs.indexOf(mLine.ssrcs[i].id) >= 0) {
                     }
                 }
 
-                for (i = 0; i < mLine.ssrcs.length; i++){
+                for (i = 0; i < mLine.ssrcs.length; i++) {
                     if (typeof mLine.ssrcs[i] !== 'undefined') {
                         newSsrcLines.push(mLine.ssrcs[i]);
                     }

modules/statistics/CallStats.js

  * @param {RTCPeerConnection} pc connection on which failure occured.
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.prototype.sendIceConnectionFailedEvent = _try_catch(function(pc, cs){
+CallStats.prototype.sendIceConnectionFailedEvent = _try_catch(function(pc, cs) {
     CallStats._reportError.call(
         cs, wrtcFuncNames.iceConnectionFailure, null, pc);
 });

modules/statistics/RTPStatsCollector.js

                     "upload": Math.round(sendBandwidth / 1000)
                 };
             }
-        } catch(e){/* not supported*/}
+        } catch(e) {/* not supported*/}
 
         if(now.type == 'googCandidatePair') {
             var ip, type, localip, active;
                 type = getStatValue(now, "transportType");
                 localip = getStatValue(now, "localAddress");
                 active = getStatValue(now, "activeConnection");
-            } catch(e){/* not supported*/}
+            } catch(e) {/* not supported*/}
             if(!ip || !type || !localip || active != "true") {
                 continue;
             }
         if(typeof nowBytesTransmitted === "number" ||
             typeof nowBytesTransmitted === "string") {
             nowBytesTransmitted = Number(nowBytesTransmitted);
-            if(!isNaN(nowBytesTransmitted)){
+            if(!isNaN(nowBytesTransmitted)) {
                 byteSentStats[ssrc] = nowBytesTransmitted;
                 if (nowBytesTransmitted > 0) {
                     bytesSent = nowBytesTransmitted -
                 resolution.height = height;
                 resolution.width = width;
             }
-        } catch(e){/* not supported*/}
+        } catch(e) {/* not supported*/}
 
         if (resolution.height && resolution.width) {
             ssrcStats.setResolution(resolution);

modules/statistics/statistics.js

     }
 
     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;

modules/transcription/audioRecorder.js

  * single JitsiTrack (either remote or local)
  * @param track The JitsiTrack the object is going to hold
  */
-var TrackRecorder = function(track){
+var TrackRecorder = function(track) {
     // The JitsiTrack holding the stream
     this.track = track;
     // The MediaRecorder recording the stream
  * This will also try to update the name
  * @param trackRecorder the TrackRecorder to stop
  */
-function stopRecorder(trackRecorder){
+function stopRecorder(trackRecorder) {
     if(trackRecorder.recorder === undefined) {
         throw new Error("Passed an object to stopRecorder which is not a " +
             "TrackRecorder object");
     // Create a new stream which only holds the audio track
     var originalStream = trackRecorder.track.getOriginalStream();
     var stream = createEmptyStream();
-    originalStream.getAudioTracks().forEach(function(track){
+    originalStream.getAudioTracks().forEach(function(track) {
         stream.addTrack(track);
     });
     // Create the MediaRecorder
  * @param jitsiConference the jitsiConference which this object
  * is going to record
  */
-var audioRecorder = function(jitsiConference){
+var audioRecorder = function(jitsiConference) {
     // array of TrackRecorders, where each trackRecorder
     // holds the JitsiTrack, MediaRecorder and recorder data
     this.recorders = [];
         this.updateNames();
         // If we're already recording, immediately start recording this new
         // track.
-        if(this.isRecording){
+        if(this.isRecording) {
             startRecorder(trackRecorder);
         }
     }
  *
  * @param {JitsiTrack} track the JitsiTrack to remove from the recording session
  */
-audioRecorder.prototype.removeTrack = function(track){
-    if(track.isVideoTrack()){
+audioRecorder.prototype.removeTrack = function(track) {
+    if(track.isVideoTrack()) {
         return;
     }
 
     var array = this.recorders;
     var i;
     for(i = 0; i < array.length; i++) {
-        if(array[i].track.getParticipantId() === track.getParticipantId()){
+        if(array[i].track.getParticipantId() === track.getParticipantId()) {
             var recorderToRemove = array[i];
-            if(this.isRecording){
+            if(this.isRecording) {
                 stopRecorder(recorderToRemove);
             } else {
                 // remove the TrackRecorder from the array
  * If it hasn't changed,it will keep the exiting name. If it changes to a
  * undefined value, the old value will also be kept.
  */
-audioRecorder.prototype.updateNames = function(){
+audioRecorder.prototype.updateNames = function() {
     var conference = this.jitsiConference;
-    this.recorders.forEach(function(trackRecorder){
-        if(trackRecorder.track.isLocal()){
+    this.recorders.forEach(function(trackRecorder) {
+        if(trackRecorder.track.isLocal()) {
             trackRecorder.name = "the transcriber";
         } else {
             var id = trackRecorder.track.getParticipantId();
     // conference, that track can instantly start recording as well
     this.isRecording = true;
     // start all the mediaRecorders
-    this.recorders.forEach(function(trackRecorder){
+    this.recorders.forEach(function(trackRecorder) {
         startRecorder(trackRecorder);
     });
     // log that recording has started
     // set the boolean flag to false
     this.isRecording = false;
     // stop all recorders
-    this.recorders.forEach(function(trackRecorder){
+    this.recorders.forEach(function(trackRecorder) {
         stopRecorder(trackRecorder);
     });
     console.log("stopped recording");

modules/transcription/recordingResult.js

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

modules/transcription/transcriber.js

  * purposes
  */
 transcriber.prototype.start = function start() {
-    if(this.state !== BEFORE_STATE){
+    if(this.state !== BEFORE_STATE) {
         throw new Error("The transcription can only start when it's in the" +
             "\"" + BEFORE_STATE + "\" state. It's currently in the " +
             "\"" + this.state + "\" state");
  * @param callback a callback which will receive the transcription
  */
 transcriber.prototype.stop = function stop(callback) {
-    if(this.state !== RECORDING_STATE){
+    if(this.state !== RECORDING_STATE) {
         throw new Error("The transcription can only stop when it's in the" +
             "\"" + RECORDING_STATE + "\" state. It's currently in the " +
             "\"" + this.state + "\" state");
     var t = this;
 
     var callBack = blobCallBack.bind(this);
-    this.audioRecorder.getRecordingResults().forEach(function(recordingResult){
+    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){
+var 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
  * this method will check if the counter is zero. If it is, it will call
  * the merging method
  */
-transcriber.prototype.maybeMerge = function(){
-    if(this.state === TRANSCRIBING_STATE && this.counter === 0){
+transcriber.prototype.maybeMerge = function() {
+    if(this.state === TRANSCRIBING_STATE && this.counter === 0) {
         // make sure to include the events in the result arrays before
         // merging starts
         this.merge();
     hasPopulatedArrays(arrays);
 
     // populate all the potential Words for a first time
-    arrays.forEach(function(array){
+    arrays.forEach(function(array) {
         pushWordToSortedArray(potentialWords, array);
     });
 
     var lowestWordArray;
     var wordToAdd;
     var foundSmaller;
-    while(hasPopulatedArrays(arrays)){
+    while(hasPopulatedArrays(arrays)) {
         // first select the lowest array;
         lowestWordArray = arrays[0];
-        arrays.forEach(function(wordArray){
-            if(wordArray[0].begin < lowestWordArray[0].begin){
+        arrays.forEach(function(wordArray) {
+            if(wordArray[0].begin < lowestWordArray[0].begin) {
                 lowestWordArray = wordArray;
             }
         });
 
         // keep going until a word in another array has a smaller time
         // or the array is empty
-        while(!foundSmaller && lowestWordArray.length > 0){
-            arrays.forEach(function(wordArray){
-                if(wordArray[0].begin < lowestWordArray[0].begin){
+        while(!foundSmaller && lowestWordArray.length > 0) {
+            arrays.forEach(function(wordArray) {
+                if(wordArray[0].begin < lowestWordArray[0].begin) {
                     foundSmaller = true;
                 }
             });
             // add next word if no smaller time has been found
-            if(!foundSmaller){
+            if(!foundSmaller) {
                 wordToAdd = lowestWordArray.shift();
                 this.updateTranscription(wordToAdd, null);
             }
 
     // set the state to finished and do the necessary left-over tasks
     this.state = FINISHED_STATE;
-    if(this.callback){
+    if(this.callback) {
         this.callback(this.transcription);
     }
 };
  * @param {Word} word the Word object holding the word to append
  * @param {String|null} name the name of a new speaker. Null if not applicable
  */
-transcriber.prototype.updateTranscription = function(word, name){
-    if(name !== undefined && name !== null){
+transcriber.prototype.updateTranscription = function(word, name) {
+    if(name !== undefined && name !== null) {
         this.transcription += "\n" + name + ":";
         this.lineLength = name.length + 1; // +1 for the semi-colon
     }
-    if(this.lineLength + word.word.length > MAXIMUM_SENTENCE_LENGTH){
+    if(this.lineLength + word.word.length > MAXIMUM_SENTENCE_LENGTH) {
         this.transcription += "\n    ";
         this.lineLength = 4; // because of the 4 spaces after the new line
     }
  * @param {Array<Array>} twoDimensionalArray the array to check
  * @returns {boolean} true if any non-zero arrays inside, otherwise false
  */
-var hasPopulatedArrays = function(twoDimensionalArray){
+var hasPopulatedArrays = function(twoDimensionalArray) {
     var i;
-    for(i = 0; i < twoDimensionalArray.length; i++){
-        if(twoDimensionalArray[i].length === 0){
+    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){
+var pushWordToSortedArray = function(array, word) {
     if(array.length === 0) {
         array.push(word);
     } else{
-        if(array[array.length - 1].begin <= word.begin){
+        if(array[array.length - 1].begin <= word.begin) {
             array.push(word);
             return;
         }
         var i;
-        for(i = 0; i < array.length; i++){
-            if(word.begin < array[i].begin){
+        for(i = 0; i < array.length; i++) {
+            if(word.begin < array[i].begin) {
                 array.splice(i, 0, word);
                 return;
             }
  * audiostream, it will not be added by the audioRecorder
  * @param {JitsiTrack} track the track to give to the audioRecorder
  */
-transcriber.prototype.addTrack = function(track){
+transcriber.prototype.addTrack = function(track) {
     this.audioRecorder.addTrack(track);
 };
 
  * Remove the given track from the auioRecorder
  * @param track
  */
-transcriber.prototype.removeTrack = function(track){
+transcriber.prototype.removeTrack = function(track) {
     this.audioRecorder.removeTrack(track);
 };
 
  * when it's not done yet
  * @returns {String} the transcription as a String
  */
-transcriber.prototype.getTranscription = function(){
-    if(this.state !== FINISHED_STATE){
+transcriber.prototype.getTranscription = function() {
+    if(this.state !== FINISHED_STATE) {
         throw new Error("The transcription can only be retrieved when it's in" +
             " the\"" + FINISHED_STATE + "\" state. It's currently in the " +
             "\"" + this.state + "\" state");
 /**
  * Returns the current state of the transcription process
  */
-transcriber.prototype.getState = function(){
+transcriber.prototype.getState = function() {
     return this.state;
 };
 

modules/transcription/transcriberHolder.js

 var transcriberHolder = {
     transcribers : [],
 
-    add(transcriber){
+    add(transcriber) {
         transcriberHolder.transcribers.push(transcriber);
     }
 };

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

  * @param {Function} callback  which will retrieve the a RecordingResult with
  *        the answer as a WordArray
  */
-TranscriptionService.prototype.send = function send(recordingResult, callback){
+TranscriptionService.prototype.send = function send(recordingResult, callback) {
     var t = this;
-    this.sendRequest(recordingResult.blob, function(response){
-        if(!t.verify(response)){
+    this.sendRequest(recordingResult.blob, function(response) {
+        if(!t.verify(response)) {
             console.log("the retrieved response from the server" +
                    " is not valid!");
             recordingResult.wordArray = [];
  * @return {Array<Word>} an array of Word objects
  */
 // eslint-disable-next-line no-unused-vars
-TranscriptionService.prototype.formatResponse = function(response){
+TranscriptionService.prototype.formatResponse = function(response) {
     throw new Error("TranscriptionService.format is abstract");
 };
 
  * @return {boolean} true if response is valid, false otherwise
  */
 // eslint-disable-next-line no-unused-vars
-TranscriptionService.prototype.verify = function(response){
+TranscriptionService.prototype.verify = function(response) {
     throw new Error("TranscriptionService.verify is abstract");
 };
 

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

     // the first value in the JSON array
     result.shift();
     var array = [];
-    result.forEach(function(word){
+    result.forEach(function(word) {
         if(!word.filler) {
             array.push(new Word(word.word, word.start, word.end));
         }
  * @param response the server response
  * @return {boolean} whether the response is valid
  */
-SphinxService.prototype.verify = function(response){
+SphinxService.prototype.verify = function(response) {
     console.log("response from server:" + response.toString());
     // test if server responded with a string object
-    if(typeof response !== "string"){
+    if(typeof response !== "string") {
         return false;
     }
     // test if the string can be parsed into valid JSON
     var json;
     try{
         json = JSON.parse(response);
-    } catch (error){
+    } catch (error) {
         console.log(error);
         return false;
     }
     // check if the JSON has a "objects" value
-    if(json.objects === undefined){
+    if(json.objects === undefined) {
         return false;
     }
     // get the "objects" value and check for a session ID
     var array = json.objects;
-    if(!(array[0] && array[0]["session-id"])){
+    if(!(array[0] && array[0]["session-id"])) {
         return false;
     }
     // everything seems to be in order
 function getURL() {
     var message = "config does not contain an url to a " +
     "Sphinx4 https server";
-    if(config.sphinxURL === undefined){
+    if(config.sphinxURL === undefined) {
         console.log(message);
     } else {
         var toReturn = config.sphinxURL;
-        if(toReturn.includes !== undefined && toReturn.includes("https://")){
+        if(toReturn.includes !== undefined && toReturn.includes("https://")) {
             return toReturn;
         } else{
             console.log(message);

modules/version/ComponentsVersions.js

         }
 
         var log = [];
-        node.children.forEach(function(item){
+        node.children.forEach(function(item) {
 
             var componentName = item.attributes.name;
             if (componentName !== ComponentsVersions.FOCUS_COMPONENT &&

modules/xmpp/ChatRoom.js

     json2packet(nodes, packet) {
         for(let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
-            if(!node || node === null){
+            if(!node || node === null) {
                 continue;
             }
             packet.c(node.tagName, node.attributes);
  * @param pres the presence JSON
  * @param nodeName the name of the node (videomuted, audiomuted, etc)
  */
-function filterNodeFromPresenceJSON(pres, nodeName){
+function filterNodeFromPresenceJSON(pres, nodeName) {
     var res = [];
     for(let i = 0; i < pres.length; i++) {
         if(pres[i].tagName === nodeName) {

modules/xmpp/SDPDiffer.js

 var SDPUtil = require("./SDPUtil");
 
-function SDPDiffer(mySDP, otherSDP){
+function SDPDiffer(mySDP, otherSDP) {
     this.mySDP = mySDP;
     this.otherSDP = otherSDP;
 }
             if(Object.keys(myMedia.ssrcs).indexOf(ssrc) === -1) {
                 // Allocate channel if we've found ssrc that doesn't exist in
                 // our channel
-                if(!newMedia[othersMediaIdx]){
+                if(!newMedia[othersMediaIdx]) {
                     newMedia[othersMediaIdx] = {
                         mediaindex: othersMedia.mediaindex,
                         mid: othersMedia.mid,
         });
 
         // Look for new ssrc groups across the channels
-        othersMedia.ssrcGroups.forEach(function(otherSsrcGroup){
+        othersMedia.ssrcGroups.forEach(function(otherSsrcGroup) {
 
             // try to match the other ssrc-group with an ssrc-group of ours
             var matched = false;
                 // Allocate channel if we've found an ssrc-group that doesn't
                 // exist in our channel
 
-                if(!newMedia[othersMediaIdx]){
+                if(!newMedia[othersMediaIdx]) {
                     newMedia[othersMediaIdx] = {
                         mediaindex: othersMedia.mediaindex,
                         mid: othersMedia.mid,
     var sdpMediaSsrcs = this.getNewMedia();
 
     var modified = false;
-    Object.keys(sdpMediaSsrcs).forEach(function(mediaindex){
+    Object.keys(sdpMediaSsrcs).forEach(function(mediaindex) {
         modified = true;
         var media = sdpMediaSsrcs[mediaindex];
         modify.c('content', {name: media.mid});

modules/xmpp/recording.js

 Recording.prototype.setRecordingJibri
     = function(state, callback, errCallback, options) {
 
-        if (state == this.state){
+        if (state == this.state) {
             errCallback(JitsiRecorderErrors.INVALID_STATE);
         }
         options = options || {};
 Recording.prototype.setRecordingJirecon =
     function(state, callback, errCallback) {
 
-        if (state == this.state){
+        if (state == this.state) {
             errCallback(new Error("Invalid state!"));
         }
 
                 ? Recording.action.START
                 : Recording.action.STOP,
             mucjid: this.roomjid});
-        if (state === 'off'){
+        if (state === 'off') {
             iq.attrs({rid: this.jireconRid});
         }
 
                 (state === Recording.status.ON ? 'started' : 'stopped') +
                 '(jirecon)' + result);
             self.state = state;
-            if (state === Recording.status.OFF){
+            if (state === Recording.status.OFF) {
                 self.jireconRid = null;
             }
 
             callback(newState);
 
             if (newState === 'pending') {
-                self.connection.addHandler(function(iq){
+                self.connection.addHandler(function(iq) {
                     var state = $(iq).find('recording').attr('state');
                     if (state) {
                         self.state = newState;
 
 Recording.prototype.setRecording =
 function(state, callback, errCallback, options) {
-    switch(this.type){
+    switch(this.type) {
     case Recording.types.JIRECON:
         this.setRecordingJirecon(state, callback, errCallback, options);
         break;