chrome-devtools-mcp 0.10.1 → 0.10.2

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Throttler.js

@@ -63,9 +63,9 @@ export class Throttler {
         }
         clearTimeout(this.#processTimeout);
         const timeout = this.#asSoonAsPossible ? 0 : this.#timeout;
-        this.#processTimeout = window.setTimeout(this.#onTimeout.bind(this), timeout);
+        this.#processTimeout = setTimeout(this.#onTimeout.bind(this), timeout);
     }
     #getTime() {
-        return window.performance.now();
+        return performance.now();
     }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/common.js

@@ -20,7 +20,6 @@ import * as Mutex from './Mutex.js';
 import * as ObjectWrapper from './Object.js';
 import * as ParsedURL from './ParsedURL.js';
 import * as Progress from './Progress.js';
-import * as QueryParamHandler from './QueryParamHandler.js';
 import * as ResolverBase from './ResolverBase.js';
 import * as ResourceType from './ResourceType.js';
 import * as ReturnToPanel from './ReturnToPanel.js';
@@ -41,4 +40,4 @@ import * as Worker from './Worker.js';
  * update all references to `Common.UIString` to `Platform.UIString`.
  */
 export { UIString } from '../platform/platform.js';
-export { App, AppProvider, Base64, CharacterIdMap, Color, ColorConverter, ColorUtils, Console, Debouncer, EventTarget, Gzip, JavaScriptMetaData, Lazy, Linkifier, MapWithDefault, Mutex, ObjectWrapper, ParsedURL, Progress, QueryParamHandler, ResolverBase, ResourceType, ReturnToPanel, Revealer, Runnable, SegmentedRange, SettingRegistration, Settings, SimpleHistoryManager, StringOutputStream, TextDictionary, Throttler, Trie, Worker, };
+export { App, AppProvider, Base64, CharacterIdMap, Color, ColorConverter, ColorUtils, Console, Debouncer, EventTarget, Gzip, JavaScriptMetaData, Lazy, Linkifier, MapWithDefault, Mutex, ObjectWrapper, ParsedURL, Progress, ResolverBase, ResourceType, ReturnToPanel, Revealer, Runnable, SegmentedRange, SettingRegistration, Settings, SimpleHistoryManager, StringOutputStream, TextDictionary, Throttler, Trie, Worker, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/AidaClient.js

@@ -368,13 +368,13 @@ export class AidaClient {
         }
         return { generatedSamples, metadata };
     }
-    async generateCode(request) {
+    async generateCode(request, options) {
         const response = await DispatchHttpRequestClient.makeHttpRequest({
             service: SERVICE_NAME,
             path: '/v1/aida:generateCode',
             method: 'POST',
             body: JSON.stringify(request),
-        });
+        }, options);
         return response;
     }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/DispatchHttpRequestClient.js

@@ -6,6 +6,7 @@ export var ErrorType;
 (function (ErrorType) {
     ErrorType["HTTP_RESPONSE_UNAVAILABLE"] = "HTTP_RESPONSE_UNAVAILABLE";
     ErrorType["NOT_FOUND"] = "NOT_FOUND";
+    ErrorType["ABORT"] = "ABORT";
 })(ErrorType || (ErrorType = {}));
 export class DispatchHttpRequestError extends Error {
     type;
@@ -14,9 +15,20 @@ export class DispatchHttpRequestError extends Error {
         this.type = type;
     }
 }
