[eslint] lines-around-comment

.eslintrc.js

         'key-spacing': 2,
         'keyword-spacing': 2,
         'linebreak-style': [ 'error', 'unix' ],
+        'lines-around-comment': [
+            'error',
+            {
+                'allowBlockStart': true,
+                'allowObjectStart': true,
+                'beforeBlockComment': true,
+                'beforeLineComment': true
+            }
+        ],
         'max-lines': 0,
         'max-nested-callbacks': 2,
         'max-statements': 0,

JitsiConference.js

     this._init(options);
     this.componentsVersions = new ComponentsVersions(this);
     this.participants = {};
+
     /**
      * Jingle Session instance
      * @type {JingleSessionPC}
         video: undefined
     };
     this.isMutedByFocus = false;
+
     // Flag indicates if the 'onCallEnded' method was ever called on this
     // instance. Used to log extra analytics event for debugging purpose.
     // We need to know if the potential issue happened before or after
     if (options.connection) {
         this.connection = options.connection;
         this.xmpp = this.connection.xmpp;
+
         // Setup XMPP events only if we have new connection object.
         this.eventManager.setupXMPPListeners();
     }
             // ChatRoom instance.
             this.getParticipants().forEach(
                 participant => this.onMemberLeft(participant.getJid()));
+
             // Close the JingleSession
             if (this.jingleSession) {
                 this.jingleSession.close();
 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);
 
         for (const localAudio of localAudioTracks) {
             this.transcriber.addTrack(localAudio);
         }
+
         // and all remote audio tracks
         const remoteAudioTracks = this.rtc.getRemoteTracks(MediaType.AUDIO);
 
     // check if track was muted by focus and now is unmuted by user
     if (this.isMutedByFocus && track.isAudioTrack() && !track.isMuted()) {
         this.isMutedByFocus = false;
+
         // unmute local user on server
         this.room.muteParticipant(this.room.myroomjid, false);
     }
             return Promise.reject(
                 new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED));
         }
+
         // Set up the ssrcHandler for the new track before we add it at the lower levels
         newTrack.ssrcHandler = function(conference, ssrcMap) {
             const trackSSRCInfo = ssrcMap.get(this.getMSID());
     // Accept incoming call
     this.jingleSession = jingleSession;
     this.room.connectionTimes['session.initiate'] = now;
+
     // Log "session.restart"
     if (this.wasStopped) {
         Statistics.sendEventToAll('session.restart');
     }
+
     // add info whether call is cross-region
     let crossRegion = null;
 
     }
 
     this.rtc.initializeDataChannels(jingleSession.peerconnection);
+
     // Add local Tracks to the ChatRoom
     this.getLocalTracks().forEach(localTrack => {
         let ssrcInfo = null;
+
         /**
          * We don't do this for Firefox because, on Firefox, we keep the
          *  stream in the peer connection and just set 'enabled' on the
             logger.error(e);
         }
     });
+
     // Generate the 'recvonly' SSRC in case there are no video tracks
     if (!this.getLocalTracks(MediaType.VIDEO).length) {
         jingleSession.generateRecvonlySsrc();
 = function(JingleSession, reasonCondition, reasonText) {
     logger.info(`Call ended: ${reasonCondition} - ${reasonText}`);
     this.wasStopped = true;
+
     // Send session.terminate event
     Statistics.sendEventToAll('session.terminate');
+
     // Stop the stats
     if (this.statistics) {
         this.statistics.stopRemoteStats();
         this.statistics.stopCallStats();
     }
+
     // Current JingleSession is invalid so set it to null on the room
     this.jingleSession = null;
+
     // Let the RTC service do any cleanups
     this.rtc.onCallEnded();
+
     // PeerConnection has been closed which means that SSRCs stored in
     // JitsiLocalTrack will not match those assigned by the old PeerConnection
     // and SSRC replacement logic will not work as expected.
     this.getLocalTracks().forEach(localTrack => {
         // Reset SSRC as it will no longer be valid
         localTrack._setSSRC(null);
+
         // Bind the handler to fetch new SSRC, it will un register itself once
         // it reads the values
         self.rtc.addListener(

JitsiConferenceErrors.js

  * Indicates that client must be authenticated to create the conference.
  */
 export const AUTHENTICATION_REQUIRED = 'conference.authenticationRequired';
+
 /**
  * Indicates that chat error occurred.
  */
 export const CHAT_ERROR = 'conference.chatError';
+
 /**
  * Indicates that conference has been destroyed.
  */
 export const CONFERENCE_DESTROYED = 'conference.destroyed';
+
 /**
  * Indicates that max users limit has been reached.
  */
 export const CONFERENCE_MAX_USERS = 'conference.max_users';
+
 /**
  * Indicates that a connection error occurred when trying to join a conference.
  */
 export const CONNECTION_ERROR = 'conference.connectionError';
+
 /**
  * Indicates that a connection error is due to not allowed,
  * occurred when trying to join a conference.
  */
 export const NOT_ALLOWED_ERROR = 'conference.connectionError.notAllowed';
+
 /**
  * Indicates that focus error happened.
  */
 export const FOCUS_DISCONNECTED = 'conference.focusDisconnected';
+
 /**
  * Indicates that focus left the conference.
  */
 export const FOCUS_LEFT = 'conference.focusLeft';
+
 /**
  * Indicates that graceful shutdown happened.
  */
 export const GRACEFUL_SHUTDOWN = 'conference.gracefulShutdown';
+
 /**
  * Indicates that the versions of the server side components are incompatible
  * with the client side.
  */
 export const INCOMPATIBLE_SERVER_VERSIONS
     = 'conference.incompatible_server_versions';
+
 /**
  * Indicates that jingle fatal error happened.
  */
 export const JINGLE_FATAL_ERROR = 'conference.jingleFatalError';
+
 /**
  * Indicates that password cannot be set for this conference.
  */
 export const PASSWORD_NOT_SUPPORTED = 'conference.passwordNotSupported';
+
 /**
  * Indicates that a password is required in order to join the conference.
  */
 export const PASSWORD_REQUIRED = 'conference.passwordRequired';
+
 /**
  * Indicates that reservation system returned error.
  */
 export const RESERVATION_ERROR = 'conference.reservationError';
+
 /**
  * Indicates that the conference setup failed.
  */
 export const SETUP_FAILED = 'conference.setup_failed';
+
 /**
  * Indicates that there is no available videobridge.
  */

JitsiConferenceEventManager.js

 
     this.chatRoomForwarder.forward(XMPPEvents.MUC_JOINED,
         JitsiConferenceEvents.CONFERENCE_JOINED);
+
     // send some analytics events
     chatRoom.addListener(XMPPEvents.MUC_JOINED,
         () => {
 
         conference.rtc.setAudioLevel(resource, level);
     });
