chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/core/common/ParsedURL.test.ts

@@ -2,14 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import * as Common from './common.js';
 
+const {urlString} = Platform.DevToolsPath;
 const ParsedURL = Common.ParsedURL.ParsedURL;
 
 function assertEqualUrlStringString(actual: Platform.DevToolsPath.UrlString|null, expected: string, message?: string) {
-  assert.strictEqual(actual, expected as Platform.DevToolsPath.UrlString, message);
+  assert.strictEqual(actual, urlString`${expected}`, message);
 }
 
 describe('Parsed URL', () => {
@@ -146,13 +147,13 @@ describe('Parsed URL', () => {
   });
 
   it('converts path that starts with "file://" to a platform path', () => {
-    const pathTest = 'file://usr/lib' as Platform.DevToolsPath.UrlString;
+    const pathTest = urlString`file://usr/lib`;
     const convertedPath = ParsedURL.urlToRawPathString(pathTest);
     assert.strictEqual(convertedPath, 'usr/lib', 'URL was not converted successfully');
   });
 
   it('converts path that starts with "file:///" to a platform path on Windows', () => {
-    const pathTest = 'file:///usr/lib' as Platform.DevToolsPath.UrlString;
+    const pathTest = urlString`file:///usr/lib`;
     const convertedPath = ParsedURL.urlToRawPathString(pathTest, true);
     assert.strictEqual(convertedPath, 'usr\\lib', 'URL was not converted successfully');
   });
@@ -191,26 +192,26 @@ describe('Parsed URL', () => {
   });
 
   it('extracts the path from a valid URL', () => {
-    const urlTest = 'http://www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`http://www.example.com/test/path`;
     const extractedPath = ParsedURL.extractPath(urlTest);
     assert.strictEqual(extractedPath, '/test/path', 'path extracted incorrectly');
   });
 
   it('returns an empty string as a path if the URL is not valid', () => {
-    const urlTest = 'www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`www.example.com/test/path`;
     const extractedPath = ParsedURL.extractPath(urlTest);
     assert.strictEqual(extractedPath, '', 'did not return an empty path');
   });
 
   it('extracts the origin from a valid URL', () => {
-    const urlTest = 'http://www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`http://www.example.com/test/path`;
     const extractedOrigin = ParsedURL.extractOrigin(urlTest);
     assert.strictEqual(extractedOrigin, 'http://www.example.com', 'origin extracted incorrectly');
   });
 
   it('returns an empty string as a origin if the URL is not valid', () => {
     const urlTest = 'www.example.com/test/path';
-    const extractedOrigin = ParsedURL.extractOrigin(urlTest as Platform.DevToolsPath.UrlString);
+    const extractedOrigin = ParsedURL.extractOrigin(urlString`${urlTest}`);
     assert.strictEqual(extractedOrigin, '', 'did not return an empty path');
   });
 
@@ -270,28 +271,28 @@ describe('Parsed URL', () => {
 
   it('uses the completeURL function to return a data URL as it is', () => {
     const hrefTest = 'data:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a blob URL as it is', () => {
     const hrefTest = 'blob:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a javascript URL as it is', () => {
     const hrefTest = 'javascript:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a mailto URL as it is', () => {
     const hrefTest = 'mailto:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
@@ -347,7 +348,7 @@ describe('Parsed URL', () => {
 
     for (const {href, expected} of cases) {
       it(`can use completeURL to normalize "${href}"`, () => {
-        const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+        const baseUrlTest = urlString`www.example.com`;
         const completeUrl = ParsedURL.completeURL(baseUrlTest, href);
         assertEqualUrlStringString(completeUrl, expected, 'complete URL is not returned correctly');
       });
@@ -356,14 +357,14 @@ describe('Parsed URL', () => {
 
   it('uses the completeURL function to return null for invalid href and invalid base URL', () => {
     const hrefTest = 'www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assert.isNull(completeUrl, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return the href if the base URL is a data URL', () => {
     const hrefTest = 'www.example.com';
-    const baseUrlTest = 'data://www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`data://www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
@@ -371,21 +372,21 @@ describe('Parsed URL', () => {
   it('uses the completeURL function to return the href with scheme if the base URL was valid and the href scheme was dropped',
      () => {
        const hrefTest = '//www.example.com';
-       const baseUrlTest = 'http://www.example.com/' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(completeUrl, 'http:' + hrefTest, 'complete URL is not returned correctly');
      });
 
   it('uses the completeURL function to resolve an empty href to a base URL without fragment', () => {
     const hrefTest = '';
-    const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, baseUrlTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to resolve a fragment href to a base URL with fragment', () => {
     const hrefTest = '#testFragment';
-    const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, baseUrlTest + hrefTest, 'complete URL is not returned correctly');
   });
@@ -393,7 +394,7 @@ describe('Parsed URL', () => {
   it('uses the completeURL function to resolve a parameters href to a base URL with the parameters from the href while the base URL has parameters',
      () => {
        const hrefTest = '?hrefParams=t';
-       const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(
            completeUrl, 'http://www.example.com/' + hrefTest, 'complete URL is not returned correctly');
@@ -402,7 +403,7 @@ describe('Parsed URL', () => {
   it('uses the completeURL function to resolve a parameters href to a base URL with the parameters from the href while the base URL does not have parameters',
      () => {
        const hrefTest = '?hrefParams=t';
-       const baseUrlTest = 'http://www.example.com/' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(completeUrl, baseUrlTest + hrefTest, 'complete URL is not returned correctly');
      });
@@ -590,18 +591,15 @@ describe('Parsed URL', () => {
 
   it('returns the correct results for all ported web_tests unit tests', () => {
     assertEqualUrlStringString(
-        ParsedURL.completeURL(
-            'http://example.com/script.js' as Platform.DevToolsPath.UrlString, 'http://example.com/map.json'),
+        ParsedURL.completeURL(urlString`http://example.com/script.js`, 'http://example.com/map.json'),
         'http://example.com/map.json');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://example.com/script.js' as Platform.DevToolsPath.UrlString, '/map.json'),
-        'http://example.com/map.json');
+        ParsedURL.completeURL(urlString`http://example.com/script.js`, '/map.json'), 'http://example.com/map.json');
     assertEqualUrlStringString(
-        ParsedURL.completeURL(
-            'http://example.com/scripts/script.js' as Platform.DevToolsPath.UrlString, '../maps/map.json'),
+        ParsedURL.completeURL(urlString`http://example.com/scripts/script.js`, '../maps/map.json'),
         'http://example.com/maps/map.json');
 
-    const baseURL = 'http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString;
+    const baseURL = urlString`http://a/b/c/d;p?q`;
 
     assertEqualUrlStringString(ParsedURL.completeURL(baseURL, 'http://h'),
                                'http://h/');  // modified from RFC3986
@@ -626,13 +624,11 @@ describe('Parsed URL', () => {
     assertEqualUrlStringString(ParsedURL.completeURL(baseURL, 'g#s/../x'), 'http://a/b/c/g#s/../x');
 
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString, '//secure.com/moo'),
-        'http://secure.com/moo');
+        ParsedURL.completeURL(urlString`http://a/b/c/d;p?q`, '//secure.com/moo'), 'http://secure.com/moo');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString, 'cat.jpeg'),
-        'http://a/b/c/cat.jpeg');
+        ParsedURL.completeURL(urlString`http://a/b/c/d;p?q`, 'cat.jpeg'), 'http://a/b/c/cat.jpeg');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://example.com/path.css?query#fragment' as Platform.DevToolsPath.UrlString, ''),
+        ParsedURL.completeURL(urlString`http://example.com/path.css?query#fragment`, ''),
         'http://example.com/path.css?query');
   });
 
@@ -687,20 +683,20 @@ describe('Parsed URL', () => {
   });
 
   it('converts relative platform path and base URL to URL', () => {
-    const baseUrl = 'http://localhost:8080/my%20folder/old%20path' as Platform.DevToolsPath.UrlString;
+    const baseUrl = urlString`http://localhost:8080/my%20folder/old%20path`;
     const relativePath = 'new spaced%20name' as Platform.DevToolsPath.RawPathString;
     const convertedUrl = ParsedURL.relativePathToUrlString(relativePath, baseUrl);
     assert.strictEqual(convertedUrl, 'http://localhost:8080/my%20folder/new%20spaced%2520name');
   });
 
   it('converts URL to a platform path that includes drive letter and spaces on Windows', () => {
-    const urlTest = 'file:///C:/Program%20Files/Google' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`file:///C:/Program%20Files/Google`;
     const convertedUrl = ParsedURL.urlToRawPathString(urlTest, true);
     assert.strictEqual(convertedUrl, 'C:\\Program Files\\Google', 'URL was not converted successfully');
   });
 
   it('converts URL to a platform path that includes spaces and percents', () => {
-    const urlTest = 'file:///home/user/with%20space/with%2520escape' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`file:///home/user/with%20space/with%2520escape`;
     const convertedUrl = ParsedURL.urlToRawPathString(urlTest, false);
     assert.strictEqual(convertedUrl, '/home/user/with space/with%20escape', 'URL was not converted successfully');
   });
@@ -715,8 +711,8 @@ describe('Parsed URL', () => {
   it('converts platform path with variety of special characters to URL and back consistently with Chrome', () => {
     const platformPathTest =
         '/home/a:b@c(d, e+f)=&g;#h$' as Platform.DevToolsPath.RawPathString;  // Valid filename on unix
-    const urlTest = 'file:///home/a:b@c(d,%20e+f)=&g%3B%23h$' as
-        Platform.DevToolsPath.UrlString;  // URL in Chrome address bar if you open that file
+    const urlTest =
+        urlString`file:///home/a:b@c(d,%20e+f)=&g%3B%23h\$`;  // URL in Chrome address bar if you open that file
     assert.strictEqual(ParsedURL.rawPathToUrlString(platformPathTest), urlTest);
     assert.strictEqual(ParsedURL.urlToRawPathString(urlTest), platformPathTest);
   });

package/front_end/core/common/ParsedURL.ts

@@ -67,7 +67,7 @@ export function normalizePath(path: string): string {
 export function schemeIs(url: Platform.DevToolsPath.UrlString, scheme: string): boolean {
   try {
     return (new URL(url)).protocol === scheme;
-  } catch (e) {
+  } catch {
     return false;
   }
 }

package/front_end/core/common/ResolverBase.test.ts

@@ -96,7 +96,7 @@ describe('ResolverBase', () => {
       resolver.assertIsNotListening();
       try {
         await obj;
-      } catch (e) {
+      } catch {
         return;
       }
       assert.fail('Expected `await obj` to throw.');

package/front_end/core/common/ResolverBase.ts

@@ -34,7 +34,7 @@ export abstract class ResolverBase<Id, T> {
   }
 
   /**
-   * Resolve the `id`. Returns the object immediatelly if it can be resolved,
+   * Resolve the `id`. Returns the object immediately if it can be resolved,
    * and otherwise waits for the object to appear and calls `callback` once
    * it is resolved.
    */
@@ -68,12 +68,7 @@ export abstract class ResolverBase<Id, T> {
     if (promiseInfo) {
       return promiseInfo.promise;
     }
-    let resolve: (value: T) => void = () => {};
-    let reject: (error: Error) => void = () => {};
-    const promise = new Promise<T>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
+    const {resolve, reject, promise} = Promise.withResolvers<T>();
     this.#unresolvedIds.set(id, {promise, resolve, reject});
     this.startListening();
     return promise;

package/front_end/core/common/ResourceType.test.ts

@@ -3,10 +3,11 @@
 // found in the LICENSE file.
 
 import {describeWithEnvironment} from '../../testing/EnvironmentHelpers.js';
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import * as Common from './common.js';
 
+const {urlString} = Platform.DevToolsPath;
 const ResourceType = Common.ResourceType.ResourceType;
 const ResourceCategory = Common.ResourceType.ResourceCategory;
 const resourceTypes = Common.ResourceType.resourceTypes;
@@ -208,18 +209,17 @@ describeWithEnvironment('ResourceType class', () => {
   });
 
   it('is able to return a mime from URL that contains a mapped extension', () => {
-    const result = ResourceType.mimeFromURL('http://www.example.com/test/path.html' as Platform.DevToolsPath.UrlString);
+    const result = ResourceType.mimeFromURL(urlString`http://www.example.com/test/path.html`);
     assert.strictEqual(result, 'text/html', 'mime returned was not correct');
   });
 
   it('is able to return a mime from URL that contains an unmapped extension', () => {
-    const result =
-        ResourceType.mimeFromURL('http://www.example.com/test/path.testExt' as Platform.DevToolsPath.UrlString);
+    const result = ResourceType.mimeFromURL(urlString`http://www.example.com/test/path.testExt`);
     assert.isUndefined(result, 'mime returned was not correct');
   });
 
   it('is able to return a mime from URL that contains a mapped name', () => {
-    const result = ResourceType.mimeFromURL('http://www.example.com/test/Cakefile' as Platform.DevToolsPath.UrlString);
+    const result = ResourceType.mimeFromURL(urlString`http://www.example.com/test/Cakefile`);
     assert.strictEqual(result, 'text/x-coffeescript', 'mime returned was not correct');
   });
 
@@ -490,71 +490,67 @@ describe('ResourceType', () => {
 
   describe('mimeFromURL', () => {
     it('returns correct MIME type for .dart files', () => {
-      const url = 'http://localhost/example.dart' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/example.dart`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'application/vnd.dart');
     });
 
     it('returns correct MIME type for Go files', () => {
-      const url = 'https://staging.server.com/main.go' as Platform.DevToolsPath.UrlString;
+      const url = urlString`https://staging.server.com/main.go`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x-go');
     });
 
     it('returns correct MIME type for .gss files', () => {
-      const url = 'https://staging.server.com/styles.gss' as Platform.DevToolsPath.UrlString;
+      const url = urlString`https://staging.server.com/styles.gss`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x-gss');
     });
 
     it('returns correct MIME type for .kt files', () => {
-      const url = 'https://staging.server.com/Main.kt' as Platform.DevToolsPath.UrlString;
+      const url = urlString`https://staging.server.com/Main.kt`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x-kotlin');
     });
 
     it('returns correct MIME type for .less files', () => {
-      const url = 'https://staging.server.com/styles.less' as Platform.DevToolsPath.UrlString;
+      const url = urlString`https://staging.server.com/styles.less`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x-less');
     });
 
     it('returns correct MIME type for .php files', () => {
-      const url = 'http://localhost/file.php' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/file.php`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'application/x-httpd-php');
     });
 
     it('returns correct MIME type for SASS files', () => {
-      assert.strictEqual(
-          ResourceType.mimeFromURL('https://staging.server.com/styles.sass' as Platform.DevToolsPath.UrlString),
-          'text/x-sass');
-      assert.strictEqual(
-          ResourceType.mimeFromURL('https://staging.server.com/styles.scss' as Platform.DevToolsPath.UrlString),
-          'text/x-scss');
+      assert.strictEqual(ResourceType.mimeFromURL(urlString`https://staging.server.com/styles.sass`), 'text/x-sass');
+      assert.strictEqual(ResourceType.mimeFromURL(urlString`https://staging.server.com/styles.scss`), 'text/x-scss');
     });
 
     it('returns correct MIME type for Scala files', () => {
-      const url = 'http://localhost/App.scala' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/App.scala`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x-scala');
     });
 
     it('returns correct MIME type for Angular component templates', () => {
-      const url = 'http://localhost/src/app/app.component.html' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/src/app/app.component.html`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x.angular');
     });
 
     it('returns correct MIME type for .svelte files', () => {
-      const url = 'http://localhost/App.svelte' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/App.svelte`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x.svelte');
     });
 
     it('returns correct MIME type for .vue files', () => {
-      const url = 'http://localhost/App.vue' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/App.vue`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'text/x.vue');
     });
 
     it('returns correct MIME type for .webmanifest files', () => {
-      const url = 'http://localhost/app.webmanifest' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/app.webmanifest`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'application/manifest+json');
     });
 
     it('returns correct MIME type for source maps', () => {
-      const url = 'http://localhost/bundle.min.js.map' as Platform.DevToolsPath.UrlString;
+      const url = urlString`http://localhost/bundle.min.js.map`;
       assert.strictEqual(ResourceType.mimeFromURL(url), 'application/json');
     });
   });

package/front_end/core/common/Revealer.ts

@@ -30,6 +30,10 @@ const UIStrings = {
    *@description The UI destination when right clicking an item that can be revealed
    */
   applicationPanel: 'Application panel',
+  /**
+   *@description The UI destination when right clicking an item that can be revealed
+   */
+  securityPanel: 'Security panel',
   /**
    *@description The UI destination when right clicking an item that can be revealed
    */
@@ -180,6 +184,7 @@ export const RevealerDestination = {
   TIMELINE_PANEL: i18nLazyString(UIStrings.timelinePanel),
   APPLICATION_PANEL: i18nLazyString(UIStrings.applicationPanel),
   SOURCES_PANEL: i18nLazyString(UIStrings.sourcesPanel),
+  SECURITY_PANEL: i18nLazyString(UIStrings.securityPanel),
   MEMORY_INSPECTOR_PANEL: i18nLazyString(UIStrings.memoryInspectorPanel),
   ANIMATIONS_PANEL: i18nLazyString(UIStrings.animationsPanel),
 };

package/front_end/core/common/SettingRegistration.test.ts

@@ -57,7 +57,7 @@ describe('SettingRegistration', () => {
       assert.strictEqual(
           preRegisteredSetting.category(), settingCategory, 'Setting category is not returned correctly');
       assert.isNotTrue(preRegisteredSetting.get(), 'Setting value is not returned correctly');
-    } catch (error) {
+    } catch {
       assert.fail('Failed to find setting registration');
     }
   });

package/front_end/core/common/Settings.ts

@@ -459,7 +459,7 @@ export class Setting<V> {
     if (this.storage.has(this.name)) {
       try {
         this.#value = this.#serializer.parse(this.storage.get(this.name));
-      } catch (e) {
+      } catch {
         this.storage.remove(this.name);
       }
     }
@@ -484,7 +484,7 @@ export class Setting<V> {
     if (value) {
       try {
         this.#value = this.#serializer.parse(value);
-      } catch (e) {
+      } catch {
         this.storage.remove(this.name);
       }
     }
@@ -648,7 +648,7 @@ export class RegExpSetting extends Setting<any> {
       if (pattern) {
         this.#regex = new RegExp(pattern, this.#regexFlags || '');
       }
-    } catch (e) {
+    } catch {
     }
     return this.#regex;
   }
@@ -1396,14 +1396,14 @@ export function settingForTest(settingName: string): Setting<unknown> {
 export {
   getLocalizedSettingsCategory,
   maybeRemoveSettingExtension,
-  registerSettingExtension,
   RegExpSettingItem,
+  registerSettingExtension,
+  registerSettingsForTest,
+  resetSettings,
   SettingCategory,
   SettingExtensionOption,
   SettingRegistration,
   SettingType,
-  registerSettingsForTest,
-  resetSettings,
 };
 
 export interface Serializer<I, O> {

package/front_end/core/common/Throttler.ts

@@ -8,7 +8,7 @@ export class Throttler {
   readonly #timeout: number;
   #isRunningProcess: boolean;
   #asSoonAsPossible: boolean;
-  #process: (() => (Promise<unknown>))|null;
+  #process: (() => (void|Promise<unknown>))|null;
   #lastCompleteTime: number;
   #schedulePromise: Promise<unknown>;
   #scheduleResolve!: (value: unknown) => void;
@@ -39,7 +39,7 @@ export class Throttler {
     // For sniffing in tests.
   }
 
-  get process(): (() => (Promise<unknown>))|null {
+  get process(): (() => (void|Promise<unknown>))|null {
     return this.#process;
   }
 
@@ -63,7 +63,7 @@ export class Throttler {
     this.#process = null;
   }
 
-  schedule(process: () => (Promise<unknown>), scheduling = Scheduling.DEFAULT): Promise<void> {
+  schedule(process: () => (void|Promise<unknown>), scheduling = Scheduling.DEFAULT): Promise<void> {
     // Deliberately skip previous #process.
     this.#process = process;