Bug 1561435 - Format tools/, a=automatic-formatting
authorVictor Porof <vporof@mozilla.com>
Fri, 05 Jul 2019 11:18:19 +0200
changeset 544286 2106cbe66fff3ea3be766493a665cd96c1475e12
parent 544285 970453d65b194690181134c0271dfe675f813f81
child 544287 c97b04d9be60c34e87a47e591f2830a0d09273e4
push id2131
push userffxbld-merge
push dateMon, 26 Aug 2019 18:30:20 +0000
treeherdermozilla-release@b19ffb3ca153 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersautomatic-formatting
bugs1561435
milestone69.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1561435 - Format tools/, a=automatic-formatting # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D35940
.eslintrc.js
.prettierignore
tools/code-coverage/PerTestCoverageUtils.jsm
tools/code-coverage/tests/xpcshell/head.js
tools/code-coverage/tests/xpcshell/test_basic.js
tools/code-coverage/tests/xpcshell/test_basic_child_and_parent.js
tools/lint/eslint/eslint-plugin-mozilla/lib/configs/browser-test.js
tools/lint/eslint/eslint-plugin-mozilla/lib/configs/chrome-test.js
tools/lint/eslint/eslint-plugin-mozilla/lib/configs/mochitest-test.js
tools/lint/eslint/eslint-plugin-mozilla/lib/configs/recommended.js
tools/lint/eslint/eslint-plugin-mozilla/lib/configs/xpcshell-test.js
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/browser-window.js
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/chrome-worker.js
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/jsm.js
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/privileged.js
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/simpletest.js
tools/lint/eslint/eslint-plugin-mozilla/lib/globals.js
tools/lint/eslint/eslint-plugin-mozilla/lib/helpers.js
tools/lint/eslint/eslint-plugin-mozilla/lib/index.js
tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xbl-bindings.js
tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xul.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-Date-timing.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-removeChild.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/balanced-listeners.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/consistent-if-bracing.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-browser-window-globals.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-content-task-globals.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/mark-exported-symbols-as-used.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-aArgs.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-arbitrary-setTimeout.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-compare-against-boolean-literals.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-define-cc-etc.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-task.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-parameters.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-removeEventListener.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-run-test.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-importGlobalProperties.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-some-requires.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/rejects-requires-await.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-cc-etc.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-generateqi.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-import.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-default-preference-values.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-includes-instead-of-indexOf.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-ownerGlobal.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-returnValue.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-services.js
tools/lint/eslint/eslint-plugin-mozilla/lib/rules/var-only-at-top-level.js
tools/lint/eslint/eslint-plugin-mozilla/reporters/mozilla-format.js
tools/lint/eslint/eslint-plugin-mozilla/scripts/createExports.js
tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-Date-timing.js
tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-removeChild.js
tools/lint/eslint/eslint-plugin-mozilla/tests/balanced-listeners.js
tools/lint/eslint/eslint-plugin-mozilla/tests/consistent-if-bracing.js
tools/lint/eslint/eslint-plugin-mozilla/tests/mark-exported-symbols-as-used.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-arbitrary-setTimeout.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-compare-against-boolean-literals.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-define-cc-etc.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-parameters.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-removeEventListener.js
tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-run-test.js
tools/lint/eslint/eslint-plugin-mozilla/tests/reject-importGlobalProperties.js
tools/lint/eslint/eslint-plugin-mozilla/tests/rejects-requires-await.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-cc-etc.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-generateqi.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-import.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-default-preference-values.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-includes-instead-of-indexOf.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-ownerGlobal.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-returnValue.js
tools/lint/eslint/eslint-plugin-mozilla/tests/use-services.js
tools/profiler/tests/browser/browser_test_feature_jsallocations.js
tools/profiler/tests/browser/browser_test_profile_multi_frame_page_info.js
tools/profiler/tests/browser/browser_test_profile_pushstate_page_info.js
tools/profiler/tests/browser/browser_test_profile_replacestate_page_info.js
tools/profiler/tests/browser/browser_test_profile_single_frame_page_info.js
tools/profiler/tests/browser/head.js
tools/profiler/tests/chrome/profiler_test_utils.js
tools/profiler/tests/xpcshell/head_profiler.js
tools/profiler/tests/xpcshell/test_asm.js
tools/profiler/tests/xpcshell/test_enterjit_osr.js
tools/profiler/tests/xpcshell/test_enterjit_osr_disabling.js
tools/profiler/tests/xpcshell/test_enterjit_osr_enabling.js
tools/profiler/tests/xpcshell/test_feature_mainthreadio.js
tools/quitter/contentscript.js
tools/quitter/parent.js
tools/tryselect/selectors/chooser/static/filter.js
tools/tryselect/selectors/chooser/static/select.js
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -40,17 +40,16 @@ module.exports = {
     "plugin:mozilla/recommended"
   ],
   "plugins": [
     "mozilla"
   ],
   "overrides": [{
       "files": [
         "devtools/**",
-        "tools/**",
         "uriloader/**",
         "view/**",
         "widget/**",
         "xpcom/**",
         "xpfe/**",
       ],
       "rules": {
         // Temporarily disable the curly everywhere, pending Prettier.
--- a/.prettierignore
+++ b/.prettierignore
@@ -35,17 +35,16 @@ security/manager/ssl/security-prefs.js
 services/common/services-common.js
 services/sync/services-sync.js
 services/sync/tests/unit/prefs_test_prefs_store.js
 testing/marionette/prefs/marionette.js
 toolkit/components/telemetry/datareporting-prefs.js
 toolkit/components/telemetry/healthreport-prefs.js
 
 # Ignore all top-level directories for now.
-tools/**
 uriloader/**
 view/**
 widget/**
 xpcom/**
 xpfe/**
 
 # Ignore all devtools directories for now, except the debugger.
 devtools/client/*.js
--- a/tools/code-coverage/PerTestCoverageUtils.jsm
+++ b/tools/code-coverage/PerTestCoverageUtils.jsm
@@ -3,56 +3,64 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* exported PerTestCoverageUtils */
 
 "use strict";
 
 var EXPORTED_SYMBOLS = ["PerTestCoverageUtils"];
 
-const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
 
-const env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
+const env = Cc["@mozilla.org/process/environment;1"].getService(
+  Ci.nsIEnvironment
+);
 // This is the directory where gcov is emitting the gcda files.
 const gcovPrefixPath = env.get("GCOV_PREFIX");
 // This is the directory where codecoverage.py is expecting to see the gcda files.
 const gcovResultsPath = env.get("GCOV_RESULTS_DIR");
 // This is the directory where the JS engine is emitting the lcov files.
 const jsvmPrefixPath = env.get("JS_CODE_COVERAGE_OUTPUT_DIR");
 // This is the directory where codecoverage.py is expecting to see the lcov files.
 const jsvmResultsPath = env.get("JSVM_RESULTS_DIR");
 
-const gcovPrefixDir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+const gcovPrefixDir = Cc["@mozilla.org/file/local;1"].createInstance(
+  Ci.nsIFile
+);
 if (gcovPrefixPath) {
   gcovPrefixDir.initWithPath(gcovPrefixPath);
 }
 
 let gcovResultsDir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
 if (gcovResultsPath) {
   gcovResultsDir.initWithPath(gcovResultsPath);
 }
 
-const jsvmPrefixDir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+const jsvmPrefixDir = Cc["@mozilla.org/file/local;1"].createInstance(
+  Ci.nsIFile
+);
 if (jsvmPrefixPath) {
   jsvmPrefixDir.initWithPath(jsvmPrefixPath);
 }
 
 let jsvmResultsDir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
 if (jsvmResultsPath) {
   jsvmResultsDir.initWithPath(jsvmResultsPath);
 }
 
 function awaitPromise(promise) {
   let ret;
   let complete = false;
   let error = null;
-  promise.catch(e => error = e).then(v => {
-    ret = v;
-    complete = true;
-  });
+  promise
+    .catch(e => (error = e))
+    .then(v => {
+      ret = v;
+      complete = true;
+    });
   Services.tm.spinEventLoopUntil(() => complete);
   if (error) {
     throw new Error(error);
   }
   return ret;
 }
 
 function removeDirectoryContents(dir) {
@@ -72,17 +80,19 @@ function moveDirectoryContents(src, dst)
 var PerTestCoverageUtils = class PerTestCoverageUtilsClass {
   // Resets the counters to 0.
   static async beforeTest() {
     if (!PerTestCoverageUtils.enabled) {
       return;
     }
 
     // Flush the counters.
-    let codeCoverageService = Cc["@mozilla.org/tools/code-coverage;1"].getService(Ci.nsICodeCoverage);
+    let codeCoverageService = Cc[
+      "@mozilla.org/tools/code-coverage;1"
+    ].getService(Ci.nsICodeCoverage);
     await codeCoverageService.flushCounters();
 
     // Remove coverage files created by the flush, and those that might have been created between the end of a previous test and the beginning of the next one (e.g. some tests can create a new content process for every sub-test).
     removeDirectoryContents(gcovPrefixDir);
     removeDirectoryContents(jsvmPrefixDir);
 
     // Move coverage files from the GCOV_RESULTS_DIR and JSVM_RESULTS_DIR directories, so we can accumulate the counters.
     moveDirectoryContents(gcovResultsDir, gcovPrefixDir);
@@ -95,17 +105,19 @@ var PerTestCoverageUtils = class PerTest
 
   // Dumps counters and moves the gcda files in the directory expected by codecoverage.py.
   static async afterTest() {
     if (!PerTestCoverageUtils.enabled) {
       return;
     }
 
     // Flush the counters.
-    let codeCoverageService = Cc["@mozilla.org/tools/code-coverage;1"].getService(Ci.nsICodeCoverage);
+    let codeCoverageService = Cc[
+      "@mozilla.org/tools/code-coverage;1"
+    ].getService(Ci.nsICodeCoverage);
     await codeCoverageService.flushCounters();
 
     // Move the coverage files in GCOV_RESULTS_DIR and JSVM_RESULTS_DIR, so that the execution from now to shutdown (or next test) is not counted.
     moveDirectoryContents(gcovPrefixDir, gcovResultsDir);
     moveDirectoryContents(jsvmPrefixDir, jsvmResultsDir);
   }
 
   static afterTestSync() {
--- a/tools/code-coverage/tests/xpcshell/head.js
+++ b/tools/code-coverage/tests/xpcshell/head.js
@@ -1,21 +1,27 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-var {AppConstants} = ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
-var {OS, require} = ChromeUtils.import("resource://gre/modules/osfile.jsm");
+var { AppConstants } = ChromeUtils.import(
+  "resource://gre/modules/AppConstants.jsm"
+);
+var { OS, require } = ChromeUtils.import("resource://gre/modules/osfile.jsm");
 
 function getFiles() {
-  const env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
+  const env = Cc["@mozilla.org/process/environment;1"].getService(
+    Ci.nsIEnvironment
+  );
   // This is the directory where gcov is emitting the gcda files.
   const jsCoveragePath = env.get("JS_CODE_COVERAGE_OUTPUT_DIR");
 
-  const jsCoverageDir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+  const jsCoverageDir = Cc["@mozilla.org/file/local;1"].createInstance(
+    Ci.nsIFile
+  );
   jsCoverageDir.initWithPath(jsCoveragePath);
 
   let files = [];
 
   let entries = jsCoverageDir.directoryEntries;
   while (entries.hasMoreElements()) {
     files.push(entries.nextFile);
   }
@@ -42,32 +48,32 @@ function parseRecords(files) {
       switch (recordType) {
         case "FNDA": {
           if (currentSF == null) {
             throw new Error("SF missing");
           }
 
           let [hits, name] = recordContent.split(",");
           currentSF.push({
-            "type": "FNDA",
-            "hits": hits,
-            "name": name,
+            type: "FNDA",
+            hits,
+            name,
           });
           break;
         }
 
         case "FN": {
           if (currentSF == null) {
             throw new Error("SF missing");
           }
 
           let name = recordContent.split(",")[1];
           currentSF.push({
-            "type": "FN",
-            "name": name,
+            type: "FN",
+            name,
           });
           break;
         }
 
         case "SF": {
           if (AppConstants.platform == "win") {
             recordContent = recordContent.replace(/\//g, "\\");
           }
--- a/tools/code-coverage/tests/xpcshell/test_basic.js
+++ b/tools/code-coverage/tests/xpcshell/test_basic.js
@@ -24,44 +24,92 @@ async function run_test() {
   const files_orig = getFiles();
 
   test_code_coverage_func1();
 
   // Flush counters for the first time, we should see this function executed, but test_code_coverage_func not executed.
   await codeCoverage.flushCounters();
 
   const first_flush_files = getFiles();
-  const first_flush_records = parseRecords(diffFiles(first_flush_files, files_orig));
+  const first_flush_records = parseRecords(
+    diffFiles(first_flush_files, files_orig)
+  );
 
   Assert.ok(first_flush_records.has("test_basic.js"));
-  let fnRecords = first_flush_records.get("test_basic.js").filter(record => record.type == "FN");
-  let fndaRecords = first_flush_records.get("test_basic.js").filter(record => record.type == "FNDA");
+  let fnRecords = first_flush_records
+    .get("test_basic.js")
+    .filter(record => record.type == "FN");
+  let fndaRecords = first_flush_records
+    .get("test_basic.js")
+    .filter(record => record.type == "FNDA");
   Assert.ok(fnRecords.some(record => record.name == "top-level"));
   Assert.ok(fnRecords.some(record => record.name == "run_test"));
-  Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func1"));
-  Assert.ok(fndaRecords.some(record => record.name == "run_test" && record.hits == 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "run_test" && record.hits != 1));
-  Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits == 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits != 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func2"));
+  Assert.ok(
+    fnRecords.some(record => record.name == "test_code_coverage_func1")
+  );
+  Assert.ok(
+    fndaRecords.some(record => record.name == "run_test" && record.hits == 1)
+  );
+  Assert.ok(
+    !fndaRecords.some(record => record.name == "run_test" && record.hits != 1)
+  );
+  Assert.ok(
+    fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits == 1
+    )
+  );
+  Assert.ok(
+    !fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits != 1
+    )
+  );
+  Assert.ok(
+    !fndaRecords.some(record => record.name == "test_code_coverage_func2")
+  );
 
   test_code_coverage_func2();
 
   // Flush counters for the second time, we should see this function not executed, but test_code_coverage_func executed.
   await codeCoverage.flushCounters();
 
   const second_flush_files = getFiles();
-  const second_flush_records = parseRecords(diffFiles(second_flush_files, first_flush_files));
+  const second_flush_records = parseRecords(
+    diffFiles(second_flush_files, first_flush_files)
+  );
 
   Assert.ok(second_flush_records.has("test_basic.js"));
-  fnRecords = second_flush_records.get("test_basic.js").filter(record => record.type == "FN");
-  fndaRecords = second_flush_records.get("test_basic.js").filter(record => record.type == "FNDA");
+  fnRecords = second_flush_records
+    .get("test_basic.js")
+    .filter(record => record.type == "FN");
+  fndaRecords = second_flush_records
+    .get("test_basic.js")
+    .filter(record => record.type == "FNDA");
   Assert.ok(fnRecords.some(record => record.name == "top-level"));
   Assert.ok(fnRecords.some(record => record.name == "run_test"));
-  Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func1"));
-  Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func2"));
-  Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits == 0));
-  Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits != 0));
-  Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func2" && record.hits == 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func2" && record.hits != 1));
+  Assert.ok(
+    fnRecords.some(record => record.name == "test_code_coverage_func1")
+  );
+  Assert.ok(
+    fnRecords.some(record => record.name == "test_code_coverage_func2")
+  );
+  Assert.ok(
+    fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits == 0
+    )
+  );
+  Assert.ok(
+    !fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits != 0
+    )
+  );
+  Assert.ok(
+    fndaRecords.some(
+      record => record.name == "test_code_coverage_func2" && record.hits == 1
+    )
+  );
+  Assert.ok(
+    !fndaRecords.some(
+      record => record.name == "test_code_coverage_func2" && record.hits != 1
+    )
+  );
 
   do_test_finished();
 }
--- a/tools/code-coverage/tests/xpcshell/test_basic_child_and_parent.js
+++ b/tools/code-coverage/tests/xpcshell/test_basic_child_and_parent.js
@@ -5,58 +5,116 @@
 function test_code_coverage_func1() {
   return 22;
 }
 
 async function run_test() {
   do_load_child_test_harness();
   do_test_pending();
 
-  const codeCoverage = Cc["@mozilla.org/tools/code-coverage;1"].getService(Ci.nsICodeCoverage);
+  const codeCoverage = Cc["@mozilla.org/tools/code-coverage;1"].getService(
+    Ci.nsICodeCoverage
+  );
 
   const files_orig = getFiles();
 
   test_code_coverage_func1();
 
   await codeCoverage.flushCounters();
 
   const first_flush_files = getFiles();
-  const first_flush_records = parseRecords(diffFiles(first_flush_files, files_orig));
+  const first_flush_records = parseRecords(
+    diffFiles(first_flush_files, files_orig)
+  );
 
   Assert.ok(first_flush_records.has("test_basic_child_and_parent.js"));
   Assert.ok(!first_flush_records.has("support.js"));
-  let fnRecords = first_flush_records.get("test_basic_child_and_parent.js").filter(record => record.type == "FN");
-  let fndaRecords = first_flush_records.get("test_basic_child_and_parent.js").filter(record => record.type == "FNDA");
+  let fnRecords = first_flush_records
+    .get("test_basic_child_and_parent.js")
+    .filter(record => record.type == "FN");
+  let fndaRecords = first_flush_records
+    .get("test_basic_child_and_parent.js")
+    .filter(record => record.type == "FNDA");
   Assert.ok(fnRecords.some(record => record.name == "top-level"));
   Assert.ok(fnRecords.some(record => record.name == "run_test"));
-  Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func1"));
-  Assert.ok(fndaRecords.some(record => record.name == "run_test" && record.hits == 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "run_test" && record.hits != 1));
-  Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits == 1));
-  Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits != 1));
+  Assert.ok(
+    fnRecords.some(record => record.name == "test_code_coverage_func1")
+  );
+  Assert.ok(
+    fndaRecords.some(record => record.name == "run_test" && record.hits == 1)
+  );
+  Assert.ok(
+    !fndaRecords.some(record => record.name == "run_test" && record.hits != 1)
+  );
+  Assert.ok(
+    fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits == 1
+    )
+  );
+  Assert.ok(
+    !fndaRecords.some(
+      record => record.name == "test_code_coverage_func1" && record.hits != 1
+    )
+  );
 
   sendCommand("load('support.js');", async function() {
-      await codeCoverage.flushCounters();
+    await codeCoverage.flushCounters();
 
-      const second_flush_files = getFiles();
-      const second_flush_records = parseRecords(diffFiles(second_flush_files, first_flush_files));
+    const second_flush_files = getFiles();
+    const second_flush_records = parseRecords(
+      diffFiles(second_flush_files, first_flush_files)
+    );
 
-      Assert.ok(second_flush_records.has("test_basic_child_and_parent.js"));
-      fnRecords = second_flush_records.get("test_basic_child_and_parent.js").filter(record => record.type == "FN");
-      fndaRecords = second_flush_records.get("test_basic_child_and_parent.js").filter(record => record.type == "FNDA");
-      Assert.ok(fnRecords.some(record => record.name == "top-level"));
-      Assert.ok(fnRecords.some(record => record.name == "run_test"));
-      Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func1"));
-      Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits == 0));
-      Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func1" && record.hits != 0));
-      Assert.ok(second_flush_records.has("support.js"));
-      fnRecords = second_flush_records.get("support.js").filter(record => record.type == "FN");
-      fndaRecords = second_flush_records.get("support.js").filter(record => record.type == "FNDA");
-      Assert.ok(fnRecords.some(record => record.name == "top-level"));
-      Assert.ok(fnRecords.some(record => record.name == "test_code_coverage_func2"));
-      Assert.ok(fndaRecords.some(record => record.name == "top-level" && record.hits == 1));
-      Assert.ok(!fndaRecords.some(record => record.name == "top-level" && record.hits != 1));
-      Assert.ok(fndaRecords.some(record => record.name == "test_code_coverage_func2" && record.hits == 1));
-      Assert.ok(!fndaRecords.some(record => record.name == "test_code_coverage_func2" && record.hits != 1));
+    Assert.ok(second_flush_records.has("test_basic_child_and_parent.js"));
+    fnRecords = second_flush_records
+      .get("test_basic_child_and_parent.js")
+      .filter(record => record.type == "FN");
+    fndaRecords = second_flush_records
+      .get("test_basic_child_and_parent.js")
+      .filter(record => record.type == "FNDA");
+    Assert.ok(fnRecords.some(record => record.name == "top-level"));
+    Assert.ok(fnRecords.some(record => record.name == "run_test"));
+    Assert.ok(
+      fnRecords.some(record => record.name == "test_code_coverage_func1")
+    );
+    Assert.ok(
+      fndaRecords.some(
+        record => record.name == "test_code_coverage_func1" && record.hits == 0
+      )
+    );
+    Assert.ok(
+      !fndaRecords.some(
+        record => record.name == "test_code_coverage_func1" && record.hits != 0
+      )
+    );
+    Assert.ok(second_flush_records.has("support.js"));
+    fnRecords = second_flush_records
+      .get("support.js")
+      .filter(record => record.type == "FN");
+    fndaRecords = second_flush_records
+      .get("support.js")
+      .filter(record => record.type == "FNDA");
+    Assert.ok(fnRecords.some(record => record.name == "top-level"));
+    Assert.ok(
+      fnRecords.some(record => record.name == "test_code_coverage_func2")
+    );
+    Assert.ok(
+      fndaRecords.some(record => record.name == "top-level" && record.hits == 1)
+    );
+    Assert.ok(
+      !fndaRecords.some(
+        record => record.name == "top-level" && record.hits != 1
+      )
+    );
+    Assert.ok(
+      fndaRecords.some(
+        record => record.name == "test_code_coverage_func2" && record.hits == 1
+      )
+    );
+    Assert.ok(
+      !fndaRecords.some(
+        record => record.name == "test_code_coverage_func2" && record.hits != 1
+      )
+    );
 