+
     // Forward the "before stats disposed" event
     conference.statistics.addBeforeDisposedListener(() => {
         conference.eventEmitter.emit(

JitsiConferenceEvents.js

  * Indicates that authentication status changed.
  */
 export const AUTH_STATUS_CHANGED = 'conference.auth_status_changed';
+
 /**
  * Indicates that available devices changed.
  */
 export const AVAILABLE_DEVICES_CHANGED = 'conference.availableDevicesChanged';
+
 /**
  * A participant avatar has changed.
  */
  * Indicates that an error occured.
  */
 export const CONFERENCE_ERROR = 'conference.error';
+
 /**
  * Indicates that conference failed.
  */
 export const CONFERENCE_FAILED = 'conference.failed';
+
 /**
  * Indicates that conference has been joined. The event does NOT provide any
  * parameters to its listeners.
  */
 export const CONFERENCE_JOINED = 'conference.joined';
+
 /**
  * Indicates that conference has been left.
  */
 export const CONFERENCE_LEFT = 'conference.left';
+
 /**
  * Indicates that the connection to the conference has been interrupted for some
  * reason.
  */
 export const CONNECTION_INTERRUPTED = 'conference.connectionInterrupted';
+
 /**
  * Indicates that the connection to the conference has been restored.
  */
 export const CONNECTION_RESTORED = 'conference.connectionRestored';
+
 /**
  * New local connection statistics are received.
  * @deprecated Use ConnectionQualityEvents.LOCAL_STATS_UPDATED instead.
  */
 export const CONNECTION_STATS = 'conference.connectionStats';
+
 /**
  * A user has changed it display name
  */
 export const DISPLAY_NAME_CHANGED = 'conference.displayNameChanged';
+
 /**
  * The dominant speaker was changed.
  */
 export const DOMINANT_SPEAKER_CHANGED = 'conference.dominantSpeaker';
+
 /**
  * Indicates that DTMF support changed.
  */
 export const DTMF_SUPPORT_CHANGED = 'conference.dtmfSupportChanged';
+
 /**
  * Indicates that a message from another participant is received on data
  * channel.
  */
 export const ENDPOINT_MESSAGE_RECEIVED = 'conference.endpoint_message_received';
+
 /**
  * You are included / excluded in somebody's last N set
  */
 export const IN_LAST_N_CHANGED = 'conference.inLastNChanged';
+
 /**
  * You are kicked from the conference.
  */
 export const KICKED = 'conferenece.kicked';
+
 /**
  * The Last N set is changed.
  */
 export const LAST_N_ENDPOINTS_CHANGED = 'conference.lastNEndpointsChanged';
+
 /**
  * Indicates that the room has been locked or unlocked.
  */
 export const LOCK_STATE_CHANGED = 'conference.lock_state_changed';
+
 /**
  * New text message was received.
  */
 export const MESSAGE_RECEIVED = 'conference.messageReceived';
+
 /**
  * Event fired when JVB sends notification about interrupted/restored user's
  * ICE connection status. First argument is the ID of the participant and
  */
 export const PARTICIPANT_CONN_STATUS_CHANGED
     = 'conference.participant_conn_status_changed';
+
 /**
  * Indicates that the features of the participant has been changed.
  */
 export const PARTCIPANT_FEATURES_CHANGED
     = 'conference.partcipant_features_changed';
+
 /**
  * Indicates that a the value of a specific property of a specific participant
  * has changed.
  */
 export const PARTICIPANT_PROPERTY_CHANGED
     = 'conference.participant_property_changed';
+
 /**
  * Indicates that phone number changed.
  */
 export const PHONE_NUMBER_CHANGED = 'conference.phoneNumberChanged';
+
 /**
  * Indicates that recording state changed.
  */
 export const RECORDER_STATE_CHANGED = 'conference.recorderStateChanged';
+
 /**
  * Indicates that start muted settings changed.
  */
 export const START_MUTED_POLICY_CHANGED
     = 'conference.start_muted_policy_changed';
+
 /**
  * Indicates that the local user has started muted.
  */
 export const STARTED_MUTED = 'conference.started_muted';
+
 /**
  * Indicates that subject of the conference has changed.
  */
 export const SUBJECT_CHANGED = 'conference.subjectChanged';
+
 /**
  * Indicates that DTMF support changed.
  */
 export const SUSPEND_DETECTED = 'conference.suspendDetected';
+
 /**
  * Event indicates that local user is talking while he muted himself
  */
 export const TALK_WHILE_MUTED = 'conference.talk_while_muted';
+
 /**
  * A new media track was added to the conference. The event provides the
  * following parameters to its listeners:
  * @param {JitsiTrack} track the added JitsiTrack
  */
 export const TRACK_ADDED = 'conference.trackAdded';
+
 /**
  * Audio levels of a media track ( attached to the conference) was changed.
  */
 export const TRACK_AUDIO_LEVEL_CHANGED = 'conference.audioLevelsChanged';
+
 /**
  * A media track ( attached to the conference) mute status was changed.
  */
 export const TRACK_MUTE_CHANGED = 'conference.trackMuteChanged';
+
 /**
  * The media track was removed from the conference. The event provides the
  * following parameters to its listeners:
  * @param {JitsiTrack} track the removed JitsiTrack
  */
 export const TRACK_REMOVED = 'conference.trackRemoved';
+
 /**
  * A new user joinned the conference.
  */
 export const USER_JOINED = 'conference.userJoined';
+
 /**
  * A user has left the conference.
  */
 export const USER_LEFT = 'conference.userLeft';
+
 /**
  * User role changed.
  */
 export const USER_ROLE_CHANGED = 'conference.roleChanged';
+
 /**
  * User status changed.
  */

JitsiConnectionErrors.js

  * case as long as the service is configured correctly (there is no bug).
  */
 export const CONNECTION_DROPPED_ERROR = 'connection.droppedError';
+
 /**
  * Indicates that a connection error occurred when trying to join a conference.
  */
 export const CONNECTION_ERROR = 'connection.connectionError';
+
 /**
  * Not specified errors.
  */
 export const OTHER_ERROR = 'connection.otherError';
+
 /**
  * Indicates that a password is required in order to join the conference.
  */
 export const PASSWORD_REQUIRED = 'connection.passwordRequired';
+
 /**
  * Indicates that the connection was dropped, because of too many 5xx HTTP
  * errors on BOSH requests.

JitsiConnectionEvents.js

  * last (known) error message
  */
 export const CONNECTION_DISCONNECTED = 'connection.connectionDisconnected';
+
 /**
  * Indicates that the connection has been established. The event provides
  * the following parameters to its listeners:
  * the context of the established connection)
  */
 export const CONNECTION_ESTABLISHED = 'connection.connectionEstablished';
+
 /**
  * Indicates that the connection has been failed for some reason. The event
  * provides the following parameters to its listeners:
  * @param err {string} the error (message) associated with the failure
  */
 export const CONNECTION_FAILED = 'connection.connectionFailed';
+
 /**
  * Indicates that the performed action cannot be executed because the
  * connection is not in the correct state(connected, disconnected, etc.)

JitsiMediaDevices.js

     enumerateDevices(callback) {
         RTC.enumerateDevices(callback);
     },
+
     /**
      * Checks if its possible to enumerate available cameras/micropones.
      * @returns {Promise<boolean>} a Promise which will be resolved only once
     isDeviceListAvailable() {
         return RTC.isDeviceListAvailable();
     },
+
     /**
      * Returns true if changing the input (camera / microphone) or output
      * (audio) device is supported and false if not.
     isDeviceChangeAvailable(deviceType) {
         return RTC.isDeviceChangeAvailable(deviceType);
     },
+
     /**
      * Returns true if user granted permission to media devices.
      * @param {'audio'|'video'} [type] - type of devices to check,
             return permissions.video === true && permissions.audio === true;
         }
     },
+
     /**
      * Returns currently used audio output device id, 'default' stands
      * for default device
     getAudioOutputDevice() {
         return RTC.getAudioOutputDevice();
     },
+
     /**
      * Sets current audio output device.
      * @param {string} deviceId - id of 'audiooutput' device from
 
         return RTC.setAudioOutputDevice(deviceId);
     },
+
     /**
      * Adds an event handler.
      * @param {string} event - event name
     addEventListener(event, handler) {
         eventEmitter.addListener(event, handler);
     },
+
     /**
      * Removes event handler.
      * @param {string} event - event name
     removeEventListener(event, handler) {
         eventEmitter.removeListener(event, handler);
     },
+
     /**
      * Emits an event.
      * @param {string} event - event name

JitsiMediaDevicesEvents.js

  *  @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
  */
 export const DEVICE_LIST_CHANGED = 'mediaDevices.devicechange';
+
 /**
  * Indicates that the environment is currently showing permission prompt to
  * access camera and/or microphone. The event provides the following

JitsiMeetJS.js

 
         return RTC.init(options || {});
     },
+
     /**
      * Returns whether the desktop sharing is enabled or not.
      * @returns {boolean}
     setLogLevel(level) {
         Logger.setLogLevel(level);
     },
+
     /**
      * Sets the log level to the <tt>Logger</tt> instance with given id.
      * @param {Logger.levels} level the logging level to be set
     setLogLevelById(level, id) {
         Logger.setLogLevelById(level, id);
     },
+
     /**
      * Registers new global logger transport to the library logging framework.
      * @param globalTransport
     addGlobalLogTransport(globalTransport) {
         Logger.addGlobalTransport(globalTransport);
     },
+
     /**
      * Removes global logging transport from the library logging framework.
      * @param globalTransport
     removeGlobalLogTransport(globalTransport) {
         Logger.removeGlobalTransport(globalTransport);
     },
+
     /**
      * Creates the media tracks and returns them trough the callback.
      * @param options Object with properties / settings specifying the tracks which should be created.
                 return Promise.reject(error);
             });
     },
+
     /**
      * Checks if its possible to enumerate available cameras/micropones.
      * @returns {Promise<boolean>} a Promise which will be resolved only once
 
         return this.mediaDevices.isDeviceListAvailable();
     },
+
     /**
      * Returns true if changing the input (camera / microphone) or output
      * (audio) device is supported and false if not.
 
         return this.mediaDevices.isDeviceChangeAvailable(deviceType);
     },
+
     /**
      * Executes callback with list of media devices connected.
      * @param {function} callback
             + 'JitsiMeetJS.mediaDevices.enumerateDevices instead');
         this.mediaDevices.enumerateDevices(callback);
     },
+
     /**
      * @returns function that can be used to be attached to window.onerror and
      * if options.enableWindowOnErrorHandler is enabled returns

JitsiTrackErrors.js

  */
 export const CHROME_EXTENSION_GENERIC_ERROR
     = 'gum.chrome_extension_generic_error';
+
 /**
  * An error which indicates that the jidesha extension for Chrome is
  * failed to install.
  */
 export const CHROME_EXTENSION_INSTALLATION_ERROR
     = 'gum.chrome_extension_installation_error';
+
 /**
  * An error which indicates that user canceled screen sharing window
  * selection dialog in jidesha extension for Chrome.
  */
 export const CHROME_EXTENSION_USER_CANCELED
     = 'gum.chrome_extension_user_canceled';
+
 /**
  * An error which indicates that some of requested constraints in
  * getUserMedia call were not satisfied.
  */
 export const CONSTRAINT_FAILED = 'gum.constraint_failed';
+
 /**
  * An error which indicates that the jidesha extension for Firefox is
  * needed to proceed with screen sharing, and that it is not installed.
  */
 export const FIREFOX_EXTENSION_NEEDED = 'gum.firefox_extension_needed';
+
 /**
  * Generic getUserMedia error.
  */
 export const GENERAL = 'gum.general';
+
 /**
  * An error which indicates that requested device was not found.
  */
 export const NOT_FOUND = 'gum.not_found';
+
 /**
  * An error which indicates that user denied permission to share requested
  * device.
  */
 export const PERMISSION_DENIED = 'gum.permission_denied';
+
 /**
  * An error which indicates that track has been already disposed and cannot
  * be longer used.
  */
 export const TRACK_IS_DISPOSED = 'track.track_is_disposed';
+
 /**
  * An error which indicates that track is currently in progress of muting or
  * unmuting itself.
  */
 export const TRACK_MUTE_UNMUTE_IN_PROGRESS = 'track.mute_unmute_inprogress';
+
 /**
  * An error which indicates that track has no MediaStream associated.
  */
 export const TRACK_NO_STREAM_FOUND = 'track.no_stream_found';
+
 /**
  * An error which indicates that requested video resolution is not supported
  * by a webcam.
  */
 export const UNSUPPORTED_RESOLUTION = 'gum.unsupported_resolution';
+
 /**
  * Indicates that the track is no receiving any data without reason(the
  * stream was stopped, etc)

JitsiTrackEvents.js

  * The media track was removed to the conference.
  */
 export const LOCAL_TRACK_STOPPED = 'track.stopped';
+
 /**
  * Audio levels of a this track was changed.
  */
  * The audio output of the track was changed.
  */
 export const TRACK_AUDIO_OUTPUT_CHANGED = 'track.audioOutputChanged';
+
 /**
  * A media track mute status was changed.
  */
 export const TRACK_MUTE_CHANGED = 'track.trackMuteChanged';
+
 /**
  * The video type("camera" or "desktop") of the track was changed.
  */
 export const TRACK_VIDEOTYPE_CHANGED = 'track.videoTypeChanged';
+
 /**
  * Indicates that the track is no receiving any data without reason(the
  * stream was stopped, etc)

doc/example/example.js

 // JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
 const initOptions = {
     disableAudioLevels: true,
+
     // The ID of the jidesha extension for Chrome.
     desktopSharingChromeExtId: 'mbocklcggfhnbahlnepmldehdhpjfcjp',
+
     // Whether desktop sharing should be disabled on Chrome.
     desktopSharingChromeDisabled: false,
+
     // The media sources to use when using screen sharing with the Chrome
     // extension.
     desktopSharingChromeSources: [ 'screen', 'window' ],
+
     // Required version of Chrome extension
     desktopSharingChromeMinExtVersion: '0.1',
 
     // The ID of the jidesha extension for Firefox. If null, we assume that no
     // extension is required.
     desktopSharingFirefoxExtId: null,
+
     // Whether desktop sharing should be disabled on Firefox.
     desktopSharingFirefoxDisabled: true,
+
     // The maximum version of Firefox which requires a jidesha extension.
     // Example: if set to 41, we will require the extension for Firefox versions
     // up to and including 41. On Firefox 42 and higher, we will run without the
     // extension.
     // If set to -1, an extension will be required for all versions of Firefox.
     desktopSharingFirefoxMaxVersionExtRequired: -1,
+
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
 };

modules/RTC/DataChannels.js

 
     dataChannel.onmessage = function(event) {
         const data = event.data;
+
         // JSON
         let obj;
 
             } else if (colibriClass === 'LastNEndpointsChangeEvent') {
                 // The new/latest list of last-n endpoint IDs.
                 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.
                     endpoint, isActive);
             } else {
                 logger.debug('Data channel JSON-formatted message: ', obj);
+
                 // The received message appears to be appropriately formatted
                 // (i.e. is a JSON object which assigns a value to the mandatory
                 // property colibriClass) so don't just swallow it, expose it to

modules/RTC/JitsiLocalTrack.js

                 if (streamInfo) {
                     self._setStream(streamInfo.stream);
                     self.track = streamInfo.track;
+
                     // This is not good when video type changes after
                     // unmute, but let's not crash here
                     if (self.videoType !== streamInfo.videoType) {
  */
 JitsiLocalTrack.prototype._setByteSent = function(bytesSent) {
     this._bytesSent = bytesSent;
+
     // FIXME it's a shame that PeerConnection and ICE status does not belong
     // to the RTC module and it has to be accessed through
     // the conference(and through the XMPP chat room ???) instead

modules/RTC/JitsiRemoteTrack.js

     this.rtc = rtc;
     this.ownerEndpointId = ownerEndpointId;
     this.muted = muted;
+
     // we want to mark whether the track has been ever muted
     // to detect ttfm events for startmuted conferences, as it can significantly
     // increase ttfm values
     this.hasBeenMuted = muted;
+
     // Bind 'onmute' and 'onunmute' event handlers
     if (this.rtc && this.track) {
         this._bindMuteHandlers();

modules/RTC/RTC.js

     constructor(conference, options = {}) {
         super();
         this.conference = conference;
+
         /**
          * A map of active <tt>TraceablePeerConnection</tt>.
          * @type {Map.<number, TraceablePeerConnection>}
          */
         this.peerConnections = new Map();
+
         /**
          * The counter used to generated id numbers assigned to peer connections
          * @type {number}
         this.peerConnectionIdCounter = 1;
 
         this.localTracks = [];
+
         // FIXME: We should support multiple streams per jid.
         this.remoteTracks = {};
         this.options = options;
+
         // A flag whether we had received that the data channel had opened
         // we can get this flag out of sync if for some reason data channel got
         // closed from server, a desired behaviour so we can see errors when this
             this._dataChannelOpenListener = () => {
                 // mark that dataChannel is opened
                 this.dataChannelsOpen = true;
+
                 // when the data channel becomes available, tell the bridge
                 // about video selections so that it can do adaptive simulcast,
                 // we want the notification to trigger even if userJid

modules/RTC/RTCBrowserType.js

     if (navigator.webkitGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_CHROME;
         const userAgent = navigator.userAgent.toLowerCase();
+
         // We can assume that user agent is chrome, because it's
         // enforced when 'ext' streaming method is set
         const ver = parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
     const match
         = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
     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.
         detectIE,
         detectSafari
     ];
+
     // Try all browser detectors
 
     for (let i = 0; i < detectors.length; i++) {

modules/RTC/RTCUIHelper.js

 
         return undefined;
     },
+
     /**
      * Sets 'volume' property of given HTML element displaying RTC audio or
      * video stream.
             streamElement.volume = volume;
         }
     },
+
     /**
      * Sets 'autoplay' property of given HTML element displaying RTC audio or
      * video stream.

modules/RTC/RTCUtils.js

 let audioOutputDeviceId = 'default'; // default device
 // whether user has explicitly set a device to use
 let audioOutputChanged = false;
+
 // Disables Acoustic Echo Cancellation
 let disableAEC = false;
+
 // Disables Noise Suppression
 let disableNS = false;
 
 let currentlyAvailableMediaDevices;
 
 let rawEnumerateDevicesWithCallback;
+
 /**
  * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
  * ready. Otherwise it is too early to assume that the devices listing is not
                 callback,
                 () => callback([]));
         }
+
         // Safari:
         // "ReferenceError: Can't find variable: MediaStreamTrack"
         // when Temasys plugin is not installed yet, have to delay this call
                 // New style of setting device id.
                 constraints.video.deviceId = options.cameraDeviceId;
             }
+
             // Old style.
             constraints.video.optional.push({
                 sourceId: options.cameraDeviceId
                     // New style of setting device id.
                     constraints.audio.deviceId = options.micDeviceId;
                 }
+
                 // Old style.
                 constraints.audio.optional.push({
                     sourceId: options.micDeviceId
                 });
             }
+
             // if it is good enough for hangouts...
             constraints.audio.optional.push(
                 { googEchoCancellation: !disableAEC },
     return {
         facing: source.facing || null,
         label: source.label,
+
         // theoretically deprecated MediaStreamTrack.getSources should
         // not return 'audiooutput' devices but let's handle it in any
         // case
             audioStream = streams.audio;
             videoStream = streams.video;
         }
+
         // Again, different choices on different types of browser.
         desktopStream = streams.desktopStream || streams.desktop;
     }
                 && rtcUtils.isDeviceChangeAvailable('output')
                 && stream.getAudioTracks
                 && stream.getAudioTracks().length
+
                 // we skip setting audio output if there was no explicit change
                 && audioOutputChanged) {
             element.setSinkId(rtcUtils.getAudioOutputDevice())
 
     if (stream) {
         src = stream.jitsiObjectURL;
+
         // Save the created URL for stream so we can reuse it and not keep
         // creating URLs.
         if (!src) {
                     // for the id of MediaStream. Let's just say that a number
                     // contains no special characters.
                     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.
                 reject(new Error('Desktop sharing is not supported!'));
             }
             if (RTCBrowserType.isFirefox()
+
                     // XXX The react-native-webrtc implementation that we
                     // utilize on React Native at the time of this writing does
                     // not support the MediaStream constructors defined by
                         screenObtainer,
                         dsOptions);
                 }
+
                 // With FF/IE we can't split the stream into audio and video because FF
                 // doesn't support media stream constructors. So, we need to get the
                 // audio stream separately from the video stream using two distinct GUM
             };
 
             eventEmitter.addListener(RTCEvents.RTC_READY, listener);
+
                 // We have no failed event, so... it either resolves or nothing
                 // happens
         });
                 || RTCBrowserType.isNWJS()
                 || RTCBrowserType.isElectron();
     }
+
     /**
      * A method to handle stopping of the stream.
      * One point to handle the differences in various implementations.

modules/RTC/ScreenObtainer.js

                     onSuccess,
                     (error, constraints) => {
                         let jitsiError;
+
                         // FIXME:
                         // This is very very durty fix for recognising that the
                         // user have clicked the cancel button from the Desktop
                 alert(
                     'Jitsi Desktop Streamer requires update. '
                     + 'Changes will take effect after next Chrome restart.');
+
                 /* eslint-enable no-alert */
             }
 
                     arg => {
                         logger.log('Extension installed successfully', arg);
                         chromeExtInstalled = true;
+
                         // We need to give a moment to the endpoint to become
                         // available.
                         waitForExtensionAfterInstall(this.options, 200, 10)
 
                 return;
             }
+
             // Check installed extension version
             const extVersion = response.version;
 
 function initChromeExtension(options) {
     // Initialize Chrome extension inline installs
     initInlineInstalls(options);
+
     // Check if extension is installed
     checkChromeExtInstalled((installed, updateRequired) => {
         chromeExtInstalled = installed;

modules/RTC/TraceablePeerConnection.js

 import RTCBrowserType from './RTCBrowserType.js';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import RtxModifier from '../xmpp/RtxModifier.js';
+
 // FIXME SDP tools should end up in some kind of util module
 import SDP from '../xmpp/SDP';
 import SdpConsistency from '../xmpp/SdpConsistency.js';
 function TraceablePeerConnection(rtc, id, signalingLayer, ice_config,
                                  constraints, options) {
     const self = this;
+
     /**
      * The parent instance of RTC service which created this
      * <tt>TracablePeerConnection</tt>.
      */
 
     this.rtc = rtc;
+
     /**
      * The peer connection identifier assigned by the RTC module.
      * @type {number}
      */
     this.id = id;
+
     /**
      * The signaling layer which operates this peer connection.
      * @type {SignalingLayer}
     this.updateLog = [];
     this.stats = {};
     this.statsinterval = null;
+
     /**
      * @type {number}
      */
     this.simulcast = new Simulcast({ numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false });
     this.sdpConsistency = new SdpConsistency();
+
     /**
      * TracablePeerConnection uses RTC's eventEmitter
      * @type {EventEmitter}
             self.ondatachannel(event);
         }
     };
+
     // XXX: do all non-firefox browsers which we support also support this?
     if (!RTCBrowserType.isFirefox() && this.maxstats) {
         this.statsinterval = window.setInterval(() => {
 
         return;
     }
+
     // Bind 'addtrack'/'removetrack' event handlers
     if (RTCBrowserType.isChrome() || RTCBrowserType.isNWJS()
         || RTCBrowserType.isElectron()) {
             this._remoteTrackRemoved(event.target, event.track);
         };
     }
+
     // Call remoteTrackAdded for each track in the stream
     const streamAudioTracks = stream.getAudioTracks();
 
 
         return;
     }
+
     // Call remoteTrackRemoved for each track in the stream
     const streamVideoTracks = stream.getVideoTracks();
 
      * @type {Map<string,TrackSSRCInfo>}
      */
     const ssrcMap = new Map();
+
     /**
      * Groups mapped by primary SSRC number
      * @type {Map<number,Array<SSRCGroupInfo>>}
                         = group.ssrcs.split(' ')
                                      .map(ssrcStr => parseInt(ssrcStr));
                     const primarySSRC = groupSSRCs[0];
+
                     // Note that group.semantics is already present
 
                     group.ssrcs = groupSSRCs;
 
 TraceablePeerConnection.prototype.removeStream = function(stream) {
     this.trace('removeStream', stream.id);
+
     // FF doesn't support this yet.
     if (this.peerconnection.removeStream) {
         this.peerconnection.removeStream(stream);
 TraceablePeerConnection.prototype.setLocalDescription
         = function(description, successCallback, failureCallback) {
             this.trace('setLocalDescription::preTransform', dumpSDP(description));
+
     // if we're running on FF, transform to Plan A first.
             if (RTCBrowserType.usesUnifiedPlan()) {
                 description = this.interop.toUnifiedPlan(description);
 TraceablePeerConnection.prototype.setRemoteDescription
         = function(description, successCallback, failureCallback) {
             this.trace('setRemoteDescription::preTransform', dumpSDP(description));
+
     // TODO the focus should squeze or explode the remote simulcast
             description = this.simulcast.mungeRemoteDescription(description);
             this.trace(
             failureCallback(err);
         }
     );
+
     /*
      if (this.statsinterval === null && this.maxstats > 0) {
      // start gathering stats
             try {
                 this.trace(
                     'createAnswerOnSuccess::preTransform', dumpSDP(answer));
+
                 // if we're running on FF, transform to Plan A first.
                 if (RTCBrowserType.usesUnifiedPlan()) {
                     answer = this.interop.toPlanB(answer);
         };
 
 TraceablePeerConnection.prototype.addIceCandidate
+
         // eslint-disable-next-line no-unused-vars
         = function(candidate, successCallback, failureCallback) {
     // var self = this;
             this.trace('addIceCandidate', JSON.stringify(candidate, null, ' '));
             this.peerconnection.addIceCandidate(candidate);
+
     /* maybe later
      this.peerconnection.addIceCandidate(candidate,
      function () {

modules/connectivity/ConnectionQuality.js

 
         let quality = 100;
         let packetLoss;
+
         // TODO: take into account packet loss for received streams
 
         if (this._localStats.packetLoss) {

modules/connectivity/ParticipantConnectionStatus.js

     constructor(rtc, conference, rtcMuteTimeout) {
         this.rtc = rtc;
         this.conference = conference;
+
         /**
          * A map of the "endpoint ID"(which corresponds to the resource part
          * of MUC JID(nickname)) to the timeout callback IDs scheduled using
          * @type {Object.<string, number>}
          */
         this.trackTimers = {};
+
         /**
          * This map holds the endpoint connection status received from the JVB
          * (as it might be different than the one stored in JitsiParticipant).
          * @type {Object.<string, boolean>}
          */
         this.connStatusFromJvb = { };
+
         /**
          * How long we're going to wait after the RTC video track muted event
          * for the corresponding signalling mute event, before the connection
         this.rtcMuteTimeout
             = typeof rtcMuteTimeout === 'number'
                 ? rtcMuteTimeout : DEFAULT_RTC_MUTE_TIMEOUT;
+
         /**
          * This map holds a timestamp indicating  when participant's video track
          * was RTC muted (it is assumed that each participant can have only 1

modules/statistics/AnalyticsAdapter.js

 class CacheAnalytics extends AnalyticsAbstract {
     constructor() {
         super();
+
         // some events may happen before init or implementation script download
         // in this case we accumulate them in this array and send them on init
         this.eventCache = [];

modules/statistics/CallStats.js

         this.callStatsSecret = options.callStatsSecret;
 
         CallStats.initializeInProgress = true;
+
         // userID is generated or given by the origin server
         callStats.initialize(this.callStatsID,
             this.callStatsSecret,
         });
         CallStats._checkInitialize();
     }
+
     // else just ignore it
 };
 

modules/statistics/RTPStatsCollector.js

     if (!keys) {
         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
 
     this.statsIntervalId = null;
     this.statsIntervalMilis = statsInterval;
+
     // Map of ssrcs to SsrcStats
     this.ssrc2stats = {};
 }
             if (!ip || !type || !localip || active != 'true') {
                 continue;
             }
+
             // Save the address unless it has been saved already.
             const conferenceStatsTransport = this.conferenceStats.transport;
 
     Object.keys(this.ssrc2stats).forEach(
         function(ssrc) {
             const ssrcStats = this.ssrc2stats[ssrc];
+
             // process packet loss stats
             const loss = ssrcStats.loss;
             const type = loss.isDownloadStream ? 'download' : 'upload';

modules/statistics/statistics.js

                 /* prepend */ true);
         isCallstatsLoaded = true;
     }
+
     // FIXME At the time of this writing, we hope that the callstats.io API will
     // have loaded by the time we needed it (i.e. CallStats.init is invoked).
 }
     this.options = options || {};
     this.callStatsIntegrationEnabled
         = this.options.callStatsID && this.options.callStatsSecret
+
             // Even though AppID and AppSecret may be specified, the integration
             // of callstats.io may be disabled because of globally-disallowed
             // requests to any third parties.
         loadCallStatsAPI(this.options.callStatsCustomScriptUrl);
     }
     this.callStats = null;
+
     // Flag indicates whether or not the CallStats have been started for this
     // Statistics instance
     this.callStatsStarted = false;
         if (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;

modules/transcription/audioRecorder.js

 const TrackRecorder = function(track) {
     // The JitsiTrack holding the stream
     this.track = track;
+
     // The MediaRecorder recording the stream
     this.recorder = null;
+
     // The array of data chunks recorded from the stream
     // acts as a buffer until the data is stored on disk
     this.data = null;
+
     // the name of the person of the JitsiTrack. This can be undefined and/or
     // not unique
     this.name = null;
+
     // the time of the start of the recording
     this.startTime = null;
 };
  */
 function instantiateTrackRecorder(track) {
     const trackRecorder = new TrackRecorder(track);
+
     // Create a new stream which only holds the audio track
     const originalStream = trackRecorder.track.getOriginalStream();
     const stream = createEmptyStream();
 
     originalStream.getAudioTracks().forEach(track => stream.addTrack(track));
+
     // Create the MediaRecorder
     trackRecorder.recorder = new MediaRecorder(stream,
         { mimeType: audioRecorder.fileType });
+
     // array for holding the recorder data. Resets it when
     // audio already has been recorder once
     trackRecorder.data = [];
+
     // function handling a dataEvent, e.g the stream gets new data
     trackRecorder.recorder.ondataavailable = function(dataEvent) {
         if (dataEvent.data.size > 0) {
     if (track.isAudioTrack()) {
         // create the track recorder
         const trackRecorder = instantiateTrackRecorder(track);
+
         // push it to the local array of all recorders
 
         this.recorders.push(trackRecorder);
+
         // update the name of the trackRecorders
         this.updateNames();
+
         // If we're already recording, immediately start recording this new
         // track.
         if (this.isRecording) {
     if (this.isRecording) {
         throw new Error('audiorecorder is already recording');
     }
+
     // set boolean isRecording flag to true so if new participants join the
     // conference, that track can instantly start recording as well
     this.isRecording = true;
+
     // start all the mediaRecorders
     this.recorders.forEach(trackRecorder => startRecorder(trackRecorder));
+
     // log that recording has started
     console.log(
         `Started the recording of the audio. There are currently ${
 audioRecorder.prototype.stop = function() {
     // set the boolean flag to false
     this.isRecording = false;
+
     // stop all recorders
     this.recorders.forEach(trackRecorder => stopRecorder(trackRecorder));
     console.log('stopped recording');
         throw new Error(
             'cannot get blobs because the AudioRecorder is still recording!');
     }
+
     // make sure the names are up to date before sending them off
     this.updateNames();
 

modules/transcription/transcriber.js

 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
     this.transcriptionService = new SphinxService();
+
     // holds a counter to keep track if merging can start
     this.counter = null;
+
     // holds the date when transcription started which makes it possible
     // to calculate the offset between recordings
     this.startTime = null;
+
     // will hold the transcription once it is completed
     this.transcription = null;
+
     // this will be a method which will be called once the transcription is done
     // with the transcription as parameter
     this.callback = null;
+
     // stores all the retrieved speech-to-text results to merge together
     // this value will store an Array<Word> object
     this.results = [];
+
     // Stores the current state of the transcription process
     this.state = BEFORE_STATE;
+
     // Used in the updateTranscription method to add a new line when the
     // sentence becomes to long
     this.lineLength = 0;
                  RECORDING_STATE}" state. It's currently in the "${
                  this.state}" state`);
     }
+
     // stop the recording
     console.log('stopping recording and sending audio files');
     this.audioRecorder.stop();
+
     // and send all recorded audio the the transcription service
     const t = this;
 
         t.transcriptionService.send(recordingResult, callBack);
         t.counter++;
     });
+
     // set the state to "transcribing" so that maybeMerge() functions correctly
     this.state = TRANSCRIBING_STATE;
+
     // and store the callback for later
     this.callback = callback;
 };
     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) {
         let offset = answer.startTime.getUTCMilliseconds()
             - this.startTime.getUTCMilliseconds();
+
         // transcriber time will always be earlier
 
         if (offset < 0) {
         });
         array += ']';
         console.log(array);
+
         // give a name value to the Array object so that the merging can access
         // the name value without having to use the whole recordingResult object
         // in the algorithm
         answer.wordArray.name = answer.name;
     }
+
     // then store the array and decrease the counter
     this.results.push(answer.wordArray);
     this.counter--;
     console.log(`current counter: ${this.counter}`);
+
     // and check if all results have been received.
     this.maybeMerge();
 };
         `starting merge process!\n The length of the array: ${
              this.results.length}`);
     this.transcription = '';
+
     // the merging algorithm will look over all Word objects who are at pos 0 in
     // every array. It will then select the one closest in time to the
     // 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
     const arrays = this.results;
+
     // arrays of Word objects
     const potentialWords = []; // array of the first Word objects
     // check if any arrays are already empty and remove them
                 lowestWordArray = wordArray;
             }
         });