-export async function makeHttpRequest(request) {
-    const response = await new Promise(resolve => {
-        InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
+export async function makeHttpRequest(request, options) {
+    const signal = options?.signal;
+    if (signal?.aborted) {
+        throw new DispatchHttpRequestError(ErrorType.ABORT);
+    }
+    const response = await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            reject(new DispatchHttpRequestError(ErrorType.ABORT));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        InspectorFrontendHostInstance.dispatchHttpRequest(request, result => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve(result);
+        });
     });
     debugLog({ request, response });
     if (response.statusCode === 404) {

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/GdpClient.js

@@ -40,6 +40,7 @@ function normalizeBadgeName(name) {
     return name.replace(/profiles\/[^/]+\/awards\//, 'profiles/me/awards/');
 }
 export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.google.com/profile/u/me';
+const ORIGIN_APPLICATION_NAME = 'APPLICATION_CHROME_DEVTOOLS';
 async function makeHttpRequest(request) {
     if (!isGdpProfilesAvailable()) {
         throw new DispatchHttpRequestClient.DispatchHttpRequestError(DispatchHttpRequestClient.ErrorType.HTTP_RESPONSE_UNAVAILABLE);
@@ -146,6 +147,9 @@ export class GdpClient {
                 body: JSON.stringify({
                     user,
                     newsletter_email: emailPreference,
+                    creation_origin: {
+                        origin_application: ORIGIN_APPLICATION_NAME,
+                    }
                 }),
             });
             this.#clearCache();

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/InspectorFrontendHost.js

@@ -295,9 +295,6 @@ export class InspectorFrontendHostStub {
                 thirdPartyCookieHeuristicsEnabled: true,
                 managedBlockThirdPartyCookies: 'Unset',
             },
-            devToolsIpProtectionPanelInDevTools: {
-                enabled: false,
-            },
             devToolsFlexibleLayout: {
                 verticalDrawerEnabled: true,
             },
@@ -371,19 +368,19 @@ export class InspectorFrontendHostStub {
      * Whereas in **Non-hosted** (aka "embedded"), DevTools is embedded and fully dockable. It's the common way DevTools is run.
      *
      * **Hosted mode** == we're using the `InspectorFrontendHostStub`. impl. (@see `InspectorFrontendHostStub` class comment)
-     * Whereas with **non-hosted** mode, native `DevToolsEmbedderMessageDispatcher` is used for CDP and more.
+     * Whereas with **non-hosted** mode, native `DevToolsEmbedderMessageDispatcher` is used for CDP and more.  `globalThis.DevToolsAPI` is present.
      *
      * Relationships to other signals:
-     * - Hosted-ness does not indicate whether the frontend is _connected to a valid CDP target_.
-     * - Being _"dockable"_ (aka `canDock`) is typically aligned but technically orthogonal.
-     * - It's unrelated to the _tab's (main frame's) URL_. Though in non-hosted, the devtools frame origin will always be `devtools://devtools`.
+     * - _Connection_: Hosted-ness does not indicate whether the frontend is _connected to a valid CDP target_.
+     * - _Dockability_: Being _"dockable"_ (aka `canDock`) is typically aligned but technically orthogonal.
+     * - _URL scheme_: If the main frame's URL scheme is `devtools://`, it's non-hosted.
      *
-     *  | Example case                                         | Mode           | Example devtools                                                                   |
-     *  | :--------------------------------------------------- | :------------- | :---------------------------------------------------------------------------- |
-     *  | tab URL: anything. embedded DevTools w/ native CDP bindings    | **NOT Hosted** | `devtools://devtools/bundled/devtools_app.html?targetType=tab&...`            |
-     *  | tab URL: `devtools://…?ws=…`                | **Hosted**     | `devtools://devtools/bundled/devtools_app.html?ws=localhost:9228/...`         |
-     *  | tab URL: `devtools://…` but no connection   | **Hosted**     | `devtools://devtools/bundled/devtools_app.html`                               |
-     *  | tab URL: `https://…` but no connection      | **Hosted**     | `https://chrome-devtools-frontend.appspot.com/serve_rev/@.../worker_app.html` |
+     *  | Example case                                | Mode           | Example devtools                                                              |
+     *  | :------------------------------------------ | :------------- | :---------------------------------------------------------------------------- |
+     *  | tab URL: `devtools://…`                     | **NOT Hosted** | `devtools://devtools/bundled/devtools_app.html?targetType=tab&...`            |
+     *  | tab URL: `devtools://…?ws=…`                | **NOT Hosted** | `devtools://devtools/bundled/devtools_app.html?ws=localhost:9228/...`         |
+     *  | tab URL: `devtools://…` but no connection   | **NOT Hosted** | `devtools://devtools/bundled/trace_app.html`                                  |
+     *  | tab URL: `https://…` but no connection      | **Hosted**     | `https://chrome-devtools-frontend.appspot.com/serve_rev/@.../trace_app.html`  |
      *  | tab URL: `http://…?ws=` (connected)         | **Hosted**     | `http://localhost:9222/devtools/inspector.html?ws=localhost:9222/...`         |
      */
     isHostedMode() {

package/build/node_modules/chrome-devtools-frontend/front_end/core/host/UserMetrics.js

@@ -225,6 +225,9 @@ export class UserMetrics {
     consoleInsightTeaserGenerated(timeInMilliseconds) {
         InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserGenerationTime', timeInMilliseconds);
     }
+    consoleInsightTeaserFirstChunkGenerated(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserFirstChunkGenerationTime', timeInMilliseconds);
+    }
 }
 /**
  * The numeric enum values are not necessarily continuous! It is possible that

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/ByteUtilities.js

@@ -0,0 +1,72 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { defineFormatter } from './NumberFormatter.js';
+const narrowBytes = defineFormatter({
+    style: 'unit',
+    unit: 'byte',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowKilobytesDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'kilobyte',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1,
+});
+const narrowKilobytesInteger = defineFormatter({
+    style: 'unit',
+    unit: 'kilobyte',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowMegabytesDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'megabyte',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1,
+});
+const narrowMegabytesInteger = defineFormatter({
+    style: 'unit',
+    unit: 'megabyte',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+/**
+ * Returns string for bytes with legible units.
+ * If necessary, can convert bytes to Kb or MB.
+ */
+export const bytesToString = (bytes) => {
+    if (bytes < 1000) {
+        return narrowBytes.format(bytes);
+    }
+    const kilobytes = bytes / 1000;
+    if (kilobytes < 100) {
+        return narrowKilobytesDecimal.format(kilobytes);
+    }
+    if (kilobytes < 1000) {
+        return narrowKilobytesInteger.format(kilobytes);
+    }
+    const megabytes = kilobytes / 1000;
+    if (megabytes < 100) {
+        return narrowMegabytesDecimal.format(megabytes);
+    }
+    return narrowMegabytesInteger.format(megabytes);
+};
+/**
+ * Returns a string for bytes converted to Kb.
+ * This is currently used on tables/rows to maintain consistency
+ * and avoid varying units.
+ */
+export const formatBytesToKb = (bytes) => {
+    const kilobytes = bytes / 1000;
+    if (kilobytes < 100) {
+        return narrowKilobytesDecimal.format(kilobytes);
+    }
+    return narrowKilobytesInteger.format(kilobytes);
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/DevToolsLocale.js

@@ -0,0 +1,64 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+let devToolsLocaleInstance = null;
+/**
+ * Simple class that determines the DevTools locale based on:
+ *   1) navigator.language, which matches the Chrome UI
+ *   2) the value of the "language" Setting the user choses
+ *   3) available locales in DevTools.
+ *
+ * The DevTools locale is only determined once during startup and
+ * guaranteed to never change. Use this class when using
+ * `Intl` APIs.
+ */
+export class DevToolsLocale {
+    locale;
+    lookupClosestDevToolsLocale;
+    constructor(data) {
+        this.lookupClosestDevToolsLocale = data.lookupClosestDevToolsLocale;
+        // TODO(crbug.com/1163928): Use constant once setting actually exists.
+        if (data.settingLanguage === 'browserLanguage') {
+            this.locale = data.navigatorLanguage || 'en-US';
+        }
+        else {
+            this.locale = data.settingLanguage;
+        }
+        this.locale = this.lookupClosestDevToolsLocale(this.locale);
+    }
+    static instance(opts = { create: false }) {
+        if (!devToolsLocaleInstance && !opts.create) {
+            throw new Error('No LanguageSelector instance exists yet.');
+        }
+        if (opts.create) {
+            devToolsLocaleInstance = new DevToolsLocale(opts.data);
+        }
+        return devToolsLocaleInstance;
+    }
+    static removeInstance() {
+        devToolsLocaleInstance = null;
+    }
+    forceFallbackLocale() {
+        // Locale is 'readonly', this is the only case where we want to forcibly
+        // overwrite the locale.
+        this.locale = 'en-US';
+    }
+    /**
+     * Returns true iff DevTools supports the language of the passed locale.
+     * Note that it doesn't have to be a one-to-one match, e.g. if DevTools supports
+     * 'de', then passing 'de-AT' will return true.
+     */
+    languageIsSupportedByDevTools(localeString) {
+        return localeLanguagesMatch(localeString, this.lookupClosestDevToolsLocale(localeString));
+    }
+}
+/**
+ * Returns true iff the two locales have matching languages. This means the
+ * passing 'de-AT' and 'de-DE' will return true, while 'de-DE' and 'en' will
+ * return false.
+ */
+export function localeLanguagesMatch(localeString1, localeString2) {
+    const locale1 = new Intl.Locale(localeString1);
+    const locale2 = new Intl.Locale(localeString2);
+    return locale1.language === locale2.language;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/NumberFormatter.js

@@ -0,0 +1,67 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { DevToolsLocale } from './DevToolsLocale.js';
+/**
+ * Creates an instance of NumberFormatter.
+ *
+ * Safe to call in top-level of a module, since the creation of Intl.NumberFormat is deferred
+ * until first usage.
+ */
+export function defineFormatter(options) {
+    let intlNumberFormat;
+    return {
+        format(value, separator) {
+            if (!intlNumberFormat) {
+                intlNumberFormat = new Intl.NumberFormat(DevToolsLocale.instance().locale, options);
+            }
+            return formatAndEnsureSpace(intlNumberFormat, value, separator);
+        },
+        formatToParts(value) {
+            if (!intlNumberFormat) {
+                intlNumberFormat = new Intl.NumberFormat(DevToolsLocale.instance().locale, options);
+            }
+            return intlNumberFormat.formatToParts(value);
+        },
+    };
+}
+/**
+ * When using 'narrow' unitDisplay, many locales exclude the space between the literal and the unit.
+ * We don't like that, so when there is no space literal we inject the provided separator manually.
+ */
+function formatAndEnsureSpace(formatter, value, separator = '\xA0') {
+    // TODO(crbug.com/443038315): this method is defined in
+    // models/ai_assistance in the UnitFormatters file. We can't currently
+    // re-use it because various models depend on i18n and that creates a
+    // circular build.
+    // We should move the unit formatters to their own model so it can be
+    // used across the codebase.
+    const parts = formatter.formatToParts(value);
+    let hasSpace = false;
+    for (const part of parts) {
+        if (part.type === 'literal') {
+            if (part.value === ' ') {
+                hasSpace = true;
+                part.value = separator;
+            }
+            else if (part.value === separator) {
+                hasSpace = true;
+            }
+        }
+    }
+    if (hasSpace) {
+        return parts.map(part => part.value).join('');
+    }
+    const unitIndex = parts.findIndex(part => part.type === 'unit');
+    // Unexpected for there to be no unit, but just in case, handle that.
+    if (unitIndex === -1) {
+        return parts.map(part => part.value).join('');
+    }
+    // For locales where the unit comes first (sw), the space has to come after the unit.
+    if (unitIndex === 0) {
+        return parts[0].value + separator + parts.slice(1).map(part => part.value).join('');
+    }
+    // Otherwise, it comes before.
+    return parts.slice(0, unitIndex).map(part => part.value).join('') + separator +
+        parts.slice(unitIndex).map(part => part.value).join('');
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/collect-ui-strings.js

@@ -0,0 +1,73 @@
+"use strict";
+// Copyright 2022 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+const glob = require('glob');
+const path = require('path');
+const yargs = require('yargs');
+const { hideBin } = require('yargs/helpers');
+const { writeIfChanged } = require('../../../scripts/build/ninja/write-if-changed.js');
+const { bakePlaceholders } = require('../../../third_party/i18n/bake-ctc-to-lhl.js');
+const { collectAllStringsInDir, createPsuedoLocaleStrings, IGNORED_PATH_COMPONENTS } = require('../../../third_party/i18n/collect-strings.js');
+/** @typedef {import('../../../third_party/i18n/bake-ctc-to-lhl.js').CtcMessage} CtcMessage */
+const yargsObject = yargs(hideBin(process.argv))
+    .option('input-directories', {
+    type: 'array',
+    demandOption: true,
+})
+    .option('output-directory', {
+    type: 'string',
+    demandOption: true,
+})
+    .option('include-en-xl', {
+    type: 'boolean',
+})
+    .strict()
+    .parseSync();
+/**
+ * @param outputDirectory
+ * @param locale
+ * @param strings
+ */
+function convertCtcToLhLAndSave(outputDirectory, locale, strings) {
+    const outputPath = path.join(outputDirectory, `${locale}.json`);
+    /** @type {Record<string, CtcMessage>} */
+    const sortedCtcStrings = {};
+    const sortedEntries = Object.entries(strings).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+    for (const [key, defn] of sortedEntries) {
+        sortedCtcStrings[key] = defn;
+    }
+    const convertedStrings = bakePlaceholders(sortedCtcStrings);
+    writeIfChanged(outputPath, JSON.stringify(convertedStrings, null, 2) + '\n');
+}
+const inputDirectories = yargsObject['input-directories'];
+if (inputDirectories.length === 0) {
+    throw new Error('Provide at least one directory!');
+}
+/** @type {Record<string, CtcMessage>} */
+let collectedStrings = {};
+/** @type {string[]} */
+const files = [];
+for (const directory of inputDirectories) {
+    collectedStrings = {
+        ...collectedStrings,
+        ...collectAllStringsInDir(directory),
+    };
+    const fs = glob.sync('**/*.{js,ts,gn}', {
+        cwd: directory,
+        ignore: IGNORED_PATH_COMPONENTS,
+    });
+    files.push(...fs.map(f => path.join(directory, f)));
+}
+const outputDirectory = yargsObject['output-directory'];
+convertCtcToLhLAndSave(outputDirectory, 'en-US', collectedStrings);
+if (yargsObject['include-en-xl']) {
+    convertCtcToLhLAndSave(outputDirectory, 'en-XL', createPsuedoLocaleStrings(collectedStrings));
+}
+// Write the depfile. This is necessary to properly rebuild en-US.json/en-XL.json
+// when any of the input TS files change. We also re-build when any GN file changes,
+// since new TS/JS files might have been added.
+const depfile = `
+${path.join(outputDirectory, 'en-US.json')}: ${files.join(' ')}
+`;
+writeIfChanged(path.join(outputDirectory, 'collected-ui-strings.d'), depfile);

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/generate-locales-js.js

@@ -0,0 +1,51 @@
+"use strict";
+// Copyright 2022 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+const path = require('path');
+const yargs = require('yargs');
+const { hideBin } = require('yargs/helpers');
+const { writeIfChanged } = require('../../../scripts/build/ninja/write-if-changed.js');
+const yargsObject = yargs(hideBin(process.argv))
+    .option('target-gen-dir', {
+    type: 'string',
+    demandOption: true,
+})
+    .option('remote-locales', {
+    type: 'array',
+    demandOption: true,
+})
+    .option('bundled-locales', {
+    type: 'array',
+    demandOption: true,
+})
+    .option('default-locale', {
+    type: 'string',
+    demandOption: true,
+})
+    .option('remote-fetch-pattern', {
+    type: 'string',
+    demandOption: true,
+})
+    .option('local-fetch-pattern', {
+    type: 'string',
+    demandOption: true,
+})
+    .strict()
+    .parseSync();
+const remoteLocaleList = yargsObject['remote-locales'].map(locale => `\n  '${locale}',`).join('');
+const bundledLocaleList = yargsObject['bundled-locales'].map(locale => `\n  '${locale}',`).join('');
+const allLocales = `[${remoteLocaleList}${bundledLocaleList}\n]`;
+const bundledLocales = `[${bundledLocaleList}\n]`;
+const content = `
+export const LOCALES = ${allLocales};
+
+export const BUNDLED_LOCALES = ${bundledLocales};
+
+export const DEFAULT_LOCALE = '${yargsObject['default-locale']}';
+
+export const REMOTE_FETCH_PATTERN = '${yargsObject['remote-fetch-pattern']}';
+
+export const LOCAL_FETCH_PATTERN = '${yargsObject['local-fetch-pattern']}';
+`;
+writeIfChanged(path.join(yargsObject['target-gen-dir'], 'locales.js'), content);

package/build/node_modules/chrome-devtools-frontend/front_end/core/i18n/i18n.js

@@ -1,60 +1,9 @@
-
-export const i18n = {
-  registerUIStrings: () => {},
-  getLocalizedString: (_, str) => {
-    // So that the string passed in gets output verbatim.
-    return str;
-  },
-  lockedLazyString: () => {},
-  getLazilyComputedLocalizedString: () => {},
-};
-
-// TODO(jacktfranklin): once the DocumentLatency insight does not depend on
-// this method, we can remove this stub.
-export const TimeUtilities = {
-  millisToString(x) {
-    const separator = ' ';
-    const formatter = new Intl.NumberFormat('en-US', {
-      style: 'unit',
-      unitDisplay: 'narrow',
-      minimumFractionDigits: 0,
-      maximumFractionDigits: 1,
-      unit: 'millisecond',
-    });
-
-    const parts = formatter.formatToParts(x);
-    for (const part of parts) {
-      if (part.type === 'literal') {
-        if (part.value === ' ') {
-          part.value = separator;
-        }
-      }
-    }
-
-    return parts.map(part => part.value).join('');
-  }
-};
-
-// TODO(jacktfranklin): once the ImageDelivery insight does not depend on this method, we can remove this stub.
-export const ByteUtilities = {
-  bytesToString(x) {
-    const separator = ' ';
-    const formatter = new Intl.NumberFormat('en-US', {
-      style: 'unit',
-      unit: 'kilobyte',
-      unitDisplay: 'narrow',
-      minimumFractionDigits: 1,
-      maximumFractionDigits: 1,
-    });
-    const parts = formatter.formatToParts(x / 1000);
-    for (const part of parts) {
-      if (part.type === 'literal') {
-        if (part.value === ' ') {
-          part.value = separator;
-        }
-      }
-    }
-
-    return parts.map(part => part.value).join('');
-  }
-};
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as ByteUtilities from './ByteUtilities.js';
+import * as DevToolsLocale from './DevToolsLocale.js';
+import * as i18n from './i18nImpl.js';
+import * as NumberFormatter from './NumberFormatter.js';
+import * as TimeUtilities from './time-utilities.js';
+export { ByteUtilities, DevToolsLocale, i18n, NumberFormatter, TimeUtilities, };