@mcp-b/chrome-devtools-mcp 2.0.0 → 2.0.2-beta.test123

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

@@ -0,0 +1,13 @@
+// Copyright 2019 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 AidaClient from './AidaClient.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import * as GdpClient from './GdpClient.js';
+import * as InspectorFrontendHost from './InspectorFrontendHost.js';
+import * as InspectorFrontendHostAPI from './InspectorFrontendHostAPI.js';
+import * as Platform from './Platform.js';
+import * as ResourceLoader from './ResourceLoader.js';
+import * as UserMetrics from './UserMetrics.js';
+export { AidaClient, DispatchHttpRequestClient, GdpClient, InspectorFrontendHost, InspectorFrontendHostAPI, Platform, ResourceLoader, UserMetrics, };
+export const userMetrics = new UserMetrics.UserMetrics();

package/build/vendor/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/vendor/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/vendor/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/vendor/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('node: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/vendor/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('node: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/vendor/chrome-devtools-frontend/front_end/core/i18n/i18n.js

@@ -0,0 +1,9 @@
+// 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, };

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

@@ -0,0 +1,135 @@
+// 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 I18n from '../../third_party/i18n/i18n.js';
+import * as Root from '../root/root.js';
+import { DevToolsLocale } from './DevToolsLocale.js';
+import { BUNDLED_LOCALES as BUNDLED_LOCALES_GENERATED, DEFAULT_LOCALE, LOCAL_FETCH_PATTERN, LOCALES, REMOTE_FETCH_PATTERN, } from './locales.js';
+const i18nInstance = new I18n.I18n.I18n(LOCALES, DEFAULT_LOCALE);
+// All the locales that are part of the DevTools bundle and should not be fetched
+// remotely.
+const BUNDLED_LOCALES = new Set([...BUNDLED_LOCALES_GENERATED]);
+/**
+ * Look up the best available locale for the requested language through these fall backs:
+ * - exact match
+ * - progressively shorter prefixes (`de-CH-1996` -> `de-CH` -> `de`)
+ * - the default locale ('en-US') if no match is found
+ *
+ * If `locale` isn't provided, the default is used.
+ */
+export function lookupClosestSupportedDevToolsLocale(locale) {
+    return i18nInstance.lookupClosestSupportedLocale(locale);
+}
+/**
+ * Returns a list of all supported DevTools locales, including pseudo locales.
+ */
+export function getAllSupportedDevToolsLocales() {
+    return [...i18nInstance.supportedLocales];
+}
+/**
+ * Returns the Url from which a locale can be fetched. This depends on the
+ * specific locale, as some are bundled with DevTools while others
+ * have to be fetched remotely.
+ */
+function getLocaleFetchUrl(locale, location) {
+    const remoteBase = Root.Runtime.getRemoteBase(location);
+    if (remoteBase?.version && !BUNDLED_LOCALES.has(locale)) {
+        return REMOTE_FETCH_PATTERN.replace('@HOST@', 'devtools://devtools')
+            .replace('@VERSION@', remoteBase.version)
+            .replace('@LOCALE@', locale);
+    }
+    const path = LOCAL_FETCH_PATTERN.replace('@LOCALE@', locale);
+    return new URL(path, import.meta.url).toString();
+}
+/**
+ * Fetches the locale data of the specified locale.
+ * Callers have to ensure that `locale` is an officially supported locale.
+ * Depending whether a locale is present in `bundledLocales`, the data will be
+ * fetched locally or remotely.
+ */
+export async function fetchAndRegisterLocaleData(locale, location = self.location.toString()) {
+    const localeDataTextPromise = fetch(getLocaleFetchUrl(locale, location)).then(result => result.json());
+    const timeoutPromise = new Promise((_, reject) => window.setTimeout(() => reject(new Error('timed out fetching locale')), 5000));
+    const localeData = await Promise.race([timeoutPromise, localeDataTextPromise]);
+    i18nInstance.registerLocaleData(locale, localeData);
+}
+export function hasLocaleDataForTest(locale) {
+    return i18nInstance.hasLocaleDataForTest(locale);
+}
+export function resetLocaleDataForTest() {
+    i18nInstance.resetLocaleDataForTest();
+}
+export function registerLocaleDataForTest(locale, messages) {
+    i18nInstance.registerLocaleData(locale, messages);
+}
+/**
+ * Returns an anonymous function that wraps a call to retrieve a localized string.
+ * This is introduced so that localized strings can be declared in environments where
+ * the i18n system has not been configured and so, cannot be directly invoked. Instead,
+ * strings are lazily localized when they are used. This is used for instance in the
+ * meta files used to register module extensions.
+ */
+export function getLazilyComputedLocalizedString(registeredStrings, id, values = {}) {
+    return () => getLocalizedString(registeredStrings, id, values);
+}
+/**
+ * Retrieve the localized string.
+ */
+export function getLocalizedString(registeredStrings, id, values = {}) {
+    return registeredStrings.getLocalizedStringSetFor(DevToolsLocale.instance().locale).getLocalizedString(id, values);
+}
+/**
+ * Register a file's UIStrings with i18n, return function to generate the string ids.
+ */
+export function registerUIStrings(path, stringStructure) {
+    return i18nInstance.registerFileStrings(path, stringStructure);
+}
+export function serializeUIString(string, values = {}) {
+    const serializedMessage = { string, values };
+    return JSON.stringify(serializedMessage);
+}
+export function deserializeUIString(serializedMessage) {
+    if (!serializedMessage) {
+        return { string: '', values: {} };
+    }
+    return JSON.parse(serializedMessage);
+}
+/**
+ * Use this function in places where a `LocalizedString` is expected but the
+ * term/phrase you want to use does not require translation.
+ */
+export function lockedString(str) {
+    return str;
+}
+/**
+ * Same as `lockedString` but for places where `i18nLazyString` would be used otherwise.
+ */
+export function lockedLazyString(str) {
+    return () => str;
+}
+/**
+ * Returns a string of the form:
+ *   "German (Austria) - Deutsch (Österreich)"
+ * where the former locale representation is written in the currently enabled DevTools
+ * locale and the latter locale representation is written in the locale of `localeString`.
+ *
+ * Should the two locales match (i.e. have the same language) then the latter locale
+ * representation is written in English.
+ */
+export function getLocalizedLanguageRegion(localeString, devtoolsLocale) {
+    const locale = new Intl.Locale(localeString);
+    const { language, baseName } = locale;
+    const devtoolsLoc = new Intl.Locale(devtoolsLocale.locale);
+    const targetLanguage = language === devtoolsLoc.language ? 'en' : baseName;
+    const languageInCurrentLocale = new Intl.DisplayNames([devtoolsLocale.locale], { type: 'language' }).of(language);
+    const languageInTargetLocale = new Intl.DisplayNames([targetLanguage], { type: 'language' }).of(language);
+    let wrappedRegionInCurrentLocale = '';
+    let wrappedRegionInTargetLocale = '';
+    if (locale.region) {
+        const regionInCurrentLocale = new Intl.DisplayNames([devtoolsLocale.locale], { type: 'region', style: 'short' }).of(locale.region);
+        const regionInTargetLocale = new Intl.DisplayNames([targetLanguage], { type: 'region', style: 'short' }).of(locale.region);
+        wrappedRegionInCurrentLocale = ` (${regionInCurrentLocale})`;
+        wrappedRegionInTargetLocale = ` (${regionInTargetLocale})`;
+    }
+    return `${languageInCurrentLocale}${wrappedRegionInCurrentLocale} - ${languageInTargetLocale}${wrappedRegionInTargetLocale}`;
+}

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

@@ -0,0 +1,4 @@
+// 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.
+export {};

package/build/vendor/chrome-devtools-frontend/front_end/core/i18n/time-utilities.js

@@ -0,0 +1,148 @@
+// 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.
+/**
+ * @file Uses Intl.NumberFormat.
+ * @see go/cpq:i18n-units-design
+ */
+import * as Platform from '../platform/platform.js';
+import { defineFormatter } from './NumberFormatter.js';
+const narrowMillisecondsInteger = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const longMilliseconds = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'long',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowMicrosecondsInteger = defineFormatter({
+    style: 'unit',
+    unit: 'microsecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+});
+const narrowMillisecondsDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'millisecond',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+const narrowSecondsDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'second',
+    unitDisplay: 'narrow',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+const shortMinutesDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'minute',
+    unitDisplay: 'short',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+const shortHoursDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'hour',
+    unitDisplay: 'short',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+const longDaysDecimal = defineFormatter({
+    style: 'unit',
+    unit: 'day',
+    unitDisplay: 'long',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+export function formatMicroSecondsTime(time) {
+    return millisToString(Platform.Timing.microSecondsToMilliSeconds(time), true);
+}
+export function formatMicroSecondsAsSeconds(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    const seconds = Platform.Timing.milliSecondsToSeconds(milliseconds);
+    return narrowSecondsDecimal.format(seconds);
+}
+export function formatMicroSecondsAsMillisFixed(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    return narrowMillisecondsInteger.format(milliseconds);
+}
+export function formatMicroSecondsAsMillisFixedExpanded(time) {
+    const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
+    return longMilliseconds.format(milliseconds);
+}
+/**
+ * @param higherResolution if true, the output may show as microsends or as milliseconds with a fractional component
+ */
+export function millisToString(ms, higherResolution) {
+    if (!isFinite(ms)) {
+        return '-';
+    }
+    if (higherResolution && ms < 0.1) {
+        return narrowMicrosecondsInteger.format(ms * 1000);
+    }
+    if (higherResolution && ms < 1000) {
+        return narrowMillisecondsDecimal.format(ms);
+    }
+    if (ms < 1000) {
+        return narrowMillisecondsInteger.format(ms);
+    }
+    const seconds = ms / 1000;
+    if (seconds < 60) {
+        return narrowSecondsDecimal.format(seconds);
+    }
+    const minutes = seconds / 60;
+    if (minutes < 60) {
+        return shortMinutesDecimal.format(minutes);
+    }
+    const hours = minutes / 60;
+    if (hours < 24) {
+        return shortHoursDecimal.format(hours);
+    }
+    const days = hours / 24;
+    return longDaysDecimal.format(days);
+}
+const preciseMillisToStringFormattersCache = new Map();
+export function preciseMillisToString(ms, precision = 0, separator) {
+    let formatter = preciseMillisToStringFormattersCache.get(precision);
+    if (!formatter) {
+        formatter = defineFormatter({
+            style: 'unit',
+            unit: 'millisecond',
+            unitDisplay: 'narrow',
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        });
+        preciseMillisToStringFormattersCache.set(precision, formatter);
+    }
+    return formatter.format(ms, separator);
+}
+const preciseSecondsToStringFormattersCache = new Map();
+export function preciseSecondsToString(ms, precision = 0) {
+    let formatter = preciseSecondsToStringFormattersCache.get(precision);
+    if (!formatter) {
+        formatter = defineFormatter({
+            style: 'unit',
+            unit: 'second',
+            unitDisplay: 'narrow',
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        });
+        preciseSecondsToStringFormattersCache.set(precision, formatter);
+    }
+    return formatter.format(ms);
+}
+export function secondsToString(seconds, higherResolution) {
+    if (!isFinite(seconds)) {
+        return '-';
+    }
+    return millisToString(seconds * 1000, higherResolution);
+}