+
         // put the word in the transcription
         wordToAdd = lowestWordArray.shift();
         this.updateTranscription(wordToAdd, lowestWordArray.name);
                     foundSmaller = true;
                 }
             });
+
             // add next word if no smaller time has been found
             if (!foundSmaller) {
                 wordToAdd = lowestWordArray.shift();

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

                 `unable to accept response from sphinx server. status: ${
                     request.status}`);
         }
+
         // if not ready no point to throw an error
     };
     request.open('POST', this.url);
  */
 SphinxService.prototype.formatResponse = function(response) {
     const result = JSON.parse(response).objects;
+
     // make sure to delete the session id object, which is always
     // the first value in the JSON array
 
  */
 SphinxService.prototype.verify = function(response) {
     console.log(`response from server:${response.toString()}`);
+
     // test if server responded with a string object
     if (typeof response !== 'string') {
         return false;
     }
+
     // test if the string can be parsed into valid JSON
     let json;
 
 
         return false;
     }
+
     // check if the JSON has a "objects" value
     if (json.objects === undefined) {
         return false;
     }
+
     // get the "objects" value and check for a session ID
     const array = json.objects;
 

modules/util/EventEmitterForwarder.js

  */
 EventEmitterForwarder.prototype.forward = function(...args) {
     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")
     this.src.addListener(
         srcEvent,

modules/util/GlobalOnErrorHandler.js

     addHandler(handler) {
         handlers.push(handler);
     },
+
     /**
      * Calls the global error handler if there is one.
      * @param error the error to pass to the error handler
         }
         errHandler(null, null, null, null, error);
     },
+
     /**
      * Calls the global rejection handler if there is one.
      * @param error the error to pass to the rejection handler.

modules/util/Listenable.js

      */
     constructor(eventEmitter = new EventEmitter()) {
         this.eventEmitter = eventEmitter;
+
         // aliases for addListener/removeListener
         this.addEventListener = this.on = this.addListener;
         this.removeEventListener = this.off = this.removeListener;

modules/util/RandomUtil.js

     randomHexDigit() {
         return randomElement(HEX_DIGITS);
     },
+
     /**
      * Returns a random string of hex digits with length 'len'.
      * @param len the length.

modules/version/ComponentsVersions.js

  * @type {string}
  */
 ComponentsVersions.FOCUS_COMPONENT = 'focus';
+
 /**
  * The constant for the name of the videobridge component.
  * @type {string}
  */
 ComponentsVersions.VIDEOBRIDGE_COMPONENT = 'videobridge';
+
 /**
  * The constant for the name of the XMPP server component.
  * @type {string}

modules/xmpp/ChatRoom.js

                 packet.up();
             }
         }
+
         // packet.up();
     }
 };
             'value': navigator.userAgent,
             'attributes': { xmlns: 'http://jitsi.org/jitmeet/user-agent' }
         });
+
         // We need to broadcast 'videomuted' status from the beginning, cause Jicofo
         // makes decisions based on that. Initialize it with 'false' here.
         this.addVideoInfoToPresence(false);
 
     onPresence(pres) {
         const from = pres.getAttribute('from');
+
         // Parse roles.
         const member = {};
 
         parser.packet2JSON(pres, nodes);
         this.lastPresences[from] = nodes;
         let jibri = null;
+
         // process nodes to extract data needed for MUC_JOINED and
         // MUC_MEMBER_JOINED events
 
                         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();
+
                     // Fixes a bug in prosody 0.9.+ https://code.google.com/p/lxmppd/issues/detail?id=373
                     formsubmit.c('field', { 'var': 'muc#roomconfig_whois' }).c('value').t('anyone').up().up();
+
                     // FIXME: is muc#roomconfig_passwordprotectedroom required?
                     this.connection.sendIQ(formsubmit, onSuccess, onError);
                 } else {

modules/xmpp/JingleSessionPC.js

         this.closed = false;
 
         this.modifyingLocalStreams = false;
+
         /**
          * Used to keep state about muted/unmuted video streams
          *  so we can prevent errant source-add/source-removes
 
         this.webrtcIceUdpDisable = Boolean(options.webrtcIceUdpDisable);
         this.webrtcIceTcpDisable = Boolean(options.webrtcIceTcpDisable);
+
         /**
          * Flag used to enforce ICE failure through the URL parameter for
          * the automatic testing purpose.
 
     doInitialize() {
         this.lasticecandidate = false;
+
         // True if reconnect is in progress
         this.isreconnect = false;
+
         // Set to true if the connection was ever stable
         this.wasstable = false;
+
         // Create new peer connection instance
         this.peerconnection
             = this.rtc.createPeerConnection(
                 this,
                 this.connection.jingle.ice_config,
+
                 /* Options */
                 {
                     disableSimulcast: this.room.options.disableSimulcast,
                 // the check complete.
                 return;
             }
+
             // XXX this is broken, candidate is not parsed.
             const candidate = ev.candidate;
 
             }
             this.sendIceCandidate(candidate);
         };
+
         // Note there is a change in the spec about closed:
         // This value moved into the RTCPeerConnectionState enum in
         // the May 13, 2016 draft of the specification, as it reflects the state
                 this.room.eventEmitter.emit(XMPPEvents.SUSPEND_DETECTED);
             }
         };
