devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/core/host/host.ts

@@ -1,23 +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 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,
-  GdpClient,
-  InspectorFrontendHost,
-  InspectorFrontendHostAPI,
-  Platform,
-  ResourceLoader,
-  UserMetrics,
-};
-
-export const userMetrics = new UserMetrics.UserMetrics();

package/lib/front_end/core/i18n/ByteUtilities.ts

@@ -1,82 +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: number): string => {
-  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: number): string => {
-  const kilobytes = bytes / 1000;
-  if (kilobytes < 100) {
-    return narrowKilobytesDecimal.format(kilobytes);
-  }
-  return narrowKilobytesInteger.format(kilobytes);
-};

package/lib/front_end/core/i18n/DevToolsLocale.ts

@@ -1,87 +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: DevToolsLocale|null = null;
-
-export interface DevToolsLocaleData {
-  settingLanguage: string;
-  navigatorLanguage: string;
-  lookupClosestDevToolsLocale: (locale: string) => string;
-}
-
-export type DevToolsLocaleCreationOptions = {
-  create: true,
-  data: DevToolsLocaleData,
-}|{
-  create: false,
-};
-
-/**
- * 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 {
-  readonly locale: string;
-  readonly lookupClosestDevToolsLocale: (locale: string) => string;
-
-  private constructor(data: DevToolsLocaleData) {
-    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: DevToolsLocaleCreationOptions = {create: false}): DevToolsLocale {
-    if (!devToolsLocaleInstance && !opts.create) {
-      throw new Error('No LanguageSelector instance exists yet.');
-    }
-
-    if (opts.create) {
-      devToolsLocaleInstance = new DevToolsLocale(opts.data);
-    }
-    return devToolsLocaleInstance as DevToolsLocale;
-  }
-
-  static removeInstance(): void {
-    devToolsLocaleInstance = null;
-  }
-
-  forceFallbackLocale(): void {
-    // Locale is 'readonly', this is the only case where we want to forcibly
-    // overwrite the locale.
-    (this.locale as unknown) = '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: string): boolean {
-    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: string, localeString2: string): boolean {
-  const locale1 = new Intl.Locale(localeString1);
-  const locale2 = new Intl.Locale(localeString2);
-  return locale1.language === locale2.language;
-}

package/lib/front_end/core/i18n/NumberFormatter.ts

@@ -1,82 +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';
-
-export interface NumberFormatter {
-  format(value: number, separator?: string): string;
-  formatToParts(value: number): Intl.NumberFormatPart[];
-}
-
-/**
- * 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: Intl.NumberFormatOptions): NumberFormatter {
-  let intlNumberFormat: Intl.NumberFormat;
-
-  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: Intl.NumberFormat, value: number, separator = '\xA0'): string {
-  // 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/lib/front_end/core/i18n/i18n.ts

@@ -1,17 +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/lib/front_end/core/i18n/i18nImpl.ts

@@ -1,204 +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.
-/* eslint-disable @devtools/no-imperative-dom-api */
-
-import * as I18n from '../../third_party/i18n/i18n.js';
-import type * as Platform from '../platform/platform.js';
-import * as Root from '../root/root.js';
-
-import {DevToolsLocale} from './DevToolsLocale.js';
-import type * as i18nTypes from './i18nTypes.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<string>([...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: string): string {
-  return i18nInstance.lookupClosestSupportedLocale(locale);
-}
-
-/**
- * Returns a list of all supported DevTools locales, including pseudo locales.
- */
-export function getAllSupportedDevToolsLocales(): string[] {
-  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: Intl.UnicodeBCP47LocaleIdentifier, location: string): string {
-  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: Intl.UnicodeBCP47LocaleIdentifier, location = self.location.toString()): Promise<void> {
-  const localeDataTextPromise = fetch(getLocaleFetchUrl(locale, location)).then(result => result.json());
-  const timeoutPromise =
-      new Promise<never>((_, 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: Intl.UnicodeBCP47LocaleIdentifier): boolean {
-  return i18nInstance.hasLocaleDataForTest(locale);
-}
-
-export function resetLocaleDataForTest(): void {
-  i18nInstance.resetLocaleDataForTest();
-}
-
-export function registerLocaleDataForTest(
-    locale: Intl.UnicodeBCP47LocaleIdentifier, messages: I18n.I18n.LocalizedMessages): void {
-  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: I18n.LocalizedStringSet.RegisteredFileStrings, id: string, values: i18nTypes.Values = {}): () =>
-    Platform.UIString.LocalizedString {
-  return (): Platform.UIString.LocalizedString => getLocalizedString(registeredStrings, id, values);
-}
-
-/**
- * Retrieve the localized string.
- */
-export function getLocalizedString(
-    registeredStrings: I18n.LocalizedStringSet.RegisteredFileStrings, id: string,
-    values: i18nTypes.Values = {}): Platform.UIString.LocalizedString {
-  return registeredStrings.getLocalizedStringSetFor(DevToolsLocale.instance().locale).getLocalizedString(id, values) as
-      Platform.UIString.LocalizedString;
-}
-
-/**
- * Register a file's UIStrings with i18n, return function to generate the string ids.
- */
-export function registerUIStrings(
-    path: string, stringStructure: Record<string, string>): I18n.LocalizedStringSet.RegisteredFileStrings {
-  return i18nInstance.registerFileStrings(path, stringStructure);
-}
-
-/**
- * Returns a span element that may contains other DOM element as placeholders
- */
-export function getFormatLocalizedString(
-    registeredStrings: I18n.LocalizedStringSet.RegisteredFileStrings, stringId: string,
-    placeholders: Record<string, Object>): HTMLSpanElement {
-  const formatter =
-      registeredStrings.getLocalizedStringSetFor(DevToolsLocale.instance().locale).getMessageFormatterFor(stringId);
-
-  const element = document.createElement('span');
-  for (const icuElement of formatter.getAst()) {
-    if (icuElement.type === /* argumentElement */ 1) {
-      const placeholderValue = placeholders[icuElement.value];
-      if (placeholderValue) {
-        element.append(placeholderValue as Node | string);
-      }
-    } else if ('value' in icuElement) {
-      element.append(String(icuElement.value));
-    }
-  }
-  return element;
-}
-
-export function serializeUIString(string: string, values: Record<string, Object> = {}): string {
-  const serializedMessage = {string, values};
-  return JSON.stringify(serializedMessage);
-}
-
-export function deserializeUIString(serializedMessage: string): i18nTypes.SerializedMessage {
-  if (!serializedMessage) {
-    return {string: '', values: {}} as i18nTypes.SerializedMessage;
-  }
-
-  return JSON.parse(serializedMessage) as i18nTypes.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: string): Platform.UIString.LocalizedString {
-  return str as Platform.UIString.LocalizedString;
-}
-
-/**
- * Same as `lockedString` but for places where `i18nLazyString` would be used otherwise.
- */
-export function lockedLazyString(str: string): () => Platform.UIString.LocalizedString {
-  return (): Platform.UIString.LocalizedString => str as Platform.UIString.LocalizedString;
-}
-
-/**
- * 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: Intl.UnicodeBCP47LocaleIdentifier,
-    devtoolsLocale: DevToolsLocale): Platform.UIString.LocalizedString {
-  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}` as Platform.UIString.LocalizedString;
-}

package/lib/front_end/core/i18n/i18nTypes.ts

@@ -1,10 +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 type Values = Record<string, string|boolean|number>;
-
-export interface SerializedMessage {
-  string: string;
-  values: Values;
-}

package/lib/front_end/core/i18n/locales.js

@@ -1,14 +0,0 @@
-// Auto-generated stub for locales.js
-// This file replaces the original generated locales file for standalone usage
-
-/** The list of all supported locales of DevTools */
-export const LOCALES = ['en-US'];
-
-/** A subset of LOCALES that are bundled with Chromium. The rest is fetched remotely */
-export const BUNDLED_LOCALES = ['en-US'];
-
-export const DEFAULT_LOCALE = 'en-US';
-
-export const REMOTE_FETCH_PATTERN = 'https://devtools://devtools/@VERSION@/locales/@LOCALE@.json';
-
-export const LOCAL_FETCH_PATTERN = './locales/@LOCALE@.json';

package/lib/front_end/core/i18n/time-utilities.ts

@@ -1,174 +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, type NumberFormatter} 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: Platform.Timing.MicroSeconds): string {
-  return millisToString(Platform.Timing.microSecondsToMilliSeconds(time), true);
-}
-
-export function formatMicroSecondsAsSeconds(time: Platform.Timing.MicroSeconds): string {
-  const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
-  const seconds = Platform.Timing.milliSecondsToSeconds(milliseconds);
-  return narrowSecondsDecimal.format(seconds);
-}
-
-export function formatMicroSecondsAsMillisFixed(time: Platform.Timing.MicroSeconds): string {
-  const milliseconds = Platform.Timing.microSecondsToMilliSeconds(time);
-  return narrowMillisecondsInteger.format(milliseconds);
-}
-
-export function formatMicroSecondsAsMillisFixedExpanded(time: Platform.Timing.MicroSeconds): string {
-  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: number, higherResolution?: boolean): string {
-  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<number, NumberFormatter>();
-
-export function preciseMillisToString(ms: number, precision = 0, separator?: string): string {
-  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<number, NumberFormatter>();
-
-export function preciseSecondsToString(ms: number, precision = 0): string {
-  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: number, higherResolution?: boolean): string {
-  if (!isFinite(seconds)) {
-    return '-';
-  }
-  return millisToString(seconds * 1000, higherResolution);
-}