[RN] Fix documentation comments

* Javadoc introduced @code as a replacement of <code> and <tt> which is
  better aligned with other javadoc tags such as @link. Use it in the
  Java source code. If we switch to Kotlin, then we'll definitely use
  Markdown.

* There are more uses of @code in the JavaScript source code than <tt>
  so use @code for the sake of consistency. Eventually, I'd rather we
  switch to Markdown because it's easier on my eyes.

* Xcode is plain confused by @code and @link. The Internet says that
  Xcode supports the backquote character to denote the beginning and end
  of a string of characters which should be formatted for display as
  code but it doesn't work for me. <tt> is not rendered at all. So use
  the backquote which is rendered itself. Hopefully, if we switch to
  Markdown, then it'll be common between JavaScript and Objective-C
  source code.

android/app/src/main/java/org/jitsi/meet/MainActivity.java

  * {@code react-native run-android}.
  */
 public class MainActivity extends JitsiMeetActivity {
-    /**
-     * {@inheritDoc}
-     */
+    @Override
     protected JitsiMeetView initializeView() {
         JitsiMeetView view = super.initializeView();
 
                             + data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onConferenceFailed(Map<String, Object> data) {
                     on("CONFERENCE_FAILED", data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onConferenceJoined(Map<String, Object> data) {
                     on("CONFERENCE_JOINED", data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onConferenceLeft(Map<String, Object> data) {
                     on("CONFERENCE_LEFT", data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onConferenceWillJoin(Map<String, Object> data) {
                     on("CONFERENCE_WILL_JOIN", data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onConferenceWillLeave(Map<String, Object> data) {
                     on("CONFERENCE_WILL_LEAVE", data);
                 }
 
-                /**
-                 * {@inheritDoc}
-                 */
                 @Override
                 public void onLoadConfigError(Map<String, Object> data) {
                     on("LOAD_CONFIG_ERROR", data);
         return view;
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         // As this is the Jitsi Meet app (i.e. not the Jitsi Meet SDK), we do

android/sdk/src/main/java/org/jitsi/meet/sdk/AndroidSettingsModule.java

         super(reactContext);
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public String getName() {
         return "AndroidSettings";

android/sdk/src/main/java/org/jitsi/meet/sdk/AppInfoModule.java

     }
 
     /**
-     * Gets a <tt>Map</tt> of constants this module exports to JS. Supports JSON
+     * Gets a {@code Map} of constants this module exports to JS. Supports JSON
      * types.
      *
      * @return a {@link Map} of constants this module exports to JS
         return constants;
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public String getName() {
         return "AppInfo";

android/sdk/src/main/java/org/jitsi/meet/sdk/AudioModeModule.java

  * Module implementing a simple API to select the appropriate audio device for a
  * conference call.
  *
- * Audio calls should use <tt>AudioModeModule.AUDIO_CALL</tt>, which uses the
+ * Audio calls should use {@code AudioModeModule.AUDIO_CALL}, which uses the
  * builtin earpiece, wired headset or bluetooth headset. The builtin earpiece is
  * the default audio device.
  *
- * Video calls should should use <tt>AudioModeModule.VIDEO_CALL</tt>, which uses
+ * Video calls should should use {@code AudioModeModule.VIDEO_CALL}, which uses
  * the builtin speaker, earpiece, wired headset or bluetooth headset. The
  * builtin speaker is the default audio device.
  *
  * Before a call has started and after it has ended the
- * <tt>AudioModeModule.DEFAULT</tt> mode should be used.
+ * {@code AudioModeModule.DEFAULT} mode should be used.
  */
 class AudioModeModule extends ReactContextBaseJavaModule {
     /**
             : Intent.ACTION_HEADSET_PLUG;
 
     /**
-     * The name of <tt>AudioModeModule</tt> to be used in the React Native
+     * The name of {@code AudioModeModule} to be used in the React Native
      * bridge.
      */
     private static final String MODULE_NAME = "AudioMode";
 
     /**
-     * The <tt>Log</tt> tag <tt>AudioModeModule</tt> is to log messages with.
+     * The {@code Log} tag {@code AudioModeModule} is to log messages with.
      */
     static final String TAG = MODULE_NAME;
 
      * Updates the audio route for the given mode.
      *
      * @param mode the audio mode to be used when computing the audio route.
-     * @return true if the audio route was updated successfully, false
-     * otherwise.
+     * @return {@code true} if the audio route was updated successfully;
+     * {@code false}, otherwise.
      */
     private boolean updateAudioRoute(int mode) {
         Log.d(TAG, "Update audio route for mode: " + mode);

android/sdk/src/main/java/org/jitsi/meet/sdk/BluetoothHeadsetMonitor.java

     /**
      * Returns the current headset availability.
      *
-     * @return true if there is a Bluetooth headset connected, false otherwise.
+     * @return {@code true} if there is a Bluetooth headset connected;
+     * {@code false}, otherwise.
      */
     public boolean isHeadsetAvailable() {
         return headsetAvailable;

android/sdk/src/main/java/org/jitsi/meet/sdk/DefaultHardwareBackBtnHandlerImpl.java

 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 
 /**
- * Defines the default behavior of <tt>JitsiMeetActivity</tt> and
- * <tt>JitsiMeetView</tt> upon invoking the back button if no
- * <tt>JitsiMeetView</tt> handles the invocation. For example, a
- * <tt>JitsiMeetView</tt> may (1) handle the invocation of the back button
+ * Defines the default behavior of {@code JitsiMeetActivity} and
+ * {@code JitsiMeetView} upon invoking the back button if no
+ * {@code JitsiMeetView} handles the invocation. For example, a
+ * {@code JitsiMeetView} may (1) handle the invocation of the back button
  * during a conference by leaving the conference and (2) not handle the
  * invocation when not in a conference.
  */
     implements DefaultHardwareBackBtnHandler {
 
     /**
-     * The <tt>Activity</tt> to which the default handling of the back button
+     * The {@code Activity} to which the default handling of the back button
      * is being provided by this instance.
      */
     private final Activity activity;
 
     /**
-     * Initializes a new <tt>DefaultHardwareBackBtnHandlerImpl</tt> instance to
+     * Initializes a new {@code DefaultHardwareBackBtnHandlerImpl} instance to
      * provide the default handling of the back button to a specific
-     * <tt>Activity</tt>.
+     * {@code Activity}.
      *
-     * @param activity - the <tt>Activity</tt> to which the new instance is to
+     * @param activity the {@code Activity} to which the new instance is to
      * provide the default behavior of the back button
      */
     public DefaultHardwareBackBtnHandlerImpl(Activity activity) {
     /**
      * {@inheritDoc}
      *
-     * Finishes the associated <tt>Activity</tt>.
+     * Finishes the associated {@code Activity}.
      */
     @Override
     public void invokeDefaultOnBackPressed() {

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetActivity.java

 
 /**
  * Base Activity for applications integrating Jitsi Meet at a higher level. It
- * contains all the required wiring between the <tt>JKConferenceView</tt> and
+ * contains all the required wiring between the {@code JKConferenceView} and
  * the Activity lifecycle methods already implemented.
  *
- * In this activity we use a single <tt>JKConferenceView</tt> instance. This
+ * In this activity we use a single {@code JKConferenceView} instance. This
  * instance gives us access to a view which displays the welcome page and the
  * conference itself. All lifetime methods associated with this Activity are
  * hooked to the React Native subsystem via proxy calls through the
- * <tt>JKConferenceView</tt> static methods.
+ * {@code JKConferenceView} static methods.
  */
 public class JitsiMeetActivity
     extends AppCompatActivity {
         = (int) (Math.random() * Short.MAX_VALUE);
 
     /**
-     * The default behavior of this <tt>JitsiMeetActivity</tt> upon invoking the
+     * The default behavior of this {@code JitsiMeetActivity} upon invoking the
      * back button if {@link #view} does not handle the invocation.
      */
     private DefaultHardwareBackBtnHandler defaultBackButtonImpl;
      * Loads the given URL and displays the conference. If the specified URL is
      * null, the welcome page is displayed instead.
      *
-     * @param url - The conference URL.
+     * @param url The conference URL.
      */
     public void loadURL(@Nullable URL url) {
         view.loadURL(url);
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onActivityResult(
             int requestCode,
         }
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onBackPressed() {
         if (!JitsiMeetView.onBackPressed()) {
         }
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         initializeContentView();
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onDestroy() {
         super.onDestroy();
         JitsiMeetView.onHostDestroy(this);
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onNewIntent(Intent intent) {
         JitsiMeetView.onNewIntent(intent);
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onPause() {
         super.onPause();
         defaultBackButtonImpl = null;
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     protected void onResume() {
         super.onResume();

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetView.java

     /**
      * Internal method to initialize the React Native instance manager. We
      * create a single instance in order to load the JavaScript bundle a single
-     * time. All <tt>ReactRootView</tt> instances will be tied to the one and
-     * only <tt>ReactInstanceManager</tt>.
+     * time. All {@code ReactRootView} instances will be tied to the one and
+     * only {@code ReactInstanceManager}.
      *
-     * @param application - <tt>Application</tt> instance which is running.
+     * @param application {@code Application} instance which is running.
      */
     private static void initReactInstanceManager(Application application) {
         reactInstanceManager
      * Loads a specific URL {@code String} in all existing
      * {@code JitsiMeetView}s.
      *
-     * @param urlString - The URL {@code String} to load in all existing
+     * @param urlString he URL {@code String} to load in all existing
      * {@code JitsiMeetView}s.
      * @return If the specified {@code urlString} was submitted for loading in
      * at least one {@code JitsiMeetView}, then {@code true}; otherwise,
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onBackPressed</tt> so we can do the required internal
+     * {@code Activity.onBackPressed} so we can do the required internal
      * processing.
      *
-     * @return - true if the back-press was processed, false otherwise. In case
-     * false is returned the application should call the parent's
+     * @return {@code true} if the back-press was processed; {@code false},
+     * otherwise. If {@code false}, the application should call the parent's
      * implementation.
      */
     public static boolean onBackPressed() {
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onDestroy</tt> so we can do the required internal
+     * {@code Activity.onDestroy} so we can do the required internal
      * processing.
      *
-     * @param activity - <tt>Activity</tt> being destroyed.
+     * @param activity {@code Activity} being destroyed.
      */
     public static void onHostDestroy(Activity activity) {
         if (reactInstanceManager != null) {
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onPause</tt> so we can do the required internal processing.
+     * {@code Activity.onPause} so we can do the required internal processing.
      *
-     * @param activity - <tt>Activity</tt> being paused.
+     * @param activity {@code Activity} being paused.
      */
     public static void onHostPause(Activity activity) {
         if (reactInstanceManager != null) {
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onResume</tt> so we can do the required internal processing.
+     * {@code Activity.onResume} so we can do the required internal processing.
      *
-     * @param activity - <tt>Activity</tt> being resumed.
+     * @param activity {@code Activity} being resumed.
      */
     public static void onHostResume(Activity activity) {
         onHostResume(activity, new DefaultHardwareBackBtnHandlerImpl(activity));
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onResume</tt> so we can do the required internal processing.
+     * {@code Activity.onResume} so we can do the required internal processing.
      *
-     * @param activity - <tt>Activity</tt> being resumed.
-     * @param defaultBackButtonImpl - a <tt>DefaultHardwareBackBtnHandler</tt>
-     * to handle invoking the back button if no <tt>JitsiMeetView</tt> handles
-     * it.
+     * @param activity {@code Activity} being resumed.
+     * @param defaultBackButtonImpl a {@code DefaultHardwareBackBtnHandler} to
+     * handle invoking the back button if no {@code JitsiMeetView} handles it.
      */
     public static void onHostResume(
             Activity activity,
 
     /**
      * Activity lifecycle method which should be called from
-     * <tt>Activity.onNewIntent</tt> so we can do the required internal
+     * {@code Activity.onNewIntent} so we can do the required internal
      * processing. Note that this is only needed if the activity's "launchMode"
      * was set to "singleTask". This is required for deep linking to work once
      * the application is already running.
      *
-     * @param intent - <tt>Intent</tt> instance which was received.
+     * @param intent {@code Intent} instance which was received.
      */
     public static void onNewIntent(Intent intent) {
         // XXX At least twice we received bug reports about malfunctioning
     /**
      * Gets the default base {@code URL} used to join a conference when a
      * partial URL (e.g. a room name only) is specified to
-     * {@link #loadURLString(String)} or {@link #loadURLObject(Bundle}. If not
+     * {@link #loadURLString(String)} or {@link #loadURLObject(Bundle)}. If not
      * set or if set to {@code null}, the default built in JavaScript is used:
      * {@link https://meet.jit.si}
      *
      * page is rendered when this {@code JitsiMeetView} is not at a URL
      * identifying a Jitsi Meet conference/room.
      *
-     * @return {@true} if the Welcome page is enabled; otherwise, {@code false}.
+     * @return {@code true} if the Welcome page is enabled; otherwise,
+     * {@code false}.
      */
     public boolean getWelcomePageEnabled() {
         return welcomePageEnabled;
      * the specified {@code URL} is {@code null} and the Welcome page is
      * enabled, the Welcome page is displayed instead.
      *
-     * @param url - The {@code URL} to load which may identify a conference to
+     * @param url The {@code URL} to load which may identify a conference to
      * join.
      */
     public void loadURL(@Nullable URL url) {
      * clients/consumers. If the specified URL is {@code null} and the Welcome
      * page is enabled, the Welcome page is displayed instead.
      *
-     * @param urlObject - The URL to load which may identify a conference to
-     * join.
+     * @param urlObject The URL to load which may identify a conference to join.
      */
     public void loadURLObject(@Nullable Bundle urlObject) {
         Bundle props = new Bundle();
      * join. If the specified URL {@code String} is {@code null} and the Welcome
      * page is enabled, the Welcome page is displayed instead.
      *
-     * @param urlString - The URL {@code String} to load which may identify a
+     * @param urlString The URL {@code String} to load which may identify a
      * conference to join.
      */
     public void loadURLString(@Nullable String urlString) {
      * {@link #loadURLString(String)} or {@link #loadURLObject(Bundle)}. Must be
      * called before {@link #loadURL(URL)} for it to take effect.
      *
-     * @param defaultURL - The {@code URL} to be set as the default base URL.
+     * @param defaultURL The {@code URL} to be set as the default base URL.
      * @see #getDefaultURL()
      */
     public void setDefaultURL(URL defaultURL) {
      * Sets a specific {@link JitsiMeetViewListener} on this
      * {@code JitsiMeetView}.
      *
-     * @param listener - The {@code JitsiMeetViewListener} to set on this
+     * @param listener The {@code JitsiMeetViewListener} to set on this
      * {@code JitsiMeetView}.
      */
     public void setListener(JitsiMeetViewListener listener) {

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetViewAdapter.java

  * all methods in the interface if they are only interested in some.
  */
 public abstract class JitsiMeetViewAdapter implements JitsiMeetViewListener {
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onConferenceFailed(Map<String, Object> data) {
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onConferenceJoined(Map<String, Object> data) {
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onConferenceLeft(Map<String, Object> data) {
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onConferenceWillJoin(Map<String, Object> data) {
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onConferenceWillLeave(Map<String, Object> data) {
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public void onLoadConfigError(Map<String, Object> data) {
     }

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetViewListener.java

      * Called when joining a conference fails or an ongoing conference is
      * interrupted due to a failure.
      *
-     * @param data - Map with an "error" key describing the problem, and
-     * a "url" key with the conference URL.
+     * @param data Map with an "error" key describing the problem, and a "url"
+     * key with the conference URL.
      */
     void onConferenceFailed(Map<String, Object> data);
 
     /**
      * Called when a conference was joined.
      *
-     * @param data - Map with a "url" key with the conference URL.
+     * @param data Map with a "url" key with the conference URL.
      */
     void onConferenceJoined(Map<String, Object> data);
 
     /**
      * Called when the conference was left, typically after hanging up.
      *
-     * @param data - Map with a "url" key with the conference URL.
+     * @param data Map with a "url" key with the conference URL.
      */
     void onConferenceLeft(Map<String, Object> data);
 
     /**
      * Called before the conference is joined.
      *
-     * @param data - Map with a "url" key with the conference URL.
+     * @param data Map with a "url" key with the conference URL.
      */
     void onConferenceWillJoin(Map<String, Object> data);
 
     /**
      * Called before the conference is left.
      *
-     * @param data - Map with a "url" key with the conference URL.
+     * @param data Map with a "url" key with the conference URL.
      */
     void onConferenceWillLeave(Map<String, Object> data);
 
      * Called when loading the main configuration file from the Jitsi Meet
      * deployment fails.
      *
-     * @param data - Map with an "error" key with the error and a "url" key with
+     * @param data Map with an "error" key with the error and a "url" key with
      * the conference URL which necessitated the loading of the configuration
      * file.
      */

android/sdk/src/main/java/org/jitsi/meet/sdk/ProximityModule.java

  */
 class ProximityModule extends ReactContextBaseJavaModule {
     /**
-     * The name of <tt>ProximityModule</tt> to be used in the React Native
+     * The name of {@code ProximityModule} to be used in the React Native
      * bridge.
      */
     private static final String MODULE_NAME = "Proximity";

android/sdk/src/main/java/org/jitsi/meet/sdk/ReactPackageAdapter.java

 import java.util.List;
 
 public class ReactPackageAdapter implements ReactPackage {
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public List<Class<? extends JavaScriptModule>> createJSModules() {
         return Collections.emptyList();
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public List<NativeModule> createNativeModules(
             ReactApplicationContext reactContext) {
         return Collections.emptyList();
     }
 
-    /**
-     * {@inheritDoc}
-     */
     @Override
     public List<ViewManager> createViewManagers(
             ReactApplicationContext reactContext) {

ios/sdk/src/ExternalAPI.m

  *
  * @param name The name of the event.
  * @param data The details/specifics of the event to send determined
- * by/associated with the specified {@code name}.
+ * by/associated with the specified `name`.
  * @param scope
  */
 RCT_EXPORT_METHOD(sendEvent:(NSString *)name
  * method name.
  *
  * @param eventName The event name to convert to a method name.
- * @return A method name constructed from the specified {@code eventName}.
+ * @return A method name constructed from the specified `eventName`.
  */
 - (NSString *)methodNameFromEventName:(NSString *)eventName {
    NSMutableString *methodName

ios/sdk/src/JitsiMeetView.m

 #import "RCTBridgeWrapper.h"
 
 /**
- * A <tt>RCTFatalHandler</tt> implementation which swallows JavaScript errors.
- * In the Release configuration, React Native will (intentionally) raise an
- * unhandled NSException for an unhandled JavaScript error. This will
- * effectively kill the application. <tt>_RCTFatal</tt> is suitable to be in
- * accord with the Web i.e. not kill the application.
+ * A `RCTFatalHandler` implementation which swallows JavaScript errors. In the
+ * Release configuration, React Native will (intentionally) raise an unhandled
+ * `NSException` for an unhandled JavaScript error. This will effectively kill
+ * the application. `_RCTFatal` is suitable to be in accord with the Web i.e.
+ * not kill the application.
  */
 RCTFatalHandler _RCTFatal = ^(NSError *error) {
     id jsStackTrace = error.userInfo[RCTJSStackTraceKey];
 };
 
 /**
- * Helper function to dynamically load custom fonts. The UIAppFonts key in the
+ * Helper function to dynamically load custom fonts. The `UIAppFonts` key in the
  * plist file doesn't work for frameworks, so fonts have to be manually loaded.
  */
 void loadCustomFonts(Class clazz) {
 void registerFatalErrorHandler() {
 #if !DEBUG
     // In the Release configuration, React Native will (intentionally) raise an
-    // unhandled NSException for an unhandled JavaScript error. This will
+    // unhandled `NSException` for an unhandled JavaScript error. This will
     // effectively kill the application. In accord with the Web, do not kill the
     // application.
     if (!RCTGetFatalHandler()) {
 
 @interface JitsiMeetView() {
     /**
-     * The unique identifier of this {@code JitsiMeetView} within the process
-     * for the purposes of {@link ExternalAPI}. The name scope was inspired by
-     * postis which we use on Web for the similar purposes of the iframe-based
-     * external API.
+     * The unique identifier of this `JitsiMeetView` within the process for the
+     * purposes of `ExternalAPI`. The name scope was inspired by postis which we
+     * use on Web for the similar purposes of the iframe-based external API.
      */
     NSString *externalAPIScope;
 
 static RCTBridgeWrapper *bridgeWrapper;
 
 /**
- * Copy of the {@code launchOptions} dictionary that the application was started
- * with. It is required for the initial URL to be used if a (Universal) link was
- * used to launch a new instance of the application.
+ * Copy of the `launchOptions` dictionary that the application was started with.
+ * It is required for the initial URL to be used if a (Universal) link was used
+ * to launch a new instance of the application.
  */
 static NSDictionary *_launchOptions;
 
 /**
- * The {@code JitsiMeetView}s associated with their {@code ExternalAPI} scopes
- * (i.e. unique identifiers within the process).
+ * The `JitsiMeetView`s associated with their `ExternalAPI` scopes (i.e. unique
+ * identifiers within the process).
  */
 static NSMapTable<NSString *, JitsiMeetView *> *views;
 
 #pragma mark API
 
 /**
- * Loads a specific {@link NSURL} which may identify a conference to join. If
- * the specified {@code NSURL} is {@code nil} and the Welcome page is enabled,
- * the Welcome page is displayed instead.
+ * Loads a specific `NSURL` which may identify a conference to join. If the
+ * specified `NSURL` is `nil` and the Welcome page is enabled, the Welcome page
+ * is displayed instead.
  *
- * @param url - The {@code NSURL} to load which may identify a conference to
- * join.
+ * @param url The `NSURL` to load which may identify a conference to join.
  */
 - (void)loadURL:(NSURL *)url {
     [self loadURLString:url ? url.absoluteString : nil];
 
 /**
  * Loads a specific URL which may identify a conference to join. The URL is
- * specified in the form of an {@link NSDictionary} of properties which (1)
- * internally are sufficient to construct a URL {@code NSString} while (2)
- * abstracting the specifics of constructing the URL away from API
- * clients/consumers. If the specified URL is {@code nil} and the Welcome page
- * is enabled, the Welcome page is displayed instead.
+ * specified in the form of an `NSDictionary` of properties which (1)
+ * internally are sufficient to construct a URL `NSString` while (2) abstracting
+ * the specifics of constructing the URL away from API clients/consumers. If the
+ * specified URL is `nil` and the Welcome page is enabled, the Welcome page is
+ * displayed instead.
  *
- * @param urlObject - The URL to load which may identify a conference to join.
+ * @param urlObject The URL to load which may identify a conference to join.
  */
 - (void)loadURLObject:(NSDictionary *)urlObject {
     NSMutableDictionary *props = [[NSMutableDictionary alloc] init];
 }
 
 /**
- * Loads a specific URL {@link NSString} which may identify a conference to
- * join. If the specified URL {@code NSString} is {@code nil} and the Welcome
- * page is enabled, the Welcome page is displayed instead.
+ * Loads a specific URL `NSString` which may identify a conference to
+ * join. If the specified URL `NSString` is `nil` and the Welcome page is
+ * enabled, the Welcome page is displayed instead.
  *
- * @param urlString - The URL {@code NSString} to load which may identify a
- * conference to join.
+ * @param urlString The URL `NSString` to load which may identify a conference
+ * to join.
  */
 - (void)loadURLString:(NSString *)urlString {
     [self loadURLObject:urlString ? @{ @"url": urlString } : nil];
 #pragma mark Private methods
 
 /**
- * Loads a specific {@link NSURL} in all existing {@code JitsiMeetView}s.
+ * Loads a specific `NSURL` in all existing `JitsiMeetView`s.
  *
- * @param url - The {@code NSURL} to load in all existing
- * {@code JitsiMeetView}s.
- * @return {@code YES} if the specified {@code url} was submitted for loading in
- * at least one {@code JitsiMeetView}; otherwise, {@code NO}.
+ * @param url The `NSURL` to load in all existing `JitsiMeetView`s.
+ * @return `YES` if the specified `url` was submitted for loading in at least
+ * one `JitsiMeetView`; otherwise, `NO`.
  */
 + (BOOL)loadURLInViews:(NSURL *)url {
     return

ios/sdk/src/JitsiMeetViewDelegate.h

  * Called when a joining a conference was unsuccessful or when there was an
  * error while in a conference.
  *
- * The {@code data} dictionary contains an "error" key describing the error and
- * a {@code url} key with the conference URL.
+ * The `data` dictionary contains an `error` key describing the error and a
+ * `url` key with the conference URL.
  */
 - (void)conferenceFailed:(NSDictionary *)data;
 
 /**
  * Called when a conference was joined.
  *
- * The {@code data} dictionary contains a {@code url} key with the conference
- * URL.
+ * The `data` dictionary contains a `url` key with the conference URL.
  */
 - (void)conferenceJoined:(NSDictionary *)data;
 
 /**
  * Called when a conference was left.
  *
- * The {@code data} dictionary contains a {@code url} key with the conference
- * URL.
+ * The `data` dictionary contains a `url` key with the conference URL.
  */
 - (void)conferenceLeft:(NSDictionary *)data;
 
 /**
  * Called before a conference is joined.
  *
- * The {@code data} dictionary contains a {@code url} key with the conference
- * URL.
+ * The `data` dictionary contains a `url` key with the conference URL.
  */
 - (void)conferenceWillJoin:(NSDictionary *)data;
 
 /**
  * Called before a conference is left.
  *
- * The {@code data} dictionary contains a {@code url} key with the conference
- * URL.
+ * The `data` dictionary contains a `url` key with the conference URL.
  */
 - (void)conferenceWillLeave:(NSDictionary *)data;
 
  * Called when loading the main configuration file from the Jitsi Meet
  * deployment file.
  *
- * The {@code data} dictionary contains an {@code error} key with the error and
- * a {@code url} key with the conference URL which necessitated the loading of
- * the configuration file.
+ * The `data` dictionary contains an `error` key with the error and a `url` key
+ * with the conference URL which necessitated the loading of the configuration
+ * file.
  */
 - (void)loadConfigError:(NSDictionary *)data;
 

ios/sdk/src/Proximity.m

  * proximity sensor automatically dims the screen and disables touch controls,
  * so there is nothing else to do (unlike on Android)!
  *
- * @param enabled {@code YES} to enable proximity (sensor) monitoring;
- * {@code NO}, otherwise.
+ * @param enabled `YES` to enable proximity (sensor) monitoring; `NO`,
+ * otherwise.
  */
 RCT_EXPORT_METHOD(setEnabled:(BOOL)enabled) {
     [[UIDevice currentDevice] setProximityMonitoringEnabled:enabled];

ios/sdk/src/RCTBridgeWrapper.h

 #import <React/RCTBridgeDelegate.h>
 
 /**
- * A wrapper around the <tt>RCTBridge</tt> which implements the delegate methods
+ * A wrapper around the `RCTBridge` which implements the delegate methods
  * that allow us to serve the JS bundle from within the framework's resources
  * directory. This is the recommended way for those cases where the builtin API
  * doesn't cut it, as is the case.

react/features/app/actions.js

 
     /**
      * Notifies that an attempt to load a configuration has completed. Due to
-     * the asynchronous nature of the loading, the specified <tt>config</tt> may
+     * the asynchronous nature of the loading, the specified {@code config} may
      * or may not be required by the time the notification arrives.
      *
      * @param {string|undefined} error - If the loading has failed, the error

react/features/authentication/actionTypes.js

 /**
  * The type of (redux) action which informs that the authentication and role
  * upgrade process has finished either with success or with a specific error.
- * If <tt>error</tt> is <tt>undefined</tt>, then the process succeeded;
+ * If {@code error} is {@code undefined}, then the process succeeded;
  * otherwise, it failed. Refer to
  * {@link JitsiConference#authenticateAndUpgradeRole} in lib-jitsi-meet for the
  * error details.

react/features/authentication/actions.js

  *
  * @param {Object} thenableWithCancel - The process of authenticating and
  * upgrading the local participant's role.
- * @param {Object} progressOrError - If the value is a <tt>number</tt>, then the
+ * @param {Object} progressOrError - If the value is a {@code number}, then the
  * process of authenticating and upgrading the local participant's role has
  * succeeded in one of its two/multiple steps; otherwise, it has failed with the
  * specified error. Refer to {@link JitsiConference#authenticateAndUpgradeRole}

react/features/authentication/components/WaitForOwnerDialog.native.js

     }
 
     /**
-     * Renders a specific <tt>string</tt> which may contain HTML.
+     * Renders a specific {@code string} which may contain HTML.
      *
-     * @param {string} html - The <tt>string</tt> which may contain HTML to
+     * @param {string} html - The {@code string} which may contain HTML to
      * render.
      * @returns {ReactElement[]|string}
      */

react/features/authentication/components/styles.js

 import { BoxModel, createStyleSheet } from '../../base/styles';
 
 /**
- * The style common to <tt>LoginDialog</tt> and <tt>WaitForOwnerDialog</tt>.
+ * The style common to {@code LoginDialog} and {@code WaitForOwnerDialog}.
  */
 const dialog = {
     marginBottom: BoxModel.margin,
 };
 
 /**
- * The style common to <tt>Text</tt> rendered by <tt>LoginDialog</tt> and
- * <tt>WaitForOwnerDialog</tt>.
+ * The style common to {@code Text} rendered by {@code LoginDialog} and
+ * {@code WaitForOwnerDialog}.
  */
 const text = {
 };
  */
 export default createStyleSheet({
     /**
-     * The style of bold <tt>Text</tt> rendered by the <tt>Dialog</tt>s of the
+     * The style of bold {@code Text} rendered by the {@code Dialog}s of the
      * feature authentication.
      */
     boldDialogText: {
     },
 
     /**
-     * The style of <tt>Text</tt> rendered by the <tt>Dialog</tt>s of the
+     * The style of {@code Text} rendered by the {@code Dialog}s of the
      * feature authentication.
      */
     dialogText: {
     },
 
     /**
-     * The style of <tt>TextInput</tt> rendered by the <tt>Dialog</tt>s of the
+     * The style of {@code TextInput} rendered by the {@code Dialog}s of the
      * feature authentication.
      */
     dialogTextInput: {
     },
 
     /**
-     * The style of <tt>LoginDialog</tt>.
+     * The style of {@code LoginDialog}.
      */
     loginDialog: {
         ...dialog,
     },
 
     /**
-     * The style of <tt>WaitForOwnerDialog</tt>.
+     * The style of {@code WaitForOwnerDialog}.
      */
     waitForOwnerDialog: {
         ...dialog,

react/features/base/config/functions.js

 /* eslint-enable no-shadow */
 
 /**
- * Sends HTTP POST request to specified <tt>endpoint</tt>. In request the name
+ * Sends HTTP POST request to specified {@code endpoint}. In request the name
  * of the room is included in JSON format:
  * {
  *     "rooomName": "someroom12345"

react/features/base/connection/functions.js

  * Converts a specific id to jid if it's not jid yet.
  *
  * @param {string} id - User id or jid.
- * @param {Object} configHosts - The <tt>hosts</tt> part of the <tt>config</tt>
+ * @param {Object} configHosts - The {@code hosts} part of the {@code config}
  * object.
  * @returns {string} A string in the form of a JID (i.e.
- * <tt>user@server.com</tt>).
+ * {@code user@server.com}).
  */
 export function toJid(id: string, { authdomain, domain }: Object): string {
     return id.indexOf('@') >= 0 ? id : `${id}@${authdomain || domain}`;

react/features/base/dialog/actions.js

 /**
  * Signals Dialog to close its dialog.
  *
- * @param {Object} [component] - The <tt>Dialog</tt> component to close/hide. If
- * <tt>undefined</tt>, closes/hides <tt>Dialog</tt> regardless of which
- * component it's rendering; otherwise, closes/hides <tt>Dialog</tt> only if
- * it's rendering the specified <tt>component</tt>.
+ * @param {Object} [component] - The {@code Dialog} component to close/hide. If
+ * {@code undefined}, closes/hides {@code Dialog} regardless of which
+ * component it's rendering; otherwise, closes/hides {@code Dialog} only if
+ * it's rendering the specified {@code component}.
  * @returns {{
  *     type: HIDE_DIALOG,
  *     component: (React.Component | undefined)
  * Signals Dialog to open dialog.
  *
  * @param {Object} component - The component to display as dialog.
- * @param {Object} [componentProps] - The React <tt>Component</tt> props of the
- * specified <tt>component</tt>.
+ * @param {Object} [componentProps] - The React {@code Component} props of the
+ * specified {@code component}.
  * @returns {{
  *     type: OPEN_DIALOG,
  *     component: React.Component,
  * dialog.
  *
  * @param {Object} component - The component to display as dialog.
- * @param {Object} [componentProps] - The React <tt>Component</tt> props of the
- * specified <tt>component</tt>.
+ * @param {Object} [componentProps] - The React {@code Component} props of the
+ * specified {@code component}.
  * @returns {Function}
  */
 export function toggleDialog(component: Object, componentProps: ?Object) {

react/features/base/dialog/components/AbstractDialog.js

  */
 export default class AbstractDialog extends Component {
     /**
-     * <tt>AbstractDialog</tt> React <tt>Component</tt>'s prop types.
+     * {@code AbstractDialog} React {@code Component}'s prop types.
      *
      * @static
      */
         ...DIALOG_PROP_TYPES,
 
         /**
-         * The React <tt>Component</tt> children of <tt>AbstractDialog</tt>
+         * The React {@code Component} children of {@code AbstractDialog}
          * which represents the dialog's body.
          */
         children: PropTypes.node,
     };
 
     /**
-     * Initializes a new <tt>AbstractDialog</tt> instance.
+     * Initializes a new {@code AbstractDialog} instance.
      *
-     * @param {Object} props - The read-only React <tt>Component</tt> props with
+     * @param {Object} props - The read-only React {@code Component} props with
      * which the new instance is to be initialized.
      */
     constructor(props) {
     }
 
     /**
-     * Submits this dialog. If the React <tt>Component</tt> prop
-     * <tt>onSubmit</tt> is defined, the function that is the value of the prop
-     * is invoked. If the function returns a <tt>thenable</tt>, then the
-     * resolution of the <tt>thenable</tt> is awaited. If the submission
+     * Submits this dialog. If the React {@code Component} prop
+     * {@code onSubmit} is defined, the function that is the value of the prop
+     * is invoked. If the function returns a {@code thenable}, then the
+     * resolution of the {@code thenable} is awaited. If the submission
      * completes successfully, a redux action will be dispatched to hide this
      * dialog.
      *
     }
 
     /**
-     * Notifies this <tt>AbstractDialog</tt> that it has been submitted
+     * Notifies this {@code AbstractDialog} that it has been submitted
      * successfully. Dispatches a redux action to hide this dialog after it has
      * been submitted.
      *
     }
 
     /**
-     * Notifies this <tt>AbstractDialog</tt> that its submission has failed.
+     * Notifies this {@code AbstractDialog} that its submission has failed.
      *
      * @private
      * @returns {void}

react/features/base/dialog/components/Dialog.native.js

 
 /**
  * The value of the style property {@link _TAG_KEY} which identifies the
- * OK/submit button of <tt>Prompt</tt>.
+ * OK/submit button of {@code Prompt}.
  */
 const _SUBMIT_TEXT_TAG_VALUE = '_SUBMIT_TEXT_TAG_VALUE';
 
 /**
- * The name of the style property which identifies ancestors of <tt>Prompt</tt>
+ * The name of the style property which identifies ancestors of {@code Prompt}
  * such as its OK/submit button for the purposes of workarounds implemented by
- * <tt>Dialog</tt>.
+ * {@code Dialog}.
  *
  * XXX The value may trigger a react-native warning in the Debug configuration
  * but, unfortunately, I couldn't find a value that wouldn't.
 const _TAG_KEY = '_TAG_KEY';
 
 /**
- * Implements <tt>AbstractDialog</tt> on react-native using <tt>Prompt</tt>.
+ * Implements {@code AbstractDialog} on react-native using {@code Prompt}.
  */
 class Dialog extends AbstractDialog {
     /**
-     * <tt>AbstractDialog</tt>'s React <tt>Component</tt> prop types.
+     * {@code AbstractDialog}'s React {@code Component} prop types.
      *
      * @static
      */
     }
 
     /**
-     * Creates a deep clone of a specific <tt>ReactElement</tt> with the results
+     * Creates a deep clone of a specific {@code ReactElement} with the results
      * of calling a specific function on every node of a specific
-     * <tt>ReactElement</tt> tree.
+     * {@code ReactElement} tree.
      *
-     * @param {ReactElement} element - The <tt>ReactElement</tt> to clone and
-     * call the specified <tt>f</tt> on.
+     * @param {ReactElement} element - The {@code ReactElement} to clone and
+     * call the specified {@code f} on.
      * @param {Function} f - The function to call on every node of the
-     * <tt>ReactElement</tt> tree represented by the specified <tt>element</tt>.
+     * {@code ReactElement} tree represented by the specified {@code element}.
      * @private
      * @returns {ReactElement}
      */

react/features/base/dialog/components/DialogContainer.js

 }
 
 /**
- * Maps (parts of) the redux state to the associated <tt>DialogContainer</tt>'s
+ * Maps (parts of) the redux state to the associated {@code DialogContainer}'s
  * props.
  *
  * @param {Object} state - The redux state.

react/features/base/dialog/components/styles.js

 import { ColorPalette, createStyleSheet } from '../../styles';
 
 /**
- * The React <tt>Component</tt> styles of the feature base/dialog.
+ * The React {@code Component} styles of the feature base/dialog.
  */
 export default createStyleSheet({
     /**
-     * The style of the <tt>Text</tt> in a <tt>Dialog</tt> button.
+     * The style of the {@code Text} in a {@code Dialog} button.
      */
     buttonText: {
         color: ColorPalette.blue
     },
 
     /**
-     * The style of the <tt>Text</tt> in a <tt>Dialog</tt> button which is
+     * The style of the {@code Text} in a {@code Dialog} button which is
      * disabled.
      */
     disabledButtonText: {

react/features/base/dialog/functions.js

 import { toState } from '../redux';
 
 /**
- * Checks if a <tt>Dialog</tt> with a specific <tt>component</tt> is currently
+ * Checks if a {@code Dialog} with a specific {@code component} is currently
  * open.
  *
  * @param {Function|Object} stateful - The redux store, the redux
- * <tt>getState</tt> function, or the redux state itself.
- * @param {React.Component} component - The <tt>component</tt> of a
- * <tt>Dialog</tt> to be checked.
+ * {@code getState} function, or the redux state itself.
+ * @param {React.Component} component - The {@code component} of a
+ * {@code Dialog} to be checked.
  * @returns {boolean}
  */
 export function isDialogOpen(stateful: Function | Object, component: Object) {

react/features/base/lib-jitsi-meet/native/RTCPeerConnection.js

 /**
  * Adapts react-native-webrtc's {@link RTCPeerConnection#setRemoteDescription}
  * implementation which uses the deprecated, callback-based version to the
- * <tt>Promise</tt>-based version.
+ * {@code Promise}-based version.
  *
  * @param {RTCSessionDescription} sessionDescription - The RTCSessionDescription
  * which specifies the configuration of the remote end of the connection.

react/features/base/lib-jitsi-meet/native/Storage.js

 
 /**
  * A Web Sorage API implementation used for polyfilling
- * <tt>window.localStorage</tt> and/or <tt>window.sessionStorage</tt>.
+ * {@code window.localStorage} and/or {@code window.sessionStorage}.
  * <p>
  * The Web Storage API is synchronous whereas React Native's builtin generic
- * storage API <tt>AsyncStorage</tt> is asynchronous so the implementation with
+ * storage API {@code AsyncStorage} is asynchronous so the implementation with
  * persistence is optimistic: it will first store the value locally in memory so
  * that results can be served synchronously and then persist the value
  * asynchronously. If an asynchronous operation produces an error, it's ignored.
  */
 export default class Storage {
     /**
-     * Initializes a new <tt>Storage</tt> instance. Loads all previously
-     * persisted data items from React Native's <tt>AsyncStorage</tt> if
+     * Initializes a new {@code Storage} instance. Loads all previously
+     * persisted data items from React Native's {@code AsyncStorage} if
      * necessary.
      *
      * @param {string|undefined} keyPrefix - The prefix of the
-     * <tt>AsyncStorage</tt> keys to be persisted by this storage.
+     * {@code AsyncStorage} keys to be persisted by this storage.
      */
     constructor(keyPrefix) {
         /**
-         * The prefix of the <tt>AsyncStorage</tt> keys persisted by this
-         * storage. If <tt>undefined</tt>, then the data items stored in this
+         * The prefix of the {@code AsyncStorage} keys persisted by this
+         * storage. If {@code undefined}, then the data items stored in this
          * storage will not be persisted.
          *
          * @private
      * Returns the value associated with a specific key in this storage.
      *
      * @param {string} key - The name of the key to retrieve the value of.
-     * @returns {string|null} The value associated with <tt>key</tt> or
-     * <tt>null</tt>.
+     * @returns {string|null} The value associated with {@code key} or
+     * {@code null}.
      */
     getItem(key) {
         return this.hasOwnProperty(key) ? this[key] : null;
      * value. If the key exists already, updates its value.
      *
      * @param {string} key - The name of the key to add/update.
-     * @param {string} value - The value to associate with <tt>key</tt>.
+     * @param {string} value - The value to associate with {@code key}.
      * @returns {void}
      */
     setItem(key, value) {

react/features/base/media/functions.js

 
 /**
  * Determines whether video is currently muted by a specific
- * <tt>VIDEO_MUTISM_AUTHORITY</tt>.
+ * {@code VIDEO_MUTISM_AUTHORITY}.
  *
  * @param {Function|Object} stateful - The redux store, state, or
  * {@code getState} function.
- * @param {number} videoMutismAuthority - The <tt>VIDEO_MUTISM_AUTHORITY</tt>
+ * @param {number} videoMutismAuthority - The {@code VIDEO_MUTISM_AUTHORITY}
  * which is to be checked whether it has muted video.
  * @returns {boolean} If video is currently muted by the specified
- * <tt>videoMutismAuthority</tt>, then <tt>true</tt>; otherwise, <tt>false</tt>.
+ * {@code videoMutismAuthority}, then {@code true}; otherwise, {@code false}.
  */
 function _isVideoMutedByAuthority(
         stateful: Function | Object,

react/features/base/participants/components/Avatar.native.js

  * specified one fails to load.
  *
  * XXX The relative path to the default/stock (image) file is defined by the
- * <tt>const</tt> <tt>DEFAULT_AVATAR_RELATIVE_PATH</tt>. Unfortunately, the
+ * {@code const} {@code DEFAULT_AVATAR_RELATIVE_PATH}. Unfortunately, the
  * packager of React Native cannot deal with it early enough for the following
- * <tt>require</tt> to succeed at runtime. Anyway, be sure to synchronize the
+ * {@code require} to succeed at runtime. Anyway, be sure to synchronize the
  * relative path on Web and mobile for the purposes of consistency.
  *
  * @private
     }
 
     /**
-     * Notifies this <tt>Component</tt> that it will be unmounted and destroyed
+     * Notifies this {@code Component} that it will be unmounted and destroyed
      * and, most importantly, that it should no longer call
-     * {@link #setState(Object)}. <tt>Avatar</tt> needs it because it downloads
+     * {@link #setState(Object)}. {@code Avatar} needs it because it downloads
      * images via {@link ImageCache} which will asynchronously notify about
      * success.
      *
      * Computes a hash over the URI and returns a HSL background color. We use
      * 75% as lightness, for nice pastel style colors.
      *
-     * @param {Object} props - The read-only React <tt>Component</tt> props from
+     * @param {Object} props - The read-only React {@code Component} props from
      * which the background color is to be generated.
      * @private
      * @returns {string} - The HSL CSS property.

react/features/base/participants/constants.js

  * XXX (1) Web/React utilizes relativity on the Jitsi Meet deployment.
  * (2) Mobile/React Native utilizes relativity on the local file system at build
  * time. Unfortunately, the packager of React Native cannot deal with the
- * <tt>const</tt> early enough for <tt>require</tt> to succeed at runtime.
+ * {@code const} early enough for {@code require} to succeed at runtime.
  * Anyway, be sure to synchronize the relative path on Web and mobile for the
  * purposes of consistency.
  *

react/features/base/participants/reducer.js

  * @property {boolean} pinned - If true, participant is currently a
  * "PINNED_ENDPOINT".
  * @property {boolean} dominantSpeaker - If this participant is the dominant
- * speaker in the (associated) conference, <tt>true</tt>; otherwise,
- * <tt>false</tt>.
+ * speaker in the (associated) conference, {@code true}; otherwise,
+ * {@code false}.
  * @property {string} email - Participant email.
  */
 

react/features/base/react/components/web/Watermarks.js

 declare var interfaceConfig: Object;
 
 /**
- * The CSS style of the element with CSS class <tt>rightwatermark</tt>.
+ * The CSS style of the element with CSS class {@code rightwatermark}.
  *
  * @private
  */

react/features/base/redux/functions.js

 
 /**
  * Sets a specific property of a specific state to a specific value. Prevents
- * unnecessary state changes (when the specified <tt>value</tt> is equal to the
- * value of the specified <tt>property</tt> of the specified <tt>state</tt>).
+ * unnecessary state changes (when the specified {@code value} is equal to the
+ * value of the specified {@code property} of the specified {@code state}).
  *
  * @param {Object} state - The (Redux) state from which a new state is to be
- * constructed by setting the specified <tt>property</tt> to the specified
- * <tt>value</tt>.
- * @param {string} property - The property of <tt>state</tt> which is to be
- * assigned the specified <tt>value</tt> (in the new state).
- * @param {*} value - The value to assign to the specified <tt>property</tt>.
- * @returns {Object} The specified <tt>state</tt> if the value of the specified
- * <tt>property</tt> equals the specified <tt>value/tt>; otherwise, a new state
- * constructed from the specified <tt>state</tt> by setting the specified
- * <tt>property</tt> to the specified <tt>value</tt>.
+ * constructed by setting the specified {@code property} to the specified
+ * {@code value}.
+ * @param {string} property - The property of {@code state} which is to be
+ * assigned the specified {@code value} (in the new state).
+ * @param {*} value - The value to assign to the specified {@code property}.
+ * @returns {Object} The specified {@code state} if the value of the specified
+ * {@code property} equals the specified <tt>value/tt>; otherwise, a new state
+ * constructed from the specified {@code state} by setting the specified
+ * {@code property} to the specified {@code value}.
  */
 export function set(state: Object, property: string, value: any) {
     return _set(state, property, value, /* copyOnWrite */ true);
 
 /**
  * Sets a specific property of a specific state to a specific value. Prevents
- * unnecessary state changes (when the specified <tt>value</tt> is equal to the
- * value of the specified <tt>property</tt> of the specified <tt>state</tt>).
+ * unnecessary state changes (when the specified {@code value} is equal to the
+ * value of the specified {@code property} of the specified {@code state}).
  *
  * @param {Object} state - The (Redux) state from which a state is to be
- * constructed by setting the specified <tt>property</tt> to the specified
- * <tt>value</tt>.
- * @param {string} property - The property of <tt>state</tt> which is to be
- * assigned the specified <tt>value</tt>.
- * @param {*} value - The value to assign to the specified <tt>property</tt>.
- * @param {boolean} copyOnWrite - If the specified <tt>state</tt> is to not be
- * modified, <tt>true</tt>; otherwise, <tt>false</tt>.
- * @returns {Object} The specified <tt>state</tt> if the value of the specified
- * <tt>property</tt> equals the specified <tt>value/tt> or <tt>copyOnWrite</tt>
+ * constructed by setting the specified {@code property} to the specified
+ * {@code value}.
+ * @param {string} property - The property of {@code state} which is to be
+ * assigned the specified {@code value}.
+ * @param {*} value - The value to assign to the specified {@code property}.
+ * @param {boolean} copyOnWrite - If the specified {@code state} is to not be
+ * modified, {@code true}; otherwise, {@code false}.
+ * @returns {Object} The specified {@code state} if the value of the specified
+ * {@code property} equals the specified <tt>value/tt> or {@code copyOnWrite}
  * is truthy; otherwise, a new state constructed from the specified
- * <tt>state</tt> by setting the specified <tt>property</tt> to the specified
- * <tt>value</tt>.
+ * {@code state} by setting the specified {@code property} to the specified
+ * {@code value}.
  */
 function _set(
         state: Object,
 /* eslint-enable max-params */
 
 /**
- * Returns redux state from the specified <tt>stateful</tt> which is presumed to
+ * Returns redux state from the specified {@code stateful} which is presumed to
  * be related to the redux state (e.g. the redux store, the redux
- * <tt>getState</tt> function).
+ * {@code getState} function).
  *
  * @param {Function|Object} stateful - The entity such as the redux store or the
- * redux <tt>getState</tt> function from which the redux state is to be
+ * redux {@code getState} function from which the redux state is to be
  * returned.
  * @returns {Object} The redux state.
  */

react/features/base/tracks/actions.js

 }
 
 /**
- * Finds the first <tt>JitsiLocalTrack</tt> in a specific array/list of
- * <tt>JitsiTrack</tt>s which is of a specific <tt>MEDIA_TYPE</tt>.
+ * Finds the first {@code JitsiLocalTrack} in a specific array/list of
+ * {@code JitsiTrack}s which is of a specific {@code MEDIA_TYPE}.
  *
- * @param {JitsiTrack[]} tracks - The array/list of <tt>JitsiTrack</tt>s to look
+ * @param {JitsiTrack[]} tracks - The array/list of {@code JitsiTrack}s to look
  * through.
- * @param {MEDIA_TYPE} mediaType - The <tt>MEDIA_TYPE</tt> of the first
- * <tt>JitsiLocalTrack</tt> to be returned.
+ * @param {MEDIA_TYPE} mediaType - The {@code MEDIA_TYPE} of the first
+ * {@code JitsiLocalTrack} to be returned.
  * @private
- * @returns {JitsiLocalTrack} The first <tt>JitsiLocalTrack</tt>, if any, in the
- * specified <tt>tracks</tt> of the specified <tt>mediaType</tt>.
+ * @returns {JitsiLocalTrack} The first {@code JitsiLocalTrack}, if any, in the
+ * specified {@code tracks} of the specified {@code mediaType}.
  */
 function _getLocalTrack(tracks, mediaType) {
     return tracks.find(track =>
 }
 
 /**
- * Implements the <tt>Promise</tt> rejection handler of
- * <tt>createLocalTracksA</tt> and <tt>createLocalTracksF</tt>.
+ * Implements the {@code Promise} rejection handler of
+ * {@code createLocalTracksA} and {@code createLocalTracksF}.
  *
- * @param {Object} reason - The <tt>Promise</tt> rejection reason.
- * @param {string} device - The device/<tt>MEDIA_TYPE</tt> associated with the
+ * @param {Object} reason - The {@code Promise} rejection reason.
+ * @param {string} device - The device/{@code MEDIA_TYPE} associated with the
  * rejection.
  * @private
  * @returns {Function}

react/features/base/tracks/functions.js

 }
 
 /**
- * Mutes or unmutes a specific <tt>JitsiLocalTrack</tt>. If the muted state of
- * the specified <tt>track</tt> is already in accord with the specified
- * <tt>muted</tt> value, then does nothing.
+ * Mutes or unmutes a specific {@code JitsiLocalTrack}. If the muted state of
+ * the specified {@code track} is already in accord with the specified
+ * {@code muted} value, then does nothing.
  *
- * @param {JitsiLocalTrack} track - The <tt>JitsiLocalTrack</tt> to mute or
+ * @param {JitsiLocalTrack} track - The {@code JitsiLocalTrack} to mute or
  * unmute.
- * @param {boolean} muted - If the specified <tt>track</tt> is to be muted, then
- * <tt>true</tt>; otherwise, <tt>false</tt>.
+ * @param {boolean} muted - If the specified {@code track} is to be muted, then
+ * {@code true}; otherwise, {@code false}.
  * @returns {Promise}
  */
 export function setTrackMuted(track, muted) {

react/features/base/tracks/middleware.js

 });
 
 /**
- * Gets the local track associated with a specific <tt>MEDIA_TYPE</tt> in a
+ * Gets the local track associated with a specific {@code MEDIA_TYPE} in a
  * specific redux store.
  *
  * @param {Store} store - The redux store from which the local track associated
- * with the specified <tt>mediaType</tt> is to be retrieved.
- * @param {MEDIA_TYPE} mediaType - The <tt>MEDIA_TYPE</tt> of the local track to
- * be retrieved from the specified <tt>store</tt>.
+ * with the specified {@code mediaType} is to be retrieved.
+ * @param {MEDIA_TYPE} mediaType - The {@code MEDIA_TYPE} of the local track to
+ * be retrieved from the specified {@code store}.
  * @private
- * @returns {Track} The local <tt>Track</tt> associated with the specified
- * <tt>mediaType</tt> in the specified <tt>store</tt>.
+ * @returns {Track} The local {@code Track} associated with the specified
+ * {@code mediaType} in the specified {@code store}.
  */
 function _getLocalTrack({ getState }, mediaType: MEDIA_TYPE) {
     return getLocalTrack(getState()['features/base/tracks'], mediaType);

react/features/base/util/loadScript.native.js

 /**
  * Loads a script from a specific URL. React Native cannot load a JS
  * file/resource/URL via a <script> HTML element, so the implementation
- * fetches the specified <tt>url</tt> as plain text using {@link fetch()} and
+ * fetches the specified {@code url} as plain text using {@link fetch()} and
  * then evaluates the fetched string as JavaScript code (using {@link eval()}).
  *
  * @param {string} url - The absolute URL from which the script is to be

react/features/conference/components/Conference.native.js

 
         /**
          * Handles a hardware button press for back navigation. Leaves the
-         * associated <tt>Conference</tt>.
+         * associated {@code Conference}.
          *
          * @private
          * @returns {boolean} As the associated conference is unconditionally
-         * left and exiting the app while it renders a <tt>Conference</tt> is
-         * undesired, <tt>true</tt> is always returned.
+         * left and exiting the app while it renders a {@code Conference} is
+         * undesired, {@code true} is always returned.
          */
         _onHardwareBackPress: PropTypes.func,
 
      * Handles a hardware button press for back navigation.
      *
      * @returns {boolean} If the hardware button press for back navigation was
-     * handled by this <tt>Conference</tt>, then <tt>true</tt>; otherwise,
-     * <tt>false</tt>.
+     * handled by this {@code Conference}, then {@code true}; otherwise,
+     * {@code false}.
      */
     _onHardwareBackPress() {
         return this._backHandler && this.props._onHardwareBackPress();
 
         /**
          * Handles a hardware button press for back navigation. Leaves the
-         * associated <tt>Conference</tt>.
+         * associated {@code Conference}.
          *
          * @returns {boolean} As the associated conference is unconditionally
-         * left and exiting the app while it renders a <tt>Conference</tt> is
-         * undesired, <tt>true</tt> is always returned.
+         * left and exiting the app while it renders a {@code Conference} is
+         * undesired, {@code true} is always returned.
          */
         _onHardwareBackPress() {
             dispatch(appNavigate(undefined));

react/features/filmstrip/components/Filmstrip.native.js

     }
 
     /**
-     * Sorts a specific array of <tt>Participant</tt>s in display order.
+     * Sorts a specific array of {@code Participant}s in display order.
      *
-     * @param {Participant[]} participants - The array of <tt>Participant</tt>s
+     * @param {Participant[]} participants - The array of {@code Participant}s
      * to sort in display order.
      * @private
      * @returns {Participant[]} A new array containing the elements of the
-     * specified <tt>participants</tt> array sorted in display order.
+     * specified {@code participants} array sorted in display order.
      */
     _sort(participants) {
         // XXX Array.prototype.sort() is not appropriate because (1) it operates

react/features/large-video/actions.js

 
 /**
  * Returns the identifier of the participant who is to be on the stage i.e.
- * should be displayed in <tt>LargeVideo</tt>.
+ * should be displayed in {@code LargeVideo}.
  *
  * @param {Object} state - The Redux state from which the participant to be
- * displayed in <tt>LargeVideo</tt> is to be elected.
+ * displayed in {@code LargeVideo} is to be elected.
  * @private
  * @returns {(string|undefined)}
  */

react/features/mobile/callkit/middleware.js

 
 /**
  * Notifies the feature jwt that the action {@link APP_WILL_MOUNT} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>APP_WILL_MOUNT</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code APP_WILL_MOUNT} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link CONFERENCE_FAILED} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>CONFERENCE_FAILED</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code CONFERENCE_FAILED} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link CONFERENCE_JOINED} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>CONFERENCE_JOINED</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code CONFERENCE_JOINED} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link CONFERENCE_LEFT} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>CONFERENCE_LEFT</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code CONFERENCE_LEFT} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link CONFERENCE_WILL_JOIN} is
- * being dispatched within a specific redux <tt>store</tt>.
+ * being dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>CONFERENCE_WILL_JOIN</tt> which
- * is being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code CONFERENCE_WILL_JOIN} which
+ * is being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 }
 
 /**
- * Handles CallKit's event <tt>performEndCallAction</tt>.
+ * Handles CallKit's event {@code performEndCallAction}.
  *
  * @param {Object} event - The details of the CallKit event
- * <tt>performEndCallAction</tt>.
+ * {@code performEndCallAction}.
  * @returns {void}
  */
 function _onPerformEndCallAction({ callUUID }) {
 }
 
 /**
- * Handles CallKit's event <tt>performSetMutedCallAction</tt>.
+ * Handles CallKit's event {@code performSetMutedCallAction}.
  *
  * @param {Object} event - The details of the CallKit event
- * <tt>performSetMutedCallAction</tt>.
+ * {@code performSetMutedCallAction}.
  * @returns {void}
  */
 function _onPerformSetMutedCallAction({ callUUID, muted: newValue }) {
 
 /**
  * Notifies the feature jwt that the action {@link SET_AUDIO_MUTED} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>SET_AUDIO_MUTED</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code SET_AUDIO_MUTED} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link _SET_CALLKIT_SUBSCRIPTIONS}
- * is being dispatched within a specific redux <tt>store</tt>.
+ * is being dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>_SET_CALLKIT_SUBSCRIPTIONS</tt>
- * which is being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code _SET_CALLKIT_SUBSCRIPTIONS}
+ * which is being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */
 
 /**
  * Notifies the feature jwt that the action {@link SET_VIDEO_MUTED} is being
- * dispatched within a specific redux <tt>store</tt>.
+ * dispatched within a specific redux {@code store}.
  *
- * @param {Store} store - The redux store in which the specified <tt>action</tt>
+ * @param {Store} store - The redux store in which the specified {@code action}
  * is being dispatched.
  * @param {Dispatch} next - The redux dispatch function to dispatch the
- * specified <tt>action</tt> to the specified <tt>store</tt>.
- * @param {Action} action - The redux action <tt>SET_VIDEO_MUTED</tt> which is
- * being dispatched in the specified <tt>store</tt>.
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code SET_VIDEO_MUTED} which is
+ * being dispatched in the specified {@code store}.
  * @private
  * @returns {*}
  */

react/features/mobile/external-api/middleware.js

 });
 
 /**
- * Gets the description of a specific <tt>Symbol</tt>.
+ * Gets the description of a specific {@code Symbol}.
  *
- * @param {Symbol} symbol - The <tt>Symbol</tt> to retrieve the description of.
+ * @param {Symbol} symbol - The {@code Symbol} to retrieve the description of.
  * @private
- * @returns {string} The description of <tt>symbol</tt>.
+ * @returns {string} The description of {@code symbol}.
  */
 function _getSymbolDescription(symbol: Symbol) {
     let description = symbol.toString();

react/features/mobile/image-cache/functions.js

 import { ImageCache } from './';
 
 /**
- * Notifies about the successful download of an <tt>Image</tt> source. The name
- * is inspired by <tt>Image</tt>. The downloaded <tt>Image</tt> source is not
+ * Notifies about the successful download of an {@code Image} source. The name
+ * is inspired by {@code Image}. The downloaded {@code Image} source is not
  * available because (1) I do not know how to get it from {@link ImageCache} and
  * (2) we do not need it bellow. The function was explicitly introduced to cut
- * down on unnecessary <tt>ImageCache</tt> <tt>observer</tt> instances.
+ * down on unnecessary {@code ImageCache} {@code observer} instances.
  *
  * @private
  * @returns {void}
 }
 
 /**
- * Initiates the retrieval of a specific <tt>Image</tt> source (if it has not
+ * Initiates the retrieval of a specific {@code Image} source (if it has not
  * been initiated already). Due to limitations of {@link ImageCache}, the source
- * may have at most one <tt>uri</tt>. The name is inspired by <tt>Image</tt>.
+ * may have at most one {@code uri}. The name is inspired by {@code Image}.
  *
- * @param {Object} source - The <tt>Image</tt> source with preferably exactly
- * one <tt>uri</tt>.
+ * @param {Object} source - The {@code Image} source with preferably exactly
+ * one {@code uri}.
  * @public
  * @returns {void}
  */

react/features/mobile/image-cache/middleware.js

  * The indicator which determines whether avatar URLs are to be prefetched in
  * the middleware here. Unless/until the implementation starts observing the
  * redux store instead of the respective redux actions, the value should very
- * likely be <tt>false</tt> because the middleware here is pretty much the last
+ * likely be {@code false} because the middleware here is pretty much the last
  * to get a chance to figure out that an avatar URL may be used. Besides, it is
  * somewhat uninformed to download just about anything that may eventually be
  * used or not.

react/features/mobile/network-activity/components/NetworkActivityIndicator.js

 import { LoadingIndicator } from '../../../base/react';
 
 /**
- * The React <tt>Component</tt> which renders a progress indicator when there
+ * The React {@code Component} which renders a progress indicator when there
  * are ongoing network requests.
  */
 class NetworkActivityIndicator extends Component {
     /**
-     * <tt>NetworkActivityIndicator</tt> React <tt>Component</tt>'s prop types.
+     * {@code NetworkActivityIndicator} React {@code Component}'s prop types.
      *
      * @static
      */
 }
 
 /**
- * Maps (parts of) the redux state to the React <tt>Component</tt> props of
- * <tt>NetworkActivityIndicator</tt>.
+ * Maps (parts of) the redux state to the React {@code Component} props of
+ * {@code NetworkActivityIndicator}.
  *
  * @param {Object} state - The redux state.
  * @private

react/features/overlay/reducer.js

  * @param {Action} action - The redux action to reduce.
  * @private
  * @returns {Object} The new state of the feature overlay after reducing the
- * specified <tt>action</tt> in the feature overlay.
+ * specified {@code action} in the feature overlay.
  */
 function _connectionWillConnect(
         state,

react/features/toolbox/middleware.js

  * @param {Store} store - The redux store.
  * @param {Function} next - The redux function to continue dispatching the
  * specified {@code action} in the specified {@code store}.
- * @param {Object} action - <tt>SET_AUDIO_AVAILABLE</tt>,
- * <tt>SET_VIDEO_AVAILABLE</tt>, or <tt>TRACK_UPDATED</tt>.
+ * @param {Object} action - {@code SET_AUDIO_AVAILABLE},
+ * {@code SET_VIDEO_AVAILABLE}, or {@code TRACK_UPDATED}.
  * @returns {*}
  */
 function _setMediaAvailableOrMuted({ dispatch, getState }, next, action) {

react/features/welcome/components/BlankPage.native.js

 import styles from './styles';
 
 /**
- * The React <tt>Component</tt> displayed by <tt>AbstractApp</tt> when it has no
- * <tt>Route</tt> to render. Renders a progress indicator when there are ongoing
+ * The React {@code Component} displayed by {@code AbstractApp} when it has no
+ * {@code Route} to render. Renders a progress indicator when there are ongoing
  * network requests.
  */
 class BlankPage extends Component {
     /**
-     * <tt>BlankPage</tt> React <tt>Component</tt>'s prop types.
+     * {@code BlankPage} React {@code Component}'s prop types.
      *
      * @static
      */
     static propTypes = {
         /**
-         * The indicator which determines whether <tt>WelcomePage</tt> is (to
+         * The indicator which determines whether {@code WelcomePage} is (to
          * be) rendered.
          *
          * @private
 }
 
 /**
- * Maps (parts of) the redux state to the React <tt>Component</tt> props of
- * <tt>BlankPage</tt>.
+ * Maps (parts of) the redux state to the React {@code Component} props of
+ * {@code BlankPage}.
  *
  * @param {Object} state - The redux state.
  * @private

react/features/welcome/components/LocalVideoTrackUnderlay.native.js

     state: {
 
         /**
-         * The style of <tt>LocalVideoTrackUnderlay</tt> which is a combination
+         * The style of {@code LocalVideoTrackUnderlay} which is a combination
          * of its default style and the consumer-specified style.
          */
         style: Object

react/features/welcome/components/WelcomePage.web.js

     }
 
     /**
-     * Handles <tt>change</tt> event of the checkbox which allows specifying
+     * Handles {@code change} event of the checkbox which allows specifying
      * whether the WelcomePage is disabled.
      *
      * @param {Event} event - The (HTML) Event which details the change such as

react/features/welcome/components/styles.js

 const TEXT_COLOR = ColorPalette.white;
 
 /**
- * The styles of the React <tt>Components</tt> of the feature welcome including
- * <tt>WelcomePage</tt> and <tt>BlankPage</tt>.
+ * The styles of the React {@code Components} of the feature welcome including
+ * {@code WelcomePage} and {@code BlankPage}.
  */
 export default createStyleSheet({
     /**
-     * The style of the top-level container of <tt>BlankPage</tt>.
+     * The style of the top-level container of {@code BlankPage}.
      */
     blankPage: {
     },
     },
 
     /**
-     * The style of the <tt>View</tt> displayed over the local video by
-     * <tt>LocalVideoTrackUnderlay</tt>. The latter is thought of as the
+     * The style of the {@code View} displayed over the local video by
+     * {@code LocalVideoTrackUnderlay}. The latter is thought of as the
      * background (content). The former is thought of as the foreground
      * (content).
      */
     },
 
     /**
-     * The style of the top-level container/<tt>View</tt> of
-     * <tt>LocalVideoTrackUnderlay</tt>.
+     * The style of the top-level container/{@code View} of
+     * {@code LocalVideoTrackUnderlay}.
      */
     localVideoTrackUnderlay: fixAndroidViewClipping({
         alignSelf: 'stretch',
     },
 
     /**
-     * The style of the top-level container of <tt>WelcomePage</tt>.
+     * The style of the top-level container of {@code WelcomePage}.
      */
     welcomePage: {
         backgroundColor: ColorPalette.blue

react/features/welcome/functions.js

 export * from './roomnameGenerator';
 
 /**
- * Determines whether the <tt>WelcomePage</tt> is enabled by the app itself
+ * Determines whether the {@code WelcomePage} is enabled by the app itself
  * (e.g. programmatically via the Jitsi Meet SDK for Android and iOS). Not to be
  * confused with {@link isWelcomePageUserEnabled}.
  *
  * @param {Object|Function} stateOrGetState - The redux state or
  * {@link getState} function.
- * @returns {boolean} If the <tt>WelcomePage</tt> is enabled by the app, then
- * <tt>true</tt>; otherwise, <tt>false</tt>.
+ * @returns {boolean} If the {@code WelcomePage} is enabled by the app, then
+ * {@code true}; otherwise, {@code false}.
  */
 export function isWelcomePageAppEnabled(stateOrGetState: Object | Function) {
     let b;
 }
 
 /**
- * Determines whether the <tt>WelcomePage</tt> is enabled by the user either
+ * Determines whether the {@code WelcomePage} is enabled by the user either
  * herself or through her deployment config(uration). Not to be confused with
  * {@link isWelcomePageAppEnabled}.
  *
  * @param {Object|Function} stateOrGetState - The redux state or
  * {@link getState} function.
- * @returns {boolean} If the <tt>WelcomePage</tt> is enabled by the user, then
- * <tt>true</tt>; otherwise, <tt>false</tt>.
+ * @returns {boolean} If the {@code WelcomePage} is enabled by the user, then
+ * {@code true}; otherwise, {@code false}.
  */
 export function isWelcomePageUserEnabled(stateOrGetState: Object | Function) {
     return (

react/features/welcome/route.js

 } from './functions';
 
 /**
- * Register route for <tt>WelcomePage</tt>.
+ * Register route for {@code WelcomePage}.
  */
 RouteRegistry.register({
     component: WelcomePage,
 });
 
 /**
- * Skips the <tt>WelcomePage</tt> if it is disabled (by the app or the user).
+ * Skips the {@code WelcomePage} if it is disabled (by the app or the user).
  *
  * @param {Object} store - The redux store.
  * @param {Function} replace - The function to redirect to another path.