+
         /**
          * The oniceconnectionstatechange event handler contains the code to
          * execute when the iceconnectionstatechange event, of type Event,
                     break;
                 }
                 this.isreconnect = true;
+
                     // Informs interested parties that the connection has been
                     // interrupted.
                 if (this.wasstable) {
             }
         } else {
             logger.log('sendIceCandidate: last candidate.');
+
             // FIXME: remember to re-think in ICE-restart
             this.lasticecandidate = true;
         }
                 for (let i = 0; i < cands.length; i++) {
                     const candidate
                         = SDPUtil.candidateToJingle(cands[i].candidate);
+
                     // Mangle ICE candidate if 'failICE' test option is enabled
 
                     if (this.failICE) {
                     }
                     cand.c('candidate', candidate).up();
                 }
+
                 // add fingerprint
                 const fingerprint_line
                     = SDPUtil.find_line(
                 cand.up(); // content
             }
         }
+
         // might merge last-candidate notification into this, but it is called
         // a lot later. See webrtc issue #2340
         // logger.log('was this the last candidate', this.lasticecandidate);
             success,
             this.newJingleErrorHandler(accept, error => {
                 failure(error);
+
                 // 'session-accept' is a critical timeout and we'll
                 // have to restart
                 this.room.eventEmitter.emit(XMPPEvents.SESSION_ACCEPT_TIMEOUT);
             }),
             IQ_TIMEOUT);
+
         // XXX Videobridge needs WebRTC's answer (ICE ufrag and pwd, DTLS
         // fingerprint and setup) ASAP in order to start the connection
         // establishment.
                                 }\r\n`;
                     }
                 });
+
             // handles both >source and >description>source
             const tmp
                 = $(content).find(
             const workFunction = finishedCallback => {
                 const oldSdp
                     = new SDP(this.peerconnection.localDescription.sdp);
+
                 // NOTE the code below assumes that no more than 1 video track
                 // can be added to the peer connection.
                 // Transition from no video to video (possibly screen sharing)
                     // 1. source-remove for the recvonly
                     // 2. source-add for the new video stream
                     this.peerconnection.clearRecvonlySsrc();
+
                 // Transition from video to no video
                 } else if (oldTrack && oldTrack.isVideoTrack() && !newTrack) {
                     // Clearing current primary SSRC and generating the recvonly
                     }
                 });
             const ssrcs = [];
+
             // handles both >source and >description>source versions
             const tmp
                 = $(content).find(
                 .then(() => {
                     const newSdp
                         = new SDP(this.peerconnection.localDescription.sdp);
+
                     // FIXME objects should not be logged
 
                     logger.log('SDPs', oldSdp, newSdp);
             return;
         }
         let sender = null;
+
         // On Firefox we don't replace MediaStreams as this messes up the
         // m-lines (which can't be removed in Plan Unified) and brings a lot
         // of complications. Instead, we use the RTPSender and remove just
      */
     close() {
         this.closed = true;
+
         // do not try to close if already closed.
         this.peerconnection
             && ((this.peerconnection.signalingState

modules/xmpp/RtxModifier.js

         ssrcs: `${primarySsrc} ${rtxSsrc}`
     });
 }
