ideamans-chrome-devtools-mcp 0.11.3 → 0.21.0

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

@@ -1,13 +0,0 @@
-// 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/node_modules/chrome-devtools-frontend/front_end/core/i18n/ByteUtilities.js

@@ -1,72 +0,0 @@
-// 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

@@ -1,64 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-"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/node_modules/chrome-devtools-frontend/front_end/core/i18n/generate-locales-js.js

@@ -1,51 +0,0 @@
-"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/node_modules/chrome-devtools-frontend/front_end/core/i18n/i18n.js

@@ -1,9 +0,0 @@
-// 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/node_modules/chrome-devtools-frontend/front_end/core/i18n/i18nImpl.js

@@ -1,135 +0,0 @@
-// 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/node_modules/chrome-devtools-frontend/front_end/core/i18n/i18nTypes.js

@@ -1,4 +0,0 @@
-// 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/node_modules/chrome-devtools-frontend/front_end/core/i18n/locales.js

@@ -1,14 +0,0 @@
-
-export const LOCALES = [
-  'en-US',
-];
-
-export const BUNDLED_LOCALES = [
-  'en-US',
-];
-
-export const DEFAULT_LOCALE = 'en-US';
-
-export const REMOTE_FETCH_PATTERN = '@HOST@/remote/serve_file/@VERSION@/core/i18n/locales/@LOCALE@.json';
-
-export const LOCAL_FETCH_PATTERN = './locales/@LOCALE@.json';

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

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