-      do_test_finished();
+    do_test_finished();
   });
 }
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/browser-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/browser-test.js
@@ -1,68 +1,66 @@
 // Parent config file for all browser-chrome files.
 "use strict";
 
 module.exports = {
-  "env": {
-    "browser": true,
+  env: {
+    browser: true,
     "mozilla/browser-window": true,
     "mozilla/simpletest": true,
     // "node": true
   },
 
   // All globals made available in the test environment.
-  "globals": {
+  globals: {
     // `$` is defined in SimpleTest.js
-    "$": false,
-    "Assert": false,
-    "BrowserTestUtils": false,
-    "ContentTask": false,
-    "ContentTaskUtils": false,
-    "EventUtils": false,
-    "PromiseDebugging": false,
-    "SpecialPowers": false,
-    "TestUtils": false,
-    "XPCNativeWrapper": false,
-    "XULDocument": false,
-    "addLoadEvent": false,
-    "add_task": false,
-    "content": false,
-    "executeSoon": false,
-    "expectUncaughtException": false,
-    "export_assertions": false,
-    "extractJarToTmp": false,
-    "finish": false,
-    "gTestPath": false,
-    "getChromeDir": false,
-    "getJar": false,
-    "getResolvedURI": false,
-    "getRootDirectory": false,
-    "getTestFilePath": false,
-    "ignoreAllUncaughtExceptions": false,
-    "info": false,
-    "is": false,
-    "isnot": false,
-    "ok": false,
-    "privateNoteIntentionalCrash": false,
-    "record": false,
-    "registerCleanupFunction": false,
-    "requestLongerTimeout": false,
-    "setExpectedFailuresForSelfTest": false,
-    "todo": false,
-    "todo_is": false,
-    "todo_isnot": false,
-    "waitForClipboard": false,
-    "waitForExplicitFinish": false,
-    "waitForFocus": false,
+    $: false,
+    Assert: false,
+    BrowserTestUtils: false,
+    ContentTask: false,
+    ContentTaskUtils: false,
+    EventUtils: false,
+    PromiseDebugging: false,
+    SpecialPowers: false,
+    TestUtils: false,
+    XPCNativeWrapper: false,
+    XULDocument: false,
+    addLoadEvent: false,
+    add_task: false,
+    content: false,
+    executeSoon: false,
+    expectUncaughtException: false,
+    export_assertions: false,
+    extractJarToTmp: false,
+    finish: false,
+    gTestPath: false,
+    getChromeDir: false,
+    getJar: false,
+    getResolvedURI: false,
+    getRootDirectory: false,
+    getTestFilePath: false,
+    ignoreAllUncaughtExceptions: false,
+    info: false,
+    is: false,
+    isnot: false,
+    ok: false,
+    privateNoteIntentionalCrash: false,
+    record: false,
+    registerCleanupFunction: false,
+    requestLongerTimeout: false,
+    setExpectedFailuresForSelfTest: false,
+    todo: false,
+    todo_is: false,
+    todo_isnot: false,
+    waitForClipboard: false,
+    waitForExplicitFinish: false,
+    waitForFocus: false,
   },
 
-  "plugins": [
-    "mozilla",
-  ],
+  plugins: ["mozilla"],
 
-  "rules": {
+  rules: {
     "mozilla/import-content-task-globals": "error",
     "mozilla/import-headjs-globals": "error",
     "mozilla/mark-test-function-used": "error",
     "mozilla/no-arbitrary-setTimeout": "error",
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/chrome-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/chrome-test.js
@@ -1,35 +1,35 @@
 // Parent config file for all mochitest files.
 "use strict";
 
 module.exports = {
-  "env": {
-    "browser": true,
+  env: {
+    browser: true,
     "mozilla/browser-window": true,
   },
 
   // All globals made available in the test environment.
-  "globals": {
+  globals: {
     // SpecialPowers is injected into the window object via SimpleTest.js
-    "SpecialPowers": false,
+    SpecialPowers: false,
   },
 
-  "overrides": [{
-    "env": {
-      // Ideally we wouldn't be using the simpletest env here, but our uses of
-      // js files mean we pick up everything from the global scope, which could
-      // be any one of a number of html files. So we just allow the basics...
-      "mozilla/simpletest": true,
+  overrides: [
+    {
+      env: {
+        // Ideally we wouldn't be using the simpletest env here, but our uses of
+        // js files mean we pick up everything from the global scope, which could
+        // be any one of a number of html files. So we just allow the basics...
+        "mozilla/simpletest": true,
+      },
+      files: ["*.js"],
     },
-    "files": ["*.js"],
-  }],
+  ],
 
-  "plugins": [
-    "mozilla",
-  ],
+  plugins: ["mozilla"],
 
   rules: {
     "mozilla/import-content-task-globals": "error",
     "mozilla/import-headjs-globals": "error",
     "mozilla/mark-test-function-used": "error",
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/mochitest-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/mochitest-test.js
@@ -1,38 +1,38 @@
 // Parent config file for all mochitest files.
 "use strict";
 
 module.exports = {
-  "env": {
-    "browser": true,
+  env: {
+    browser: true,
   },
 
   // All globals made available in the test environment.
-  "globals": {
+  globals: {
     // SpecialPowers is injected into the window object via SimpleTest.js
-    "SpecialPowers": false,
-    "XPCNativeWrapper": false,
+    SpecialPowers: false,
+    XPCNativeWrapper: false,
   },
 
-  "overrides": [{
-    "env": {
-      // Ideally we wouldn't be using the simpletest env here, but our uses of
-      // js files mean we pick up everything from the global scope, which could
-      // be any one of a number of html files. So we just allow the basics...
-      "mozilla/simpletest": true,
+  overrides: [
+    {
+      env: {
+        // Ideally we wouldn't be using the simpletest env here, but our uses of
+        // js files mean we pick up everything from the global scope, which could
+        // be any one of a number of html files. So we just allow the basics...
+        "mozilla/simpletest": true,
+      },
+      files: ["*.js"],
     },
-    "files": ["*.js"],
-  }],
-
-  "plugins": [
-    "mozilla",
   ],
 
-  "rules": {
+  plugins: ["mozilla"],
+
+  rules: {
     "mozilla/import-content-task-globals": "error",
     "mozilla/import-headjs-globals": "error",
     "mozilla/mark-test-function-used": "error",
     // Turn off no-define-cc-etc for mochitests as these don't have Cc etc defined in the
     // global scope.
     "mozilla/no-define-cc-etc": "off",
     "no-shadow": "error",
   },
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/recommended.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/recommended.js
@@ -3,109 +3,108 @@
 /**
  * The configuration is based on eslint:recommended config. The details for all
  * the ESLint rules, and which ones are in the recommended configuration can
  * be found here:
  *
  * https://eslint.org/docs/rules/
  */
 module.exports = {
-  "env": {
-    "browser": true,
-    "es6": true,
+  env: {
+    browser: true,
+    es6: true,
     "mozilla/privileged": true,
   },
 
-  "extends": [
-    "eslint:recommended",
-    "plugin:prettier/recommended",
-  ],
+  extends: ["eslint:recommended", "plugin:prettier/recommended"],
 
-  "globals": {
-    "Cc": false,
+  globals: {
+    Cc: false,
     // Specific to Firefox (Chrome code only).
-    "ChromeUtils": false,
-    "Ci": false,
-    "Components": false,
-    "Cr": false,
-    "Cu": false,
-    "Debugger": false,
-    "InstallTrigger": false,
+    ChromeUtils: false,
+    Ci: false,
+    Components: false,
+    Cr: false,
+    Cu: false,
+    Debugger: false,
+    InstallTrigger: false,
     // Specific to Firefox
     // https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/InternalError
-    "InternalError": true,
-    "Intl": false,
-    "SharedArrayBuffer": false,
-    "StopIteration": false,
-    "dump": true,
+    InternalError: true,
+    Intl: false,
+    SharedArrayBuffer: false,
+    StopIteration: false,
+    dump: true,
     // Override the "browser" env definition of "location" to allow writing as it
     // is a writeable property.
     // See https://bugzilla.mozilla.org/show_bug.cgi?id=1509270#c1 for more information.
-    "location": true,
-    "openDialog": false,
-    "saveStack": false,
-    "sizeToContent": false,
+    location: true,
+    openDialog: false,
+    saveStack: false,
+    sizeToContent: false,
     // Specific to Firefox
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/uneval
-    "uneval": false,
+    uneval: false,
   },
 
-  "overrides": [{
-    // Turn off use-services for xml files. XBL bindings are going away, and
-    // working out the valid globals for those is difficult.
-    "files": "**/*.xml",
-    "rules": {
-      "mozilla/use-services": "off",
-    },
-  }, {
-    // We don't have the general browser environment for jsm files, but we do
-    // have our own special environments for them.
-    "env": {
-      "browser": false,
-      "mozilla/jsm": true,
+  overrides: [
+    {
+      // Turn off use-services for xml files. XBL bindings are going away, and
+      // working out the valid globals for those is difficult.
+      files: "**/*.xml",
+      rules: {
+        "mozilla/use-services": "off",
+      },
     },
-    "files": "**/*.jsm",
-    "rules": {
-      "mozilla/mark-exported-symbols-as-used": "error",
-      // JSM modules are far easier to check for no-unused-vars on a global scope,
-      // than our content files. Hence we turn that on here.
-      "no-unused-vars": ["error", {
-        "args": "none",
-        "vars": "all",
-      }],
+    {
+      // We don't have the general browser environment for jsm files, but we do
+      // have our own special environments for them.
+      env: {
+        browser: false,
+        "mozilla/jsm": true,
+      },
+      files: "**/*.jsm",
+      rules: {
+        "mozilla/mark-exported-symbols-as-used": "error",
+        // JSM modules are far easier to check for no-unused-vars on a global scope,
+        // than our content files. Hence we turn that on here.
+        "no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            vars: "all",
+          },
+        ],
+      },
     },
-  }],
+  ],
 
-  "parserOptions": {
-    "ecmaVersion": 9,
+  parserOptions: {
+    ecmaVersion: 9,
   },
 
   // When adding items to this file please check for effects on sub-directories.
-  "plugins": [
-    "html",
-    "fetch-options",
-    "no-unsanitized",
-  ],
+  plugins: ["html", "fetch-options", "no-unsanitized"],
 
   // When adding items to this file please check for effects on all of toolkit
   // and browser
-  "rules": {
+  rules: {
     // Warn about cyclomatic complexity in functions.
     // XXX Get this down to 20?
-    "complexity": ["error", 34],
+    complexity: ["error", 34],
 
     // Functions must always return something or nothing
     "consistent-return": "error",
 
     // XXX This rule line should be removed to enable it. See bug 1487642.
     // Require super() calls in constructors
     "constructor-super": "off",
 
     // Require braces around blocks that start a new line
-    "curly": ["error", "all"],
+    curly: ["error", "all"],
 
     // Encourage the use of dot notation whenever possible.
     "dot-notation": "error",
 
     // XXX This rule should be enabled, see Bug 1557040
     // No credentials submitted with fetch calls
     "fetch-options/no-fetch-credentials": "off",
 
@@ -159,17 +158,17 @@ module.exports = {
 
     // No duplicate keys in object declarations
     "no-dupe-keys": "error",
 
     // If an if block ends with a return no need for an else block
     "no-else-return": "error",
 
     // No empty statements
-    "no-empty": ["error", {"allowEmptyCatch": true}],
+    "no-empty": ["error", { allowEmptyCatch: true }],
 
     // Disallow eval and setInteral/setTimeout with strings
     "no-eval": "error",
 
     // Disallow unnecessary calls to .bind()
     "no-extra-bind": "error",
 
     // XXX Bug 1487642 - decide if we want to enable this or not.
@@ -184,17 +183,17 @@ module.exports = {
 
     // This has been superseded since we're using ES6.
     // Disallow variable or function declarations in nested blocks
     "no-inner-declarations": "off",
 
     // Disallow the use of the __iterator__ property
     "no-iterator": "error",
 
-     // No labels
+    // No labels
     "no-labels": "error",
 
     // Disallow unnecessary nested blocks
     "no-lone-blocks": "error",
 
     // No single if block inside an else block
     "no-lonely-if": "error",
 
@@ -233,20 +232,23 @@ module.exports = {
     "no-unneeded-ternary": "error",
 
     // No unsanitized use of innerHTML=, document.write() etc.
     // cf. https://github.com/mozilla/eslint-plugin-no-unsanitized#rule-details
     "no-unsanitized/method": "error",
     "no-unsanitized/property": "error",
 
     // No declaring variables that are never used
-    "no-unused-vars": ["error", {
-      "args": "none",
-      "vars": "local",
-    }],
+    "no-unused-vars": [
+      "error",
+      {
+        args: "none",
+        vars: "local",
+      },
+    ],
 
     // No using variables before defined
     // "no-use-before-define": ["error", "nofunc"],
 
     // Disallow unnecessary .call() and .apply()
     "no-useless-call": "error",
 
     // Don't concatenate string literals together (unless they span multiple
@@ -259,22 +261,22 @@ module.exports = {
 
     // Disallow redundant return statements
     "no-useless-return": "error",
 
     // No using with
     "no-with": "error",
 
     // Require object-literal shorthand with ES6 method syntax
-    "object-shorthand": ["error", "always", { "avoidQuotes": true }],
+    "object-shorthand": ["error", "always", { avoidQuotes: true }],
 
     // XXX Bug 1487642 - decide if we want to enable this or not.
     // Require generator functions to contain yield
     "require-yield": "off",
   },
 
   // To avoid bad interactions of the html plugin with the xml preprocessor in
   // eslint-plugin-mozilla, we turn off processing of the html plugin for .xml
   // files.
-  "settings": {
-    "html/xml-extensions": [ ".xhtml" ],
+  settings: {
+    "html/xml-extensions": [".xhtml"],
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/xpcshell-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/configs/xpcshell-test.js
@@ -1,87 +1,92 @@
 // Parent config file for all xpcshell files.
 "use strict";
 
 module.exports = {
   // All globals made available in the test environment.
-  "globals": {
-    "Assert": false,
-    "PromiseDebugging": false,
-    "_TEST_FILE": false,
-    "add_task": false,
-    "add_test": false,
+  globals: {
+    Assert: false,
+    PromiseDebugging: false,
+    _TEST_FILE: false,
+    add_task: false,
+    add_test: false,
     // Test-only function.
-    "allocationMarker": false,
-    "byteSize": false,
-    "deepEqual": false,
-    "do_await_remote_message": false,
-    "do_check_instanceof": false,
-    "do_get_cwd": false,
-    "do_get_file": false,
-    "do_get_idle": false,
-    "do_get_profile": false,
-    "do_get_tempdir": false,
-    "do_load_child_test_harness": false,
-    "do_load_manifest": false,
-    "do_load_module": false,
-    "do_note_exception": false,
-    "do_parse_document": false,
-    "do_report_unexpected_exception": false,
-    "do_send_remote_message": false,
-    "do_test_finished": false,
-    "do_test_pending": false,
-    "do_throw": false,
-    "do_timeout": false,
-    "equal": false,
-    "executeSoon": false,
-    "gc": false,
+    allocationMarker: false,
+    byteSize: false,
+    deepEqual: false,
+    do_await_remote_message: false,
+    do_check_instanceof: false,
+    do_get_cwd: false,
+    do_get_file: false,
+    do_get_idle: false,
+    do_get_profile: false,
+    do_get_tempdir: false,
+    do_load_child_test_harness: false,
+    do_load_manifest: false,
+    do_load_module: false,
+    do_note_exception: false,
+    do_parse_document: false,
+    do_report_unexpected_exception: false,
+    do_send_remote_message: false,
+    do_test_finished: false,
+    do_test_pending: false,
+    do_throw: false,
+    do_timeout: false,
+    equal: false,
+    executeSoon: false,
+    gc: false,
     // XPCShell specific function, see XPCShellEnvironment.cpp
-    "gczeal": false,
-    "greater": false,
-    "greaterOrEqual": false,
-    "info": false,
-    "less": false,
-    "lessOrEqual": false,
-    "load": false,
-    "mozinfo": false,
-    "notDeepEqual": false,
-    "notEqual": false,
-    "notStrictEqual": false,
-    "ok": false,
-    "registerCleanupFunction": false,
-    "run_next_test": false,
-    "run_test": false,
-    "run_test_in_child": false,
-    "runningInParent": false,
+    gczeal: false,
+    greater: false,
+    greaterOrEqual: false,
+    info: false,
+    less: false,
+    lessOrEqual: false,
+    load: false,
+    mozinfo: false,
+    notDeepEqual: false,
+    notEqual: false,
+    notStrictEqual: false,
+    ok: false,
+    registerCleanupFunction: false,
+    run_next_test: false,
+    run_test: false,
+    run_test_in_child: false,
+    runningInParent: false,
     // Defined in XPCShellImpl.
-    "sendCommand": false,
-    "strictEqual": false,
-    "throws": false,
-    "todo": false,
-    "todo_check_false": false,
-    "todo_check_true": false,
+    sendCommand: false,
+    strictEqual: false,
+    throws: false,
+    todo: false,
+    todo_check_false: false,
+    todo_check_true: false,
     // Firefox specific function.
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/uneval
-    "uneval": false,
+    uneval: false,
   },
 
-  "overrides": [{
-    // If it is a head file, we turn off global unused variable checks, as it
-    // would require searching the other test files to know if they are used or not.
-    // This would be expensive and slow, and it isn't worth it for head files.
-    // We could get developers to declare as exported, but that doesn't seem worth it.
-    "files": "head*.js",
-    "rules": {
-      "no-unused-vars": ["error", {
-        "args": "none",
-        "vars": "local",
-      }],
+  overrides: [
+    {
+      // If it is a head file, we turn off global unused variable checks, as it
+      // would require searching the other test files to know if they are used or not.
+      // This would be expensive and slow, and it isn't worth it for head files.
+      // We could get developers to declare as exported, but that doesn't seem worth it.
+      files: "head*.js",
+      rules: {
+        "no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            vars: "local",
+          },
+        ],
+      },
     },
-  }],
+  ],
 
   rules: {
     "mozilla/import-headjs-globals": "error",
     "mozilla/mark-test-function-used": "error",
     "mozilla/no-arbitrary-setTimeout": "error",
     "mozilla/no-useless-run-test": "error",
     "no-shadow": "error",
   },
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/browser-window.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/browser-window.js
@@ -33,52 +33,54 @@ const EXTRA_SCRIPTS = [
   "toolkit/content/customElements.js",
   "toolkit/content/editMenuOverlay.js",
 ];
 
 const extraDefinitions = [
   // Via Components.utils, defineModuleGetter, defineLazyModuleGetters or
   // defineLazyScriptGetter (and map to
   // single) variable.
-  {name: "XPCOMUtils", writable: false},
-  {name: "Task", writable: false},
+  { name: "XPCOMUtils", writable: false },
+  { name: "Task", writable: false },
 ];
 
 // Some files in global-scripts.inc need mapping to specific locations.
 const MAPPINGS = {
   "printUtils.js": "toolkit/components/printing/content/printUtils.js",
   "panelUI.js": "browser/components/customizableui/content/panelUI.js",
   "viewSourceUtils.js":
     "toolkit/components/viewsource/content/viewSourceUtils.js",
   "places-tree.js": "browser/components/places/content/places-tree.js",
 };
 
-const globalScriptsRegExp =
-  /^\s*Services.scriptloader.loadSubScript\(\"(.*?)\", this\);$/;
+const globalScriptsRegExp = /^\s*Services.scriptloader.loadSubScript\(\"(.*?)\", this\);$/;
 
 function getGlobalScriptIncludes(scriptPath) {
   let fileData;
   try {
-    fileData = fs.readFileSync(scriptPath, {encoding: "utf8"});
+    fileData = fs.readFileSync(scriptPath, { encoding: "utf8" });
   } catch (ex) {
     // The file isn't present, so this isn't an m-c repository.
     return null;
   }
 
   fileData = fileData.split("\n");
 
   let result = [];
 
   for (let line of fileData) {
     let match = line.match(globalScriptsRegExp);
     if (match) {
       let sourceFile = match[1]
-                .replace("chrome://browser/content/search/", "browser/components/search/content/")
-                .replace("chrome://browser/content/", "browser/base/content/")
-                .replace("chrome://global/content/", "toolkit/content/");
+        .replace(
+          "chrome://browser/content/search/",
+          "browser/components/search/content/"
+        )
+        .replace("chrome://browser/content/", "browser/base/content/")
+        .replace("chrome://global/content/", "toolkit/content/");
 
       for (let mapping of Object.getOwnPropertyNames(MAPPINGS)) {
         if (sourceFile.includes(mapping)) {
           sourceFile = MAPPINGS[mapping];
         }
       }
 
       result.push(sourceFile);
@@ -105,17 +107,18 @@ function getScriptGlobals() {
 
   for (let script of scripts.concat(EXTRA_SCRIPTS)) {
     let fileName = path.join(rootDir, script);
     try {
       fileGlobals = fileGlobals.concat(globals.getGlobalsForFile(fileName));
     } catch (e) {
       console.error(`Could not load globals from file ${fileName}: ${e}`);
       console.error(
-        `You may need to update the mappings in ${module.filename}`);
+        `You may need to update the mappings in ${module.filename}`
+      );
       throw new Error(`Could not load globals from file ${fileName}: ${e}`);
     }
   }
 
   return fileGlobals.concat(extraDefinitions);
 }
 
 function mapGlobals(fileGlobals) {
@@ -128,11 +131,11 @@ function mapGlobals(fileGlobals) {
 
 function getMozillaCentralItems() {
   return {
     globals: mapGlobals(getScriptGlobals()),
     browserjsScripts: getGlobalScripts().concat(EXTRA_SCRIPTS),
   };
 }
 
-module.exports = helpers.isMozillaCentralBased() ?
- getMozillaCentralItems() :
- helpers.getSavedEnvironmentItems("browser-window");
+module.exports = helpers.isMozillaCentralBased()
+  ? getMozillaCentralItems()
+  : helpers.getSavedEnvironmentItems("browser-window");
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/chrome-worker.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/chrome-worker.js
@@ -8,15 +8,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
 "use strict";
 
 var globals = require("globals");
 var util = require("util");
 
-var workerGlobals = util._extend({
-  ctypes: false,
-}, globals.worker);
+var workerGlobals = util._extend(
+  {
+    ctypes: false,
+  },
+  globals.worker
+);
 
 module.exports = {
   globals: workerGlobals,
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/jsm.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/jsm.js
@@ -4,21 +4,21 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
 "use strict";
 
 module.exports = {
-  "globals": {
+  globals: {
     // These globals are hard-coded and available in .jsm scopes.
     // https://searchfox.org/mozilla-central/rev/ed212c79cfe86357e9a5740082b9364e7f6e526f/js/xpconnect/loader/mozJSComponentLoader.cpp#134-140
-    "atob": false,
-    "btoa": false,
-    "debug": false,
-    "dump": false,
+    atob: false,
+    btoa: false,
+    debug: false,
+    dump: false,
     // The WebAssembly global is available in most (if not all) contexts where
     // JS can run. It's definitely available in JSMs. So even if this is not
     // the perfect place to add it, it's not wrong, and we can move it later.
-    "WebAssembly": false,
+    WebAssembly: false,
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/privileged.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/privileged.js
@@ -4,761 +4,761 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
 "use strict";
 
 module.exports = {
-  "globals": {
+  globals: {
     // This list of items is currently obtained manually from the list of
     // mozilla::dom::constructor::id::ID enumerations in an object directory
     // generated dom/bindings/RegisterBindings.cpp
-    "APZHitResultFlags": false,
-    "AbortController": false,
-    "AbortSignal": false,
-    "AccessibleNode": false,
-    "Addon": false,
-    "AddonEvent": false,
-    "AddonInstall": false,
-    "AddonManager": true,
-    "AddonManagerPermissions": false,
-    "AnalyserNode": false,
-    "Animation": false,
-    "AnimationEffect": false,
-    "AnimationEvent": false,
-    "AnimationPlaybackEvent": false,
-    "AnimationTimeline": false,
-    "AnonymousContent": false,
-    "Attr": false,
-    "AudioBuffer": false,
-    "AudioBufferSourceNode": false,
-    "AudioContext": false,
-    "AudioDestinationNode": false,
-    "AudioListener": false,
-    "AudioNode": false,
-    "AudioParam": false,
-    "AudioParamMap": false,
-    "AudioProcessingEvent": false,
-    "AudioScheduledSourceNode": false,
-    "AudioTrack": false,
-    "AudioTrackList": false,
-    "AudioWorklet": false,
-    "AudioWorkletNode": false,
-    "AuthenticatorAssertionResponse": false,
-    "AuthenticatorAttestationResponse": false,
-    "AuthenticatorResponse": false,
-    "BarProp": false,
-    "BaseAudioContext": false,
-    "BatteryManager": false,
-    "BeforeUnloadEvent": false,
-    "BiquadFilterNode": false,
-    "Blob": false,
-    "BlobEvent": false,
-    "BoxObject": false,
-    "BroadcastChannel": false,
-    "BrowsingContext": false,
-    "CDATASection": false,
-    "CSS": false,
-    "CSS2Properties": false,
-    "CSSAnimation": false,
-    "CSSConditionRule": false,
-    "CSSCounterStyleRule": false,
-    "CSSFontFaceRule": false,
-    "CSSFontFeatureValuesRule": false,
-    "CSSGroupingRule": false,
-    "CSSImportRule": false,
-    "CSSKeyframeRule": false,
-    "CSSKeyframesRule": false,
-    "CSSMediaRule": false,
-    "CSSMozDocumentRule": false,
-    "CSSNamespaceRule": false,
-    "CSSPageRule": false,
-    "CSSPseudoElement": false,
-    "CSSRule": false,
-    "CSSRuleList": false,
-    "CSSStyleDeclaration": false,
-    "CSSStyleRule": false,
-    "CSSStyleSheet": false,
-    "CSSSupportsRule": false,
-    "CSSTransition": false,
-    "Cache": false,
-    "CacheStorage": false,
-    "CanvasCaptureMediaStream": false,
-    "CanvasGradient": false,
-    "CanvasPattern": false,
-    "CanvasRenderingContext2D": false,
-    "CaretPosition": false,
-    "CaretStateChangedEvent": false,
-    "ChannelMergerNode": false,
-    "ChannelSplitterNode": false,
-    "ChannelWrapper": false,
-    "CharacterData": false,
-    "CheckerboardReportService": false,
-    "ChildProcessMessageManager": false,
-    "ChildSHistory": false,
-    "ChromeMessageBroadcaster": false,
-    "ChromeMessageSender": false,
-    "ChromeNodeList": false,
-    "ChromeUtils": false,
-    "ChromeWorker": false,
-    "Clipboard": false,
-    "ClipboardEvent": false,
-    "CloseEvent": false,
-    "CommandEvent": false,
-    "Comment": false,
-    "CompositionEvent": false,
-    "ConsoleInstance": false,
-    "ConstantSourceNode": false,
-    "ContentFrameMessageManager": false,
-    "ContentProcessMessageManager": false,
-    "ConvolverNode": false,
-    "CreateOfferRequest": false,
-    "Credential": false,
-    "CredentialsContainer": false,
-    "Crypto": false,
-    "CryptoKey": false,
-    "CustomElementRegistry": false,
-    "CustomEvent": false,
-    "DOMError": false,
-    "DOMException": false,
-    "DOMImplementation": false,
-    "DOMLocalization": false,
-    "DOMMatrix": false,
-    "DOMMatrixReadOnly": false,
-    "DOMParser": false,
-    "DOMPoint": false,
-    "DOMPointReadOnly": false,
-    "DOMQuad": false,
-    "DOMRect": false,
-    "DOMRectList": false,
-    "DOMRectReadOnly": false,
-    "DOMRequest": false,
-    "DOMStringList": false,
-    "DOMStringMap": false,
-    "DOMTokenList": false,
-    "DataTransfer": false,
-    "DataTransferItem": false,
-    "DataTransferItemList": false,
-    "DelayNode": false,
-    "DeprecationReportBody": false,
-    "DeviceLightEvent": false,
-    "DeviceMotionEvent": false,
-    "DeviceOrientationEvent": false,
-    "DeviceProximityEvent": false,
-    "Directory": false,
-    "Document": false,
-    "DocumentFragment": false,
-    "DocumentTimeline": false,
-    "DocumentType": false,
-    "DominatorTree": false,
-    "DragEvent": false,
-    "DynamicsCompressorNode": false,
-    "Element": false,
-    "ErrorEvent": false,
-    "Event": false,
-    "EventSource": false,
-    "EventTarget": false,
-    "FeaturePolicyViolationReportBody": false,
-    "FetchObserver": false,
-    "File": false,
-    "FileList": false,
-    "FileReader": false,
-    "FileSystem": false,
-    "FileSystemDirectoryEntry": false,
-    "FileSystemDirectoryReader": false,
-    "FileSystemEntry": false,
-    "FileSystemFileEntry": false,
-    "Flex": false,
-    "FlexItemValues": false,
-    "FlexLineValues": false,
-    "FocusEvent": false,
-    "FontFace": false,
-    "FontFaceSet": false,
-    "FontFaceSetLoadEvent": false,
-    "FormData": false,
-    "FrameLoader": false,
-    "GainNode": false,
-    "Gamepad": false,
-    "GamepadAxisMoveEvent": false,
-    "GamepadButton": false,
-    "GamepadButtonEvent": false,
-    "GamepadEvent": false,
-    "GamepadHapticActuator": false,
-    "GamepadPose": false,
-    "GamepadServiceTest": false,
-    "Grid": false,
-    "GridArea": false,
-    "GridDimension": false,
-    "GridLine": false,
-    "GridLines": false,
-    "GridTrack": false,
-    "GridTracks": false,
-    "HTMLAllCollection": false,
-    "HTMLAnchorElement": false,
-    "HTMLAreaElement": false,
-    "HTMLAudioElement": false,
-    "Audio": false,
-    "HTMLBRElement": false,
-    "HTMLBaseElement": false,
-    "HTMLBodyElement": false,
-    "HTMLButtonElement": false,
-    "HTMLCanvasElement": false,
-    "HTMLCollection": false,
-    "HTMLDListElement": false,
-    "HTMLDataElement": false,
-    "HTMLDataListElement": false,
-    "HTMLDetailsElement": false,
-    "HTMLDialogElement": false,
-    "HTMLDirectoryElement": false,
-    "HTMLDivElement": false,
-    "HTMLDocument": false,
-    "HTMLElement": false,
-    "HTMLEmbedElement": false,
-    "HTMLFieldSetElement": false,
-    "HTMLFontElement": false,
-    "HTMLFormControlsCollection": false,
-    "HTMLFormElement": false,
-    "HTMLFrameElement": false,
-    "HTMLFrameSetElement": false,
-    "HTMLHRElement": false,
-    "HTMLHeadElement": false,
-    "HTMLHeadingElement": false,
-    "HTMLHtmlElement": false,
-    "HTMLIFrameElement": false,
-    "HTMLImageElement": false,
-    "Image": false,
-    "HTMLInputElement": false,
-    "HTMLLIElement": false,
-    "HTMLLabelElement": false,
-    "HTMLLegendElement": false,
-    "HTMLLinkElement": false,
-    "HTMLMapElement": false,
-    "HTMLMarqueeElement": false,
-    "HTMLMediaElement": false,
-    "HTMLMenuElement": false,
-    "HTMLMenuItemElement": false,
-    "HTMLMetaElement": false,
-    "HTMLMeterElement": false,
-    "HTMLModElement": false,
-    "HTMLOListElement": false,
-    "HTMLObjectElement": false,
-    "HTMLOptGroupElement": false,
-    "HTMLOptionElement": false,
-    "Option": false,
-    "HTMLOptionsCollection": false,
-    "HTMLOutputElement": false,
-    "HTMLParagraphElement": false,
-    "HTMLParamElement": false,
-    "HTMLPictureElement": false,
-    "HTMLPreElement": false,
-    "HTMLProgressElement": false,
-    "HTMLQuoteElement": false,
-    "HTMLScriptElement": false,
-    "HTMLSelectElement": false,
-    "HTMLSlotElement": false,
-    "HTMLSourceElement": false,
-    "HTMLSpanElement": false,
-    "HTMLStyleElement": false,
-    "HTMLTableCaptionElement": false,
-    "HTMLTableCellElement": false,
-    "HTMLTableColElement": false,
-    "HTMLTableElement": false,
-    "HTMLTableRowElement": false,
-    "HTMLTableSectionElement": false,
-    "HTMLTemplateElement": false,
-    "HTMLTextAreaElement": false,
-    "HTMLTimeElement": false,
-    "HTMLTitleElement": false,
-    "HTMLTrackElement": false,
-    "HTMLUListElement": false,
-    "HTMLUnknownElement": false,
-    "HTMLVideoElement": false,
-    "HashChangeEvent": false,
-    "Headers": false,
-    "HeapSnapshot": false,
-    "HiddenPluginEvent": false,
-    "History": false,
-    "IDBCursor": false,
-    "IDBCursorWithValue": false,
-    "IDBDatabase": false,
-    "IDBFactory": false,
-    "IDBFileHandle": false,
-    "IDBFileRequest": false,
-    "IDBIndex": false,
-    "IDBKeyRange": false,
-    "IDBLocaleAwareKeyRange": false,
-    "IDBMutableFile": false,
-    "IDBObjectStore": false,
-    "IDBOpenDBRequest": false,
-    "IDBRequest": false,
-    "IDBTransaction": false,
-    "IDBVersionChangeEvent": false,
-    "IIRFilterNode": false,
-    "IdleDeadline": false,
-    "ImageBitmap": false,
-    "ImageBitmapRenderingContext": false,
-    "ImageCapture": false,
-    "ImageCaptureErrorEvent": false,
-    "ImageData": false,
-    "ImageDocument": false,
-    "InputEvent": false,
-    "InspectorFontFace": false,
-    "InspectorUtils": false,
-    "InstallTriggerImpl": false,
-    "IntersectionObserver": false,
-    "IntersectionObserverEntry": false,
-    "JSWindowActorChild": false,
-    "JSWindowActorParent": false,
-    "KeyEvent": false,
-    "KeyboardEvent": false,
-    "KeyframeEffect": false,
-    "Localization": false,
-    "Location": false,
-    "MIDIAccess": false,
-    "MIDIConnectionEvent": false,
-    "MIDIInput": false,
-    "MIDIInputMap": false,
-    "MIDIMessageEvent": false,
-    "MIDIOutput": false,
-    "MIDIOutputMap": false,
-    "MIDIPort": false,
-    "MatchGlob": false,
-    "MatchPattern": false,
-    "MatchPatternSet": false,
-    "MediaCapabilities": false,
-    "MediaCapabilitiesInfo": false,
-    "MediaDeviceInfo": false,
-    "MediaDevices": false,
-    "MediaElementAudioSourceNode": false,
-    "MediaEncryptedEvent": false,
-    "MediaError": false,
-    "MediaKeyError": false,
-    "MediaKeyMessageEvent": false,
-    "MediaKeySession": false,
-    "MediaKeyStatusMap": false,
-    "MediaKeySystemAccess": false,
-    "MediaKeys": false,
-    "MediaList": false,
-    "MediaQueryList": false,
-    "MediaQueryListEvent": false,
-    "MediaRecorder": false,
-    "MediaRecorderErrorEvent": false,
-    "MediaSource": false,
-    "MediaStream": false,
-    "MediaStreamAudioDestinationNode": false,
-    "MediaStreamAudioSourceNode": false,
-    "MediaStreamEvent": false,
-    "MediaStreamTrack": false,
-    "MediaStreamTrackEvent": false,
-    "MerchantValidationEvent": false,
-    "MessageBroadcaster": false,
-    "MessageChannel": false,
-    "MessageEvent": false,
-    "MessageListenerManager": false,
-    "MessagePort": false,
-    "MessageSender": false,
-    "MimeType": false,
-    "MimeTypeArray": false,
-    "MouseEvent": false,
-    "MouseScrollEvent": false,
-    "MozCanvasPrintState": false,
-    "MozDocumentMatcher": false,
-    "MozDocumentObserver": false,
-    "MozQueryInterface": false,
-    "MozSharedMap": false,
-    "MozSharedMapChangeEvent": false,
-    "MozStorageAsyncStatementParams": false,
-    "MozStorageStatementParams": false,
-    "MozStorageStatementRow": false,
-    "MozWritableSharedMap": false,
-    "MutationEvent": false,
-    "MutationObserver": false,
-    "MutationRecord": false,
-    "NamedNodeMap": false,
-    "Navigator": false,
-    "NetworkInformation": false,
-    "Node": false,
-    "NodeFilter": false,
-    "NodeIterator": false,
-    "NodeList": false,
-    "Notification": false,
-    "NotifyPaintEvent": false,
-    "OfflineAudioCompletionEvent": false,
-    "OfflineAudioContext": false,
-    "OfflineResourceList": false,
-    "OffscreenCanvas": false,
-    "OscillatorNode": false,
-    "PageTransitionEvent": false,
-    "PaintRequest": false,
-    "PaintRequestList": false,
-    "PannerNode": false,
-    "ParentProcessMessageManager": false,
-    "ParentSHistory": false,
-    "Path2D": false,
-    "PaymentAddress": false,
-    "PaymentMethodChangeEvent": false,
-    "PaymentRequest": false,
-    "PaymentRequestUpdateEvent": false,
-    "PaymentResponse": false,
-    "PeerConnectionImpl": false,
-    "PeerConnectionObserver": false,
-    "Performance": false,
-    "PerformanceEntry": false,
-    "PerformanceEntryEvent": false,
-    "PerformanceMark": false,
-    "PerformanceMeasure": false,
-    "PerformanceNavigation": false,
-    "PerformanceNavigationTiming": false,
-    "PerformanceObserver": false,
-    "PerformanceObserverEntryList": false,
-    "PerformanceResourceTiming": false,
-    "PerformanceServerTiming": false,
-    "PerformanceTiming": false,
-    "PeriodicWave": false,
-    "PermissionStatus": false,
-    "Permissions": false,
-    "PlacesBookmark": false,
-    "PlacesBookmarkAddition": false,
-    "PlacesEvent": false,
-    "PlacesObservers": false,
-    "PlacesVisit": false,
-    "PlacesWeakCallbackWrapper": false,
-    "Plugin": false,
-    "PluginArray": false,
-    "PluginCrashedEvent": false,
-    "PointerEvent": false,
-    "PopStateEvent": false,
-    "PopupBlockedEvent": false,
-    "PrecompiledScript": false,
-    "Presentation": false,
-    "PresentationAvailability": false,
-    "PresentationConnection": false,
-    "PresentationConnectionAvailableEvent": false,
-    "PresentationConnectionCloseEvent": false,
-    "PresentationConnectionList": false,
-    "PresentationReceiver": false,
-    "PresentationRequest": false,
-    "PrioEncoder": false,
-    "ProcessMessageManager": false,
-    "ProcessingInstruction": false,
-    "ProgressEvent": false,
-    "PromiseDebugging": false,
-    "PromiseRejectionEvent": false,
-    "PublicKeyCredential": false,
-    "PushManager": false,
-    "PushManagerImpl": false,
-    "PushSubscription": false,
-    "PushSubscriptionOptions": false,
-    "RTCCertificate": false,
-    "RTCDTMFSender": false,
-    "RTCDTMFToneChangeEvent": false,
-    "RTCDataChannel": false,
-    "RTCDataChannelEvent": false,
-    "RTCIceCandidate": false,
-    "RTCPeerConnection": false,
-    "RTCPeerConnectionIceEvent": false,
-    "RTCPeerConnectionStatic": false,
-    "RTCRtpReceiver": false,
-    "RTCRtpSender": false,
-    "RTCRtpTransceiver": false,
-    "RTCSessionDescription": false,
-    "RTCStatsReport": false,
-    "RTCTrackEvent": false,
-    "RadioNodeList": false,
-    "Range": false,
-    "Report": false,
-    "ReportBody": false,
-    "ReportingObserver": false,
-    "Request": false,
-    "Response": false,
-    "SessionStoreUtils": false,
-    "SVGAElement": false,
-    "SVGAngle": false,
-    "SVGAnimateElement": false,
-    "SVGAnimateMotionElement": false,
-    "SVGAnimateTransformElement": false,
-    "SVGAnimatedAngle": false,
-    "SVGAnimatedBoolean": false,
-    "SVGAnimatedEnumeration": false,
-    "SVGAnimatedInteger": false,
-    "SVGAnimatedLength": false,
-    "SVGAnimatedLengthList": false,
-    "SVGAnimatedNumber": false,
-    "SVGAnimatedNumberList": false,
-    "SVGAnimatedPreserveAspectRatio": false,
-    "SVGAnimatedRect": false,
-    "SVGAnimatedString": false,
-    "SVGAnimatedTransformList": false,
-    "SVGAnimationElement": false,
-    "SVGCircleElement": false,
-    "SVGClipPathElement": false,
-    "SVGComponentTransferFunctionElement": false,
-    "SVGDefsElement": false,
-    "SVGDescElement": false,
-    "SVGElement": false,
-    "SVGEllipseElement": false,
-    "SVGFEBlendElement": false,
-    "SVGFEColorMatrixElement": false,
-    "SVGFEComponentTransferElement": false,
-    "SVGFECompositeElement": false,
-    "SVGFEConvolveMatrixElement": false,
-    "SVGFEDiffuseLightingElement": false,
-    "SVGFEDisplacementMapElement": false,
-    "SVGFEDistantLightElement": false,
-    "SVGFEDropShadowElement": false,
-    "SVGFEFloodElement": false,
-    "SVGFEFuncAElement": false,
-    "SVGFEFuncBElement": false,
-    "SVGFEFuncGElement": false,
-    "SVGFEFuncRElement": false,
-    "SVGFEGaussianBlurElement": false,
-    "SVGFEImageElement": false,
-    "SVGFEMergeElement": false,
-    "SVGFEMergeNodeElement": false,
-    "SVGFEMorphologyElement": false,
-    "SVGFEOffsetElement": false,
-    "SVGFEPointLightElement": false,
-    "SVGFESpecularLightingElement": false,
-    "SVGFESpotLightElement": false,
-    "SVGFETileElement": false,
-    "SVGFETurbulenceElement": false,
-    "SVGFilterElement": false,
-    "SVGForeignObjectElement": false,
-    "SVGGElement": false,
-    "SVGGeometryElement": false,
-    "SVGGradientElement": false,
-    "SVGGraphicsElement": false,
-    "SVGImageElement": false,
-    "SVGLength": false,
-    "SVGLengthList": false,
-    "SVGLineElement": false,
-    "SVGLinearGradientElement": false,
-    "SVGMPathElement": false,
-    "SVGMarkerElement": false,
-    "SVGMaskElement": false,
-    "SVGMatrix": false,
-    "SVGMetadataElement": false,
-    "SVGNumber": false,
-    "SVGNumberList": false,
-    "SVGPathElement": false,
-    "SVGPathSegList": false,
-    "SVGPatternElement": false,
-    "SVGPoint": false,
-    "SVGPointList": false,
-    "SVGPolygonElement": false,
-    "SVGPolylineElement": false,
-    "SVGPreserveAspectRatio": false,
-    "SVGRadialGradientElement": false,
-    "SVGRect": false,
-    "SVGRectElement": false,
-    "SVGSVGElement": false,
-    "SVGScriptElement": false,
-    "SVGSetElement": false,
-    "SVGStopElement": false,
-    "SVGStringList": false,
-    "SVGStyleElement": false,
-    "SVGSwitchElement": false,
-    "SVGSymbolElement": false,
-    "SVGTSpanElement": false,
-    "SVGTextContentElement": false,
-    "SVGTextElement": false,
-    "SVGTextPathElement": false,
-    "SVGTextPositioningElement": false,
-    "SVGTitleElement": false,
-    "SVGTransform": false,
-    "SVGTransformList": false,
-    "SVGUnitTypes": false,
-    "SVGUseElement": false,
-    "SVGViewElement": false,
-    "SVGZoomAndPan": false,
-    "Screen": false,
-    "ScreenLuminance": false,
-    "ScreenOrientation": false,
-    "ScriptProcessorNode": false,
-    "ScrollAreaEvent": false,
-    "ScrollViewChangeEvent": false,
-    "SecurityPolicyViolationEvent": false,
-    "Selection": false,
-    "ServiceWorker": false,
-    "ServiceWorkerContainer": false,
-    "ServiceWorkerRegistration": false,
-    "ShadowRoot": false,
-    "SharedWorker": false,
-    "SimpleGestureEvent": false,
-    "SourceBuffer": false,
-    "SourceBufferList": false,
-    "SpeechGrammar": false,
-    "SpeechGrammarList": false,
-    "SpeechRecognition": false,
-    "SpeechRecognitionAlternative": false,
-    "SpeechRecognitionError": false,
-    "SpeechRecognitionEvent": false,
-    "SpeechRecognitionResult": false,
-    "SpeechRecognitionResultList": false,
-    "SpeechSynthesis": false,
-    "SpeechSynthesisErrorEvent": false,
-    "SpeechSynthesisEvent": false,
-    "SpeechSynthesisUtterance": false,
-    "SpeechSynthesisVoice": false,
-    "StereoPannerNode": false,
-    "Storage": false,
-    "StorageEvent": false,
-    "StorageManager": false,
-    "StreamFilter": false,
-    "StreamFilterDataEvent": false,
-    "StructuredCloneHolder": false,
-    "StructuredCloneTester": false,
-    "StyleRuleChangeEvent": false,
-    "StyleSheet": false,
-    "StyleSheetApplicableStateChangeEvent": false,
-    "StyleSheetChangeEvent": false,
-    "StyleSheetList": false,
-    "SubtleCrypto": false,
-    "SyncMessageSender": false,
-    "TCPServerSocket": false,
-    "TCPServerSocketEvent": false,
-    "TCPSocket": false,
-    "TCPSocketErrorEvent": false,
-    "TCPSocketEvent": false,
-    "TelemetryStopwatch": false,
-    "TestingDeprecatedInterface": false,
-    "Text": false,
-    "TextClause": false,
-    "TextDecoder": false,
-    "TextEncoder": false,
-    "TextMetrics": false,
-    "TextTrack": false,
-    "TextTrackCue": false,
-    "TextTrackCueList": false,
-    "TextTrackList": false,
-    "TimeEvent": false,
-    "TimeRanges": false,
-    "Touch": false,
-    "TouchEvent": false,
-    "TouchList": false,
-    "TrackEvent": false,
-    "TransceiverImpl": false,
-    "TransitionEvent": false,
-    "TreeColumn": false,
-    "TreeColumns": false,
-    "TreeContentView": false,
-    "TreeWalker": false,
-    "U2F": false,
-    "UDPMessageEvent": false,
-    "UDPSocket": false,
-    "UIEvent": false,
-    "URL": false,
-    "URLSearchParams": false,
-    "UserProximityEvent": false,
-    "VRDisplay": false,
-    "VRDisplayCapabilities": false,
-    "VRDisplayEvent": false,
-    "VREyeParameters": false,
-    "VRFieldOfView": false,
-    "VRFrameData": false,
-    "VRMockController": false,
-    "VRMockDisplay": false,
-    "VRPose": false,
-    "VRServiceTest": false,
-    "VRStageParameters": false,
-    "VRSubmitFrameResult": false,
-    "VTTCue": false,
-    "VTTRegion": false,
-    "ValidityState": false,
-    "VideoPlaybackQuality": false,
-    "VideoTrack": false,
-    "VideoTrackList": false,
-    "VisualViewport": false,
-    "WaveShaperNode": false,
-    "WebExtensionContentScript": false,
-    "WebExtensionPolicy": false,
-    "WebGL2RenderingContext": false,
-    "WebGLActiveInfo": false,
-    "WebGLBuffer": false,
-    "WebGLContextEvent": false,
-    "WebGLFramebuffer": false,
-    "WebGLProgram": false,
-    "WebGLQuery": false,
-    "WebGLRenderbuffer": false,
-    "WebGLRenderingContext": false,
-    "WebGLSampler": false,
-    "WebGLShader": false,
-    "WebGLShaderPrecisionFormat": false,
-    "WebGLSync": false,
-    "WebGLTexture": false,
-    "WebGLTransformFeedback": false,
-    "WebGLUniformLocation": false,
-    "WebGLVertexArrayObject": false,
-    "WebGPU": false,
-    "WebGPUAdapter": false,
-    "WebGPUAttachmentState": false,
-    "WebGPUBindGroup": false,
-    "WebGPUBindGroupLayout": false,
-    "WebGPUBindingType": false,
-    "WebGPUBlendFactor": false,
-    "WebGPUBlendOperation": false,
-    "WebGPUBlendState": false,
-    "WebGPUBuffer": false,
-    "WebGPUBufferUsage": false,
-    "WebGPUColorWriteBits": false,
-    "WebGPUCommandBuffer": false,
-    "WebGPUCommandEncoder": false,
-    "WebGPUCompareFunction": false,
-    "WebGPUComputePipeline": false,
-    "WebGPUDepthStencilState": false,
-    "WebGPUDevice": false,
-    "WebGPUFence": false,
-    "WebGPUFilterMode": false,
-    "WebGPUIndexFormat": false,
-    "WebGPUInputState": false,
-    "WebGPUInputStepMode": false,
-    "WebGPULoadOp": false,
-    "WebGPULogEntry": false,
-    "WebGPUPipelineLayout": false,
-    "WebGPUPrimitiveTopology": false,
-    "WebGPUQueue": false,
-    "WebGPURenderPipeline": false,
-    "WebGPUSampler": false,
-    "WebGPUShaderModule": false,
-    "WebGPUShaderStage": false,
-    "WebGPUShaderStageBit": false,
-    "WebGPUStencilOperation": false,
-    "WebGPUStoreOp": false,
-    "WebGPUSwapChain": false,
-    "WebGPUTexture": false,
-    "WebGPUTextureDimension": false,
-    "WebGPUTextureFormat": false,
-    "WebGPUTextureUsage": false,
-    "WebGPUTextureView": false,
-    "WebGPUVertexFormat": false,
-    "WebKitCSSMatrix": false,
-    "WebSocket": false,
-    "WebrtcGlobalInformation": false,
-    "WheelEvent": false,
-    "Window": false,
-    "WindowRoot": false,
-    "Worker": false,
-    "Worklet": false,
-    "XMLDocument": false,
-    "XMLHttpRequest": false,
-    "XMLHttpRequestEventTarget": false,
-    "XMLHttpRequestUpload": false,
-    "XMLSerializer": false,
-    "XPathEvaluator": false,
-    "XPathExpression": false,
-    "XPathResult": false,
-    "XSLTProcessor": false,
-    "XULCommandEvent": false,
-    "XULDocument": false,
-    "XULElement": false,
-    "XULFrameElement": false,
-    "XULMenuElement": false,
-    "XULPopupElement": false,
-    "XULScrollElement": false,
-    "XULTextElement": false,
-    "console": false,
-    "mozRTCIceCandidate": false,
-    "mozRTCPeerConnection": false,
-    "mozRTCSessionDescription": false,
+    APZHitResultFlags: false,
+    AbortController: false,
+    AbortSignal: false,
+    AccessibleNode: false,
+    Addon: false,
+    AddonEvent: false,
+    AddonInstall: false,
+    AddonManager: true,
+    AddonManagerPermissions: false,
+    AnalyserNode: false,
+    Animation: false,
+    AnimationEffect: false,
+    AnimationEvent: false,
+    AnimationPlaybackEvent: false,
+    AnimationTimeline: false,
+    AnonymousContent: false,
+    Attr: false,
+    AudioBuffer: false,
+    AudioBufferSourceNode: false,
+    AudioContext: false,
+    AudioDestinationNode: false,
+    AudioListener: false,
+    AudioNode: false,
+    AudioParam: false,
+    AudioParamMap: false,
+    AudioProcessingEvent: false,
+    AudioScheduledSourceNode: false,
+    AudioTrack: false,
+    AudioTrackList: false,
+    AudioWorklet: false,
+    AudioWorkletNode: false,
+    AuthenticatorAssertionResponse: false,
+    AuthenticatorAttestationResponse: false,
+    AuthenticatorResponse: false,
+    BarProp: false,
+    BaseAudioContext: false,
+    BatteryManager: false,
+    BeforeUnloadEvent: false,
+    BiquadFilterNode: false,
+    Blob: false,
+    BlobEvent: false,
+    BoxObject: false,
+    BroadcastChannel: false,
+    BrowsingContext: false,
+    CDATASection: false,
+    CSS: false,
+    CSS2Properties: false,
+    CSSAnimation: false,
+    CSSConditionRule: false,
+    CSSCounterStyleRule: false,
+    CSSFontFaceRule: false,
+    CSSFontFeatureValuesRule: false,
+    CSSGroupingRule: false,
+    CSSImportRule: false,
+    CSSKeyframeRule: false,
+    CSSKeyframesRule: false,
+    CSSMediaRule: false,
+    CSSMozDocumentRule: false,
+    CSSNamespaceRule: false,
+    CSSPageRule: false,
+    CSSPseudoElement: false,
+    CSSRule: false,
+    CSSRuleList: false,
+    CSSStyleDeclaration: false,
+    CSSStyleRule: false,
+    CSSStyleSheet: false,
+    CSSSupportsRule: false,
+    CSSTransition: false,
+    Cache: false,
+    CacheStorage: false,
+    CanvasCaptureMediaStream: false,
+    CanvasGradient: false,
+    CanvasPattern: false,
+    CanvasRenderingContext2D: false,
+    CaretPosition: false,
+    CaretStateChangedEvent: false,
+    ChannelMergerNode: false,
+    ChannelSplitterNode: false,
+    ChannelWrapper: false,
+    CharacterData: false,
+    CheckerboardReportService: false,
+    ChildProcessMessageManager: false,
+    ChildSHistory: false,
+    ChromeMessageBroadcaster: false,
+    ChromeMessageSender: false,
+    ChromeNodeList: false,
+    ChromeUtils: false,
+    ChromeWorker: false,
+    Clipboard: false,
+    ClipboardEvent: false,
+    CloseEvent: false,
+    CommandEvent: false,
+    Comment: false,
+    CompositionEvent: false,
+    ConsoleInstance: false,
+    ConstantSourceNode: false,
+    ContentFrameMessageManager: false,
+    ContentProcessMessageManager: false,
+    ConvolverNode: false,
+    CreateOfferRequest: false,
+    Credential: false,
+    CredentialsContainer: false,
+    Crypto: false,
+    CryptoKey: false,
+    CustomElementRegistry: false,
+    CustomEvent: false,
+    DOMError: false,
+    DOMException: false,
+    DOMImplementation: false,
+    DOMLocalization: false,
+    DOMMatrix: false,
+    DOMMatrixReadOnly: false,
+    DOMParser: false,
+    DOMPoint: false,
+    DOMPointReadOnly: false,
+    DOMQuad: false,
+    DOMRect: false,
+    DOMRectList: false,
+    DOMRectReadOnly: false,
+    DOMRequest: false,
+    DOMStringList: false,
+    DOMStringMap: false,
+    DOMTokenList: false,
+    DataTransfer: false,
+    DataTransferItem: false,
+    DataTransferItemList: false,
+    DelayNode: false,
+    DeprecationReportBody: false,
+    DeviceLightEvent: false,
+    DeviceMotionEvent: false,
+    DeviceOrientationEvent: false,
+    DeviceProximityEvent: false,
+    Directory: false,
+    Document: false,
+    DocumentFragment: false,
+    DocumentTimeline: false,
+    DocumentType: false,
+    DominatorTree: false,
+    DragEvent: false,
+    DynamicsCompressorNode: false,
+    Element: false,
+    ErrorEvent: false,
+    Event: false,
+    EventSource: false,
+    EventTarget: false,
+    FeaturePolicyViolationReportBody: false,
+    FetchObserver: false,
+    File: false,
+    FileList: false,
+    FileReader: false,
+    FileSystem: false,
+    FileSystemDirectoryEntry: false,
+    FileSystemDirectoryReader: false,
+    FileSystemEntry: false,
+    FileSystemFileEntry: false,
+    Flex: false,
+    FlexItemValues: false,
+    FlexLineValues: false,
+    FocusEvent: false,
+    FontFace: false,
+    FontFaceSet: false,
+    FontFaceSetLoadEvent: false,
+    FormData: false,
+    FrameLoader: false,
+    GainNode: false,
+    Gamepad: false,
+    GamepadAxisMoveEvent: false,
+    GamepadButton: false,
+    GamepadButtonEvent: false,
+    GamepadEvent: false,
+    GamepadHapticActuator: false,
+    GamepadPose: false,
+    GamepadServiceTest: false,
+    Grid: false,
+    GridArea: false,
+    GridDimension: false,
+    GridLine: false,
+    GridLines: false,
+    GridTrack: false,
+    GridTracks: false,
+    HTMLAllCollection: false,
+    HTMLAnchorElement: false,
+    HTMLAreaElement: false,
+    HTMLAudioElement: false,
+    Audio: false,
+    HTMLBRElement: false,
+    HTMLBaseElement: false,
+    HTMLBodyElement: false,
+    HTMLButtonElement: false,
+    HTMLCanvasElement: false,
+    HTMLCollection: false,
+    HTMLDListElement: false,
+    HTMLDataElement: false,
+    HTMLDataListElement: false,
+    HTMLDetailsElement: false,
+    HTMLDialogElement: false,
+    HTMLDirectoryElement: false,
+    HTMLDivElement: false,
+    HTMLDocument: false,
+    HTMLElement: false,
+    HTMLEmbedElement: false,
+    HTMLFieldSetElement: false,
+    HTMLFontElement: false,
+    HTMLFormControlsCollection: false,
+    HTMLFormElement: false,
+    HTMLFrameElement: false,
+    HTMLFrameSetElement: false,
+    HTMLHRElement: false,
+    HTMLHeadElement: false,
+    HTMLHeadingElement: false,
+    HTMLHtmlElement: false,
+    HTMLIFrameElement: false,
+    HTMLImageElement: false,
+    Image: false,
+    HTMLInputElement: false,
+    HTMLLIElement: false,
+    HTMLLabelElement: false,
+    HTMLLegendElement: false,
+    HTMLLinkElement: false,
+    HTMLMapElement: false,
+    HTMLMarqueeElement: false,
+    HTMLMediaElement: false,
+    HTMLMenuElement: false,
+    HTMLMenuItemElement: false,
+    HTMLMetaElement: false,
+    HTMLMeterElement: false,
+    HTMLModElement: false,
+    HTMLOListElement: false,
+    HTMLObjectElement: false,
+    HTMLOptGroupElement: false,
+    HTMLOptionElement: false,
+    Option: false,
+    HTMLOptionsCollection: false,
+    HTMLOutputElement: false,
+    HTMLParagraphElement: false,
+    HTMLParamElement: false,
+    HTMLPictureElement: false,
+    HTMLPreElement: false,
+    HTMLProgressElement: false,
+    HTMLQuoteElement: false,
+    HTMLScriptElement: false,
+    HTMLSelectElement: false,
+    HTMLSlotElement: false,
+    HTMLSourceElement: false,
+    HTMLSpanElement: false,
+    HTMLStyleElement: false,
+    HTMLTableCaptionElement: false,
+    HTMLTableCellElement: false,
+    HTMLTableColElement: false,
+    HTMLTableElement: false,
+    HTMLTableRowElement: false,
+    HTMLTableSectionElement: false,
+    HTMLTemplateElement: false,
+    HTMLTextAreaElement: false,
+    HTMLTimeElement: false,
+    HTMLTitleElement: false,
+    HTMLTrackElement: false,
+    HTMLUListElement: false,
+    HTMLUnknownElement: false,
+    HTMLVideoElement: false,
+    HashChangeEvent: false,
+    Headers: false,
+    HeapSnapshot: false,
+    HiddenPluginEvent: false,
+    History: false,
+    IDBCursor: false,
+    IDBCursorWithValue: false,
+    IDBDatabase: false,
+    IDBFactory: false,
+    IDBFileHandle: false,
+    IDBFileRequest: false,
+    IDBIndex: false,
+    IDBKeyRange: false,
+    IDBLocaleAwareKeyRange: false,
+    IDBMutableFile: false,
+    IDBObjectStore: false,
+    IDBOpenDBRequest: false,
+    IDBRequest: false,
+    IDBTransaction: false,
+    IDBVersionChangeEvent: false,
+    IIRFilterNode: false,
+    IdleDeadline: false,
+    ImageBitmap: false,
+    ImageBitmapRenderingContext: false,
+    ImageCapture: false,
+    ImageCaptureErrorEvent: false,
+    ImageData: false,
+    ImageDocument: false,
+    InputEvent: false,
+    InspectorFontFace: false,
+    InspectorUtils: false,
+    InstallTriggerImpl: false,
+    IntersectionObserver: false,
+    IntersectionObserverEntry: false,
+    JSWindowActorChild: false,
+    JSWindowActorParent: false,
+    KeyEvent: false,
+    KeyboardEvent: false,
+    KeyframeEffect: false,
+    Localization: false,
+    Location: false,
+    MIDIAccess: false,
+    MIDIConnectionEvent: false,
+    MIDIInput: false,
+    MIDIInputMap: false,
+    MIDIMessageEvent: false,
+    MIDIOutput: false,
+    MIDIOutputMap: false,
+    MIDIPort: false,
+    MatchGlob: false,
+    MatchPattern: false,
+    MatchPatternSet: false,
+    MediaCapabilities: false,
+    MediaCapabilitiesInfo: false,
+    MediaDeviceInfo: false,
+    MediaDevices: false,
+    MediaElementAudioSourceNode: false,
+    MediaEncryptedEvent: false,
+    MediaError: false,
+    MediaKeyError: false,
+    MediaKeyMessageEvent: false,
+    MediaKeySession: false,
+    MediaKeyStatusMap: false,
+    MediaKeySystemAccess: false,
+    MediaKeys: false,
+    MediaList: false,
+    MediaQueryList: false,
+    MediaQueryListEvent: false,
+    MediaRecorder: false,
+    MediaRecorderErrorEvent: false,
+    MediaSource: false,
+    MediaStream: false,
+    MediaStreamAudioDestinationNode: false,
+    MediaStreamAudioSourceNode: false,
+    MediaStreamEvent: false,
+    MediaStreamTrack: false,
+    MediaStreamTrackEvent: false,
+    MerchantValidationEvent: false,
+    MessageBroadcaster: false,
+    MessageChannel: false,
+    MessageEvent: false,
+    MessageListenerManager: false,
+    MessagePort: false,
+    MessageSender: false,
+    MimeType: false,
+    MimeTypeArray: false,
+    MouseEvent: false,
+    MouseScrollEvent: false,
+    MozCanvasPrintState: false,
+    MozDocumentMatcher: false,
+    MozDocumentObserver: false,
+    MozQueryInterface: false,
+    MozSharedMap: false,
+    MozSharedMapChangeEvent: false,
+    MozStorageAsyncStatementParams: false,
+    MozStorageStatementParams: false,
+    MozStorageStatementRow: false,
+    MozWritableSharedMap: false,
+    MutationEvent: false,
+    MutationObserver: false,
+    MutationRecord: false,
+    NamedNodeMap: false,
+    Navigator: false,
+    NetworkInformation: false,
+    Node: false,
+    NodeFilter: false,
+    NodeIterator: false,
+    NodeList: false,
+    Notification: false,
+    NotifyPaintEvent: false,
+    OfflineAudioCompletionEvent: false,
+    OfflineAudioContext: false,
+    OfflineResourceList: false,
+    OffscreenCanvas: false,
+    OscillatorNode: false,
+    PageTransitionEvent: false,
+    PaintRequest: false,
+    PaintRequestList: false,
+    PannerNode: false,
+    ParentProcessMessageManager: false,
+    ParentSHistory: false,
+    Path2D: false,
+    PaymentAddress: false,
+    PaymentMethodChangeEvent: false,
+    PaymentRequest: false,
+    PaymentRequestUpdateEvent: false,
+    PaymentResponse: false,
+    PeerConnectionImpl: false,
+    PeerConnectionObserver: false,
+    Performance: false,
+    PerformanceEntry: false,
+    PerformanceEntryEvent: false,
+    PerformanceMark: false,
+    PerformanceMeasure: false,
+    PerformanceNavigation: false,
+    PerformanceNavigationTiming: false,
+    PerformanceObserver: false,
+    PerformanceObserverEntryList: false,
+    PerformanceResourceTiming: false,
+    PerformanceServerTiming: false,
+    PerformanceTiming: false,
+    PeriodicWave: false,
+    PermissionStatus: false,
+    Permissions: false,
+    PlacesBookmark: false,
+    PlacesBookmarkAddition: false,
+    PlacesEvent: false,
+    PlacesObservers: false,
+    PlacesVisit: false,
+    PlacesWeakCallbackWrapper: false,
+    Plugin: false,
+    PluginArray: false,
+    PluginCrashedEvent: false,
+    PointerEvent: false,
+    PopStateEvent: false,
+    PopupBlockedEvent: false,
+    PrecompiledScript: false,
+    Presentation: false,
+    PresentationAvailability: false,
+    PresentationConnection: false,
+    PresentationConnectionAvailableEvent: false,
+    PresentationConnectionCloseEvent: false,
+    PresentationConnectionList: false,
+    PresentationReceiver: false,
+    PresentationRequest: false,
+    PrioEncoder: false,
+    ProcessMessageManager: false,
+    ProcessingInstruction: false,
+    ProgressEvent: false,
+    PromiseDebugging: false,
+    PromiseRejectionEvent: false,
+    PublicKeyCredential: false,
+    PushManager: false,
+    PushManagerImpl: false,
+    PushSubscription: false,
+    PushSubscriptionOptions: false,
+    RTCCertificate: false,
+    RTCDTMFSender: false,
+    RTCDTMFToneChangeEvent: false,
+    RTCDataChannel: false,
+    RTCDataChannelEvent: false,
+    RTCIceCandidate: false,
+    RTCPeerConnection: false,
+    RTCPeerConnectionIceEvent: false,
+    RTCPeerConnectionStatic: false,
+    RTCRtpReceiver: false,
+    RTCRtpSender: false,
+    RTCRtpTransceiver: false,
+    RTCSessionDescription: false,
+    RTCStatsReport: false,
+    RTCTrackEvent: false,
+    RadioNodeList: false,
+    Range: false,
+    Report: false,
+    ReportBody: false,
+    ReportingObserver: false,
+    Request: false,
+    Response: false,
+    SessionStoreUtils: false,
+    SVGAElement: false,
+    SVGAngle: false,
+    SVGAnimateElement: false,
+    SVGAnimateMotionElement: false,
+    SVGAnimateTransformElement: false,
+    SVGAnimatedAngle: false,
+    SVGAnimatedBoolean: false,
+    SVGAnimatedEnumeration: false,
+    SVGAnimatedInteger: false,
+    SVGAnimatedLength: false,
+    SVGAnimatedLengthList: false,
+    SVGAnimatedNumber: false,
+    SVGAnimatedNumberList: false,
+    SVGAnimatedPreserveAspectRatio: false,
+    SVGAnimatedRect: false,
+    SVGAnimatedString: false,
+    SVGAnimatedTransformList: false,
+    SVGAnimationElement: false,
+    SVGCircleElement: false,
+    SVGClipPathElement: false,
+    SVGComponentTransferFunctionElement: false,
+    SVGDefsElement: false,
+    SVGDescElement: false,
+    SVGElement: false,
+    SVGEllipseElement: false,
+    SVGFEBlendElement: false,
+    SVGFEColorMatrixElement: false,
+    SVGFEComponentTransferElement: false,
+    SVGFECompositeElement: false,
+    SVGFEConvolveMatrixElement: false,
+    SVGFEDiffuseLightingElement: false,
+    SVGFEDisplacementMapElement: false,
+    SVGFEDistantLightElement: false,
+    SVGFEDropShadowElement: false,
+    SVGFEFloodElement: false,
+    SVGFEFuncAElement: false,
+    SVGFEFuncBElement: false,
+    SVGFEFuncGElement: false,
+    SVGFEFuncRElement: false,
+    SVGFEGaussianBlurElement: false,
+    SVGFEImageElement: false,
+    SVGFEMergeElement: false,
+    SVGFEMergeNodeElement: false,
+    SVGFEMorphologyElement: false,
+    SVGFEOffsetElement: false,
+    SVGFEPointLightElement: false,
+    SVGFESpecularLightingElement: false,
+    SVGFESpotLightElement: false,
+    SVGFETileElement: false,
+    SVGFETurbulenceElement: false,
+    SVGFilterElement: false,
+    SVGForeignObjectElement: false,
+    SVGGElement: false,
+    SVGGeometryElement: false,
+    SVGGradientElement: false,
+    SVGGraphicsElement: false,
+    SVGImageElement: false,
+    SVGLength: false,
+    SVGLengthList: false,
+    SVGLineElement: false,
+    SVGLinearGradientElement: false,
+    SVGMPathElement: false,
+    SVGMarkerElement: false,
+    SVGMaskElement: false,
+    SVGMatrix: false,
+    SVGMetadataElement: false,
+    SVGNumber: false,
+    SVGNumberList: false,
+    SVGPathElement: false,
+    SVGPathSegList: false,
+    SVGPatternElement: false,
+    SVGPoint: false,
+    SVGPointList: false,
+    SVGPolygonElement: false,
+    SVGPolylineElement: false,
+    SVGPreserveAspectRatio: false,
+    SVGRadialGradientElement: false,
+    SVGRect: false,
+    SVGRectElement: false,
+    SVGSVGElement: false,
+    SVGScriptElement: false,
+    SVGSetElement: false,
+    SVGStopElement: false,
+    SVGStringList: false,
+    SVGStyleElement: false,
+    SVGSwitchElement: false,
+    SVGSymbolElement: false,
+    SVGTSpanElement: false,
+    SVGTextContentElement: false,
+    SVGTextElement: false,
+    SVGTextPathElement: false,
+    SVGTextPositioningElement: false,
+    SVGTitleElement: false,
+    SVGTransform: false,
+    SVGTransformList: false,
+    SVGUnitTypes: false,
+    SVGUseElement: false,
+    SVGViewElement: false,
+    SVGZoomAndPan: false,
+    Screen: false,
+    ScreenLuminance: false,
+    ScreenOrientation: false,
+    ScriptProcessorNode: false,
+    ScrollAreaEvent: false,
+    ScrollViewChangeEvent: false,
+    SecurityPolicyViolationEvent: false,
+    Selection: false,
+    ServiceWorker: false,
+    ServiceWorkerContainer: false,
+    ServiceWorkerRegistration: false,
+    ShadowRoot: false,
+    SharedWorker: false,
+    SimpleGestureEvent: false,
+    SourceBuffer: false,
+    SourceBufferList: false,
+    SpeechGrammar: false,
+    SpeechGrammarList: false,
+    SpeechRecognition: false,
+    SpeechRecognitionAlternative: false,
+    SpeechRecognitionError: false,
+    SpeechRecognitionEvent: false,
+    SpeechRecognitionResult: false,
+    SpeechRecognitionResultList: false,
+    SpeechSynthesis: false,
+    SpeechSynthesisErrorEvent: false,
+    SpeechSynthesisEvent: false,
+    SpeechSynthesisUtterance: false,
+    SpeechSynthesisVoice: false,
+    StereoPannerNode: false,
+    Storage: false,
+    StorageEvent: false,
+    StorageManager: false,
+    StreamFilter: false,
+    StreamFilterDataEvent: false,
+    StructuredCloneHolder: false,
+    StructuredCloneTester: false,
+    StyleRuleChangeEvent: false,
+    StyleSheet: false,
+    StyleSheetApplicableStateChangeEvent: false,
+    StyleSheetChangeEvent: false,
+    StyleSheetList: false,
+    SubtleCrypto: false,
+    SyncMessageSender: false,
+    TCPServerSocket: false,
+    TCPServerSocketEvent: false,
+    TCPSocket: false,
+    TCPSocketErrorEvent: false,
+    TCPSocketEvent: false,
+    TelemetryStopwatch: false,
+    TestingDeprecatedInterface: false,
+    Text: false,
+    TextClause: false,
+    TextDecoder: false,
+    TextEncoder: false,
+    TextMetrics: false,
+    TextTrack: false,
+    TextTrackCue: false,
+    TextTrackCueList: false,
+    TextTrackList: false,
+    TimeEvent: false,
+    TimeRanges: false,
+    Touch: false,
+    TouchEvent: false,
+    TouchList: false,
+    TrackEvent: false,
+    TransceiverImpl: false,
+    TransitionEvent: false,
+    TreeColumn: false,
+    TreeColumns: false,
+    TreeContentView: false,
+    TreeWalker: false,
+    U2F: false,
+    UDPMessageEvent: false,
+    UDPSocket: false,
+    UIEvent: false,
+    URL: false,
+    URLSearchParams: false,
+    UserProximityEvent: false,
+    VRDisplay: false,
+    VRDisplayCapabilities: false,
+    VRDisplayEvent: false,
+    VREyeParameters: false,
+    VRFieldOfView: false,
+    VRFrameData: false,
+    VRMockController: false,
+    VRMockDisplay: false,
+    VRPose: false,
+    VRServiceTest: false,
+    VRStageParameters: false,
+    VRSubmitFrameResult: false,
+    VTTCue: false,
+    VTTRegion: false,
+    ValidityState: false,
+    VideoPlaybackQuality: false,
+    VideoTrack: false,
+    VideoTrackList: false,
+    VisualViewport: false,
+    WaveShaperNode: false,
+    WebExtensionContentScript: false,
+    WebExtensionPolicy: false,
+    WebGL2RenderingContext: false,
+    WebGLActiveInfo: false,
+    WebGLBuffer: false,
+    WebGLContextEvent: false,
+    WebGLFramebuffer: false,
+    WebGLProgram: false,
+    WebGLQuery: false,
+    WebGLRenderbuffer: false,
+    WebGLRenderingContext: false,
+    WebGLSampler: false,
+    WebGLShader: false,
+    WebGLShaderPrecisionFormat: false,
+    WebGLSync: false,
+    WebGLTexture: false,
+    WebGLTransformFeedback: false,
+    WebGLUniformLocation: false,
+    WebGLVertexArrayObject: false,
+    WebGPU: false,
+    WebGPUAdapter: false,
+    WebGPUAttachmentState: false,
+    WebGPUBindGroup: false,
+    WebGPUBindGroupLayout: false,
+    WebGPUBindingType: false,
+    WebGPUBlendFactor: false,
+    WebGPUBlendOperation: false,
+    WebGPUBlendState: false,
+    WebGPUBuffer: false,
+    WebGPUBufferUsage: false,
+    WebGPUColorWriteBits: false,
+    WebGPUCommandBuffer: false,
+    WebGPUCommandEncoder: false,
+    WebGPUCompareFunction: false,
+    WebGPUComputePipeline: false,
+    WebGPUDepthStencilState: false,
+    WebGPUDevice: false,
+    WebGPUFence: false,
+    WebGPUFilterMode: false,
+    WebGPUIndexFormat: false,
+    WebGPUInputState: false,
+    WebGPUInputStepMode: false,
+    WebGPULoadOp: false,
+    WebGPULogEntry: false,
+    WebGPUPipelineLayout: false,
+    WebGPUPrimitiveTopology: false,
+    WebGPUQueue: false,
+    WebGPURenderPipeline: false,
+    WebGPUSampler: false,
+    WebGPUShaderModule: false,
+    WebGPUShaderStage: false,
+    WebGPUShaderStageBit: false,
+    WebGPUStencilOperation: false,
+    WebGPUStoreOp: false,
+    WebGPUSwapChain: false,
+    WebGPUTexture: false,
+    WebGPUTextureDimension: false,
+    WebGPUTextureFormat: false,
+    WebGPUTextureUsage: false,
+    WebGPUTextureView: false,
+    WebGPUVertexFormat: false,
+    WebKitCSSMatrix: false,
+    WebSocket: false,
+    WebrtcGlobalInformation: false,
+    WheelEvent: false,
+    Window: false,
+    WindowRoot: false,
+    Worker: false,
+    Worklet: false,
+    XMLDocument: false,
+    XMLHttpRequest: false,
+    XMLHttpRequestEventTarget: false,
+    XMLHttpRequestUpload: false,
+    XMLSerializer: false,
+    XPathEvaluator: false,
+    XPathExpression: false,
+    XPathResult: false,
+    XSLTProcessor: false,
+    XULCommandEvent: false,
+    XULDocument: false,
+    XULElement: false,
+    XULFrameElement: false,
+    XULMenuElement: false,
+    XULPopupElement: false,
+    XULScrollElement: false,
+    XULTextElement: false,
+    console: false,
+    mozRTCIceCandidate: false,
+    mozRTCPeerConnection: false,
+    mozRTCSessionDescription: false,
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/simpletest.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/environments/simpletest.js
@@ -49,12 +49,12 @@ function mapGlobals(fileGlobals) {
   var globalObjects = {};
   for (let global of fileGlobals) {
     globalObjects[global.name] = global.writable;
   }
   return globalObjects;
 }
 
 module.exports = {
-  globals: helpers.isMozillaCentralBased() ?
-    mapGlobals(getScriptGlobals()) :
-    helpers.getSavedEnvironmentItems("simpletest").globals,
+  globals: helpers.isMozillaCentralBased()
+    ? mapGlobals(getScriptGlobals())
+    : helpers.getSavedEnvironmentItems("simpletest").globals,
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/globals.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/globals.js
@@ -40,17 +40,17 @@ function parseBooleanConfig(string, comm
     let pos = name.indexOf(":");
     let value;
     if (pos !== -1) {
       value = name.substring(pos + 1, name.length);
       name = name.substring(0, pos);
     }
 
     items[name] = {
-      value: (value === "true"),
+      value: value === "true",
       comment,
     };
   });
 
   return items;
 }
 
 /**
@@ -130,27 +130,33 @@ GlobalsForNode.prototype = {
 
   ExpressionStatement(node, parents, globalScope) {
     let isGlobal = helpers.getIsGlobalScope(parents);
     let globals = [];
 
     // Note: We check the expression types here and only call the necessary
     // functions to aid performance.
     if (node.expression.type === "AssignmentExpression") {
-      globals = helpers.convertThisAssignmentExpressionToGlobals(node, isGlobal);
+      globals = helpers.convertThisAssignmentExpressionToGlobals(
+        node,
+        isGlobal
+      );
     } else if (node.expression.type === "CallExpression") {
       globals = helpers.convertCallExpressionToGlobals(node, isGlobal);
     }
 
     // Here we assume that if importScripts is set in the global scope, then
     // this is a worker. It would be nice if eslint gave us a way of getting
     // the environment directly.
     if (globalScope && globalScope.set.get("importScripts")) {
-      let workerDetails = helpers.convertWorkerExpressionToGlobals(node,
-        isGlobal, this.dirname);
+      let workerDetails = helpers.convertWorkerExpressionToGlobals(
+        node,
+        isGlobal,
+        this.dirname
+      );
       globals = globals.concat(workerDetails);
     }
 
     return globals;
   },
 };
 
 module.exports = {
@@ -260,29 +266,41 @@ module.exports = {
         continue;
       }
       let scriptName;
       if (script.src.includes("http:")) {
         // We don't handle this currently as the paths are complex to match.
       } else if (script.src.includes("chrome")) {
         // This is one way of referencing test files.
         script.src = script.src.replace("chrome://mochikit/content/", "/");
-        scriptName = path.join(helpers.rootDir, "testing", "mochitest", script.src);
+        scriptName = path.join(
+          helpers.rootDir,
+          "testing",
+          "mochitest",
+          script.src
+        );
       } else if (script.src.includes("SimpleTest")) {
         // This is another way of referencing test files...
-        scriptName = path.join(helpers.rootDir, "testing", "mochitest", script.src);
+        scriptName = path.join(
+          helpers.rootDir,
+          "testing",
+          "mochitest",
+          script.src
+        );
       } else {
         // Fallback to hoping this is a relative path.
         scriptName = path.join(dir, script.src);
       }
       if (scriptName && fs.existsSync(scriptName)) {
-        globals.push(...module.exports.getGlobalsForFile(scriptName, {
-          ecmaVersion: helpers.getECMAVersion(),
-          sourceType: script.type,
-        }));
+        globals.push(
+          ...module.exports.getGlobalsForFile(scriptName, {
+            ecmaVersion: helpers.getECMAVersion(),
+            sourceType: script.type,
+          })
+        );
       }
     }
 
     lastHTMLGlobals.filePath = filePath;
     return (lastHTMLGlobals.globals = globals);
   },
 
   /**
@@ -312,15 +330,19 @@ module.exports = {
 
     for (let type of Object.keys(GlobalsForNode.prototype)) {
       parser[type] = function(node) {
         if (type === "Program") {
           globalScope = context.getScope();
           helpers.addGlobals(extraHTMLGlobals, globalScope);
         }
         let globals = handler[type](node, context.getAncestors(), globalScope);
-        helpers.addGlobals(globals, globalScope, node.type !== "Program" && node);
+        helpers.addGlobals(
+          globals,
+          globalScope,
+          node.type !== "Program" && node
+        );
       };
     }
 
     return parser;
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/helpers.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/helpers.js
@@ -48,17 +48,23 @@ const imports = [
 ];
 
 const workerImportFilenameMatch = /(.*\/)*((.*?)\.jsm?)/;
 
 module.exports = {
   get modulesGlobalData() {
     if (!gModules) {
       if (this.isMozillaCentralBased()) {
-        gModules = require(path.join(this.rootDir, "tools", "lint", "eslint", "modules.json"));
+        gModules = require(path.join(
+          this.rootDir,
+          "tools",
+          "lint",
+          "eslint",
+          "modules.json"
+        ));
       } else {
         gModules = require("./modules.json");
       }
     }
 
     return gModules;
   },
 
@@ -73,17 +79,17 @@ module.exports = {
    *         the configuration from getPermissiveConfig().
    *
    * @return {Object}
    *         The resulting AST.
    */
   getAST(sourceText, astOptions = {}) {
     // Use a permissive config file to allow parsing of anything that Espree
     // can parse.
-    let config = {...this.getPermissiveConfig(), ...astOptions};
+    let config = { ...this.getPermissiveConfig(), ...astOptions };
 
     return espree.parse(sourceText, config);
   },
 
   /**
    * A simplistic conversion of some AST nodes to a standard string form.
    *
    * @param  {Object} node
@@ -92,20 +98,25 @@ module.exports = {
    * @return {String}
    *         The JS source for the node.
    */
   getASTSource(node, context) {
     switch (node.type) {
       case "MemberExpression":
         if (node.computed) {
           let filename = context && context.getFilename();
-          throw new Error(`getASTSource unsupported computed MemberExpression in ${filename}`);
+          throw new Error(
+            `getASTSource unsupported computed MemberExpression in ${filename}`
+          );
         }
-        return this.getASTSource(node.object) + "." +
-          this.getASTSource(node.property);
+        return (
+          this.getASTSource(node.object) +
+          "." +
+          this.getASTSource(node.property)
+        );
       case "ThisExpression":
         return "this";
       case "Identifier":
         return node.name;
       case "Literal":
         return JSON.stringify(node.value);
       case "CallExpression":
         var args = node.arguments.map(a => this.getASTSource(a)).join(", ");
@@ -116,20 +127,27 @@ module.exports = {
         return this.getASTSource(node.expression) + ";";
       case "FunctionExpression":
         return "function() {}";
       case "ArrayExpression":
         return "[" + node.elements.map(this.getASTSource, this).join(",") + "]";
       case "ArrowFunctionExpression":
         return "() => {}";
       case "AssignmentExpression":
-        return this.getASTSource(node.left) + " = " +
-          this.getASTSource(node.right);
+        return (
+          this.getASTSource(node.left) + " = " + this.getASTSource(node.right)
+        );
       case "BinaryExpression":
-        return this.getASTSource(node.left) + " " + node.operator + " " + this.getASTSource(node.right);
+        return (
+          this.getASTSource(node.left) +
+          " " +
+          node.operator +
+          " " +
+          this.getASTSource(node.right)
+        );
       default:
         throw new Error("getASTSource unsupported node type: " + node.type);
     }
   },
 
   /**
    * This walks an AST in a manner similar to ESLint passing node events to the
    * listener. The listener is expected to be a simple function
@@ -182,33 +200,37 @@ module.exports = {
   convertWorkerExpressionToGlobals(node, isGlobal, dirname) {
     var getGlobalsForFile = require("./globals").getGlobalsForFile;
 
     let globalModules = this.modulesGlobalData;
 
     let results = [];
     let expr = node.expression;
 
-    if (node.expression.type === "CallExpression" &&
-        expr.callee &&
-        expr.callee.type === "Identifier" &&
-        expr.callee.name === "importScripts") {
+    if (
+      node.expression.type === "CallExpression" &&
+      expr.callee &&
+      expr.callee.type === "Identifier" &&
+      expr.callee.name === "importScripts"
+    ) {
       for (var arg of expr.arguments) {
         var match = arg.value && arg.value.match(workerImportFilenameMatch);
         if (match) {
           if (!match[1]) {
             let filePath = path.resolve(dirname, match[2]);
             if (fs.existsSync(filePath)) {
               let additionalGlobals = getGlobalsForFile(filePath);
               results = results.concat(additionalGlobals);
             }
           } else if (match[2] in globalModules) {
-            results = results.concat(globalModules[match[2]].map(name => {
-              return { name, writable: true };
-            }));
+            results = results.concat(
+              globalModules[match[2]].map(name => {
+                return { name, writable: true };
+              })
+            );
           } else {
             results.push({ name: match[3], writable: true, explicit: true });
           }
         }
       }
     }
 
     return results;
@@ -226,22 +248,24 @@ module.exports = {
    * @return {Array}
    *         An array of objects that contain details about the globals:
    *         - {String} name
    *                    The name of the global.
    *         - {Boolean} writable
    *                     If the global is writeable or not.
    */
   convertThisAssignmentExpressionToGlobals(node, isGlobal) {
-    if (isGlobal &&
-        node.expression.left &&
-        node.expression.left.object &&
-        node.expression.left.object.type === "ThisExpression" &&
-        node.expression.left.property &&
-        node.expression.left.property.type === "Identifier") {
+    if (
+      isGlobal &&
+      node.expression.left &&
+      node.expression.left.object &&
+      node.expression.left.object.type === "ThisExpression" &&
+      node.expression.left.property &&
+      node.expression.left.property.type === "Identifier"
+    ) {
       return [{ name: node.expression.left.property.name, writable: true }];
     }
     return [];
   },
 
   /**
    * Attempts to convert an CallExpressions that look like module imports
    * into global variable definitions, using modules.json data if appropriate.
@@ -255,24 +279,26 @@ module.exports = {
    *         An array of objects that contain details about the globals:
    *         - {String} name
    *                    The name of the global.
    *         - {Boolean} writable
    *                     If the global is writeable or not.
    */
   convertCallExpressionToGlobals(node, isGlobal) {
     let express = node.expression;
-    if (express.type === "CallExpression" &&
-        express.callee.type === "MemberExpression" &&
-        express.callee.object &&
-        express.callee.object.type === "Identifier" &&
-        express.arguments.length === 1 &&
-        express.arguments[0].type === "ArrayExpression" &&
-        express.callee.property.type === "Identifier" &&
-        express.callee.property.name === "importGlobalProperties") {
+    if (
+      express.type === "CallExpression" &&
+      express.callee.type === "MemberExpression" &&
+      express.callee.object &&
+      express.callee.object.type === "Identifier" &&
+      express.arguments.length === 1 &&
+      express.arguments[0].type === "ArrayExpression" &&
+      express.callee.property.type === "Identifier" &&
+      express.callee.property.name === "importGlobalProperties"
+    ) {
       return express.arguments[0].elements.map(literal => {
         return {
           explicit: true,
           name: literal.value,
           writable: false,
         };
       });
     }
@@ -296,17 +322,19 @@ module.exports = {
 
         if (match[1] in globalModules) {
           // XXX We mark as explicit when there is only one exported symbol from
           // the module. For now this avoids no-unused-vars complaining in the
           // cases where we import everything from a module but only use one
           // of them.
           let explicit = globalModules[match[1]].length == 1;
           return globalModules[match[1]].map(name => ({
-            name, writable: true, explicit,
+            name,
+            writable: true,
+            explicit,
           }));
         }
 
         return [{ name: match[2], writable: true, explicit: true }];
       }
     }
 
     // The definition matches below must be in the global scope for us to define
@@ -317,37 +345,53 @@ module.exports = {
 
     for (let reg of callExpressionDefinitions) {
       let match = source.match(reg);
       if (match) {
         return [{ name: match[1], writable: true, explicit: true }];
       }
     }
 
-    if (callExpressionMultiDefinitions.some(expr => source.startsWith(expr)) &&
-        node.expression.arguments[1]) {
+    if (
+      callExpressionMultiDefinitions.some(expr => source.startsWith(expr)) &&
+      node.expression.arguments[1]
+    ) {
       let arg = node.expression.arguments[1];
       if (arg.type === "ObjectExpression") {
         return arg.properties
-                  .map(p => ({ name: p.type === "Property" && p.key.name, writable: true, explicit: true }))
-                  .filter(g => g.name);
+          .map(p => ({
+            name: p.type === "Property" && p.key.name,
+            writable: true,
+            explicit: true,
+          }))
+          .filter(g => g.name);
       }
       if (arg.type === "ArrayExpression") {
         return arg.elements
-                  .map(p => ({ name: p.type === "Literal" && p.value, writable: true, explicit: true }))
-                  .filter(g => typeof g.name == "string");
+          .map(p => ({
+            name: p.type === "Literal" && p.value,
+            writable: true,
+            explicit: true,
+          }))
+          .filter(g => typeof g.name == "string");
       }
     }
 
-    if (node.expression.callee.type == "MemberExpression" &&
-        node.expression.callee.property.type == "Identifier" &&
-        node.expression.callee.property.name == "defineLazyScriptGetter") {
+    if (
+      node.expression.callee.type == "MemberExpression" &&
+      node.expression.callee.property.type == "Identifier" &&
+      node.expression.callee.property.name == "defineLazyScriptGetter"
+    ) {
       // The case where we have a single symbol as a string has already been
       // handled by the regexp, so we have an array of symbols here.
-      return node.expression.arguments[1].elements.map(n => ({ name: n.value, writable: true, explicit: true }));
+      return node.expression.arguments[1].elements.map(n => ({
+        name: n.value,
+        writable: true,
+        explicit: true,
+      }));
     }
 
     return [];
   },
 
   /**
    * Add a variable to the current scope.
    * HACK: This relies on eslint internals so it could break at any time.
@@ -363,17 +407,17 @@ module.exports = {
    */
   addVarToScope(name, scope, writable, node) {
     scope.__defineGeneric(name, scope.set, scope.variables, null, null);
 
     let variable = scope.set.get(name);
     variable.eslintExplicitGlobal = false;
     variable.writeable = writable;
     if (node) {
-      variable.defs.push({node, name: {name}});
+      variable.defs.push({ node, name: { name } });
       variable.identifiers.push(node);
     }
 
     // Walk to the global scope which holds all undeclared variables.
     while (scope.type != "global") {
       scope = scope.upper;
     }
 
@@ -397,17 +441,19 @@ module.exports = {
    * @param {Array} globalVars
    *        An array of global variable names.
    * @param {ASTScope} scope
    *        The scope.
    * @param {Object} [node]
    *        The AST node that defined the globals.
    */
   addGlobals(globalVars, scope, node) {
-    globalVars.forEach(v => this.addVarToScope(v.name, scope, v.writable, v.explicit && node));
+    globalVars.forEach(v =>
+      this.addVarToScope(v.name, scope, v.writable, v.explicit && node)
+    );
   },
 
   /**
    * To allow espree to parse almost any JavaScript we need as many features as
    * possible turned on. This method returns that config.
    *
    * @return {Object}
    *         Espree compatible permissive config.
@@ -498,21 +544,24 @@ module.exports = {
   getTestHeadFiles(scope) {
     if (!this.getIsTest(scope)) {
       return [];
     }
 
     let filepath = this.cleanUpPath(scope.getFilename());
     let dir = path.dirname(filepath);
 
-    let names =
-      fs.readdirSync(dir)
-        .filter(name => (name.startsWith("head") ||
-                         name.startsWith("xpcshell-head")) && name.endsWith(".js"))
-        .map(name => path.join(dir, name));
+    let names = fs
+      .readdirSync(dir)
+      .filter(
+        name =>
+          (name.startsWith("head") || name.startsWith("xpcshell-head")) &&
+          name.endsWith(".js")
+      )
+      .map(name => path.join(dir, name));
     return names;
   },
 
   /**
    * Gets all the test manifest data for a directory
    *
    * @param  {String} dir
    *         The directory
@@ -543,18 +592,17 @@ module.exports = {
 
       try {
         let manifest = ini.parse(fs.readFileSync(path.join(dir, name), "utf8"));
 
         manifests.push({
           file: path.join(dir, name),
           manifest,
         });
-      } catch (e) {
-      }
+      } catch (e) {}
     }
 
     directoryManifests.set(dir, manifests);
     return manifests;
   },
 
   /**
    * Gets the manifest file a test is listed in
@@ -668,17 +716,20 @@ module.exports = {
           }
           // Move up a level
           dirName = parsed.dir;
           parsed = path.parse(dirName);
         }
         return null;
       }
 
-      let possibleRoot = searchUpForIgnore(path.dirname(module.filename), ".eslintignore");
+      let possibleRoot = searchUpForIgnore(
+        path.dirname(module.filename),
+        ".eslintignore"
+      );
       if (!possibleRoot) {
         possibleRoot = searchUpForIgnore(path.resolve(), ".eslintignore");
       }
       if (!possibleRoot) {
         possibleRoot = searchUpForIgnore(path.resolve(), "package.json");
       }
       if (!possibleRoot) {
         // We've couldn't find a root from the module or CWD, so lets just go
@@ -712,43 +763,51 @@ module.exports = {
       //   fileName: /path/to/mozilla/repo/a/b/c/d.js
       //   cwd: /path/to/mozilla/repo
       return fileName;
     } else if (path.basename(fileName) == fileName) {
       // Case 1b: executed from a nested directory, fileName is the base name
       // without any path info (happens in Atom with linter-eslint)
       return path.join(cwd, fileName);
     }
-      // Case 1: executed form in a nested directory, e.g. from a text editor:
-      //   fileName: a/b/c/d.js
-      //   cwd: /path/to/mozilla/repo/a/b/c
+    // Case 1: executed form in a nested directory, e.g. from a text editor:
+    //   fileName: a/b/c/d.js
+    //   cwd: /path/to/mozilla/repo/a/b/c
     var dirName = path.dirname(fileName);
     return cwd.slice(0, cwd.length - dirName.length) + fileName;
   },
 
   /**
    * When ESLint is run from SublimeText, paths retrieved from
    * context.getFileName contain leading and trailing double-quote characters.
    * These characters need to be removed.
    */
   cleanUpPath(pathName) {
     return pathName.replace(/^"/, "").replace(/"$/, "");
   },
 
   get globalScriptPaths() {
     return [
       path.join(this.rootDir, "browser", "base", "content", "browser.xhtml"),
-      path.join(this.rootDir, "browser", "base", "content", "global-scripts.inc"),
+      path.join(
+        this.rootDir,
+        "browser",
+        "base",
+        "content",
+        "global-scripts.inc"
+      ),
     ];
   },
 
   isMozillaCentralBased() {
     return fs.existsSync(this.globalScriptPaths[0]);
   },
 
   getSavedEnvironmentItems(environment) {
-    return require("./environments/saved-globals.json").environments[environment];
+    return require("./environments/saved-globals.json").environments[
+      environment
+    ];
   },
 
   getSavedRuleData(rule) {
     return require("./rules/saved-rules-data.json").rulesData[rule];
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/index.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/index.js
@@ -11,62 +11,56 @@
 // ------------------------------------------------------------------------------
 // Plugin Definition
 // ------------------------------------------------------------------------------
 module.exports = {
   configs: {
     "browser-test": require("../lib/configs/browser-test"),
     "chrome-test": require("../lib/configs/chrome-test"),
     "mochitest-test": require("../lib/configs/mochitest-test"),
-    "recommended": require("../lib/configs/recommended"),
+    recommended: require("../lib/configs/recommended"),
     "xpcshell-test": require("../lib/configs/xpcshell-test"),
   },
   environments: {
     "browser-window": require("../lib/environments/browser-window.js"),
     "chrome-worker": require("../lib/environments/chrome-worker.js"),
     "frame-script": require("../lib/environments/frame-script.js"),
-    "jsm": require("../lib/environments/jsm.js"),
-    "simpletest": require("../lib/environments/simpletest.js"),
-    "privileged": require("../lib/environments/privileged.js"),
+    jsm: require("../lib/environments/jsm.js"),
+    simpletest: require("../lib/environments/simpletest.js"),
+    privileged: require("../lib/environments/privileged.js"),
   },
   processors: {
     ".xml": require("../lib/processors/xbl-bindings"),
     ".xul": require("../lib/processors/xul"),
   },
   rules: {
     "avoid-Date-timing": require("../lib/rules/avoid-Date-timing"),
     "avoid-removeChild": require("../lib/rules/avoid-removeChild"),
     "balanced-listeners": require("../lib/rules/balanced-listeners"),
     "consistent-if-bracing": require("../lib/rules/consistent-if-bracing"),
-    "import-browser-window-globals":
-      require("../lib/rules/import-browser-window-globals"),
-    "import-content-task-globals":
-      require("../lib/rules/import-content-task-globals"),
+    "import-browser-window-globals": require("../lib/rules/import-browser-window-globals"),
+    "import-content-task-globals": require("../lib/rules/import-content-task-globals"),
     "import-globals": require("../lib/rules/import-globals"),
     "import-headjs-globals": require("../lib/rules/import-headjs-globals"),
     "mark-exported-symbols-as-used": require("../lib/rules/mark-exported-symbols-as-used"),
     "mark-test-function-used": require("../lib/rules/mark-test-function-used"),
     "no-aArgs": require("../lib/rules/no-aArgs"),
     "no-arbitrary-setTimeout": require("../lib/rules/no-arbitrary-setTimeout"),
     "no-compare-against-boolean-literals": require("../lib/rules/no-compare-against-boolean-literals"),
     "no-define-cc-etc": require("../lib/rules/no-define-cc-etc"),
     "no-task": require("../lib/rules/no-task"),
     "no-useless-parameters": require("../lib/rules/no-useless-parameters"),
-    "no-useless-removeEventListener":
-      require("../lib/rules/no-useless-removeEventListener"),
-    "no-useless-run-test":
-      require("../lib/rules/no-useless-run-test"),
-    "reject-importGlobalProperties":
-      require("../lib/rules/reject-importGlobalProperties"),
+    "no-useless-removeEventListener": require("../lib/rules/no-useless-removeEventListener"),
+    "no-useless-run-test": require("../lib/rules/no-useless-run-test"),
+    "reject-importGlobalProperties": require("../lib/rules/reject-importGlobalProperties"),
     "reject-some-requires": require("../lib/rules/reject-some-requires"),
     "rejects-requires-await": require("../lib/rules/rejects-requires-await"),
     "use-cc-etc": require("../lib/rules/use-cc-etc"),
     "use-chromeutils-generateqi": require("../lib/rules/use-chromeutils-generateqi"),
     "use-chromeutils-import": require("../lib/rules/use-chromeutils-import"),
-    "use-default-preference-values":
-      require("../lib/rules/use-default-preference-values"),
+    "use-default-preference-values": require("../lib/rules/use-default-preference-values"),
     "use-ownerGlobal": require("../lib/rules/use-ownerGlobal"),
     "use-includes-instead-of-indexOf": require("../lib/rules/use-includes-instead-of-indexOf"),
     "use-returnValue": require("../lib/rules/use-returnValue"),
     "use-services": require("../lib/rules/use-services"),
     "var-only-at-top-level": require("../lib/rules/var-only-at-top-level"),
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xbl-bindings.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xbl-bindings.js
@@ -56,18 +56,21 @@ function addNodeLines(node, reindent) {
   // the CDATA block.
   let lastIndent = 0;
   if (lines.length && lines[lines.length - 1].trim() == "") {
     lastIndent = lines[lines.length - 1].length;
   }
 
   // If the second to last line is also blank and has a higher indent than the
   // last one, then the CDATA block doesn't close with the closing tag.
-  if (lines.length > 2 && lines[lines.length - 2].trim() == "" &&
-      lines[lines.length - 2].length > lastIndent) {
+  if (
+    lines.length > 2 &&
+    lines[lines.length - 2].trim() == "" &&
+    lines[lines.length - 2].length > lastIndent
+  ) {
     lastIndent = lines[lines.length - 2].length;
   }
 
   // Strip off any whitespace lines at the end. These are often used to line
   // up the closing tags
   while (lines.length && lines[lines.length - 1].trim() == "") {
     lines.pop();
   }
@@ -77,18 +80,19 @@ function addNodeLines(node, reindent) {
     // ESLint counts columns starting at 1 rather than 0
     lineMap[scriptLines.length] = { line: startLine, offset: startColumn - 1 };
     scriptLines.push(firstLine);
     startLine++;
   }
 
   // Find the preceding whitespace for all lines that aren't entirely
   // whitespace.
-  let indents = lines.filter(s => s.trim().length > 0)
-                     .map(s => s.length - s.trimLeft().length);
+  let indents = lines
+    .filter(s => s.trim().length > 0)
+    .map(s => s.length - s.trimLeft().length);
   // Find the smallest indent level in use
   let minIndent = Math.min.apply(null, indents);
   let indent = Math.max(2, minIndent - lastIndent);
 
   for (let line of lines) {
     if (line.trim().length == 0) {
       // Don't offset lines that are only whitespace, the only possible JS error
       // is trailing whitespace and we want it to point at the right place
@@ -167,17 +171,20 @@ module.exports = {
             case "field": {
               // Fields are something like lazy getter functions
 
               // Ignore empty fields
               if (item.textContent.trim().length == 0) {
                 continue;
               }
 
-              addSyntheticLine(`get ${item.attributes.name}() {`, item.textLine);
+              addSyntheticLine(
+                `get ${item.attributes.name}() {`,
+                item.textLine
+              );
               addSyntheticLine(`return (`, item.textLine);
 
               // Remove trailing semicolons, as we are adding our own
               item.textContent = item.textContent.replace(/;(?=\s*$)/, "");
               addNodeLines(item, 5);
 
               addSyntheticLine(`);`, item.textLine);
               addSyntheticLine(`},`, item.textEndLine);
@@ -190,41 +197,51 @@ module.exports = {
               addNodeLines(item, 4);
               addSyntheticLine(`},`, item.textEndLine);
               break;
             }
             case "method": {
               // Methods become function declarations with the appropriate
               // params.
 
-              let params = item.children.filter(n => {
-                return n.local == "parameter" && n.namespace == NS_XBL;
-              })
-                                        .map(n => n.attributes.name)
-                                        .join(", ");
+              let params = item.children
+                .filter(n => {
+                  return n.local == "parameter" && n.namespace == NS_XBL;
+                })
+                .map(n => n.attributes.name)
+                .join(", ");
               let body = item.children.filter(n => {
                 return n.local == "body" && n.namespace == NS_XBL;
               })[0];
 
-              addSyntheticLine(`${item.attributes.name}(${params}) {`, item.textLine);
+              addSyntheticLine(
+                `${item.attributes.name}(${params}) {`,
+                item.textLine
+              );
               addNodeLines(body, 4);
               addSyntheticLine(`},`, item.textEndLine);
               break;
             }
             case "property": {
               // Properties become one or two function declarations
               for (let propdef of item.children) {
                 if (propdef.namespace != NS_XBL) {
                   continue;
                 }
 
                 if (propdef.local == "setter") {
-                  addSyntheticLine(`set ${item.attributes.name}(val) {`, propdef.textLine);
+                  addSyntheticLine(
+                    `set ${item.attributes.name}(val) {`,
+                    propdef.textLine
+                  );
                 } else if (propdef.local == "getter") {
-                  addSyntheticLine(`get ${item.attributes.name}() {`, propdef.textLine);
+                  addSyntheticLine(
+                    `get ${item.attributes.name}() {`,
+                    propdef.textLine
+                  );
                 } else {
                   continue;
                 }
                 addNodeLines(propdef, 4);
                 addSyntheticLine(`},`, propdef.textEndLine);
               }
               break;
             }
@@ -236,17 +253,20 @@ module.exports = {
               addSyntheticLine(`},`, item.textEndLine);
               break;
             }
             default:
               continue;
           }
         }
 
-        addSyntheticLine((part.local == "implementation" ? `},` : `],`), part.textEndLine);
+        addSyntheticLine(
+          part.local == "implementation" ? `},` : `],`,
+          part.textEndLine
+        );
       }
       addSyntheticLine(`},`, binding.textEndLine);
     }
     addSyntheticLine(`};`, bindings.textEndLine);
 
     let script = scriptLines.join("\n") + "\n";
     return [script];
   },
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xul.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/processors/xul.js
@@ -46,18 +46,22 @@ function dealWithIfdefs(text, filename) 
     let outputLines = [];
     let inSkippingIfdef = [false];
     for (let i = 0; i < input.length; i++) {
       let line = input[i];
       let shouldSkip = inSkippingIfdef.some(x => x);
       if (!line.startsWith("#")) {
         outputLines.push(shouldSkip ? "" : line);
       } else {
-        if (line.startsWith("# ") || line.startsWith("#filter") ||
-            line == "#" || line.startsWith("#define")) {
+        if (
+          line.startsWith("# ") ||
+          line.startsWith("#filter") ||
+          line == "#" ||
+          line.startsWith("#define")
+        ) {
           outputLines.push("");
           continue;
         }
         // if this isn't just a comment (which we skip), figure out what to do:
         let term = "";
         let negate = false;
         if (line.startsWith("#ifdef")) {
           term = line.match(/^#ifdef *([A-Z_]+)/);
@@ -81,17 +85,17 @@ function dealWithIfdefs(text, filename) 
         } else if (line.startsWith("#expand")) {
           // Just strip expansion instructions
           outputLines.push(line.substring("#expand ".length));
         } else if (line.startsWith("#include")) {
           // Uh oh.
           if (!shouldSkip) {
             let fileToInclude = line.substr("#include ".length).trim();
             let subpath = path.join(path.dirname(innerFile), fileToInclude);
-            let contents = fs.readFileSync(subpath, {encoding: "utf-8"});
+            let contents = fs.readFileSync(subpath, { encoding: "utf-8" });
             contents = contents.split(/\n/);
             // Recurse:
             contents = stripIfdefsFromLines(contents, subpath);
             if (innerFile == filename) {
               includedRanges.push({
                 start: i,
                 end: i + contents.length,
                 filename: subpath,
@@ -183,17 +187,17 @@ module.exports = {
     // scripts and get globals from them (though ideally we should do that at some point).
     scriptLines = [
       "/* eslint-disable indent */",
       "/* eslint-disable indent-legacy */",
       "/* eslint-disable semi */",
       "/* eslint-disable quotes */",
       "/* eslint-disable no-undef */",
     ];
-    lineMap = scriptLines.map(() => ({line: 0}));
+    lineMap = scriptLines.map(() => ({ line: 0 }));
     includedRanges = [];
     // Do C-style preprocessing first:
     text = dealWithIfdefs(text, filename);
 
     let xp = new XMLParser(text);
     if (xp.lastError) {
       xmlParseError = xp.lastError;
     }
@@ -220,34 +224,38 @@ module.exports = {
     // correct place.
     let errors = [];
     for (let i = 0; i < messages.length; i++) {
       for (let message of messages[i]) {
         // ESLint indexes lines starting at 1 but our arrays start at 0
         let mapped = lineMap[message.line - 1];
         // Ensure we don't modify this by making a copy. We might need it for another failure.
         let target = mapped.line;
-        let includedRange = includedRanges.find(r => (target >= r.start && target <= r.end));
+        let includedRange = includedRanges.find(
+          r => target >= r.start && target <= r.end
+        );
         // If this came from an #included file, indicate this in the message
         if (includedRange) {
           target = includedRange.start;
-          message.message += " (from included file " + path.basename(includedRange.filename) + ")";
+          message.message +=
+            " (from included file " +
+            path.basename(includedRange.filename) +
+            ")";
         }
         // Compensate for line numbers shifting as a result of #include:
-        let includeBallooning =
-          includedRanges.filter(r => (target >= r.end))
-                        .map(r => r.end - r.start)
-                        .reduce((acc, next) => acc + next, 0);
+        let includeBallooning = includedRanges
+          .filter(r => target >= r.end)
+          .map(r => r.end - r.start)
+          .reduce((acc, next) => acc + next, 0);
         target -= includeBallooning;
         // Add back the 1 to go back to 1-indexing.
         message.line = target + 1;
 
         // We never have column information, unfortunately.
         message.column = NaN;
 
         errors.push(message);
       }
     }
 
     return errors;
   },
 };
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-Date-timing.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-Date-timing.js
@@ -22,37 +22,46 @@ module.exports = {
   },
 
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   create(context) {
     return {
-      "CallExpression": function(node) {
+      CallExpression(node) {
         let callee = node.callee;
-        if (callee.type !== "MemberExpression" ||
-            callee.object.type !== "Identifier" ||
-            callee.object.name !== "Date" ||
-            callee.property.type !== "Identifier" ||
-            callee.property.name !== "now") {
+        if (
+          callee.type !== "MemberExpression" ||
+          callee.object.type !== "Identifier" ||
+          callee.object.name !== "Date" ||
+          callee.property.type !== "Identifier" ||
+          callee.property.name !== "now"
+        ) {
           return;
         }
 
-        context.report(node, "use performance.now() instead of Date.now() for timing " +
-                             "measurements");
+        context.report(
+          node,
+          "use performance.now() instead of Date.now() for timing " +
+            "measurements"
+        );
       },
 
-      "NewExpression": function(node) {
+      NewExpression(node) {
         let callee = node.callee;
-        if (callee.type !== "Identifier" ||
-            callee.name !== "Date" ||
-            node.arguments.length > 0) {
+        if (
+          callee.type !== "Identifier" ||
+          callee.name !== "Date" ||
+          node.arguments.length > 0
+        ) {
           return;
         }
 
-        context.report(node, "use performance.now() instead of new Date() for timing " +
-                             "measurements");
+        context.report(
+          node,
+          "use performance.now() instead of new Date() for timing " +
+            "measurements"
+        );
       },
     };
   },
 };
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-removeChild.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/avoid-removeChild.js
@@ -16,37 +16,49 @@
 var helpers = require("../helpers");
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "CallExpression": function(node) {
+    CallExpression(node) {
       let callee = node.callee;
-      if (callee.type !== "MemberExpression" ||
-          callee.property.type !== "Identifier" ||
-          callee.property.name != "removeChild" ||
-          node.arguments.length != 1) {
+      if (
+        callee.type !== "MemberExpression" ||
+        callee.property.type !== "Identifier" ||
+        callee.property.name != "removeChild" ||
+        node.arguments.length != 1
+      ) {
         return;
       }
 
-      if (callee.object.type == "MemberExpression" &&
-          callee.object.property.type == "Identifier" &&
-          callee.object.property.name == "parentNode" &&
-          helpers.getASTSource(callee.object.object, context) ==
-            helpers.getASTSource(node.arguments[0])) {
-        context.report(node, "use element.remove() instead of " +
-                             "element.parentNode.removeChild(element)");
+      if (
+        callee.object.type == "MemberExpression" &&
+        callee.object.property.type == "Identifier" &&
+        callee.object.property.name == "parentNode" &&
+        helpers.getASTSource(callee.object.object, context) ==
+          helpers.getASTSource(node.arguments[0])
+      ) {
+        context.report(
+          node,
+          "use element.remove() instead of " +
+            "element.parentNode.removeChild(element)"
+        );
       }
 
-      if (node.arguments[0].type == "MemberExpression" &&
-          node.arguments[0].property.type == "Identifier" &&
-          node.arguments[0].property.name == "firstChild" &&
-          helpers.getASTSource(callee.object, context) ==
-            helpers.getASTSource(node.arguments[0].object)) {
-        context.report(node, "use element.firstChild.remove() instead of " +
-                             "element.removeChild(element.firstChild)");
+      if (
+        node.arguments[0].type == "MemberExpression" &&
+        node.arguments[0].property.type == "Identifier" &&
+        node.arguments[0].property.name == "firstChild" &&
+        helpers.getASTSource(callee.object, context) ==
+          helpers.getASTSource(node.arguments[0].object)
+      ) {
+        context.report(
+          node,
+          "use element.firstChild.remove() instead of " +
+            "element.removeChild(element.firstChild)"
+        );
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/balanced-listeners.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/balanced-listeners.js
@@ -17,41 +17,45 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Helpers
   // ---------------------------------------------------------------------------
 
   var DICTIONARY = {
-    "addEventListener": "removeEventListener",
-    "on": "off",
+    addEventListener: "removeEventListener",
+    on: "off",
   };
   // Invert this dictionary to make it easy later.
   var INVERTED_DICTIONARY = {};
   for (var i in DICTIONARY) {
     INVERTED_DICTIONARY[DICTIONARY[i]] = i;
   }
 
   // Collect the add/remove listeners in these 2 arrays.
   var addedListeners = [];
   var removedListeners = [];
 
   function addAddedListener(node) {
     var capture = false;
     let options = node.arguments[2];
     if (options) {
       if (options.type == "ObjectExpression") {
-        if (options.properties.some(p => p.key.name == "once" &&
-                                         p.value.value === true)) {
+        if (
+          options.properties.some(
+            p => p.key.name == "once" && p.value.value === true
+          )
+        ) {
           // No point in adding listeners using the 'once' option.
           return;
         }
-        capture = options.properties.some(p => p.key.name == "capture" &&
-                                               p.value.value === true);
+        capture = options.properties.some(
+          p => p.key.name == "capture" && p.value.value === true
+        );
       } else {
         capture = options.value;
       }
     }
     addedListeners.push({
       functionName: node.callee.property.name,
       type: node.arguments[0].value,
       node: node.callee.property,
@@ -59,18 +63,19 @@ module.exports = function(context) {
     });
   }
 
   function addRemovedListener(node) {
     var capture = false;
     let options = node.arguments[2];
     if (options) {
       if (options.type == "ObjectExpression") {
-        capture = options.properties.some(p => p.key.name == "capture" &&
-                                               p.value.value === true);
+        capture = options.properties.some(
+          p => p.key.name == "capture" && p.value.value === true
+        );
       } else {
         capture = options.value;
       }
     }
     removedListeners.push({
       functionName: node.callee.property.name,
       type: node.arguments[0].value,
       useCapture: capture,
@@ -88,19 +93,21 @@ module.exports = function(context) {
     addedListeners = removedListeners = [];
 
     return unbalanced;
   }
 
   function hasRemovedListener(addedListener) {
     for (var k = 0; k < removedListeners.length; k++) {
       var listener = removedListeners[k];
-      if (DICTIONARY[addedListener.functionName] === listener.functionName &&
-          addedListener.type === listener.type &&
-          addedListener.useCapture === listener.useCapture) {
+      if (
+        DICTIONARY[addedListener.functionName] === listener.functionName &&
+        addedListener.type === listener.type &&
+        addedListener.useCapture === listener.useCapture
+      ) {
         return true;
       }
     }
 
     return false;
   }
 
   // ---------------------------------------------------------------------------
@@ -121,18 +128,20 @@ module.exports = function(context) {
         } else if (INVERTED_DICTIONARY.hasOwnProperty(listenerMethodName)) {
           addRemovedListener(node);
         }
       }
     },
 
     "Program:exit": function() {
       getUnbalancedListeners().forEach(function(listener) {
-        context.report(listener.node,
+        context.report(
+          listener.node,
           "No corresponding '{{functionName}}({{type}})' was found.",
           {
             functionName: DICTIONARY[listener.functionName],
             type: listener.type,
-          });
+          }
+        );
       });
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/consistent-if-bracing.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/consistent-if-bracing.js
@@ -15,20 +15,27 @@ module.exports = {
     },
   },
 
   create(context) {
     return {
       IfStatement(node) {
         if (node.parent.type !== "IfStatement") {
           let types = new Set();
-          for (let currentNode = node; currentNode; currentNode = currentNode.alternate) {
+          for (
+            let currentNode = node;
+            currentNode;
+            currentNode = currentNode.alternate
+          ) {
             let type = currentNode.consequent.type;
             types.add(type == "BlockStatement" ? "Block" : "NotBlock");
-            if (currentNode.alternate && currentNode.alternate.type !== "IfStatement") {
+            if (
+              currentNode.alternate &&
+              currentNode.alternate.type !== "IfStatement"
+            ) {
               type = currentNode.alternate.type;
               types.add(type == "BlockStatement" ? "Block" : "NotBlock");
               break;
             }
           }
           if (types.size > 1) {
             context.report({
               node,
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-browser-window-globals.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-browser-window-globals.js
@@ -27,18 +27,23 @@ module.exports = function(context) {
       let filePath = helpers.getAbsoluteFilePath(context);
       let relativePath = path.relative(helpers.rootDir, filePath);
       // We need to translate the path on Windows, due to the change
       // from \ to /, and browserjsScripts assumes Posix.
       if (path.win32) {
         relativePath = relativePath.split(path.sep).join("/");
       }
 
-      if (browserWindowEnv.browserjsScripts &&
-          browserWindowEnv.browserjsScripts.includes(relativePath)) {
+      if (
+        browserWindowEnv.browserjsScripts &&
+        browserWindowEnv.browserjsScripts.includes(relativePath)
+      ) {
         for (let global in browserWindowEnv.globals) {
-          helpers.addVarToScope(global, context.getScope(),
-                                browserWindowEnv.globals[global]);
+          helpers.addVarToScope(
+            global,
+            context.getScope(),
+            browserWindowEnv.globals[global]
+          );
         }
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-content-task-globals.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/import-content-task-globals.js
@@ -20,16 +20,21 @@ var helpers = require("../helpers");
 var frameScriptEnv = require("../environments/frame-script");
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   // ---------------------------------------------------------------------------
 
   return {
-    "CallExpression[callee.object.name='ContentTask'][callee.property.name='spawn']": function(node) {
+    "CallExpression[callee.object.name='ContentTask'][callee.property.name='spawn']": function(
+      node
+    ) {
       for (let global in frameScriptEnv.globals) {
-        helpers.addVarToScope(global, context.getScope(),
-                              frameScriptEnv.globals[global]);
+        helpers.addVarToScope(
+          global,
+          context.getScope(),
+          frameScriptEnv.globals[global]
+        );
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/mark-exported-symbols-as-used.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/mark-exported-symbols-as-used.js
@@ -38,40 +38,45 @@ module.exports = function(context) {
   }
 
   // ---------------------------------------------------------------------------
   // Public
   // ---------------------------------------------------------------------------
 
   return {
     AssignmentExpression(node, parents) {
-      if (node.operator === "=" &&
-          node.left.type === "MemberExpression" &&
-          node.left.object.type === "ThisExpression" &&
-          node.left.property.name === "EXPORTED_SYMBOLS" &&
-          isGlobalScope()) {
+      if (
+        node.operator === "=" &&
+        node.left.type === "MemberExpression" &&
+        node.left.object.type === "ThisExpression" &&
+        node.left.property.name === "EXPORTED_SYMBOLS" &&
+        isGlobalScope()
+      ) {
         markArrayElementsAsUsed(context, node, node.right);
       }
     },
 
     VariableDeclaration(node, parents) {
       if (!isGlobalScope()) {
         return;
       }
 
       for (let item of node.declarations) {
-        if (item.id &&
-            item.id.type == "Identifier" &&
-            item.id.name === "EXPORTED_SYMBOLS") {
+        if (
+          item.id &&
+          item.id.type == "Identifier" &&
+          item.id.name === "EXPORTED_SYMBOLS"
+        ) {
           if (node.kind === "let") {
             // The use of 'let' isn't allowed as the lexical scope may die after
             // the script executes.
             context.report({
               node,
-              message: "EXPORTED_SYMBOLS cannot be declared via `let`. Use `var` or `this.EXPORTED_SYMBOLS =`",
+              message:
+                "EXPORTED_SYMBOLS cannot be declared via `let`. Use `var` or `this.EXPORTED_SYMBOLS =`",
             });
           }
 
           markArrayElementsAsUsed(context, node, item.init);
         }
       }
     },
   };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-aArgs.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-aArgs.js
@@ -18,38 +18,39 @@ module.exports = function(context) {
   // Helpers
   // ---------------------------------------------------------------------------
 
   function isPrefixed(name) {
     return name.length >= 2 && /^a[A-Z]/.test(name);
   }
 
   function deHungarianize(name) {
-    return name.substring(1, 2).toLowerCase() +
-           name.substring(2, name.length);
+    return name.substring(1, 2).toLowerCase() + name.substring(2, name.length);
   }
 
   function checkFunction(node) {
     for (var i = 0; i < node.params.length; i++) {
       var param = node.params[i];
       if (param.name && isPrefixed(param.name)) {
         var errorObj = {
           name: param.name,
           suggestion: deHungarianize(param.name),
         };
-        context.report(param,
-                       "Parameter '{{name}}' uses Hungarian Notation, " +
-                       "consider using '{{suggestion}}' instead.",
-                       errorObj);
+        context.report(
+          param,
+          "Parameter '{{name}}' uses Hungarian Notation, " +
+            "consider using '{{suggestion}}' instead.",
+          errorObj
+        );
       }
     }
   }
 
   // ---------------------------------------------------------------------------
   // Public
   // ---------------------------------------------------------------------------
 
   return {
-    "FunctionDeclaration": checkFunction,
-    "ArrowFunctionExpression": checkFunction,
-    "FunctionExpression": checkFunction,
+    FunctionDeclaration: checkFunction,
+    ArrowFunctionExpression: checkFunction,
+    FunctionExpression: checkFunction,
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-arbitrary-setTimeout.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-arbitrary-setTimeout.js
@@ -8,62 +8,63 @@
 
 "use strict";
 
 // -----------------------------------------------------------------------------
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 var helpers = require("../helpers");
-var testTypes = new Set([
-  "browser",
-  "xpcshell",
-]);
+var testTypes = new Set(["browser", "xpcshell"]);
 
 module.exports = {
   meta: {
     docs: {
       description: "disallow setTimeout with non-zero values in tests",
       category: "Best Practices",
     },
     schema: [],
   },
 
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   create(context) {
     return {
-      "CallExpression": function(node) {
+      CallExpression(node) {
         // We don't want to run this on mochitest plain as it already
         // prevents flaky setTimeout at runtime. This check is built-in
         // to the rule itself as sometimes other tests can live alongside
         // plain mochitests and so it can't be configured via eslintrc.
         if (!testTypes.has(helpers.getTestType(context))) {
           return;
         }
 
         let callee = node.callee;
         if (callee.type === "MemberExpression") {
-          if (callee.property.name !== "setTimeout" ||
-              callee.object.name !== "window" ||
-              node.arguments.length < 2) {
+          if (
+            callee.property.name !== "setTimeout" ||
+            callee.object.name !== "window" ||
+            node.arguments.length < 2
+          ) {
             return;
           }
         } else if (callee.type === "Identifier") {
-          if (callee.name !== "setTimeout" ||
-              node.arguments.length < 2) {
+          if (callee.name !== "setTimeout" || node.arguments.length < 2) {
             return;
           }
         } else {
           return;
         }
 
         let timeout = node.arguments[1];
         if (timeout.type !== "Literal" || timeout.value > 0) {
-          context.report(node, "listen for events instead of setTimeout() " +
-                               "with arbitrary delay");
+          context.report(
+            node,
+            "listen for events instead of setTimeout() " +
+              "with arbitrary delay"
+          );
         }
       },
     };
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-compare-against-boolean-literals.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-compare-against-boolean-literals.js
@@ -13,17 +13,22 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "BinaryExpression": function(node) {
-      if (["==", "!="].includes(node.operator) &&
-          (["true", "false"].includes(node.left.raw) ||
-           ["true", "false"].includes(node.right.raw))) {
-        context.report(node, "Don't compare for inexact equality against boolean literals");
+    BinaryExpression(node) {
+      if (
+        ["==", "!="].includes(node.operator) &&
+        (["true", "false"].includes(node.left.raw) ||
+          ["true", "false"].includes(node.right.raw))
+      ) {
+        context.report(
+          node,
+          "Don't compare for inexact equality against boolean literals"
+        );
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-define-cc-etc.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-define-cc-etc.js
@@ -15,25 +15,39 @@
 const componentsBlacklist = ["Cc", "Ci", "Cr", "Cu"];
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "VariableDeclarator": function(node) {
-      if (node.id.type == "Identifier" && componentsBlacklist.includes(node.id.name)) {
-        context.report(node,
-          `${node.id.name} is now defined in global scope, a separate definition is no longer necessary.`);
+    VariableDeclarator(node) {
+      if (
+        node.id.type == "Identifier" &&
+        componentsBlacklist.includes(node.id.name)
+      ) {
+        context.report(
+          node,
+          `${
+            node.id.name
+          } is now defined in global scope, a separate definition is no longer necessary.`
+        );
       }
 
       if (node.id.type == "ObjectPattern") {
         for (let property of node.id.properties) {
-          if (property.type == "Property" && componentsBlacklist.includes(property.value.name)) {
-            context.report(node,
-              `${property.value.name} is now defined in global scope, a separate definition is no longer necessary.`);
+          if (
+            property.type == "Property" &&
+            componentsBlacklist.includes(property.value.name)
+          ) {
+            context.report(
+              node,
+              `${
+                property.value.name
+              } is now defined in global scope, a separate definition is no longer necessary.`
+            );
           }
         }
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-task.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-task.js
@@ -14,18 +14,20 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "CallExpression": function(node) {
+    CallExpression(node) {
       let callee = node.callee;
-      if (callee.type === "MemberExpression" &&
-          callee.object.type === "Identifier" &&
-          callee.object.name === "Task") {
-        context.report({node, message: "Task.jsm is deprecated."});
+      if (
+        callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier" &&
+        callee.object.name === "Task"
+      ) {
+        context.report({ node, message: "Task.jsm is deprecated." });
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-parameters.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-parameters.js
@@ -11,41 +11,50 @@
 
 // -----------------------------------------------------------------------------
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   function getRangeAfterArgToEnd(argNumber, args) {
     let sourceCode = context.getSourceCode();
-    return [sourceCode.getTokenAfter(args[argNumber]).range[0],
-      args[args.length - 1].range[1]];
+    return [
+      sourceCode.getTokenAfter(args[argNumber]).range[0],
+      args[args.length - 1].range[1],
+    ];
   }
 
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "CallExpression": function(node) {
+    CallExpression(node) {
       let callee = node.callee;
-      if (callee.type !== "MemberExpression" ||
-          callee.property.type !== "Identifier") {
+      if (
+        callee.type !== "MemberExpression" ||
+        callee.property.type !== "Identifier"
+      ) {
         return;
       }
 
       let isFalse = arg => arg.type === "Literal" && arg.value === false;
       let isFalsy = arg => arg.type === "Literal" && !arg.value;
-      let isBool = arg => arg.type === "Literal" && (arg.value === false ||
-                                                     arg.value === true);
+      let isBool = arg =>
+        arg.type === "Literal" && (arg.value === false || arg.value === true);
       let name = callee.property.name;
       let args = node.arguments;
 
-      if (["addEventListener", "removeEventListener", "addObserver"]
-          .includes(name) && args.length === 3 && isFalse(args[2])) {
+      if (
+        ["addEventListener", "removeEventListener", "addObserver"].includes(
+          name
+        ) &&
+        args.length === 3 &&
+        isFalse(args[2])
+      ) {
         context.report({
           node,
           fix: fixer => {
             return fixer.removeRange(getRangeAfterArgToEnd(1, args));
           },
           message: `${name}'s third parameter can be omitted when it's false.`,
         });
       }
@@ -75,47 +84,54 @@ module.exports = function(context) {
           node,
           fix: fixer => {
             return fixer.removeRange(getRangeAfterArgToEnd(0, args));
           },
           message: `${name}'s second parameter can be omitted when it's false.`,
         });
       }
 
-      if (name === "notifyObservers" && args.length === 3 &&
-          isFalsy(args[2])) {
+      if (name === "notifyObservers" && args.length === 3 && isFalsy(args[2])) {
         context.report({
           node,
           fix: fixer => {
             return fixer.removeRange(getRangeAfterArgToEnd(1, args));
           },
           message: `${name}'s third parameter can be omitted.`,
         });
       }
 
-      if (name === "getComputedStyle" && args.length === 2 &&
-          isFalsy(args[1])) {
+      if (
+        name === "getComputedStyle" &&
+        args.length === 2 &&
+        isFalsy(args[1])
+      ) {
         context.report({
           node,
           fix: fixer => {
             return fixer.removeRange(getRangeAfterArgToEnd(0, args));
           },
           message: "getComputedStyle's second parameter can be omitted.",
         });
       }
 
-      if (name === "newURI" && args.length > 1 &&
-          isFalsy(args[args.length - 1])) {
+      if (
+        name === "newURI" &&
+        args.length > 1 &&
+        isFalsy(args[args.length - 1])
+      ) {
         context.report({
           node,
           fix: fixer => {
             if (args.length > 2 && isFalsy(args[args.length - 2])) {
               return fixer.removeRange(getRangeAfterArgToEnd(0, args));
             }
 
-            return fixer.removeRange(getRangeAfterArgToEnd(args.length - 2, args));
+            return fixer.removeRange(
+              getRangeAfterArgToEnd(args.length - 2, args)
+            );
           },
           message: "newURI's last parameters are optional.",
         });
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-removeEventListener.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-removeEventListener.js
@@ -14,43 +14,51 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "CallExpression": function(node) {
+    CallExpression(node) {
       let callee = node.callee;
-      if (callee.type !== "MemberExpression" ||
-          callee.property.type !== "Identifier" ||
-          callee.property.name !== "addEventListener" ||
-          node.arguments.length == 4) {
+      if (
+        callee.type !== "MemberExpression" ||
+        callee.property.type !== "Identifier" ||
+        callee.property.name !== "addEventListener" ||
+        node.arguments.length == 4
+      ) {
         return;
       }
 
       let listener = node.arguments[1];
-      if (!listener ||
-          listener.type != "FunctionExpression" ||
-          !listener.body ||
-          listener.body.type != "BlockStatement" ||
-          !listener.body.body.length ||
-          listener.body.body[0].type != "ExpressionStatement" ||
-          listener.body.body[0].expression.type != "CallExpression") {
+      if (
+        !listener ||
+        listener.type != "FunctionExpression" ||
+        !listener.body ||
+        listener.body.type != "BlockStatement" ||
+        !listener.body.body.length ||
+        listener.body.body[0].type != "ExpressionStatement" ||
+        listener.body.body[0].expression.type != "CallExpression"
+      ) {
         return;
       }
 
       let call = listener.body.body[0].expression;
-      if (call.callee.type == "MemberExpression" &&
-          call.callee.property.type == "Identifier" &&
-          call.callee.property.name == "removeEventListener" &&
-          ((call.arguments[0].type == "Literal" &&
-            call.arguments[0].value == node.arguments[0].value) ||
-           (call.arguments[0].type == "Identifier" &&
-            call.arguments[0].name == node.arguments[0].name))) {
-        context.report(call,
-                       "use {once: true} instead of removeEventListener as " +
-                       "the first instruction of the listener");
+      if (
+        call.callee.type == "MemberExpression" &&
+        call.callee.property.type == "Identifier" &&
+        call.callee.property.name == "removeEventListener" &&
+        ((call.arguments[0].type == "Literal" &&
+          call.arguments[0].value == node.arguments[0].value) ||
+          (call.arguments[0].type == "Identifier" &&
+            call.arguments[0].name == node.arguments[0].name))
+      ) {
+        context.report(
+          call,
+          "use {once: true} instead of removeEventListener as " +
+            "the first instruction of the listener"
+        );
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-run-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/no-useless-run-test.js
@@ -14,22 +14,24 @@
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
     "Program > FunctionDeclaration": function(node) {
-      if (node.id.name === "run_test" &&
-          node.body.type === "BlockStatement" &&
-          node.body.body.length === 1 &&
-          node.body.body[0].type === "ExpressionStatement" &&
-          node.body.body[0].expression.type === "CallExpression" &&
-          node.body.body[0].expression.callee.name === "run_next_test") {
+      if (
+        node.id.name === "run_test" &&
+        node.body.type === "BlockStatement" &&
+        node.body.body.length === 1 &&
+        node.body.body[0].type === "ExpressionStatement" &&
+        node.body.body[0].expression.type === "CallExpression" &&
+        node.body.body[0].expression.callee.name === "run_next_test"
+      ) {
         context.report({
           node,
           fix: fixer => {
             let sourceCode = context.getSourceCode();
             let startNode;
             if (sourceCode.getCommentsBefore) {
               // ESLint 4 has getCommentsBefore.
               startNode = sourceCode.getCommentsBefore(node);
@@ -46,22 +48,23 @@ module.exports = function(context) {
               startNode = startNode[startNode.length - 1];
             } else {
               startNode = sourceCode.getTokenBefore(node);
             }
 
             return fixer.removeRange([
               // If there's no startNode, we fall back to zero, i.e. start of
               // file.
-              startNode ? (startNode.end + 1) : 0,
+              startNode ? startNode.end + 1 : 0,
               // We know the function is a block and it'll end with }. Normally
               // there's a new line after that, so just advance past it. This
               // may be slightly not dodgy in some cases, but covers the existing
               // cases.
               node.end + 1,
             ]);
           },
-          message: "Useless run_test function - only contains run_next_test; whole function can be removed",
+          message:
+            "Useless run_test function - only contains run_next_test; whole function can be removed",
         });
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-importGlobalProperties.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-importGlobalProperties.js
@@ -3,53 +3,60 @@
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
 "use strict";
 
-const privilegedGlobals = Object.keys(require("../environments/privileged.js").globals);
+const privilegedGlobals = Object.keys(
+  require("../environments/privileged.js").globals
+);
 
 // -----------------------------------------------------------------------------
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 module.exports = {
   meta: {
     messages: {
       unexpectedCall: "Unexpected call to Cu.importGlobalProperties",
-      unexpectedCallWebIdl: "Unnecessary call to Cu.importGlobalProperties (webidl names are automatically imported)",
+      unexpectedCallWebIdl:
+        "Unnecessary call to Cu.importGlobalProperties (webidl names are automatically imported)",
     },
-    schema: [{
-      // XXX Better name?
-      "enum": ["everything", "allownonwebidl"],
-    }],
+    schema: [
+      {
+        // XXX Better name?
+        enum: ["everything", "allownonwebidl"],
+      },
+    ],
     type: "problem",
   },
 
   create(context) {
     return {
-      "CallExpression": function(node) {
+      CallExpression(node) {
         if (node.callee.type !== "MemberExpression") {
           return;
         }
         let memexp = node.callee;
-        if (memexp.object.type === "Identifier" &&
-            // Only Cu, not Components.utils; see bug 1230369.
-            memexp.object.name === "Cu" &&
-            memexp.property.type === "Identifier" &&
-            memexp.property.name === "importGlobalProperties") {
+        if (
+          memexp.object.type === "Identifier" &&
+          // Only Cu, not Components.utils; see bug 1230369.
+          memexp.object.name === "Cu" &&
+          memexp.property.type === "Identifier" &&
+          memexp.property.name === "importGlobalProperties"
+        ) {
           if (context.options.includes("allownonwebidl")) {
             for (let element of node.arguments[0].elements) {
               if (privilegedGlobals.includes(element.value)) {
-                context.report({ node, messageId: "unexpectedCallWebIdl"});
+                context.report({ node, messageId: "unexpectedCallWebIdl" });
               }
             }
           } else {
-            context.report({node, messageId: "unexpectedCall"});
+            context.report({ node, messageId: "unexpectedCall" });
           }
         }
       },
     };
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-some-requires.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/reject-some-requires.js
@@ -12,36 +12,40 @@
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
-  if (typeof(context.options[0]) !== "string") {
+  if (typeof context.options[0] !== "string") {
     throw new Error("reject-some-requires expects a regexp");
   }
   const RX = new RegExp(context.options[0]);
 
   const checkPath = function(node, path) {
     if (RX.test(path)) {
       context.report(node, `require(${path}) is not allowed`);
     }
   };
 
   return {
-    "CallExpression": function(node) {
-      if (node.callee.type == "Identifier" &&
-          node.callee.name == "require" &&
-          node.arguments.length == 1 &&
-          node.arguments[0].type == "Literal") {
+    CallExpression(node) {
+      if (
+        node.callee.type == "Identifier" &&
+        node.callee.name == "require" &&
+        node.arguments.length == 1 &&
+        node.arguments[0].type == "Literal"
+      ) {
         checkPath(node, node.arguments[0].value);
-      } else if (node.callee.type == "MemberExpression" &&
-                 node.callee.property.type == "Identifier" &&
-                 node.callee.property.name == "lazyRequireGetter" &&
-                 node.arguments.length >= 3 &&
-                 node.arguments[2].type == "Literal") {
+      } else if (
+        node.callee.type == "MemberExpression" &&
+        node.callee.property.type == "Identifier" &&
+        node.callee.property.name == "lazyRequireGetter" &&
+        node.arguments.length >= 3 &&
+        node.arguments[2].type == "Literal"
+      ) {
         checkPath(node, node.arguments[2].value);
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/rejects-requires-await.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/rejects-requires-await.js
@@ -12,23 +12,25 @@ module.exports = {
   meta: {
     messages: {
       rejectRequiresAwait: "Assert.rejects needs to be preceded by await.",
     },
   },
 
   create(context) {
     return {
-      "CallExpression": function(node) {
+      CallExpression(node) {
         if (node.callee.type === "MemberExpression") {
           let memexp = node.callee;
-          if (memexp.object.type === "Identifier" &&
-              memexp.object.name === "Assert" &&
-              memexp.property.type === "Identifier" &&
-              memexp.property.name === "rejects") {
+          if (
+            memexp.object.type === "Identifier" &&
+            memexp.object.name === "Assert" &&
+            memexp.property.type === "Identifier" &&
+            memexp.property.name === "rejects"
+          ) {
             // We have ourselves an Assert.rejects.
 
             if (node.parent.type !== "AwaitExpression") {
               context.report({
                 node,
                 messageId: "rejectRequiresAwait",
               });
             }
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-cc-etc.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-cc-etc.js
@@ -20,19 +20,25 @@ const componentsMap = {
 };
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "MemberExpression": function(node) {
-      if (node.object.type === "Identifier" &&
-          node.object.name === "Components" &&
-          node.property.type === "Identifier" &&
-          Object.getOwnPropertyNames(componentsMap).includes(node.property.name)) {
-        context.report(node,
-          `Use ${componentsMap[node.property.name]} rather than Components.${node.property.name}`);
+    MemberExpression(node) {
+      if (
+        node.object.type === "Identifier" &&
+        node.object.name === "Components" &&
+        node.property.type === "Identifier" &&
+        Object.getOwnPropertyNames(componentsMap).includes(node.property.name)
+      ) {
+        context.report(
+          node,
+          `Use ${componentsMap[node.property.name]} rather than Components.${
+            node.property.name
+          }`
+        );
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-generateqi.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-generateqi.js
@@ -13,85 +13,91 @@
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 function isIdentifier(node, id) {
   return node && node.type === "Identifier" && node.name === id;
 }
 
 function isMemberExpression(node, object, member) {
-  return (node.type === "MemberExpression" &&
-          isIdentifier(node.object, object) &&
-          isIdentifier(node.property, member));
+  return (
+    node.type === "MemberExpression" &&
+    isIdentifier(node.object, object) &&
+    isIdentifier(node.property, member)
+  );
 }
 
-const MSG_NO_JS_QUERY_INTERFACE = (
+const MSG_NO_JS_QUERY_INTERFACE =
   "Please use ChromeUtils.generateQI rather than manually creating " +
-  "JavaScript QueryInterface functions");
+  "JavaScript QueryInterface functions";
 
-const MSG_NO_XPCOMUTILS_GENERATEQI = (
-  "Please use ChromeUtils.generateQI instead of XPCOMUtils.generateQI");
+const MSG_NO_XPCOMUTILS_GENERATEQI =
+  "Please use ChromeUtils.generateQI instead of XPCOMUtils.generateQI";
 
 function funcToGenerateQI(context, node) {
   const sourceCode = context.getSourceCode();
   const text = sourceCode.getText(node);
 
   let interfaces = [];
   let match;
   let re = /\bCi\.([a-zA-Z0-9]+)\b|\b(nsI[A-Z][a-zA-Z0-9]+)\b/g;
   while ((match = re.exec(text))) {
     interfaces.push(match[1] || match[2]);
   }
 
-  let ifaces = interfaces.filter(iface => iface != "nsISupports")
-                         .map(iface => JSON.stringify(iface))
-                         .join(", ");
+  let ifaces = interfaces
+    .filter(iface => iface != "nsISupports")
+    .map(iface => JSON.stringify(iface))
+    .join(", ");
 
   return `ChromeUtils.generateQI([${ifaces}])`;
 }
 
 module.exports = {
   meta: {
     fixable: "code",
   },
 
   create(context) {
     return {
-      "CallExpression": function(node) {
-        let {callee} = node;
+      CallExpression(node) {
+        let { callee } = node;
         if (isMemberExpression(callee, "XPCOMUtils", "generateQI")) {
           context.report({
             node,
             message: MSG_NO_XPCOMUTILS_GENERATEQI,
             fix(fixer) {
               return fixer.replaceText(callee, "ChromeUtils.generateQI");
             },
           });
         }
       },
 
-      "AssignmentExpression > MemberExpression[property.name='QueryInterface']": function(node) {
-        const {right} = node.parent;
+      "AssignmentExpression > MemberExpression[property.name='QueryInterface']": function(
+        node
+      ) {
+        const { right } = node.parent;
         if (right.type === "FunctionExpression") {
           context.report({
             node: node.parent,
             message: MSG_NO_JS_QUERY_INTERFACE,
             fix(fixer) {
               return fixer.replaceText(right, funcToGenerateQI(context, right));
             },
           });
         }
       },
 
-      "Property[key.name='QueryInterface'][value.type='FunctionExpression']": function(node) {
+      "Property[key.name='QueryInterface'][value.type='FunctionExpression']": function(
+        node
+      ) {
         context.report({
           node,
           message: MSG_NO_JS_QUERY_INTERFACE,
           fix(fixer) {
             let generateQI = funcToGenerateQI(context, node.value);
             return fixer.replaceText(node, `QueryInterface: ${generateQI}`);
           },
         });
       },
     };
   },
 };
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-import.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-chromeutils-import.js
@@ -13,67 +13,77 @@
 // Rule Definition
 // -----------------------------------------------------------------------------
 
 function isIdentifier(node, id) {
   return node && node.type === "Identifier" && node.name === id;
 }
 
 function isMemberExpression(node, object, member) {
-  return (node.type === "MemberExpression" &&
-          isIdentifier(node.object, object) &&
-          isIdentifier(node.property, member));
+  return (
+    node.type === "MemberExpression" &&
+    isIdentifier(node.object, object) &&
+    isIdentifier(node.property, member)
+  );
 }
 
 module.exports = {
   meta: {
     schema: [
       {
-        "type": "object",
-        "properties": {
-          "allowCu": {
-            "type": "boolean",
+        type: "object",
+        properties: {
+          allowCu: {
+            type: "boolean",
           },
         },
-        "additionalProperties": false,
+        additionalProperties: false,
       },
     ],
     fixable: "code",
   },
 
   create(context) {
     return {
-      "CallExpression": function(node) {
+      CallExpression(node) {
         if (node.callee.type !== "MemberExpression") {
           return;
         }
 
-        let {allowCu} = context.options[0] || {};
-        let {callee} = node;
+        let { allowCu } = context.options[0] || {};
+        let { callee } = node;
 
         // Is the expression starting with `Cu` or `Components.utils`?
-        if (((!allowCu && isIdentifier(callee.object, "Cu")) ||
-             isMemberExpression(callee.object, "Components", "utils")) &&
-            isIdentifier(callee.property, "import")) {
+        if (
+          ((!allowCu && isIdentifier(callee.object, "Cu")) ||
+            isMemberExpression(callee.object, "Components", "utils")) &&
+          isIdentifier(callee.property, "import")
+        ) {
           context.report({
             node,
             message: "Please use ChromeUtils.import instead of Cu.import",
             fix(fixer) {
               return fixer.replaceText(callee, "ChromeUtils.import");
             },
           });
         }
 
-        if (isMemberExpression(callee, "XPCOMUtils", "defineLazyModuleGetter") &&
-            node.arguments.length < 4) {
+        if (
+          isMemberExpression(callee, "XPCOMUtils", "defineLazyModuleGetter") &&
+          node.arguments.length < 4
+        ) {
           context.report({
             node,
-            message: ("Please use ChromeUtils.defineModuleGetter instead of " +
-                      "XPCOMUtils.defineLazyModuleGetter"),
+            message:
+              "Please use ChromeUtils.defineModuleGetter instead of " +
+              "XPCOMUtils.defineLazyModuleGetter",
             fix(fixer) {
-              return fixer.replaceText(callee, "ChromeUtils.defineModuleGetter");
+              return fixer.replaceText(
+                callee,
+                "ChromeUtils.defineModuleGetter"
+              );
             },
           });
         }
       },
     };
   },
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-default-preference-values.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-default-preference-values.js
@@ -14,31 +14,32 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "TryStatement": function(node) {
+    TryStatement(node) {
       let types = ["Bool", "Char", "Float", "Int"];
       let methods = types.map(type => "get" + type + "Pref");
-      if (node.block.type != "BlockStatement" ||
-          node.block.body.length != 1) {
+      if (node.block.type != "BlockStatement" || node.block.body.length != 1) {
         return;
       }
 
       let firstStm = node.block.body[0];
-      if (firstStm.type != "ExpressionStatement" ||
-          firstStm.expression.type != "AssignmentExpression" ||
-          firstStm.expression.right.type != "CallExpression" ||
-          firstStm.expression.right.callee.type != "MemberExpression" ||
-          firstStm.expression.right.callee.property.type != "Identifier" ||
-          !methods.includes(firstStm.expression.right.callee.property.name)) {
+      if (
+        firstStm.type != "ExpressionStatement" ||
+        firstStm.expression.type != "AssignmentExpression" ||
+        firstStm.expression.right.type != "CallExpression" ||
+        firstStm.expression.right.callee.type != "MemberExpression" ||
+        firstStm.expression.right.callee.property.type != "Identifier" ||
+        !methods.includes(firstStm.expression.right.callee.property.name)
+      ) {
         return;
       }
 
       let msg = "provide a default value instead of using a try/catch block";
       context.report(node, msg);
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-includes-instead-of-indexOf.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-includes-instead-of-indexOf.js
@@ -13,29 +13,33 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "BinaryExpression": function(node) {
-      if (node.left.type != "CallExpression" ||
-          node.left.callee.type != "MemberExpression" ||
-          node.left.callee.property.type != "Identifier" ||
-          node.left.callee.property.name != "indexOf") {
+    BinaryExpression(node) {
+      if (
+        node.left.type != "CallExpression" ||
+        node.left.callee.type != "MemberExpression" ||
+        node.left.callee.property.type != "Identifier" ||
+        node.left.callee.property.name != "indexOf"
+      ) {
         return;
       }
 
-      if ((["!=", "!==", "==", "==="].includes(node.operator) &&
-           node.right.type == "UnaryExpression" &&
-           node.right.operator == "-" &&
-           node.right.argument.type == "Literal" &&
-           node.right.argument.value == 1) ||
-          ([">=", "<"].includes(node.operator) &&
-           node.right.type == "Literal" &&
-           node.right.value == 0)) {
+      if (
+        (["!=", "!==", "==", "==="].includes(node.operator) &&
+          node.right.type == "UnaryExpression" &&
+          node.right.operator == "-" &&
+          node.right.argument.type == "Literal" &&
+          node.right.argument.value == 1) ||
+        ([">=", "<"].includes(node.operator) &&
+          node.right.type == "Literal" &&
+          node.right.value == 0)
+      ) {
         context.report(node, "use .includes instead of .indexOf");
       }
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-ownerGlobal.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-ownerGlobal.js
@@ -13,22 +13,26 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "MemberExpression": function(node) {
-      if (node.property.type != "Identifier" ||
-          node.property.name != "defaultView" ||
-          node.object.type != "MemberExpression" ||
-          node.object.property.type != "Identifier" ||
-          node.object.property.name != "ownerDocument") {
+    MemberExpression(node) {
+      if (
+        node.property.type != "Identifier" ||
+        node.property.name != "defaultView" ||
+        node.object.type != "MemberExpression" ||
+        node.object.property.type != "Identifier" ||
+        node.object.property.name != "ownerDocument"
+      ) {
         return;
       }
 
-      context.report(node,
-                     "use .ownerGlobal instead of .ownerDocument.defaultView");
+      context.report(
+        node,
+        "use .ownerGlobal instead of .ownerDocument.defaultView"
+      );
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-returnValue.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-returnValue.js
@@ -13,26 +13,32 @@
 // -----------------------------------------------------------------------------
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "ExpressionStatement": function(node) {
-      if (!node.expression ||
-          node.expression.type != "CallExpression" ||
-          !node.expression.callee ||
-          node.expression.callee.type != "MemberExpression" ||
-          !node.expression.callee.property ||
-          node.expression.callee.property.type != "Identifier" ||
-          (node.expression.callee.property.name != "concat" &&
-           node.expression.callee.property.name != "join" &&
-           node.expression.callee.property.name != "slice")) {
+    ExpressionStatement(node) {
+      if (
+        !node.expression ||
+        node.expression.type != "CallExpression" ||
+        !node.expression.callee ||
+        node.expression.callee.type != "MemberExpression" ||
+        !node.expression.callee.property ||
+        node.expression.callee.property.type != "Identifier" ||
+        (node.expression.callee.property.name != "concat" &&
+          node.expression.callee.property.name != "join" &&
+          node.expression.callee.property.name != "slice")
+      ) {
         return;
       }
 
-      context.report(node,
-                     `{Array/String}.${node.expression.callee.property.name} doesn't modify the instance in-place`);
+      context.report(
+        node,
+        `{Array/String}.${
+          node.expression.callee.property.name
+        } doesn't modify the instance in-place`
+      );
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-services.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/use-services.js
@@ -17,37 +17,39 @@ const path = require("path");
  *
  * It is specifically built around the current structure of the Services.jsm
  * file.
  */
 var servicesASTParser = {
   identifiers: {},
   // These interfaces are difficult/not possible to get via processing.
   result: {
-    "nsIPrefBranch": "prefs",
-    "nsIPrefService": "prefs",
-    "nsIXULRuntime": "appinfo",
-    "nsIXULAppInfo": "appinfo",
-    "nsIDirectoryService": "dirsvc",
-    "nsIProperties": "dirsvc",
-    "nsIIOService": "io",
-    "nsISpeculativeConnect": "io",
-    "nsICookieManager": "cookies",
-    "nsIBlocklistService": "blocklist",
+    nsIPrefBranch: "prefs",
+    nsIPrefService: "prefs",
+    nsIXULRuntime: "appinfo",
+    nsIXULAppInfo: "appinfo",
+    nsIDirectoryService: "dirsvc",
+    nsIProperties: "dirsvc",
+    nsIIOService: "io",
+    nsISpeculativeConnect: "io",
+    nsICookieManager: "cookies",
+    nsIBlocklistService: "blocklist",
   },
 
   /**
    * This looks for any global variable declarations that are being initialised
    * with objects, and records the assumed interface definitions.
    */
   VariableDeclaration(node, parents) {
-    if (node.declarations.length === 1 &&
-        node.declarations[0].id &&
-        helpers.getIsGlobalScope(parents) &&
-        node.declarations[0].init.type === "ObjectExpression") {
+    if (
+      node.declarations.length === 1 &&
+      node.declarations[0].id &&
+      helpers.getIsGlobalScope(parents) &&
+      node.declarations[0].init.type === "ObjectExpression"
+    ) {
       let name = node.declarations[0].id.name;
       let interfaces = {};
 
       for (let property of node.declarations[0].init.properties) {
         if (property.value.elements.length > 1) {
           interfaces[property.key.name] = property.value.elements[1].value;
         }
       }
@@ -56,53 +58,63 @@ var servicesASTParser = {
     }
   },
 
   /**
    * This looks for any additions to the global variable declarations, and adds
    * them to the identifier tables created by the VariableDeclaration calls.
    */
   AssignmentExpression(node, parents) {
-    if (node.left.type === "MemberExpression" &&
-        node.right.type === "ArrayExpression" &&
-        helpers.getIsGlobalScope(parents)) {
+    if (
+      node.left.type === "MemberExpression" &&
+      node.right.type === "ArrayExpression" &&
+      helpers.getIsGlobalScope(parents)
+    ) {
       let variableName = node.left.object.name;
       if (variableName in this.identifiers) {
         let servicesPropName = node.left.property.name;
-        this.identifiers[variableName][servicesPropName] = node.right.elements[1].value;
+        this.identifiers[variableName][servicesPropName] =
+          node.right.elements[1].value;
       }
     }
   },
 
   /**
    * This looks for any XPCOMUtils.defineLazyServiceGetters calls, and looks
    * into the arguments they are called with to work out the interfaces that
    * Services.jsm is caching.
    */
   CallExpression(node) {
-    if (node.callee.object &&
-        node.callee.object.name === "XPCOMUtils" &&
-        node.callee.property &&
-        node.callee.property.name === "defineLazyServiceGetters" &&
-        node.arguments.length >= 2) {
+    if (
+      node.callee.object &&
+      node.callee.object.name === "XPCOMUtils" &&
+      node.callee.property &&
+      node.callee.property.name === "defineLazyServiceGetters" &&
+      node.arguments.length >= 2
+    ) {
       // The second argument has the getters name.
       let gettersVarName = node.arguments[1].name;
       if (!(gettersVarName in this.identifiers)) {
         throw new Error(`Could not find definition for ${gettersVarName}`);
       }
 
       for (let name of Object.keys(this.identifiers[gettersVarName])) {
         this.result[this.identifiers[gettersVarName][name]] = name;
       }
     }
   },
 };
 
 function getInterfacesFromServicesFile() {
-  let filePath = path.join(helpers.rootDir, "toolkit", "modules", "Services.jsm");
+  let filePath = path.join(
+    helpers.rootDir,
+    "toolkit",
+    "modules",
+    "Services.jsm"
+  );
 
   let content = fs.readFileSync(filePath, "utf8");
 
   // Parse the content into an AST
   let ast = helpers.getAST(content);
 
   helpers.walkAST(ast, (type, node, parents) => {
     if (type in servicesASTParser) {
@@ -115,19 +127,19 @@ function getInterfacesFromServicesFile()
 
   // nsIPropertyBag2 is used for system-info, but it is also used for other
   // services and items as well, so we can't really warn for it.
   delete servicesASTParser.result.nsIPropertyBag2;
 
   return servicesASTParser.result;
 }
 
-let getServicesInterfaceMap = helpers.isMozillaCentralBased() ?
-  getInterfacesFromServicesFile() :
-  helpers.getSavedRuleData("use-services.js");
+let getServicesInterfaceMap = helpers.isMozillaCentralBased()
+  ? getInterfacesFromServicesFile()
+  : helpers.getSavedRuleData("use-services.js");
 
 // -----------------------------------------------------------------------------
 // Rule Definition
 // -----------------------------------------------------------------------------
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
@@ -136,27 +148,32 @@ module.exports = function(context) {
     // for part of the rule. We want to export the servicesInterfaceArray for
     // the purposes of createExports, so we return it via a function which
     // makes everything happy.
     getServicesInterfaceMap() {
       return getServicesInterfaceMap;
     },
 
     CallExpression(node) {
-      if (!node.callee ||
-          !node.callee.property ||
-          node.callee.property.type != "Identifier" ||
-          node.callee.property.name != "getService" ||
-          node.arguments.length != 1 ||
-          !node.arguments[0].property ||
-          node.arguments[0].property.type != "Identifier" ||
-          !node.arguments[0].property.name ||
-          !(node.arguments[0].property.name in getServicesInterfaceMap)) {
+      if (
+        !node.callee ||
+        !node.callee.property ||
+        node.callee.property.type != "Identifier" ||
+        node.callee.property.name != "getService" ||
+        node.arguments.length != 1 ||
+        !node.arguments[0].property ||
+        node.arguments[0].property.type != "Identifier" ||
+        !node.arguments[0].property.name ||
+        !(node.arguments[0].property.name in getServicesInterfaceMap)
+      ) {
         return;
       }
 
-      let serviceName = getServicesInterfaceMap[node.arguments[0].property.name];
+      let serviceName =
+        getServicesInterfaceMap[node.arguments[0].property.name];
 
-      context.report(node,
-                     `Use Services.${serviceName} rather than getService().`);
+      context.report(
+        node,
+        `Use Services.${serviceName} rather than getService().`
+      );
     },
   };
 };
--- a/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/var-only-at-top-level.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/lib/rules/var-only-at-top-level.js
@@ -16,17 +16,17 @@
 var helpers = require("../helpers");
 
 module.exports = function(context) {
   // ---------------------------------------------------------------------------
   // Public
   //  --------------------------------------------------------------------------
 
   return {
-    "VariableDeclaration": function(node) {
+    VariableDeclaration(node) {
       if (node.kind === "var") {
         if (helpers.getIsGlobalScope(context.getAncestors())) {
           return;
         }
 
         context.report(node, "Unexpected var, use let or const instead.");
       }
     },
--- a/tools/lint/eslint/eslint-plugin-mozilla/reporters/mozilla-format.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/reporters/mozilla-format.js
@@ -24,17 +24,21 @@ function MozillaFormatter(runner) {
     let title = test.title.replace(/\n/g, "|");
     console.log(`TEST-PASS | ${path.basename(test.file)} | ${title}`);
   });
 
   runner.on("fail", function(test, err) {
     failures++;
     // Replace any newlines in the title.
     let title = test.title.replace(/\n/g, "|");
-    console.log(`TEST-UNEXPECTED-FAIL | ${path.basename(test.file)} | ${title} | ${err.message}`);
+    console.log(
+      `TEST-UNEXPECTED-FAIL | ${path.basename(test.file)} | ${title} | ${
+        err.message
+      }`
+    );
   });
 
   runner.on("end", function() {
     console.log("INFO | Result summary:");
     console.log(`INFO | Passed: ${passes}`);
     console.log(`INFO | Failed: ${failures}`);
     console.log("SUITE-END");
     process.exit(failures);
--- a/tools/lint/eslint/eslint-plugin-mozilla/scripts/createExports.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/scripts/createExports.js
@@ -5,52 +5,69 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 "use strict";
 
 var fs = require("fs");
 var path = require("path");
 var helpers = require("../lib/helpers");
 
-const eslintDir = path.join(helpers.rootDir,
-                            "tools", "lint", "eslint");
+const eslintDir = path.join(helpers.rootDir, "tools", "lint", "eslint");
 
-const globalsFile = path.join(eslintDir, "eslint-plugin-mozilla",
-                              "lib", "environments", "saved-globals.json");
-const rulesFile = path.join(eslintDir, "eslint-plugin-mozilla",
-                            "lib", "rules", "saved-rules-data.json");
+const globalsFile = path.join(
+  eslintDir,
+  "eslint-plugin-mozilla",
+  "lib",
+  "environments",
+  "saved-globals.json"
+);
+const rulesFile = path.join(
+  eslintDir,
+  "eslint-plugin-mozilla",
+  "lib",
+  "rules",
+  "saved-rules-data.json"
+);
 
 console.log("Copying modules.json");
 
 const modulesFile = path.join(eslintDir, "modules.json");
-const shipModulesFile = path.join(eslintDir, "eslint-plugin-mozilla", "lib",
-                                  "modules.json");
+const shipModulesFile = path.join(
+  eslintDir,
+  "eslint-plugin-mozilla",
+  "lib",
+  "modules.json"
+);
 
 fs.writeFileSync(shipModulesFile, fs.readFileSync(modulesFile));
 
 console.log("Generating globals file");
 
 // Export the environments.
 let environmentGlobals = require("../lib/index.js").environments;
 
-return fs.writeFile(globalsFile, JSON.stringify({environments: environmentGlobals}), err => {
-  if (err) {
-    console.error(err);
-    process.exit(1);
-  }
-
-  console.log("Globals file generation complete");
-
-  console.log("Creating rules data file");
-  // Also export data for the use-services.js rule
-  let rulesData = {
-    "use-services.js": require("../lib/rules/use-services.js")().getServicesInterfaceMap(),
-  };
-
-  return fs.writeFile(rulesFile, JSON.stringify({rulesData}), err1 => {
-    if (err1) {
-      console.error(err1);
+return fs.writeFile(
+  globalsFile,
+  JSON.stringify({ environments: environmentGlobals }),
+  err => {
+    if (err) {
+      console.error(err);
       process.exit(1);
     }
 
     console.log("Globals file generation complete");
-  });
-});
+
+    console.log("Creating rules data file");
+    // Also export data for the use-services.js rule
+    let rulesData = {
+      "use-services.js": require("../lib/rules/use-services.js")().getServicesInterfaceMap(),
+    };
+
+    return fs.writeFile(rulesFile, JSON.stringify({ rulesData }), err1 => {
+      if (err1) {
+        console.error(err1);
+        process.exit(1);
+      }
+
+      console.log("Globals file generation complete");
+    });
+  }
+);
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-Date-timing.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-Date-timing.js
@@ -12,28 +12,31 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, type, message) {
-  return {code, errors: [{message, type}]};
+  return { code, errors: [{ message, type }] };
 }
 
 ruleTester.run("avoid-Date-timing", rule, {
   valid: [
     "new Date('2017-07-11');",
     "new Date(1499790192440);",
     "new Date(2017, 7, 11);",
     "Date.UTC(2017, 7);",
   ],
   invalid: [
-    invalidCode("Date.now();", "CallExpression",
-                "use performance.now() instead of Date.now() " +
-                "for timing measurements"),
-    invalidCode("new Date();", "NewExpression",
-                "use performance.now() instead of new Date() " +
-                "for timing measurements"),
+    invalidCode(
+      "Date.now();",
+      "CallExpression",
+      "use performance.now() instead of Date.now() " + "for timing measurements"
+    ),
+    invalidCode(
+      "new Date();",
+      "NewExpression",
+      "use performance.now() instead of new Date() " + "for timing measurements"
+    ),
   ],
 });
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-removeChild.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/avoid-removeChild.js
@@ -13,31 +13,34 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, message) {
   if (!message) {
-    message = "use element.remove() instead of " +
-              "element.parentNode.removeChild(element)";
+    message =
+      "use element.remove() instead of " +
+      "element.parentNode.removeChild(element)";
   }
-  return {code, errors: [{message, type: "CallExpression"}]};
+  return { code, errors: [{ message, type: "CallExpression" }] };
 }
 
 ruleTester.run("avoid-removeChild", rule, {
   valid: [
     "elt.remove();",
     "elt.parentNode.parentNode.removeChild(elt2.parentNode);",
     "elt.parentNode.removeChild(elt2);",
     "elt.removeChild(elt2);",
   ],
   invalid: [
     invalidCode("elt.parentNode.removeChild(elt);"),
     invalidCode("elt.parentNode.parentNode.removeChild(elt.parentNode);"),
     invalidCode("$(e).parentNode.removeChild($(e));"),
     invalidCode("$('e').parentNode.removeChild($('e'));"),
-    invalidCode("elt.removeChild(elt.firstChild);",
-                "use element.firstChild.remove() instead of " +
-                "element.removeChild(element.firstChild)"),
+    invalidCode(
+      "elt.removeChild(elt.firstChild);",
+      "use element.firstChild.remove() instead of " +
+        "element.removeChild(element.firstChild)"
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/balanced-listeners.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/balanced-listeners.js
@@ -14,66 +14,76 @@ const ruleTester = new RuleTester({ pars
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function error(code, message) {
   return {
     code,
-    errors: [{message, type: "Identifier"}],
+    errors: [{ message, type: "Identifier" }],
   };
 }
 
 ruleTester.run("balanced-listeners", rule, {
   valid: [
     "elt.addEventListener('event', handler);" +
-    "elt.removeEventListener('event', handler);",
+      "elt.removeEventListener('event', handler);",
 
     "elt.addEventListener('event', handler, true);" +
-    "elt.removeEventListener('event', handler, true);",
+      "elt.removeEventListener('event', handler, true);",
 
     "elt.addEventListener('event', handler, false);" +
-    "elt.removeEventListener('event', handler, false);",
+      "elt.removeEventListener('event', handler, false);",
 
     "elt.addEventListener('event', handler);" +
-    "elt.removeEventListener('event', handler, false);",
+      "elt.removeEventListener('event', handler, false);",
 
     "elt.addEventListener('event', handler, false);" +
-    "elt.removeEventListener('event', handler);",
+      "elt.removeEventListener('event', handler);",
 
     "elt.addEventListener('event', handler, {capture: false});" +
-    "elt.removeEventListener('event', handler);",
+      "elt.removeEventListener('event', handler);",
 
     "elt.addEventListener('event', handler);" +
-    "elt.removeEventListener('event', handler, {capture: false});",
+      "elt.removeEventListener('event', handler, {capture: false});",
 
     "elt.addEventListener('event', handler, {capture: true});" +
-    "elt.removeEventListener('event', handler, true);",
+      "elt.removeEventListener('event', handler, true);",
 
     "elt.addEventListener('event', handler, true);" +
-    "elt.removeEventListener('event', handler, {capture: true});",
+      "elt.removeEventListener('event', handler, {capture: true});",
 
     "elt.addEventListener('event', handler, {once: true});",
 
     "elt.addEventListener('event', handler, {once: true, capture: true});",
   ],
   invalid: [
-    error("elt.addEventListener('click', handler, false);",
-          "No corresponding 'removeEventListener(click)' was found."),
+    error(
+      "elt.addEventListener('click', handler, false);",
+      "No corresponding 'removeEventListener(click)' was found."
+    ),
 
-    error("elt.addEventListener('click', handler, false);" +
-          "elt.removeEventListener('click', handler, true);",
-          "No corresponding 'removeEventListener(click)' was found."),
+    error(
+      "elt.addEventListener('click', handler, false);" +
+        "elt.removeEventListener('click', handler, true);",
+      "No corresponding 'removeEventListener(click)' was found."
+    ),
 
-    error("elt.addEventListener('click', handler, {capture: false});" +
-          "elt.removeEventListener('click', handler, true);",
-          "No corresponding 'removeEventListener(click)' was found."),
+    error(
+      "elt.addEventListener('click', handler, {capture: false});" +
+        "elt.removeEventListener('click', handler, true);",
+      "No corresponding 'removeEventListener(click)' was found."
+    ),
 
-    error("elt.addEventListener('click', handler, {capture: true});" +
-          "elt.removeEventListener('click', handler);",
-          "No corresponding 'removeEventListener(click)' was found."),
+    error(
+      "elt.addEventListener('click', handler, {capture: true});" +
+        "elt.removeEventListener('click', handler);",
+      "No corresponding 'removeEventListener(click)' was found."
+    ),
 
-    error("elt.addEventListener('click', handler, true);" +
-          "elt.removeEventListener('click', handler);",
-          "No corresponding 'removeEventListener(click)' was found."),
+    error(
+      "elt.addEventListener('click', handler, true);" +
+        "elt.removeEventListener('click', handler);",
+      "No corresponding 'removeEventListener(click)' was found."
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/consistent-if-bracing.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/consistent-if-bracing.js
@@ -12,17 +12,17 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 8 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code) {
-  return {code, errors: [{messageId: "consistentIfBracing"}]};
+  return { code, errors: [{ messageId: "consistentIfBracing" }] };
 }
 
 ruleTester.run("consistent-if-bracing", rule, {
   valid: [
     "if (true) {1} else {0}",
     "if (false) 1; else 0",
     "if (true) {1} else if (true) {2} else {0}",
     "if (true) {1} else if (true) {2} else if (true) {3} else {0}",
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/mark-exported-symbols-as-used.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/mark-exported-symbols-as-used.js
@@ -12,25 +12,34 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, type, message) {
-  return {code, errors: [{message, type}]};
+  return { code, errors: [{ message, type }] };
 }
 
 ruleTester.run("mark-exported-symbols-as-used", rule, {
   valid: [
     "var EXPORTED_SYMBOLS = ['foo'];",
     "this.EXPORTED_SYMBOLS = ['foo'];",
   ],
   invalid: [
-    invalidCode("let EXPORTED_SYMBOLS = ['foo'];", "VariableDeclaration",
-                "EXPORTED_SYMBOLS cannot be declared via `let`. Use `var` or `this.EXPORTED_SYMBOLS =`"),
-    invalidCode("var EXPORTED_SYMBOLS = 'foo';", "VariableDeclaration",
-                "Unexpected assignment of non-Array to EXPORTED_SYMBOLS"),
-    invalidCode("this.EXPORTED_SYMBOLS = 'foo';", "AssignmentExpression",
-                "Unexpected assignment of non-Array to EXPORTED_SYMBOLS"),
+    invalidCode(
+      "let EXPORTED_SYMBOLS = ['foo'];",
+      "VariableDeclaration",
+      "EXPORTED_SYMBOLS cannot be declared via `let`. Use `var` or `this.EXPORTED_SYMBOLS =`"
+    ),
+    invalidCode(
+      "var EXPORTED_SYMBOLS = 'foo';",
+      "VariableDeclaration",
+      "Unexpected assignment of non-Array to EXPORTED_SYMBOLS"
+    ),
+    invalidCode(
+      "this.EXPORTED_SYMBOLS = 'foo';",
+      "AssignmentExpression",
+      "Unexpected assignment of non-Array to EXPORTED_SYMBOLS"
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-arbitrary-setTimeout.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-arbitrary-setTimeout.js
@@ -12,30 +12,30 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function wrapCode(code, filename = "xpcshell/test_foo.js") {
-  return {code, filename};
+  return { code, filename };
 }
 
 function invalidCode(code) {
-  let message = "listen for events instead of setTimeout() with arbitrary delay";
+  let message =
+    "listen for events instead of setTimeout() with arbitrary delay";
   let obj = wrapCode(code);
-  obj.errors = [{message, type: "CallExpression"}];
+  obj.errors = [{ message, type: "CallExpression" }];
   return obj;
 }
 
 ruleTester.run("no-arbitrary-setTimeout", rule, {
   valid: [
     wrapCode("setTimeout(function() {}, 0);"),
     wrapCode("setTimeout(function() {});"),
     wrapCode("setTimeout(function() {}, 10);", "test_foo.js"),
   ],
   invalid: [
     invalidCode("setTimeout(function() {}, 10);"),
     invalidCode("setTimeout(function() {}, timeout);"),
   ],
 });
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-compare-against-boolean-literals.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-compare-against-boolean-literals.js
@@ -12,26 +12,23 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function callError(message) {
-  return [{message, type: "BinaryExpression"}];
+  return [{ message, type: "BinaryExpression" }];
 }
 
 const MESSAGE = "Don't compare for inexact equality against boolean literals";
 
 ruleTester.run("no-compare-against-boolean-literals", rule, {
-  valid: [
-    `if (!foo) {}`,
-    `if (!!foo) {}`,
-  ],
+  valid: [`if (!foo) {}`, `if (!!foo) {}`],
   invalid: [
     {
       code: `if (foo == true) {}`,
       errors: callError(MESSAGE),
     },
     {
       code: `if (foo != true) {}`,
       errors: callError(MESSAGE),
@@ -57,9 +54,8 @@ ruleTester.run("no-compare-against-boole
       errors: callError(MESSAGE),
     },
     {
       code: `if (false != foo) {}`,
       errors: callError(MESSAGE),
     },
   ],
 });
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-define-cc-etc.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-define-cc-etc.js
@@ -16,20 +16,23 @@ const ruleTester = new RuleTester({ pars
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, varNames) {
   if (!Array.isArray(varNames)) {
     varNames = [varNames];
   }
   return {
-    code, errors: varNames.map(name => [{
-      message: `${name} is now defined in global scope, a separate definition is no longer necessary.`,
-      type: "VariableDeclarator",
-    }]),
+    code,
+    errors: varNames.map(name => [
+      {
+        message: `${name} is now defined in global scope, a separate definition is no longer necessary.`,
+        type: "VariableDeclarator",
+      },
+    ]),
   };
 }
 
 ruleTester.run("no-define-cc-etc", rule, {
   valid: [
     "var Cm = Components.manager;",
     "const CC = Components.Constructor;",
     "var {Constructor: CC, manager: Cm} = Components;",
@@ -42,12 +45,18 @@ ruleTester.run("no-define-cc-etc", rule,
     invalidCode("let Cc;", "Cc"),
     invalidCode("let Ci;", "Ci"),
     invalidCode("let Cr;", "Cr"),
     invalidCode("let Cu;", "Cu"),
     invalidCode("var Cc = Components.classes;", "Cc"),
     invalidCode("const {classes: Cc} = Components;", "Cc"),
     invalidCode("let {classes: Cc, manager: Cm} = Components", "Cc"),
     invalidCode("const Cu = Components.utils;", "Cu"),
-    invalidCode("var Ci = Components.interfaces, Cc = Components.classes;", ["Ci", "Cc"]),
-    invalidCode("var {'interfaces': Ci, 'classes': Cc} = Components;", ["Ci", "Cc"]),
+    invalidCode("var Ci = Components.interfaces, Cc = Components.classes;", [
+      "Ci",
+      "Cc",
+    ]),
+    invalidCode("var {'interfaces': Ci, 'classes': Cc} = Components;", [
+      "Ci",
+      "Cc",
+    ]),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-parameters.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-parameters.js
@@ -12,17 +12,17 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function callError(message) {
-  return [{message, type: "CallExpression"}];
+  return [{ message, type: "CallExpression" }];
 }
 
 ruleTester.run("no-useless-parameters", rule, {
   valid: [
     "Services.prefs.clearUserPref('browser.search.custom');",
     "Services.removeObserver('notification name', {});",
     "Services.io.newURI('http://example.com');",
     "Services.io.newURI('http://example.com', 'utf8');",
@@ -86,57 +86,57 @@ ruleTester.run("no-useless-parameters", 
       code: "Services.io.newURI('http://example.com', '');",
       output: "Services.io.newURI('http://example.com');",
       errors: callError("newURI's last parameters are optional."),
     },
     {
       code: "elt.addEventListener('click', handler, false);",
       output: "elt.addEventListener('click', handler);",
       errors: callError(
-        "addEventListener's third parameter can be omitted when it's false."),
+        "addEventListener's third parameter can be omitted when it's false."
+      ),
     },
     {
       code: "elt.removeEventListener('click', handler, false);",
       output: "elt.removeEventListener('click', handler);",
       errors: callError(
         "removeEventListener's third parameter can be omitted when it's" +
-        " false."),
+          " false."
+      ),
     },
     {
       code: "Services.obs.addObserver(this, 'topic', false);",
       output: "Services.obs.addObserver(this, 'topic');",
       errors: callError(
-        "addObserver's third parameter can be omitted when it's" +
-        " false."),
+        "addObserver's third parameter can be omitted when it's" + " false."
+      ),
     },
     {
       code: "Services.prefs.addObserver('branch', this, false);",
       output: "Services.prefs.addObserver('branch', this);",
       errors: callError(
-        "addObserver's third parameter can be omitted when it's" +
-        " false."),
+        "addObserver's third parameter can be omitted when it's" + " false."
+      ),
     },
     {
       code: "array.appendElement(elt, false);",
       output: "array.appendElement(elt);",
       errors: callError(
-        "appendElement's second parameter can be omitted when it's" +
-        " false."),
+        "appendElement's second parameter can be omitted when it's" + " false."
+      ),
     },
     {
       code: "Services.obs.notifyObservers(obj, 'topic', null);",
       output: "Services.obs.notifyObservers(obj, 'topic');",
-      errors: callError(
-        "notifyObservers's third parameter can be omitted."),
+      errors: callError("notifyObservers's third parameter can be omitted."),
     },
     {
       code: "Services.obs.notifyObservers(obj, 'topic', '');",
       output: "Services.obs.notifyObservers(obj, 'topic');",
-      errors: callError(
-        "notifyObservers's third parameter can be omitted."),
+      errors: callError("notifyObservers's third parameter can be omitted."),
     },
     {
       code: "window.getComputedStyle(elt, null);",
       output: "window.getComputedStyle(elt);",
       errors: callError("getComputedStyle's second parameter can be omitted."),
     },
     {
       code: "window.getComputedStyle(elt, '');",
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-removeEventListener.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-removeEventListener.js
@@ -12,75 +12,88 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code) {
-  let message = "use {once: true} instead of removeEventListener " +
-                "as the first instruction of the listener";
-  return {code, errors: [{message, type: "CallExpression"}]};
+  let message =
+    "use {once: true} instead of removeEventListener " +
+    "as the first instruction of the listener";
+  return { code, errors: [{ message, type: "CallExpression" }] };
 }
 
 ruleTester.run("no-useless-removeEventListener", rule, {
   valid: [
     // Listeners that aren't a function are always valid.
     "elt.addEventListener('click', handler);",
     "elt.addEventListener('click', handler, true);",
     "elt.addEventListener('click', handler, {once: true});",
 
     // Should not fail on empty functions.
     "elt.addEventListener('click', function() {});",
 
     // Should not reject when removing a listener for another event.
     "elt.addEventListener('click', function listener() {" +
-    "  elt.removeEventListener('keypress', listener);" +
-    "});",
+      "  elt.removeEventListener('keypress', listener);" +
+      "});",
 
     // Should not reject when there's another instruction before
     // removeEventListener.
     "elt.addEventListener('click', function listener() {" +
-    "  elt.focus();" +
-    "  elt.removeEventListener('click', listener);" +
-    "});",
+      "  elt.focus();" +
+      "  elt.removeEventListener('click', listener);" +
+      "});",
 
     // Should not reject when wantsUntrusted is true.
     "elt.addEventListener('click', function listener() {" +
-    "  elt.removeEventListener('click', listener);" +
-    "}, false, true);",
+      "  elt.removeEventListener('click', listener);" +
+      "}, false, true);",
 
     // Should not reject when there's a literal and a variable
     "elt.addEventListener('click', function listener() {" +
-    "  elt.removeEventListener(eventName, listener);" +
-    "});",
+      "  elt.removeEventListener(eventName, listener);" +
+      "});",
 
     // Should not reject when there's 2 different variables
     "elt.addEventListener(event1, function listener() {" +
-    "  elt.removeEventListener(event2, listener);" +
-    "});",
+      "  elt.removeEventListener(event2, listener);" +
+      "});",
 
     // Should not fail if this is a different type of event listener function.
     "myfunc.addEventListener(listener);",
   ],
   invalid: [
-    invalidCode("elt.addEventListener('click', function listener() {" +
-                "  elt.removeEventListener('click', listener);" +
-                "});"),
-    invalidCode("elt.addEventListener('click', function listener() {" +
-                "  elt.removeEventListener('click', listener, true);" +
-                "}, true);"),
-    invalidCode("elt.addEventListener('click', function listener() {" +
-                "  elt.removeEventListener('click', listener);" +
-                "}, {once: true});"),
-    invalidCode("elt.addEventListener('click', function listener() {" +
-                "  /* Comment */" +
-                "  elt.removeEventListener('click', listener);" +
-                "});"),
-    invalidCode("elt.addEventListener('click', function() {" +
-                "  elt.removeEventListener('click', arguments.callee);" +
-                "});"),
-    invalidCode("elt.addEventListener(eventName, function listener() {" +
-                "  elt.removeEventListener(eventName, listener);" +
-                "});"),
+    invalidCode(
+      "elt.addEventListener('click', function listener() {" +
+        "  elt.removeEventListener('click', listener);" +
+        "});"
+    ),
+    invalidCode(
+      "elt.addEventListener('click', function listener() {" +
+        "  elt.removeEventListener('click', listener, true);" +
+        "}, true);"
+    ),
+    invalidCode(
+      "elt.addEventListener('click', function listener() {" +
+        "  elt.removeEventListener('click', listener);" +
+        "}, {once: true});"
+    ),
+    invalidCode(
+      "elt.addEventListener('click', function listener() {" +
+        "  /* Comment */" +
+        "  elt.removeEventListener('click', listener);" +
+        "});"
+    ),
+    invalidCode(
+      "elt.addEventListener('click', function() {" +
+        "  elt.removeEventListener('click', arguments.callee);" +
+        "});"
+    ),
+    invalidCode(
+      "elt.addEventListener(eventName, function listener() {" +
+        "  elt.removeEventListener(eventName, listener);" +
+        "});"
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-run-test.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/no-useless-run-test.js
@@ -14,85 +14,94 @@ const ruleTester = new RuleTester({ pars
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, output) {
   let message =
     "Useless run_test function - only contains run_next_test; whole function can be removed";
-  return {code, output, errors: [{message, type: "FunctionDeclaration"}]};
+  return { code, output, errors: [{ message, type: "FunctionDeclaration" }] };
 }
 
 ruleTester.run("no-useless-run-test", rule, {
   valid: [
     "function run_test() {}",
     "function run_test() {let args = 1; run_next_test();}",
     "function run_test() {fakeCall(); run_next_test();}",
   ],
   invalid: [
     // Single-line case.
+    invalidCode("function run_test() { run_next_test(); }", ""),
+    // Multiple-line cases
     invalidCode(
-      "function run_test() { run_next_test(); }",
-      ""),
-    // Multiple-line cases
-    invalidCode(`
+      `
 function run_test() {
   run_next_test();
 }`,
-      ``),
-    invalidCode(`
+      ``
+    ),
+    invalidCode(
+      `
 foo();
 function run_test() {
  run_next_test();
 }
 `,
       `
 foo();
-`),
-    invalidCode(`
+`
+    ),
+    invalidCode(
+      `
 foo();
 function run_test() {
   run_next_test();
 }
 bar();
 `,
       `
 foo();
 bar();
-`),
-    invalidCode(`
+`
+    ),
+    invalidCode(
+      `
 foo();
 
 function run_test() {
   run_next_test();
 }
 
 bar();`,
       `
 foo();
 
-bar();`),
-    invalidCode(`
+bar();`
+    ),
+    invalidCode(
+      `
 foo();
 
 function run_test() {
   run_next_test();
 }
 
 // A comment
 bar();
 `,
       `
 foo();
 
 // A comment
 bar();
-`),
-    invalidCode(`
+`
+    ),
+    invalidCode(
+      `
 foo();
 
 /**
  * A useful comment.
  */
 function run_test() {
   run_next_test();
 }
@@ -104,11 +113,12 @@ bar();
 foo();
 
 /**
  * A useful comment.
  */
 
 // A comment
 bar();
-`),
+`
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/reject-importGlobalProperties.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/reject-importGlobalProperties.js
@@ -12,28 +12,35 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 8 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 ruleTester.run("reject-importGlobalProperties", rule, {
-  valid: [{
-    code: "Cu.something();",
-  }, {
-    options: ["allownonwebidl"],
-    code: "Cu.importGlobalProperties(['fetch'])",
-  }],
-  invalid: [{
-    code: "Cu.importGlobalProperties(['fetch'])",
-    options: ["everything"],
-    errors: [{ messageId: "unexpectedCall"}],
-  }, {
-    code: "Cu.importGlobalProperties(['TextEncoder'])",
-    options: ["everything"],
-    errors: [{ messageId: "unexpectedCall"}],
-  }, {
-    code: "Cu.importGlobalProperties(['TextEncoder'])",
-    options: ["allownonwebidl"],
-    errors: [{ messageId: "unexpectedCallWebIdl"}],
-  }],
+  valid: [
+    {
+      code: "Cu.something();",
+    },
+    {
+      options: ["allownonwebidl"],
+      code: "Cu.importGlobalProperties(['fetch'])",
+    },
+  ],
+  invalid: [
+    {
+      code: "Cu.importGlobalProperties(['fetch'])",
+      options: ["everything"],
+      errors: [{ messageId: "unexpectedCall" }],
+    },
+    {
+      code: "Cu.importGlobalProperties(['TextEncoder'])",
+      options: ["everything"],
+      errors: [{ messageId: "unexpectedCall" }],
+    },
+    {
+      code: "Cu.importGlobalProperties(['TextEncoder'])",
+      options: ["allownonwebidl"],
+      errors: [{ messageId: "unexpectedCallWebIdl" }],
+    },
+  ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/rejects-requires-await.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/rejects-requires-await.js
@@ -12,17 +12,17 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 8 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, messageId) {
-  return {code, errors: [{messageId: "rejectRequiresAwait"}]};
+  return { code, errors: [{ messageId: "rejectRequiresAwait" }] };
 }
 
 ruleTester.run("reject-requires-await", rule, {
   valid: [
     "async() => { await Assert.rejects(foo, /assertion/) }",
     "async() => { await Assert.rejects(foo, /assertion/, 'msg') }",
   ],
   invalid: [
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-cc-etc.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-cc-etc.js
@@ -12,26 +12,44 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, originalName, newName) {
-  return {code, errors: [{
-    message: `Use ${newName} rather than ${originalName}`,
-    type: "MemberExpression",
-  }]};
+  return {
+    code,
+    errors: [
+      {
+        message: `Use ${newName} rather than ${originalName}`,
+        type: "MemberExpression",
+      },
+    ],
+  };
 }
 
 ruleTester.run("use-cc-etc", rule, {
-  valid: [
-    "Components.Constructor();",
-    "let x = Components.foo;",
-  ],
+  valid: ["Components.Constructor();", "let x = Components.foo;"],
   invalid: [
-    invalidCode("let foo = Components.classes['bar'];", "Components.classes", "Cc"),
-    invalidCode("let bar = Components.interfaces.bar;", "Components.interfaces", "Ci"),
-    invalidCode("Components.results.NS_ERROR_ILLEGAL_INPUT;", "Components.results", "Cr"),
-    invalidCode("Components.utils.reportError('fake');", "Components.utils", "Cu"),
+    invalidCode(
+      "let foo = Components.classes['bar'];",
+      "Components.classes",
+      "Cc"
+    ),
+    invalidCode(
+      "let bar = Components.interfaces.bar;",
+      "Components.interfaces",
+      "Ci"
+    ),
+    invalidCode(
+      "Components.results.NS_ERROR_ILLEGAL_INPUT;",
+      "Components.results",
+      "Cr"
+    ),
+    invalidCode(
+      "Components.utils.reportError('fake');",
+      "Components.utils",
+      "Cu"
+    ),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-generateqi.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-generateqi.js
@@ -12,35 +12,37 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function callError(message) {
-  return [{message, type: "CallExpression"}];
+  return [{ message, type: "CallExpression" }];
 }
 function error(message, type) {
-  return [{message, type}];
+  return [{ message, type }];
 }
 
-const MSG_NO_JS_QUERY_INTERFACE = (
+const MSG_NO_JS_QUERY_INTERFACE =
   "Please use ChromeUtils.generateQI rather than manually creating " +
-  "JavaScript QueryInterface functions");
+  "JavaScript QueryInterface functions";
 
-const MSG_NO_XPCOMUTILS_GENERATEQI = (
-  "Please use ChromeUtils.generateQI instead of XPCOMUtils.generateQI");
+const MSG_NO_XPCOMUTILS_GENERATEQI =
+  "Please use ChromeUtils.generateQI instead of XPCOMUtils.generateQI";
 
 /* globals nsIFlug */
 function QueryInterface(iid) {
-  if (iid.equals(Ci.nsISupports) ||
-      iid.equals(Ci.nsIMeh) ||
-      iid.equals(nsIFlug) ||
-      iid.equals(Ci.amIFoo)) {
+  if (
+    iid.equals(Ci.nsISupports) ||
+    iid.equals(Ci.nsIMeh) ||
+    iid.equals(nsIFlug) ||
+    iid.equals(Ci.amIFoo)
+  ) {
     return this;
   }
   throw Cr.NS_ERROR_NO_INTERFACE;
 }
 
 ruleTester.run("use-chromeutils-generateqi", rule, {
   valid: [
     `X.prototype.QueryInterface = ChromeUtils.generateQI(["nsIMeh"]);`,
@@ -58,20 +60,22 @@ ruleTester.run("use-chromeutils-generate
       errors: callError(MSG_NO_XPCOMUTILS_GENERATEQI),
     },
     {
       code: `X.prototype = { QueryInterface: ${QueryInterface} };`,
       output: `X.prototype = { QueryInterface: ChromeUtils.generateQI(["nsIMeh", "nsIFlug", "amIFoo"]) };`,
       errors: error(MSG_NO_JS_QUERY_INTERFACE, "Property"),
     },
     {
-      code: `X.prototype = { ${String(QueryInterface).replace(/^function /, "")} };`,
+      code: `X.prototype = { ${String(QueryInterface).replace(
+        /^function /,
+        ""
+      )} };`,
       output: `X.prototype = { QueryInterface: ChromeUtils.generateQI(["nsIMeh", "nsIFlug", "amIFoo"]) };`,
       errors: error(MSG_NO_JS_QUERY_INTERFACE, "Property"),
     },
     {
       code: `X.prototype.QueryInterface = ${QueryInterface};`,
       output: `X.prototype.QueryInterface = ChromeUtils.generateQI(["nsIMeh", "nsIFlug", "amIFoo"]);`,
       errors: error(MSG_NO_JS_QUERY_INTERFACE, "AssignmentExpression"),
     },
   ],
 });
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-import.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-chromeutils-import.js
@@ -12,37 +12,38 @@ var RuleTester = require("eslint/lib/tes
 
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function callError(message) {
-  return [{message, type: "CallExpression"}];
+  return [{ message, type: "CallExpression" }];
 }
 
 const MESSAGE_IMPORT = "Please use ChromeUtils.import instead of Cu.import";
-const MESSAGE_DEFINE = ("Please use ChromeUtils.defineModuleGetter instead of " +
-                        "XPCOMUtils.defineLazyModuleGetter");
+const MESSAGE_DEFINE =
+  "Please use ChromeUtils.defineModuleGetter instead of " +
+  "XPCOMUtils.defineLazyModuleGetter";
 
 ruleTester.run("use-chromeutils-import", rule, {
   valid: [
     `ChromeUtils.import("resource://gre/modules/Service.jsm");`,
     `ChromeUtils.import("resource://gre/modules/Service.jsm", this);`,
     `ChromeUtils.defineModuleGetter(this, "Services",
                                     "resource://gre/modules/Service.jsm");`,
     `XPCOMUtils.defineLazyModuleGetter(this, "Services",
                                        "resource://gre/modules/Service.jsm",
                                        "Foo");`,
     `XPCOMUtils.defineLazyModuleGetter(this, "Services",
                                        "resource://gre/modules/Service.jsm",
                                        undefined, preServicesLambda);`,
     {
-      options: [{allowCu: true}],
+      options: [{ allowCu: true }],
       code: `Cu.import("resource://gre/modules/Service.jsm");`,
     },
   ],
   invalid: [
     {
       code: `Cu.import("resource://gre/modules/Services.jsm");`,
       output: `ChromeUtils.import("resource://gre/modules/Services.jsm");`,
       errors: callError(MESSAGE_IMPORT),
@@ -58,23 +59,22 @@ ruleTester.run("use-chromeutils-import",
       errors: callError(MESSAGE_IMPORT),
     },
     {
       code: `Components.utils.import("resource://gre/modules/Services.jsm");`,
       output: `ChromeUtils.import("resource://gre/modules/Services.jsm");`,
       errors: callError(MESSAGE_IMPORT),
     },
     {
-      options: [{allowCu: true}],
+      options: [{ allowCu: true }],
       code: `Components.utils.import("resource://gre/modules/Services.jsm", this);`,
       output: `ChromeUtils.import("resource://gre/modules/Services.jsm", this);`,
       errors: callError(MESSAGE_IMPORT),
     },
     {
       code: `XPCOMUtils.defineLazyModuleGetter(this, "Services",
                                                "resource://gre/modules/Services.jsm");`,
       output: `ChromeUtils.defineModuleGetter(this, "Services",
                                                "resource://gre/modules/Services.jsm");`,
       errors: callError(MESSAGE_DEFINE),
     },
   ],
 });
-
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-default-preference-values.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-default-preference-values.js
@@ -13,27 +13,30 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code) {
   let message = "provide a default value instead of using a try/catch block";
-  return {code, errors: [{message, type: "TryStatement"}]};
+  return { code, errors: [{ message, type: "TryStatement" }] };
 }
 
 let types = ["Bool", "Char", "Float", "Int"];
 let methods = types.map(type => "get" + type + "Pref");
 
 ruleTester.run("use-default-preference-values", rule, {
   valid: [].concat(
     methods.map(m => "blah = branch." + m + "('blah', true);"),
     methods.map(m => "blah = branch." + m + "('blah');"),
-    methods.map(m => "try { canThrow();" +
-                          " blah = branch." + m + "('blah'); } catch(e) {}")
+    methods.map(
+      m =>
+        "try { canThrow();" + " blah = branch." + m + "('blah'); } catch(e) {}"
+    )
   ),
 
   invalid: [].concat(
     methods.map(m =>
-      invalidCode("try { blah = branch." + m + "('blah'); } catch(e) {}"))
+      invalidCode("try { blah = branch." + m + "('blah'); } catch(e) {}")
+    )
   ),
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-includes-instead-of-indexOf.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-includes-instead-of-indexOf.js
@@ -13,17 +13,17 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code) {
   let message = "use .includes instead of .indexOf";
-  return {code, errors: [{message, type: "BinaryExpression"}]};
+  return { code, errors: [{ message, type: "BinaryExpression" }] };
 }
 
 ruleTester.run("use-includes-instead-of-indexOf", rule, {
   valid: [
     "let a = foo.includes(bar);",
     "let a = foo.indexOf(bar) > 0;",
     "let a = foo.indexOf(bar) != 0;",
   ],
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-ownerGlobal.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-ownerGlobal.js
@@ -13,24 +13,23 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code) {
   let message = "use .ownerGlobal instead of .ownerDocument.defaultView";
-  return {code, errors: [{message, type: "MemberExpression"}]};
+  return { code, errors: [{ message, type: "MemberExpression" }] };
 }
 
 ruleTester.run("use-ownerGlobal", rule, {
   valid: [
     "aEvent.target.ownerGlobal;",
     "this.DOMPointNode.ownerGlobal.getSelection();",
     "windowToMessageManager(node.ownerGlobal);",
   ],
   invalid: [
     invalidCode("aEvent.target.ownerDocument.defaultView;"),
-    invalidCode(
-      "this.DOMPointNode.ownerDocument.defaultView.getSelection();"),
+    invalidCode("this.DOMPointNode.ownerDocument.defaultView.getSelection();"),
     invalidCode("windowToMessageManager(node.ownerDocument.defaultView);"),
   ],
 });
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-returnValue.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-returnValue.js
@@ -13,17 +13,17 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, methodName) {
   let message = `{Array/String}.${methodName} doesn't modify the instance in-place`;
-  return {code, errors: [{message, type: "ExpressionStatement"}]};
+  return { code, errors: [{ message, type: "ExpressionStatement" }] };
 }
 
 ruleTester.run("use-returnValue", rule, {
   valid: [
     "a = foo.concat(bar)",
     "b = bar.concat([1,3,4])",
     "c = baz.concat()",
     "d = qux.join(' ')",
--- a/tools/lint/eslint/eslint-plugin-mozilla/tests/use-services.js
+++ b/tools/lint/eslint/eslint-plugin-mozilla/tests/use-services.js
@@ -13,25 +13,28 @@ var RuleTester = require("eslint/lib/tes
 const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
 function invalidCode(code, name) {
   let message = `Use Services.${name} rather than getService().`;
-  return {code, errors: [{message, type: "CallExpression"}]};
+  return { code, errors: [{ message, type: "CallExpression" }] };
 }
 
 ruleTester.run("use-services", rule, {
   valid: [
     'Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator)',
     'Components.classes["@mozilla.org/uuid-generator;1"].getService(Components.interfaces.nsIUUIDGenerator)',
     "Services.wm.addListener()",
   ],
   invalid: [
-    invalidCode('Cc["@mozilla.org/appshell/window-mediator;1"].getService(Ci.nsIWindowMediator);',
-      "wm"),
+    invalidCode(
+      'Cc["@mozilla.org/appshell/window-mediator;1"].getService(Ci.nsIWindowMediator);',
+      "wm"
+    ),
     invalidCode(
       'Components.classes["@mozilla.org/toolkit/app-startup;1"].getService(Components.interfaces.nsIAppStartup);',
-      "startup"),
+      "startup"
+    ),
   ],
 });
--- a/tools/profiler/tests/browser/browser_test_feature_jsallocations.js
+++ b/tools/profiler/tests/browser/browser_test_feature_jsallocations.js
@@ -6,93 +6,115 @@
  * Test the JS Allocations feature. This is done as a browser test to ensure that
  * we realistically try out how the JS allocations are running. This ensures that
  * we are collecting allocations for the content process and the parent process.
  */
 add_task(async function test_profile_feature_jsallocations() {
   if (!AppConstants.MOZ_GECKO_PROFILER) {
     return;
   }
-  Assert.ok(!Services.profiler.IsActive(), "The profiler is not currently active");
+  Assert.ok(
+    !Services.profiler.IsActive(),
+    "The profiler is not currently active"
+  );
 
   startProfiler({ features: ["threads", "js", "jsallocations"] });
 
   const url = BASE_URL + "do_work_500ms.html";
-  await BrowserTestUtils.withNewTab(url, async (contentBrowser) => {
-    const contentPid = await ContentTask.spawn(contentBrowser, null,
-      () => Services.appinfo.processID);
+  await BrowserTestUtils.withNewTab(url, async contentBrowser => {
+    const contentPid = await ContentTask.spawn(
+      contentBrowser,
+      null,
+      () => Services.appinfo.processID
+    );
 
-      // Wait 500ms so that the tab finishes executing.
-      await wait(500);
+    // Wait 500ms so that the tab finishes executing.
+    await wait(500);
 
-      // Check that we can get some allocations when the feature is turned on.
-      {
-        const { parentThread, contentThread } = await stopProfilerAndGetThreads(contentPid);
-        Assert.greater(getPayloadsOfType(parentThread, "JS allocation").length, 0,
-          "Allocations were recorded for the parent process' main thread when the " +
-            "JS Allocation feature was turned on.");
-        Assert.greater(getPayloadsOfType(contentThread, "JS allocation").length, 0,
-          "Allocations were recorded for the content process' main thread when the " +
-            "JS Allocation feature was turned on.");
-      }
+    // Check that we can get some allocations when the feature is turned on.
+    {
+      const { parentThread, contentThread } = await stopProfilerAndGetThreads(
+        contentPid
+      );
+      Assert.greater(
+        getPayloadsOfType(parentThread, "JS allocation").length,
+        0,
+        "Allocations were recorded for the parent process' main thread when the " +
+          "JS Allocation feature was turned on."
+      );
+      Assert.greater(
+        getPayloadsOfType(contentThread, "JS allocation").length,
+        0,
+        "Allocations were recorded for the content process' main thread when the " +
+          "JS Allocation feature was turned on."
+      );
+    }
 
-      // Flush out any straggling allocation markers that may have not been collected
-      // yet by starting and stopping the profiler once.
-      startProfiler({ features: ["threads", "js"] });
-      await stopProfilerAndGetThreads(contentPid);
+    // Flush out any straggling allocation markers that may have not been collected
+    // yet by starting and stopping the profiler once.
+    startProfiler({ features: ["threads", "js"] });
+    await stopProfilerAndGetThreads(contentPid);
 
-      // Now reload the tab with a clean run.
-      gBrowser.reload();
-      await wait(500);
-      startProfiler({ features: ["threads", "js"] });
+    // Now reload the tab with a clean run.
+    gBrowser.reload();
+    await wait(500);
+    startProfiler({ features: ["threads", "js"] });
 
-      // Check that no allocations were recorded, and allocation tracking was correctly
-      // turned off.
-      {
-        const { parentThread, contentThread } = await stopProfilerAndGetThreads(contentPid);
-        Assert.equal(
-          getPayloadsOfType(parentThread, "JS allocation").length, 0,
-          "No allocations were recorded for the parent processes' main thread when " +
-            "JS allocation was not turned on.");
+    // Check that no allocations were recorded, and allocation tracking was correctly
+    // turned off.
+    {
+      const { parentThread, contentThread } = await stopProfilerAndGetThreads(
+        contentPid
+      );
+      Assert.equal(
+        getPayloadsOfType(parentThread, "JS allocation").length,
+        0,
+        "No allocations were recorded for the parent processes' main thread when " +
+          "JS allocation was not turned on."
+      );
 
-        Assert.equal(
-          getPayloadsOfType(contentThread, "JS allocation").length, 0,
-          "No allocations were recorded for the content processes' main thread when " +
-            "JS allocation was not turned on.");
-      }
+      Assert.equal(
+        getPayloadsOfType(contentThread, "JS allocation").length,
+        0,
+        "No allocations were recorded for the content processes' main thread when " +
+          "JS allocation was not turned on."
+      );
+    }
   });
 });
 
 /**
  * Markers are collected only after a periodic sample. This function ensures that
  * at least one periodic sample has been done.
  */
 async function doAtLeastOnePeriodicSample() {
   async function getProfileSampleCount() {
     const profile = await Services.profiler.getProfileDataAsync();
     return profile.threads[0].samples.data.length;
   }
 
   const sampleCount = await getProfileSampleCount();
   // Create an infinite loop until a sample has been collected.
   while (true) {
-    if (sampleCount < await getProfileSampleCount()) {
+    if (sampleCount < (await getProfileSampleCount())) {
       return;
     }
   }
 }
 
 async function stopProfilerAndGetThreads(contentPid) {
   await doAtLeastOnePeriodicSample();
 
   const profile = await Services.profiler.getProfileDataAsync();
   Services.profiler.StopProfiler();
 
   const parentThread = profile.threads[0];
-  const contentProcess = profile.processes.find(p => p.threads[0].pid == contentPid);
+  const contentProcess = profile.processes.find(
+    p => p.threads[0].pid == contentPid
+  );
   if (!contentProcess) {
     throw new Error("Could not find the content process.");
   }
   const contentThread = contentProcess.threads[0];
 
   if (!parentThread) {
     throw new Error("The parent thread was not found in the profile.");
   }
--- a/tools/profiler/tests/browser/browser_test_profile_multi_frame_page_info.js
+++ b/tools/profiler/tests/browser/browser_test_profile_multi_frame_page_info.js
@@ -19,17 +19,19 @@ add_task(async function test_profile_sin
     });
   });
 
   const profile = await Services.profiler.getProfileDataAsync();
   Services.profiler.StopProfiler();
 
   let pageFound = false;
   // We need to find the correct content process for that tab.
-  let contentProcess = profile.processes.find(p => p.threads[0].pid == contentPid);
+  let contentProcess = profile.processes.find(
+    p => p.threads[0].pid == contentPid
+  );
   for (const page of contentProcess.pages) {
     if (page.url == url) {
       Assert.equal(page.url, url);
       Assert.equal(typeof page.docshellId, "string");
       Assert.equal(typeof page.historyId, "number");
       Assert.equal(page.isSubFrame, false);
       pageFound = true;
       break;
--- a/tools/profiler/tests/browser/browser_test_profile_pushstate_page_info.js
+++ b/tools/profiler/tests/browser/browser_test_profile_pushstate_page_info.js
@@ -19,17 +19,19 @@ add_task(async function test_profile_pus
     });
   });
 
   const profile = await Services.profiler.getProfileDataAsync();
   Services.profiler.StopProfiler();
 
   let foundPage = 0;
   // We need to find the correct content process for that tab.
-  let contentProcess = profile.processes.find(p => p.threads[0].pid == contentPid);
+  let contentProcess = profile.processes.find(
+    p => p.threads[0].pid == contentPid
+  );
   for (const page of contentProcess.pages) {
     // Before pushState
     if (page.url == url) {
       Assert.equal(page.url, url);
       Assert.equal(typeof page.docshellId, "string");
       Assert.equal(typeof page.historyId, "number");
       Assert.equal(page.isSubFrame, false);
       foundPage++;
--- a/tools/profiler/tests/browser/browser_test_profile_replacestate_page_info.js
+++ b/tools/profiler/tests/browser/browser_test_profile_replacestate_page_info.js
@@ -19,17 +19,19 @@ add_task(async function test_profile_rep
     });
   });
 
   const profile = await Services.profiler.getProfileDataAsync();
   Services.profiler.StopProfiler();
 
   let foundPage = 0;
   // We need to find the correct content process for that tab.
-  let contentProcess = profile.processes.find(p => p.threads[0].pid == contentPid);
+  let contentProcess = profile.processes.find(
+    p => p.threads[0].pid == contentPid
+  );
   for (const page of contentProcess.pages) {
     // Before replaceState
     if (page.url == url) {
       Assert.equal(page.url, url);
       Assert.equal(typeof page.docshellId, "string");
       Assert.equal(typeof page.historyId, "number");
       Assert.equal(page.isSubFrame, false);
       foundPage++;
--- a/tools/profiler/tests/browser/browser_test_profile_single_frame_page_info.js
+++ b/tools/profiler/tests/browser/browser_test_profile_single_frame_page_info.js
@@ -20,17 +20,19 @@ add_task(async function test_profile_mul
     });
   });
 
   const profile = await Services.profiler.getProfileDataAsync();
   Services.profiler.StopProfiler();
 
   let foundPage = 0;
   // We need to find the correct content process for that tab.
-  let contentProcess = profile.processes.find(p => p.threads[0].pid == contentPid);
+  let contentProcess = profile.processes.find(
+    p => p.threads[0].pid == contentPid
+  );
   for (const page of contentProcess.pages) {
     // Parent page
     if (page.url == url) {
       Assert.equal(page.url, url);
       Assert.equal(typeof page.docshellId, "string");
       Assert.equal(typeof page.historyId, "number");
       Assert.equal(page.isSubFrame, false);
       foundPage++;
--- a/tools/profiler/tests/browser/head.js
+++ b/tools/profiler/tests/browser/head.js
@@ -1,10 +1,11 @@
-
-const { BrowserTestUtils } = ChromeUtils.import("resource://testing-common/BrowserTestUtils.jsm");
+const { BrowserTestUtils } = ChromeUtils.import(
+  "resource://testing-common/BrowserTestUtils.jsm"
+);
 
 const BASE_URL = "http://example.com/browser/tools/profiler/tests/browser/";
 
 const defaultSettings = {
   entries: 1000000, // 9MB
   interval: 1, // ms
   features: ["threads"],
   threads: ["GeckoMain"],
@@ -39,17 +40,17 @@ function wait(time) {
 /**
  * Get the payloads of a type from a single thread.
  *
  * @param {Object} thread The thread from a profile.
  * @param {string} type The marker payload type, e.g. "DiskIO".
  * @return {Array} The payloads.
  */
 function getPayloadsOfType(thread, type) {
-  const {markers} = thread;
+  const { markers } = thread;
   const results = [];
   for (const markerTuple of markers.data) {
     const payload = markerTuple[markers.schema.data];
     if (payload && payload.type === type) {
       results.push(payload);
     }
   }
   return results;
--- a/tools/profiler/tests/chrome/profiler_test_utils.js
+++ b/tools/profiler/tests/chrome/profiler_test_utils.js
@@ -1,59 +1,63 @@
 "use strict";
 
 (function() {
-const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
-
-function startProfiler(settings) {
-  Services.profiler.StartProfiler(
-    settings.entries,
-    settings.interval,
-    settings.features,
-    settings.threads,
-    settings.duration
+  const { Services } = ChromeUtils.import(
+    "resource://gre/modules/Services.jsm"
   );
 
-  info("Profiler has started");
-}
+  function startProfiler(settings) {
+    Services.profiler.StartProfiler(
+      settings.entries,
+      settings.interval,
+      settings.features,
+      settings.threads,
+      settings.duration
+    );
 
-function getProfile() {
-  const profile = Services.profiler.getProfileData();
-  info("We got a profile, run the mochitest with `--keep-open true` to see the logged profile in the Web Console.");
+    info("Profiler has started");
+  }
 
-  // Run the mochitest with `--keep-open true` to see the logged profile in the
-  // Web console.
-  console.log(profile);
+  function getProfile() {
+    const profile = Services.profiler.getProfileData();
+    info(
+      "We got a profile, run the mochitest with `--keep-open true` to see the logged profile in the Web Console."
+    );
 
-  return profile;
-}
+    // Run the mochitest with `--keep-open true` to see the logged profile in the
+    // Web console.
+    console.log(profile);
 
-function stopProfiler() {
-  Services.profiler.StopProfiler();
-  info("Profiler has stopped");
-}
+    return profile;
+  }
 
-function end(error) {
-  if (error) {
-    ok(false, `We got an error: ${error}`);
-  } else {
-    ok(true, "We ran the whole process");
+  function stopProfiler() {
+    Services.profiler.StopProfiler();
+    info("Profiler has stopped");
   }
-  SimpleTest.finish();
-}
+
+  function end(error) {
+    if (error) {
+      ok(false, `We got an error: ${error}`);
+    } else {
+      ok(true, "We ran the whole process");
+    }
+    SimpleTest.finish();
+  }
 
-async function runTest(settings, workload) {
-  SimpleTest.waitForExplicitFinish();
-  try {
-    await startProfiler(settings);
-    await workload();
-    await getProfile();
-    await stopProfiler();
-    await end();
-  } catch (e) {
-    // By catching and handling the error, we're being nice to mochitest
-    // runners: instead of waiting for the timeout, we fail right away.
-    await end(e);
+  async function runTest(settings, workload) {
+    SimpleTest.waitForExplicitFinish();
+    try {
+      await startProfiler(settings);
+      await workload();
+      await getProfile();
+      await stopProfiler();
+      await end();
+    } catch (e) {
+      // By catching and handling the error, we're being nice to mochitest
+      // runners: instead of waiting for the timeout, we fail right away.
+      await end(e);
+    }
   }
-}
 
-window.runTest = runTest;
+  window.runTest = runTest;
 })();
--- a/tools/profiler/tests/xpcshell/head_profiler.js
+++ b/tools/profiler/tests/xpcshell/head_profiler.js
@@ -1,42 +1,43 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
-  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-var {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
-var {AppConstants} = ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
-var {setTimeout} = ChromeUtils.import("resource://gre/modules/Timer.jsm");
+var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+var { AppConstants } = ChromeUtils.import(
+  "resource://gre/modules/AppConstants.jsm"
+);
+var { setTimeout } = ChromeUtils.import("resource://gre/modules/Timer.jsm");
 
 /**
  * Get the payloads of a type recursively, including from all subprocesses.
  *
  * @param {Object} profile The gecko profile.
  * @param {string} type The marker payload type, e.g. "DiskIO".
  * @param {Array} payloadTarget The recursive list of payloads.
  * @return {Array} The final payloads.
  */
 function getAllPayloadsOfType(profile, type, payloadTarget = []) {
-  for (const {markers} of profile.threads) {
+  for (const { markers } of profile.threads) {
     for (const markerTuple of markers.data) {
       const payload = markerTuple[markers.schema.data];
       if (payload && payload.type === type) {
         payloadTarget.push(payload);
       }
     }
   }
 
   for (const subProcess of profile.processes) {
     getAllPayloadsOfType(subProcess, type, payloadTarget);
   }
 
   return payloadTarget;
 }
 
-
 /**
  * This is a helper function be able to run `await wait(500)`. Unfortunately this
  * is needed as the act of collecting functions relies on the periodic sampling of
  * the threads. See: https://bugzilla.mozilla.org/show_bug.cgi?id=1529053
  *
  * @param {number} time
  * @returns {Promise}
  */
--- a/tools/profiler/tests/xpcshell/test_asm.js
+++ b/tools/profiler/tests/xpcshell/test_asm.js
@@ -1,77 +1,81 @@
 // Check that asm.js code shows up on the stack.
 function run_test() {
-    // Just skip the test if the profiler component isn't present.
-    if (!AppConstants.MOZ_GECKO_PROFILER) {
-      return;
-    }
+  // Just skip the test if the profiler component isn't present.
+  if (!AppConstants.MOZ_GECKO_PROFILER) {
+    return;
+  }
 
-    // This test assumes that it's starting on an empty profiler stack.
-    // (Note that the other profiler tests also assume the profiler
-    // isn't already started.)
-    Assert.ok(!Services.profiler.IsActive());
+  // This test assumes that it's starting on an empty profiler stack.
+  // (Note that the other profiler tests also assume the profiler
+  // isn't already started.)
+  Assert.ok(!Services.profiler.IsActive());
 
-    let jsFuns = Cu.getJSTestingFunctions();
-    if (!jsFuns.isAsmJSCompilationAvailable())
-        return;
+  let jsFuns = Cu.getJSTestingFunctions();
+  if (!jsFuns.isAsmJSCompilationAvailable()) {
+    return;
+  }
 
-    const ms = 10;
-    Services.profiler.StartProfiler(10000, ms, ["js"]);
+  const ms = 10;
+  Services.profiler.StartProfiler(10000, ms, ["js"]);
 
-    let stack = null;
-    function ffi_function() {
-        var delayMS = 5;
-        while (1) {
-            let then = Date.now();
-            do {
-              // do nothing
-            } while (Date.now() - then < delayMS);
+  let stack = null;
+  function ffi_function() {
+    var delayMS = 5;
+    while (1) {
+      let then = Date.now();
+      do {
+        // do nothing
+      } while (Date.now() - then < delayMS);
 
-            var thread0 = Services.profiler.getProfileData().threads[0];
+      var thread0 = Services.profiler.getProfileData().threads[0];
 
-            if (delayMS > 30000)
-                return;
+      if (delayMS > 30000) {
+        return;
+      }
 
-            delayMS *= 2;
+      delayMS *= 2;
 
-            if (thread0.samples.data.length == 0)
-                continue;
+      if (thread0.samples.data.length == 0) {
+        continue;
+      }
 
-            var lastSample = thread0.samples.data[thread0.samples.data.length - 1];
-            stack = String(getInflatedStackLocations(thread0, lastSample));
-            if (stack.includes("trampoline"))
-                return;
-        }
+      var lastSample = thread0.samples.data[thread0.samples.data.length - 1];
+      stack = String(getInflatedStackLocations(thread0, lastSample));
+      if (stack.includes("trampoline")) {
+        return;
+      }
     }
+  }
 
-    function asmjs_module(global, ffis) {
-        "use asm";
-        var ffi = ffis.ffi;
-        function asmjs_function() {
-            ffi();
-        }
-        return asmjs_function;
+  function asmjs_module(global, ffis) {
+    "use asm";
+    var ffi = ffis.ffi;
+    function asmjs_function() {
+      ffi();
     }
+    return asmjs_function;
+  }
 
-    Assert.ok(jsFuns.isAsmJSModule(asmjs_module));
+  Assert.ok(jsFuns.isAsmJSModule(asmjs_module));
 
-    var asmjs_function = asmjs_module(null, {ffi: ffi_function});
-    Assert.ok(jsFuns.isAsmJSFunction(asmjs_function));
+  var asmjs_function = asmjs_module(null, { ffi: ffi_function });
+  Assert.ok(jsFuns.isAsmJSFunction(asmjs_function));
 
-    asmjs_function();
+  asmjs_function();
 
-    Assert.notEqual(stack, null);
+  Assert.notEqual(stack, null);
 
-    var i1 = stack.indexOf("entry trampoline");
-    Assert.ok(i1 !== -1);
-    var i2 = stack.indexOf("asmjs_function");
-    Assert.ok(i2 !== -1);
-    var i3 = stack.indexOf("exit trampoline");
-    Assert.ok(i3 !== -1);
-    var i4 = stack.indexOf("ffi_function");
-    Assert.ok(i4 !== -1);
-    Assert.ok(i1 < i2);
-    Assert.ok(i2 < i3);
-    Assert.ok(i3 < i4);
+  var i1 = stack.indexOf("entry trampoline");
+  Assert.ok(i1 !== -1);
+  var i2 = stack.indexOf("asmjs_function");
+  Assert.ok(i2 !== -1);
+  var i3 = stack.indexOf("exit trampoline");
+  Assert.ok(i3 !== -1);
+  var i4 = stack.indexOf("ffi_function");
+  Assert.ok(i4 !== -1);
+  Assert.ok(i1 < i2);
+  Assert.ok(i2 < i3);
+  Assert.ok(i3 < i4);
 
-    Services.profiler.StopProfiler();
+  Services.profiler.StopProfiler();
 }
--- a/tools/profiler/tests/xpcshell/test_enterjit_osr.js
+++ b/tools/profiler/tests/xpcshell/test_enterjit_osr.js
@@ -1,52 +1,55 @@
 // Check that the EnterJIT frame, added by the JIT trampoline and
 // usable by a native unwinder to resume unwinding after encountering
 // JIT code, is pushed as expected.
 function run_test() {
-    if (!AppConstants.MOZ_GECKO_PROFILER) {
-      return;
-    }
+  if (!AppConstants.MOZ_GECKO_PROFILER) {
+    return;
+  }
+
+  // This test assumes that it's starting on an empty profiler stack.
+  // (Note that the other profiler tests also assume the profiler
+  // isn't already started.)
+  Assert.ok(!Services.profiler.IsActive());
+
+  const ms = 5;
+  Services.profiler.StartProfiler(10000, ms, ["js"]);
 
-    // This test assumes that it's starting on an empty profiler stack.
-    // (Note that the other profiler tests also assume the profiler
-    // isn't already started.)
-    Assert.ok(!Services.profiler.IsActive());
-
-    const ms = 5;
-    Services.profiler.StartProfiler(10000, ms, ["js"]);
+  function has_arbitrary_name_in_stack() {
+    // A frame for |arbitrary_name| has been pushed.  Do a sequence of
+    // increasingly long spins until we get a sample.
+    var delayMS = 5;
+    while (1) {
+      info("loop: ms = " + delayMS);
+      const then = Date.now();
+      do {
+        let n = 10000;
+        while (--n) {} // OSR happens here
+        // Spin in the hope of getting a sample.
+      } while (Date.now() - then < delayMS);
+      let profile = Services.profiler.getProfileData().threads[0];
 
-    function has_arbitrary_name_in_stack() {
-        // A frame for |arbitrary_name| has been pushed.  Do a sequence of
-        // increasingly long spins until we get a sample.
-        var delayMS = 5;
-        while (1) {
-            info("loop: ms = " + delayMS);
-            const then = Date.now();
-            do {
-                let n = 10000;
-                while (--n); // OSR happens here
-                // Spin in the hope of getting a sample.
-            } while (Date.now() - then < delayMS);
-            let profile = Services.profiler.getProfileData().threads[0];
+      // Go through all of the stacks, and search for this function name.
+      for (const sample of profile.samples.data) {
+        const stack = getInflatedStackLocations(profile, sample);
+        info(`The following stack was found: ${stack}`);
+        for (var i = 0; i < stack.length; i++) {
+          if (stack[i].match(/arbitrary_name/)) {
+            // This JS sample was correctly found.
+            return true;
+          }
+        }
+      }
 
-            // Go through all of the stacks, and search for this function name.
-            for (const sample of profile.samples.data) {
-                const stack = getInflatedStackLocations(profile, sample);
-                info(`The following stack was found: ${stack}`);
-                for (var i = 0; i < stack.length; i++) {
-                    if (stack[i].match(/arbitrary_name/)) {
-                        // This JS sample was correctly found.
-                        return true;
-                    }
-                }
-            }
-
-            // Continue running this function with an increasingly long delay.
-            delayMS *= 2;
-            if (delayMS > 30000) {
-                return false;
-            }
-        }
+      // Continue running this function with an increasingly long delay.
+      delayMS *= 2;
+      if (delayMS > 30000) {
+        return false;
+      }
     }
-    Assert.ok(has_arbitrary_name_in_stack(), "A JS frame was found before the test timeout.");
-    Services.profiler.StopProfiler();
+  }
+  Assert.ok(
+    has_arbitrary_name_in_stack(),
+    "A JS frame was found before the test timeout."
+  );
+  Services.profiler.StopProfiler();
 }
--- a/tools/profiler/tests/xpcshell/test_enterjit_osr_disabling.js
+++ b/tools/profiler/tests/xpcshell/test_enterjit_osr_disabling.js
@@ -6,13 +6,13 @@ function run_test() {
 
   Assert.ok(!Services.profiler.IsActive());
 
   Services.profiler.StartProfiler(100, 10, ["js"]);
   // The function is entered with the profiler enabled
   (function() {
     Services.profiler.StopProfiler();
     let n = 10000;
-    while (--n); // OSR happens here with the profiler disabled.
+    while (--n) {} // OSR happens here with the profiler disabled.
     // An assertion will fail when this function returns, if the
     // profiler stack was misbalanced.
   })();
 }
--- a/tools/profiler/tests/xpcshell/test_enterjit_osr_enabling.js
+++ b/tools/profiler/tests/xpcshell/test_enterjit_osr_enabling.js
@@ -4,14 +4,14 @@ function run_test() {
   }
 
   Assert.ok(!Services.profiler.IsActive());
 
   // The function is entered with the profiler disabled.
   (function() {
     Services.profiler.StartProfiler(100, 10, ["js"]);
     let n = 10000;
-    while (--n); // OSR happens here with the profiler enabled.
+    while (--n) {} // OSR happens here with the profiler enabled.
     // An assertion will fail when this function returns, if the
     // profiler stack was misbalanced.
   })();
   Services.profiler.StopProfiler();
 }
--- a/tools/profiler/tests/xpcshell/test_feature_mainthreadio.js
+++ b/tools/profiler/tests/xpcshell/test_feature_mainthreadio.js
@@ -1,13 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-const {FileUtils} = ChromeUtils.import("resource://gre/modules/FileUtils.jsm");
+const { FileUtils } = ChromeUtils.import(
+  "resource://gre/modules/FileUtils.jsm"
+);
 
 /**
  * Test that the IOInterposer is working correctly to capture main thread IO.
  *
  * This test should not run on release or beta, as the IOInterposer is wrapped in
  * an ifdef.
  */
 add_task(async () => {
@@ -16,43 +18,58 @@ add_task(async () => {
   }
 
   // Let the test harness settle, in order to avoid extraneous FileIO operations. This
   // helps avoid false positives that we are actually triggering FileIO.
   await wait(10);
 
   {
     const filename = "profiler-mainthreadio-test-firstrun";
-    const payloads = await startProfilerAndgetFileIOPayloads(["mainthreadio"], filename);
+    const payloads = await startProfilerAndgetFileIOPayloads(
+      ["mainthreadio"],
+      filename
+    );
 
-    greater(payloads.length, 0,
-       "FileIO markers were found when using the mainthreadio feature on the profiler.");
+    greater(
+      payloads.length,
+      0,
+      "FileIO markers were found when using the mainthreadio feature on the profiler."
+    );
 
     // It would be better to check on the filename, but Linux does not currently include
     // it. See https://bugzilla.mozilla.org/show_bug.cgi?id=1533531
     // ok(hasWritePayload(payloads, filename),
     //    "A FileIO marker is found when using the mainthreadio feature on the profiler.");
   }
 
   {
     const filename = "profiler-mainthreadio-test-no-instrumentation";
     const payloads = await startProfilerAndgetFileIOPayloads([], filename);
 
-    equal(payloads.length, 0,
-          "No FileIO markers are found when the mainthreadio feature is not turned on " +
-          "in the profiler.");
+    equal(
+      payloads.length,
+      0,
+      "No FileIO markers are found when the mainthreadio feature is not turned on " +
+        "in the profiler."
+    );
   }
 
   {
     const filename = "profiler-mainthreadio-test-secondrun";
-    const payloads = await startProfilerAndgetFileIOPayloads(["mainthreadio"], filename);
+    const payloads = await startProfilerAndgetFileIOPayloads(
+      ["mainthreadio"],
+      filename
+    );
 
-    greater(payloads.length, 0,
-       "FileIO markers were found when re-starting the mainthreadio feature on the " +
-       "profiler.");
+    greater(
+      payloads.length,
+      0,
+      "FileIO markers were found when re-starting the mainthreadio feature on the " +
+        "profiler."
+    );
     // It would be better to check on the filename, but Linux does not currently include
     // it. See https://bugzilla.mozilla.org/show_bug.cgi?id=1533531
     // ok(hasWritePayload(payloads, filename),
     //    "Re-enabling the mainthreadio re-installs the interposer, and we can capture " +
     //    "another FileIO payload.");
   }
 });
 
@@ -62,24 +79,23 @@ add_task(async () => {
  * @param {string} filename A filename to trigger a write operation
  */
 async function startProfilerAndgetFileIOPayloads(features, filename) {
   const entries = 10000;
   const interval = 10;
   const threads = [];
   Services.profiler.StartProfiler(entries, interval, features, threads);
 
-
   const file = FileUtils.getFile("TmpD", [filename]);
   if (file.exists()) {
     console.warn(
       "This test is triggering FileIO by writing to a file. However, the test found an " +
-      "existing file at the location it was trying to write to. This could happen " +
-      "because a previous run of the test failed to clean up after itself. This test " +
-      " will now clean up that file before running the test again."
+        "existing file at the location it was trying to write to. This could happen " +
+        "because a previous run of the test failed to clean up after itself. This test " +
+        " will now clean up that file before running the test again."
     );
     file.remove(false);
   }
 
   const outputStream = FileUtils.openSafeFileOutputStream(file);
 
   const data = "Test data.";
   outputStream.write(data, data.length);
--- a/tools/quitter/contentscript.js
+++ b/tools/quitter/contentscript.js
@@ -2,12 +2,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 /* eslint-env webextensions */
 
 const Quitter = {
-  quit() { browser.runtime.sendMessage("quit"); },
+  quit() {
+    browser.runtime.sendMessage("quit");
+  },
 };
 
-window.wrappedJSObject.Quitter = cloneInto(Quitter, window, {cloneFunctions: true});
+window.wrappedJSObject.Quitter = cloneInto(Quitter, window, {
+  cloneFunctions: true,
+});
--- a/tools/quitter/parent.js
+++ b/tools/quitter/parent.js
@@ -1,20 +1,22 @@
 "use strict";
 
 /* globals ExtensionAPI */
 
-const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
 
 this.quitter = class extends ExtensionAPI {
   getAPI(context) {
     return {
       quitter: {
         async quit() {
-          let browserWindow = Services.wm.getMostRecentWindow("navigator:browser");
+          let browserWindow = Services.wm.getMostRecentWindow(
+            "navigator:browser"
+          );
           if (browserWindow && browserWindow.gBrowserInit) {
             await browserWindow.gBrowserInit.idleTasksFinishedPromise;
           }
           Services.startup.quit(Ci.nsIAppStartup.eForceQuit);
         },
       },
     };
   }
--- a/tools/tryselect/selectors/chooser/static/filter.js
+++ b/tools/tryselect/selectors/chooser/static/filter.js
@@ -14,50 +14,57 @@ var updateLabels = () => {
 };
 
 var apply = () => {
   let filters = {};
   let kinds = [];
 
   $(".filter:checked").each(function(index) {
     for (let kind of this.name.split(",")) {
-      if (!(kinds.includes(kind)))
+      if (!kinds.includes(kind)) {
         kinds.push(kind);
+      }
     }
 
     // Checkbox element values are generated by Section.get_context() in app.py
     let attrs = JSON.parse(this.value);
     for (let attr in attrs) {
-      if (!(attr in filters))
+      if (!(attr in filters)) {
         filters[attr] = [];
+      }
 
       let values = attrs[attr];
       filters[attr] = filters[attr].concat(values);
     }
   });
   updateLabels();
 
-  if (Object.keys(filters).length == 0 || (Object.keys(filters).length == 1 && "build_type" in filters)) {
+  if (
+    Object.keys(filters).length == 0 ||
+    (Object.keys(filters).length == 1 && "build_type" in filters)
+  ) {
     selection.value = "";
     count.innerHTML = "0 tasks selected";
     return;
   }
 
-  var taskMatches = (label) => {
+  var taskMatches = label => {
     let task = tasks[label];
 
     // If no box for the given kind has been checked, this task is
     // automatically not selected.
-    if (!(kinds.includes(task.kind)))
+    if (!kinds.includes(task.kind)) {
       return false;
+    }
 
     for (let attr in filters) {
       let values = filters[attr];
-      if (!(attr in task) || values.includes(task[attr]))
+      if (!(attr in task) || values.includes(task[attr])) {
         continue;
+      }
       return false;
     }
     return true;
   };
 
   selected = Object.keys(tasks).filter(taskMatches);
   applyChunks();
 };
--- a/tools/tryselect/selectors/chooser/static/select.js
+++ b/tools/tryselect/selectors/chooser/static/select.js
@@ -1,32 +1,36 @@
 const labels = $("label.multiselect");
 const boxes = $("label.multiselect input:checkbox");
 var lastChecked = {};
 
 // implements shift+click
 labels.click(function(e) {
-  if (e.target.tagName === "INPUT")
+  if (e.target.tagName === "INPUT") {
     return;
+  }
 
   let box = $("#" + this.htmlFor)[0];
   let activeSection = $("div.tab-pane.active")[0].id;
 
   if (activeSection in lastChecked) {
     // Bug 559506 - In Firefox shift/ctrl/alt+clicking a label doesn't check the box.
     let isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
 
     if (e.shiftKey) {
-      if (isFirefox)
+      if (isFirefox) {
         box.checked = !box.checked;
+      }
 
       let start = boxes.index(box);
       let end = boxes.index(lastChecked[activeSection]);
 
-      boxes.slice(Math.min(start, end), Math.max(start, end) + 1).prop("checked", box.checked);
+      boxes
+        .slice(Math.min(start, end), Math.max(start, end) + 1)
+        .prop("checked", box.checked);
       apply();
     }
   }
 
   lastChecked[activeSection] = box;
 });
 
 function selectAll(btn) {