+
 /**
  * End helper functions
  */
             } else {
                 logger.debug(
                     `No previously associated rtx ssrc for video ssrc ${ssrc}`);
+
                 // If there's one in the sdp already for it, we'll just set
                 //  that as the corresponding one
                 const previousAssociatedRtxStream = videoMLine.getRtxSSRC(ssrc);
             return sdpStr;
         }
         const fidGroups = videoMLine.findGroups('FID');
+
         // Remove the fid groups from the mline
 
         videoMLine.removeGroupsBySemantics('FID');
+
         // Get the rtx ssrcs and remove them from the mline
         for (const fidGroup of fidGroups) {
             const rtxSsrc = parseSecondarySSRC(fidGroup);

modules/xmpp/RtxModifier.spec.js

                 const newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
 
                 expect(newPrimaryVideoSsrc).toEqual(this.primaryVideoSsrc);
+
           // Should now have an rtx ssrc as well
                 expect(numVideoSsrcs(newSdp)).toEqual(2);
+
           // Should now have an FID group
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
                 const newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
 
                 expect(newPrimaryVideoSsrcs).toEqual(this.primaryVideoSsrcs);
+
           // Should now have rtx ssrcs as well
                 expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
+
           // Should now have FID groups
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
 
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
+
           // Save the first mapping that is made
 
                 fidGroups.forEach(fidGroup => {
 
                     rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
                 });
+
           // Now pass the original sdp through again and make sure we get the same mapping
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
 
                 const rtxMapping = new Map();
                 let fidGroups = getVideoGroups(newSdp, 'FID');
+
           // Save the first mapping that is made
 
                 fidGroups.forEach(fidGroup => {
                 });
 
                 this.rtxModifier.clearSsrcCache();
+
           // Now pass the original sdp through again and make sure we get the same mapping
                 newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);

modules/xmpp/SDP.js

         media_ssrcs[mediaindex] = media;
         tmp.forEach(line => {
             const linessrc = line.substring(7).split(' ')[0];
+
             // allocate new ChannelSsrc
 
             if (!media.ssrcs[linessrc]) {
 
     return media_ssrcs;
 };
+
 /**
  * Returns <tt>true</tt> if this SDP contains given SSRC.
  * @param ssrc the ssrc to check.
 
     return lines;
 };
+
 // remove lines matching prefix from a media section specified by mediaindex
 // TODO: non-numeric mediaindex could match mid
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
 // add content's to a jingle element
 SDP.prototype.toJingle = function(elem, thecreator) {
     let i, j, k, lines, mline, rtpmap, ssrc, tmp;
+
     // new bundle plan
 
     lines = SDPUtil.find_lines(this.session, 'a=group:');
             for (j = 0; j < mline.fmt.length; j++) {
                 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/>
                 const afmtpline = SDPUtil.find_line(this.media[i], `a=fmtp:${mline.fmt[j]}`);
 
                 // new style mapping
                 elem.c('source', { ssrc,
                     xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
+
                 // FIXME: group by ssrc and support multiple different ssrcs
                 const ssrclines = SDPUtil.find_lines(this.media[i], 'a=ssrc:');
 
                         value: Math.random().toString(36).substring(7)
                     });
                     elem.up();
+
                     // FIXME what case does this code handle ? remove ???
                     let msid = null;
+
                     // FIXME what is this ? global APP.RTC in SDP ?
                     const localTrack = APP.RTC.getLocalTracks(mline.media);
 
                             break;
                         }
                     }
+
                     // TODO: handle params
                     elem.up();
                 }
             number: sctpAttrs[0], /* SCTP port */
             protocol: sctpAttrs[1] /* protocol */
         });
+
         // Optional stream count attribute
         if (sctpAttrs.length > 2) {
             elem.attrs({ streams: sctpAttrs[2] });
         }
         elem.up();
     }
+
     // XEP-0320
     const fingerprints
         = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
     if (tmp) {
         tmp.xmlns = 'urn:xmpp:jingle:transports:ice-udp:1';
         elem.attrs(tmp);
+
         // XEP-0176
         if (SDPUtil.find_line(this.media[mediaindex], 'a=candidate:', this.session)) { // add any a=candidate lines
             const lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
                     .join('; ');
             media += '\r\n';
         }
+
         // xep-0293
         media += self.rtcpFbFromJingle($(this), this.getAttribute('id'));
     });

modules/xmpp/SDPDiffer.js

 
             return;
         }
+
         // Look for new ssrcs across the channel
         Object.keys(othersMedia.ssrcs).forEach(ssrc => {
             if (Object.keys(myMedia.ssrcs).indexOf(ssrc) === -1) {
         modify.c('description',
             { xmlns: 'urn:xmpp:jingle:apps:rtp:1',
                 media: media.mid });
+
         // FIXME: not completely sure this operates on blocks and / or handles
         // different ssrcs correctly
         // generate sources from lines
 
             modify.c('source', { xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
             modify.attrs({ ssrc: mediaSsrc.ssrc });
+
             // iterate over ssrc lines
             mediaSsrc.lines.forEach(line => {
                 const idx = line.indexOf(' ');

modules/xmpp/SDPUtil.js

 
         return data;
     },
+
     /**
      * Parses SDP line "a=sctpmap:..." and extracts SCTP port from it.
      * @param line eg. "a=sctpmap:5000 webrtc-datachannel"
         const parts = line.substring(10).split(' ');
         const sctpPort = parts[0];
         const protocol = parts[1];
+
         // Stream count is optional
         const streamCount = parts.length > 2 ? parts[2] : null;
 
         candidate.priority = elems[3];
         candidate.ip = elems[4];
         candidate.port = elems[5];
+
         // elems[6] => "typ"
         candidate.type = elems[7];
         candidate.generation = 0; // default value, may be overwritten below
         if (!sessionpart) {
             return false;
         }
+
         // search session part
         lines = sessionpart.split('\r\n');
         for (let j = 0; j < lines.length; j++) {
         if (needles.length || !sessionpart) {
             return needles;
         }
+
         // search session part
         lines = sessionpart.split('\r\n');
         for (let j = 0; j < lines.length; j++) {
         candidate.priority = elems[3];
         candidate.ip = elems[4];
         candidate.port = elems[5];
+
         // elems[6] => "typ"
         candidate.type = elems[7];
 
         line += ' ';
 
         let protocol = cand.getAttribute('protocol');
+
         // use tcp candidates for FF
 
         if (RTCBrowserType.isFirefox() && protocol.toLowerCase() == 'ssltcp') {
     getMedia(sdp, type) {
         return sdp.media.find(m => m.type === type);
     },
+
     /**
      * Sets the given codecName as the preferred codec by
      *  moving it to the beginning of the payload types

modules/xmpp/SampleSdpStrings.js

 
 // A full sdp string representing a client doing simulcast
 const simulcastSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastVideoMLineSdp + baseDataMLineSdp;
+
 // A full sdp string representing a client doing simulcast and rtx
 const simulcastRtxSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastRtxVideoMLineSdp + baseDataMLineSdp;
+
 // A full sdp string representing a client doing a single video stream
 const plainVideoSdpStr = baseSessionSdp + baseAudioMLineSdp + plainVideoMLineSdp + baseDataMLineSdp;
+
 // A full sdp string representing a client doing a single video stream with rtx
 const rtxVideoSdpStr = baseSessionSdp + baseAudioMLineSdp + rtxVideoMLineSdp + baseDataMLineSdp;
+
 // A full sdp string representing a client doing a single video stream with multiple codec options
 const multiCodecVideoSdpStr = baseSessionSdp + baseAudioMLineSdp + multiCodecVideoMLine + baseDataMLineSdp;
 

modules/xmpp/SdpTransformUtil.js

             // Not using _ssrcs on purpose here
             return this.mLine.ssrcs[0].id;
         }
+
             // Look for a SIM or FID group
         if (this.mLine.ssrcGroups) {
             const simGroup = this.findGroup('SIM');

modules/xmpp/moderator.js

 
             return;
         }
+
         // Calculate next timeout
         const timeout = Math.pow(2, count - 1);
 
     this.xmppService = xmpp;
     this.getNextTimeout = createExpBackoffTimer(1000);
     this.getNextErrorTimeout = createExpBackoffTimer(1000);
+
     // External authentication stuff
     this.externalAuthEnabled = false;
     this.options = options;
     this.eventEmitter = emitter;
 
     this.connection = this.xmppService.connection;
+
     // FIXME:
     // Message listener that talks to POPUP window
     function listener(event) {
                 return;
             }
             Settings.setSessionId(event.data.sessionId);
+
             // After popup is closed we will authenticate
         }
     }
+
     // Register
     if (window.addEventListener) {
         window.addEventListener('message', listener, false);
 Moderator.prototype.getFocusComponent = function() {
     // Get focus component address
     let focusComponent = this.options.connection.hosts.focus;
+
     // If not specified use default:  'focus.domain'
 
     if (!focusComponent) {
                 value: this.options.connection.enforcedBridge
             }).up();
     }
+
     // Tell the focus we have Jigasi configured
     if (this.options.connection.hosts !== undefined
         && this.options.connection.hosts.call_control !== undefined) {
 Moderator.prototype.allocateConferenceFocus = function(callback) {
     // Try to use focus user JID from the config
     this.setFocusUserJid(this.options.connection.focusUserJid);
+
     // Send create conference IQ
     this.connection.sendIQ(
         this.createConferenceIq(),
         result => this._allocateConferenceFocusSuccess(result, callback),
         error => this._allocateConferenceFocusError(error, callback));
+
     // XXX We're pressed for time here because we're beginning a complex and/or
     // lengthy conference-establishment process which supposedly involves
     // multiple RTTs. We don't have the time to wait for Strophe to decide to
 
         return;
     }
+
     // Check for error returned by the reservation system
     const reservationErr = $(error).find('>error>reservation-error');
 
 
         return;
     }
+
     // Not authorized to create new room
     if ($(error).find('>error>not-authorized').length) {
         logger.warn('Unauthorized to start the conference', error);
 
     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
     logger.error(errmsg, error);
+
     // Show message
     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
 
         this.eventEmitter.emit(
                 XMPPEvents.FOCUS_DISCONNECTED, focusComponent, retrySec);
     }
+
     // Reset response timeout
     this.getNextTimeout(true);
     window.setTimeout(() => this.allocateConferenceFocus(callback), waitMs);
 
     // Reset the error timeout (because we haven't failed here).
     this.getNextErrorTimeout(true);
+
     // eslint-disable-next-line newline-per-chained-call
     if ($(result).find('conference').attr('ready') === 'true') {
         // Reset the non-error timeout (because we've succeeded here).
         this.getNextTimeout(true);
+
         // Exec callback
         callback();
     } else {
         str = `POPUP ${str}`;
     }
     iq.c('login-url', attrs);
+
     /**
      * Implements a failure callback which reports an error message and an error
      * through (1) GlobalOnErrorHandler, (2) logger, and (3) failureCb.

modules/xmpp/strophe.emuc.js

 
     init(connection) {
         super.init(connection);
+
         // add handlers (just once)
         this.connection.addHandler(this.onPresence.bind(this), null,
             'presence', null, null, null, null);

modules/xmpp/strophe.jingle.js

                 'OfferToReceiveAudio': true,
                 'OfferToReceiveVideo': true
             }
+
             // MozDontOfferDataChannel: true when this is firefox
         };
     }
         const sid = $(iq).find('jingle').attr('sid');
         const action = $(iq).find('jingle').attr('action');
         const fromJid = iq.getAttribute('from');
+
         // send ack first
         const ack = $iq({ type: 'result',
             to: fromJid,
 
                 return true;
             }
+
             // local jid is not checked
             if (fromJid != sess.peerjid) {
                 logger.warn(
             return true;
         }
         const now = window.performance.now();
+
         // see http://xmpp.org/extensions/xep-0166.html#concepts-session
 
         switch (action) {
                     case 'turns': {
                         dict.url = `${type}:`;
                         const username = el.attr('username');
+
                             // https://code.google.com/p/webrtc/issues/detail?id=1508
 
                         if (username) {
                 logger.warn('getting turn credentials failed', err);
                 logger.warn('is mod_turncredentials or similar installed?');
             });
+
         // implement push?
     }
 

modules/xmpp/strophe.ping.js

                 if (this.failedPings >= PING_THRESHOLD) {
                     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
                     logger.error(errmsg, error);
+
                     // FIXME it doesn't help to disconnect when 3rd PING
                     // times out, it only stops Strophe from retrying.
                     // Not really sure what's the right thing to do in that

modules/xmpp/strophe.util.js

                 && msg.indexOf('timed out (secondary), restarting') !== -1) {
             level = Strophe.LogLevel.WARN;
         }
+
         /* eslint-disable no-case-declarations */
         switch (level) {
         case Strophe.LogLevel.DEBUG:
             logger.error(msg);
             break;
         }
+
         /* eslint-enable no-case-declarations */
     };
 

modules/xmpp/xmpp.js

                 // more than 4 times. The connection is dropped without
                 // supplying a reason(error message/event) through the API.
                 logger.error('XMPP connection dropped!');
+
                 // XXX if the last request error is within 5xx range it means it
                 // was a server failure
                 const lastErrorStatus = Strophe.getLastErrorStatus();
             let configDomain
                 = this.options.hosts.anonymousdomain
                     || this.options.hosts.domain;
+
             // Force authenticated domain if room is appended with '?login=true'
             // or if we're joining with the token
 
             // node of the anonymous JID is very long - here we trim it a bit
             mucNickname = mucNickname.substr(0, 8);
         }
+
         // Constant JIDs need some random part to be appended in order to be
         // able to join the MUC more than once.
         if (this.authenticatedUser || cfgNickname !== null) {

service/RTC/RTCEvents.js

      * Indicates error while create answer call.
      */
     CREATE_ANSWER_FAILED: 'rtc.create_answer_failed',
+
     /**
      * Indicates error while create offer call.
      * FIXME not used (yet), but hook up with create offer failure once added
      */
     CREATE_OFFER_FAILED: 'rtc.create_offer_failed',
     RTC_READY: 'rtc.ready',
+
     /**
      * FIXME: rename to something closer to "local streams SDP changed"
      * Indicates that the local sendrecv streams in local SDP are changed.
     LASTN_ENDPOINT_CHANGED: 'rtc.lastn_endpoint_changed',
     AVAILABLE_DEVICES_CHANGED: 'rtc.available_devices_changed',
     TRACK_ATTACHED: 'rtc.track_attached',
+
     /**
      * Event fired when we remote track is added to the conference.
      * The following structure is passed as an argument:
       *         'null' if unknown
      **/
     REMOTE_TRACK_ADDED: 'rtc.remote_track_added',
+
     // FIXME get rid of this event in favour of NO_DATA_FROM_SOURCE event
     // (currently implemented for local tracks only)
     REMOTE_TRACK_MUTE: 'rtc.remote_track_mute',
+
     /**
      * Indicates that the remote track has been removed from the conference.
      * 1st event argument is the ID of the parent WebRTC stream to which
      * 2nd event argument is the ID of the removed track.
      */
     REMOTE_TRACK_REMOVED: 'rtc.remote_track_removed',
+
     // FIXME get rid of this event in favour of NO_DATA_FROM_SOURCE event
     // (currently implemented for local tracks only)
     REMOTE_TRACK_UNMUTE: 'rtc.remote_track_unmute',
+
     /**
      * Indicates error while set local description.
      */
     SET_LOCAL_DESCRIPTION_FAILED: 'rtc.set_local_description_failed',
+
     /**
      * Indicates error while set remote description.
      */
     AUDIO_OUTPUT_DEVICE_CHANGED: 'rtc.audio_output_device_changed',
     DEVICE_LIST_CHANGED: 'rtc.device_list_changed',
     DEVICE_LIST_AVAILABLE: 'rtc.device_list_available',
+
     /**
      * Indicates that a message from another participant is received on
      * data channel.

service/RTC/Resolutions.js

         height: 720,
         order: 5
     },
+
     // 16:9 resolution first.
     '360': {
         width: 640,
         height: 480,
         order: 3
     },
+
     // 16:9 resolution first.
     '180': {
         width: 320,

service/RTC/SignalingLayer.js

     getSSRCOwner(ssrc) { // eslint-disable-line no-unused-vars
         throw new Error('not implemented');
     }
+
     /**
      * Obtains the info about given media advertised in the MUC presence of
      * the participant identified by the given MUC JID.

service/RTC/VideoType.js

      * The camera video type.
      */
     CAMERA: 'camera',
+
     /**
      * The desktop video type.
      */

service/xmpp/XMPPEvents.js

      * Indicates error while adding ice candidate.
      */
     ADD_ICE_CANDIDATE_FAILED: 'xmpp.add_ice_candidate_failed',
+
     // Designates an event indicating that the focus has asked us to mute our
     // audio.
     AUDIO_MUTED_BY_FOCUS: 'xmpp.audio_muted_by_focus',
     AUTHENTICATION_REQUIRED: 'xmpp.authentication_required',
     BRIDGE_DOWN: 'xmpp.bridge_down',
+
     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.
     CALL_INCOMING: 'xmpp.callincoming.jingle',
+
     // Triggered when Jicofo kills our media session, this can happen while
     // we're still in the MUC, when it decides to terminate the media session.
     // For example when the session is idle for too long, because we're the only
     CALL_ENDED: 'xmpp.callended.jingle',
     CHAT_ERROR_RECEIVED: 'xmpp.chat_error_received',
     CONFERENCE_SETUP_FAILED: 'xmpp.conference_setup_failed',
+
     // Designates an event indicating that the connection to the XMPP server
     // failed.
     CONNECTION_FAILED: 'xmpp.connection.failed',
+
     // Designates an event indicating that the media (ICE) connection was
     // interrupted. This should go to the RTC module.
     CONNECTION_INTERRUPTED: 'xmpp.connection.interrupted',
+
     // Designates an event indicating that the media (ICE) connection was
     // restored. This should go to the RTC module.
     CONNECTION_RESTORED: 'xmpp.connection.restored',
+
     // Designates an event indicating that the media (ICE) connection failed.
     // This should go to the RTC module.
     CONNECTION_ICE_FAILED: 'xmpp.connection.ice.failed',
+
     // Designates an event indicating that the display name of a participant
     // has changed.
     DISPLAY_NAME_CHANGED: 'xmpp.display_name_changed',
+
     /**
      * Chat room instance have been added to Strophe.emuc plugin.
      */
     EMUC_ROOM_ADDED: 'xmpp.emuc_room_added',
+
     /**
      * Chat room instance have been removed from Strophe.emuc plugin.
      */
     FOCUS_DISCONNECTED: 'xmpp.focus_disconnected',
     FOCUS_LEFT: 'xmpp.focus_left',
     GRACEFUL_SHUTDOWN: 'xmpp.graceful_shutdown',
+
     /**
      * Event fired when 'transport-replace' Jingle message has been received,
      * before the new offer is set on the PeerConnection.
      */
     ICE_RESTARTING: 'rtc.ice_restarting',
+
     /* Event fired when XMPP error is returned to any request, it is meant to be
      * used to report 'signaling' errors to CallStats
      *
      * }
      */
     JINGLE_ERROR: 'xmpp.jingle_error',
+
     // Event fired when we have failed to set initial offer
     JINGLE_FATAL_ERROR: 'xmpp.jingle_fatal_error',
+
     // Designates an event indicating that we were kicked from the XMPP MUC.
     KICKED: 'xmpp.kicked',
+
     // Designates an event indicating that our role in the XMPP MUC has changed.
     LOCAL_ROLE_CHANGED: 'xmpp.localrole_changed',
+
     // Designates an event indicating that an XMPP message in the MUC was
     // received.
     MESSAGE_RECEIVED: 'xmpp.message_received',
+
     // Designates an event indicating that the XMPP MUC was destroyed.
     MUC_DESTROYED: 'xmpp.muc_destroyed',
+
     // Designates an event indicating that we have joined the XMPP MUC.
     MUC_JOINED: 'xmpp.muc_joined',
+
     // Designates an event indicating that a participant joined the XMPP MUC.
     MUC_MEMBER_JOINED: 'xmpp.muc_member_joined',
+
     // Designates an event indicating that a participant left the XMPP MUC.
     MUC_MEMBER_LEFT: 'xmpp.muc_member_left',
+
     // Designates an event indicating that local participant left the muc
     MUC_LEFT: 'xmpp.muc_left',
+
     // Designates an event indicating that the MUC role of a participant has
     // changed.
     MUC_ROLE_CHANGED: 'xmpp.muc_role_changed',
+
     // Designates an event indicating that the MUC has been locked or unlocked.
     MUC_LOCK_CHANGED: 'xmpp.muc_lock_changed',
+
     // Designates an event indicating that a participant in the XMPP MUC has
     // advertised that they have audio muted (or unmuted).
     PARTICIPANT_AUDIO_MUTED: 'xmpp.audio_muted',
+
     // Designates an event indicating that a participant in the XMPP MUC has
     // advertised that they have video muted (or unmuted).
     PARTICIPANT_VIDEO_MUTED: 'xmpp.video_muted',
+
     // Designates an event indicating that the video type (e.g. 'camera' or
     // 'screen') for a participant has changed.
     // Note: currently this event fires every time we receive presence from
     // someone (regardless of whether or not the "video type" changed).
     PARTICIPANT_VIDEO_TYPE_CHANGED: 'xmpp.video_type',
+
     /**
      * Indicates that the features of the participant has been changed.
      */
     PARTCIPANT_FEATURES_CHANGED: 'xmpp.partcipant_features_changed',
     PASSWORD_REQUIRED: 'xmpp.password_required',
     PEERCONNECTION_READY: 'xmpp.peerconnection_ready',
+
     /**
      * Indicates that phone number changed.
      */
     PHONE_NUMBER_CHANGED: 'conference.phoneNumberChanged',
     PRESENCE_STATUS: 'xmpp.presence_status',
     PROMPT_FOR_LOGIN: 'xmpp.prompt_for_login',
+
     // xmpp is connected and obtained user media
     READY_TO_JOIN: 'xmpp.ready_to_join',
+
     /**
      * Indicates that recording state changed.
      */
     RECORDER_STATE_CHANGED: 'xmpp.recorderStateChanged',
+
     // Designates an event indicating that we received statistics from a
     // participant in the MUC.
     REMOTE_STATS: 'xmpp.remote_stats',
     ROOM_CONNECT_ERROR: 'xmpp.room_connect_error',
     ROOM_CONNECT_NOT_ALLOWED_ERROR: 'xmpp.room_connect_error.not_allowed',
     ROOM_JOIN_ERROR: 'xmpp.room_join_error',
+
     /**
      * Indicates that max users limit has been reached.
      */
     ROOM_MAX_USERS_ERROR: 'xmpp.room_max_users_error',
+
     // Designates an event indicating that we sent an XMPP message to the MUC.
     SENDING_CHAT_MESSAGE: 'xmpp.sending_chat_message',
+
     /**
      * Event fired when we do not get our 'session-accept' acknowledged by
      * Jicofo. It most likely means that there is serious problem with our
      * packets means that most likely it has never seen our IQ.
      */
     SESSION_ACCEPT_TIMEOUT: 'xmpp.session_accept_timeout',
+
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS: 'xmpp.start_muted_from_focus',
+
     // Designates an event indicating that the subject of the XMPP MUC has
     // changed.
     SUBJECT_CHANGED: 'xmpp.subject_changed',
+
     // suspending detected
     SUSPEND_DETECTED: 'xmpp.suspend_detected',
+
     // Designates an event indicating that the local ICE username fragment of
     // the jingle session has changed.
     LOCAL_UFRAG_CHANGED: 'xmpp.local_ufrag_changed',
+
     // Designates an event indicating that the local ICE username fragment of
     // the jingle session has changed.
     REMOTE_UFRAG_CHANGED: 'xmpp.remote_ufrag_changed',
+
     // Designates an event indicating that the local ICE connection state has
     // changed.
     ICE_CONNECTION_STATE_CHANGED: 'xmpp.ice_connection_state_changed'