@nubjs/nub-darwin-x64 0.2.3 → 0.2.5

package/runtime/node_modules/@js-temporal/polyfill/lib/debug.ts

@@ -1,7 +0,0 @@
-interface GlobalDebugInfo {
-  __debug__?: boolean;
-  __enableAsserts__?: boolean;
-}
-
-export const DEBUG = !!(globalThis as GlobalDebugInfo).__debug__;
-export const ENABLE_ASSERTS = !!(globalThis as GlobalDebugInfo).__enableAsserts__ || DEBUG;

package/runtime/node_modules/@js-temporal/polyfill/lib/duration.ts

@@ -1,438 +0,0 @@
-import { DEBUG } from './debug';
-import { assert } from './assert';
-import * as ES from './ecmascript';
-import { ModifiedIntlDurationFormatPrototypeFormat } from './intl';
-import { MakeIntrinsicClass } from './intrinsicclass';
-import {
-  YEARS,
-  MONTHS,
-  WEEKS,
-  DAYS,
-  HOURS,
-  MINUTES,
-  SECONDS,
-  MILLISECONDS,
-  MICROSECONDS,
-  NANOSECONDS,
-  CALENDAR,
-  EPOCHNANOSECONDS,
-  CreateSlots,
-  GetSlot,
-  ISO_DATE,
-  SetSlot,
-  TIME_ZONE
-} from './slots';
-import { TimeDuration } from './timeduration';
-import type { Temporal } from '..';
-import type { DurationParams as Params, DurationReturn as Return } from './internaltypes';
-import JSBI from 'jsbi';
-
-export class Duration implements Temporal.Duration {
-  constructor(
-    yearsParam: Params['constructor'][0] = 0,
-    monthsParam: Params['constructor'][1] = 0,
-    weeksParam: Params['constructor'][2] = 0,
-    daysParam: Params['constructor'][3] = 0,
-    hoursParam: Params['constructor'][4] = 0,
-    minutesParam: Params['constructor'][5] = 0,
-    secondsParam: Params['constructor'][6] = 0,
-    millisecondsParam: Params['constructor'][7] = 0,
-    microsecondsParam: Params['constructor'][8] = 0,
-    nanosecondsParam: Params['constructor'][9] = 0
-  ) {
-    const years = yearsParam === undefined ? 0 : ES.ToIntegerIfIntegral(yearsParam);
-    const months = monthsParam === undefined ? 0 : ES.ToIntegerIfIntegral(monthsParam);
-    const weeks = weeksParam === undefined ? 0 : ES.ToIntegerIfIntegral(weeksParam);
-    const days = daysParam === undefined ? 0 : ES.ToIntegerIfIntegral(daysParam);
-    const hours = hoursParam === undefined ? 0 : ES.ToIntegerIfIntegral(hoursParam);
-    const minutes = minutesParam === undefined ? 0 : ES.ToIntegerIfIntegral(minutesParam);
-    const seconds = secondsParam === undefined ? 0 : ES.ToIntegerIfIntegral(secondsParam);
-    const milliseconds = millisecondsParam === undefined ? 0 : ES.ToIntegerIfIntegral(millisecondsParam);
-    const microseconds = microsecondsParam === undefined ? 0 : ES.ToIntegerIfIntegral(microsecondsParam);
-    const nanoseconds = nanosecondsParam === undefined ? 0 : ES.ToIntegerIfIntegral(nanosecondsParam);
-
-    ES.RejectDuration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
-
-    CreateSlots(this);
-    SetSlot(this, YEARS, years);
-    SetSlot(this, MONTHS, months);
-    SetSlot(this, WEEKS, weeks);
-    SetSlot(this, DAYS, days);
-    SetSlot(this, HOURS, hours);
-    SetSlot(this, MINUTES, minutes);
-    SetSlot(this, SECONDS, seconds);
-    SetSlot(this, MILLISECONDS, milliseconds);
-    SetSlot(this, MICROSECONDS, microseconds);
-    SetSlot(this, NANOSECONDS, nanoseconds);
-
-    if (DEBUG) {
-      Object.defineProperty(this, '_repr_', {
-        value: `Temporal.Duration <${ES.TemporalDurationToString(this, 'auto')}>`,
-        writable: false,
-        enumerable: false,
-        configurable: false
-      });
-    }
-  }
-  get years(): Return['years'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, YEARS);
-  }
-  get months(): Return['months'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, MONTHS);
-  }
-  get weeks(): Return['weeks'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, WEEKS);
-  }
-  get days(): Return['days'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, DAYS);
-  }
-  get hours(): Return['hours'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, HOURS);
-  }
-  get minutes(): Return['minutes'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, MINUTES);
-  }
-  get seconds(): Return['seconds'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, SECONDS);
-  }
-  get milliseconds(): Return['milliseconds'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, MILLISECONDS);
-  }
-  get microseconds(): Return['microseconds'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, MICROSECONDS);
-  }
-  get nanoseconds(): Return['nanoseconds'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return GetSlot(this, NANOSECONDS);
-  }
-  get sign(): Return['sign'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.DurationSign(this);
-  }
-  get blank(): Return['blank'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.DurationSign(this) === 0;
-  }
-  with(durationLike: Params['with'][0]): Return['with'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    const partialDuration = ES.ToTemporalPartialDurationRecord(durationLike);
-    const {
-      years = GetSlot(this, YEARS),
-      months = GetSlot(this, MONTHS),
-      weeks = GetSlot(this, WEEKS),
-      days = GetSlot(this, DAYS),
-      hours = GetSlot(this, HOURS),
-      minutes = GetSlot(this, MINUTES),
-      seconds = GetSlot(this, SECONDS),
-      milliseconds = GetSlot(this, MILLISECONDS),
-      microseconds = GetSlot(this, MICROSECONDS),
-      nanoseconds = GetSlot(this, NANOSECONDS)
-    } = partialDuration;
-    return new Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
-  }
-  negated(): Return['negated'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.CreateNegatedTemporalDuration(this);
-  }
-  abs(): Return['abs'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return new Duration(
-      Math.abs(GetSlot(this, YEARS)),
-      Math.abs(GetSlot(this, MONTHS)),
-      Math.abs(GetSlot(this, WEEKS)),
-      Math.abs(GetSlot(this, DAYS)),
-      Math.abs(GetSlot(this, HOURS)),
-      Math.abs(GetSlot(this, MINUTES)),
-      Math.abs(GetSlot(this, SECONDS)),
-      Math.abs(GetSlot(this, MILLISECONDS)),
-      Math.abs(GetSlot(this, MICROSECONDS)),
-      Math.abs(GetSlot(this, NANOSECONDS))
-    );
-  }
-  add(other: Params['add'][0]): Return['add'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.AddDurations('add', this, other);
-  }
-  subtract(other: Params['subtract'][0]): Return['subtract'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.AddDurations('subtract', this, other);
-  }
-  round(roundToParam: Params['round'][0]): Return['round'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    if (roundToParam === undefined) throw new TypeError('options parameter is required');
-
-    const existingLargestUnit = ES.DefaultTemporalLargestUnit(this);
-    const roundTo =
-      typeof roundToParam === 'string'
-        ? (ES.CreateOnePropObject('smallestUnit', roundToParam) as Exclude<typeof roundToParam, string>)
-        : ES.GetOptionsObject(roundToParam);
-
-    let largestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'largestUnit', 'datetime', undefined, ['auto']);
-    let { plainRelativeTo, zonedRelativeTo } = ES.GetTemporalRelativeToOption(roundTo);
-    const roundingIncrement = ES.GetTemporalRoundingIncrementOption(roundTo);
-    const roundingMode = ES.GetRoundingModeOption(roundTo, 'halfExpand');
-    let smallestUnit = ES.GetTemporalUnitValuedOption(roundTo, 'smallestUnit', 'datetime', undefined);
-
-    let smallestUnitPresent = true;
-    if (!smallestUnit) {
-      smallestUnitPresent = false;
-      smallestUnit = 'nanosecond';
-    }
-    const defaultLargestUnit = ES.LargerOfTwoTemporalUnits(existingLargestUnit, smallestUnit);
-    let largestUnitPresent = true;
-    if (!largestUnit) {
-      largestUnitPresent = false;
-      largestUnit = defaultLargestUnit;
-    }
-    if (largestUnit === 'auto') largestUnit = defaultLargestUnit;
-    if (!smallestUnitPresent && !largestUnitPresent) {
-      throw new RangeError('at least one of smallestUnit or largestUnit is required');
-    }
-    if (ES.LargerOfTwoTemporalUnits(largestUnit, smallestUnit) !== largestUnit) {
-      throw new RangeError(`largestUnit ${largestUnit} cannot be smaller than smallestUnit ${smallestUnit}`);
-    }
-
-    const maximumIncrements = {
-      hour: 24,
-      minute: 60,
-      second: 60,
-      millisecond: 1000,
-      microsecond: 1000,
-      nanosecond: 1000
-    } as { [k in Temporal.DateTimeUnit]?: number };
-    const maximum = maximumIncrements[smallestUnit];
-    if (maximum !== undefined) ES.ValidateTemporalRoundingIncrement(roundingIncrement, maximum, false);
-    if (roundingIncrement > 1 && ES.TemporalUnitCategory(smallestUnit) === 'date' && largestUnit !== smallestUnit) {
-      throw new RangeError('For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit');
-    }
-
-    if (zonedRelativeTo) {
-      let duration = ES.ToInternalDurationRecord(this);
-      const timeZone = GetSlot(zonedRelativeTo, TIME_ZONE);
-      const calendar = GetSlot(zonedRelativeTo, CALENDAR);
-      const relativeEpochNs = GetSlot(zonedRelativeTo, EPOCHNANOSECONDS);
-      const targetEpochNs = ES.AddZonedDateTime(relativeEpochNs, timeZone, calendar, duration);
-      duration = ES.DifferenceZonedDateTimeWithRounding(
-        relativeEpochNs,
-        targetEpochNs,
-        timeZone,
-        calendar,
-        largestUnit,
-        roundingIncrement,
-        smallestUnit,
-        roundingMode
-      );
-      if (ES.TemporalUnitCategory(largestUnit) === 'date') largestUnit = 'hour';
-      return ES.TemporalDurationFromInternal(duration, largestUnit);
-    }
-
-    if (plainRelativeTo) {
-      let duration = ES.ToInternalDurationRecordWith24HourDays(this);
-      const targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.time);
-
-      // Delegate the date part addition to the calendar
-      const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
-      const calendar = GetSlot(plainRelativeTo, CALENDAR);
-      const dateDuration = ES.AdjustDateDurationRecord(duration.date, targetTime.deltaDays);
-      const targetDate = ES.CalendarDateAdd(calendar, isoRelativeToDate, dateDuration, 'constrain');
-
-      const isoDateTime = ES.CombineISODateAndTimeRecord(isoRelativeToDate, ES.MidnightTimeRecord());
-      const targetDateTime = ES.CombineISODateAndTimeRecord(targetDate, targetTime);
-      duration = ES.DifferencePlainDateTimeWithRounding(
-        isoDateTime,
-        targetDateTime,
-        calendar,
-        largestUnit,
-        roundingIncrement,
-        smallestUnit,
-        roundingMode
-      );
-      return ES.TemporalDurationFromInternal(duration, largestUnit);
-    }
-
-    // No reference date to calculate difference relative to
-    if (ES.IsCalendarUnit(existingLargestUnit)) {
-      throw new RangeError(`a starting point is required for ${existingLargestUnit}s balancing`);
-    }
-    if (ES.IsCalendarUnit(largestUnit)) {
-      throw new RangeError(`a starting point is required for ${largestUnit}s balancing`);
-    }
-    assert(!ES.IsCalendarUnit(smallestUnit), 'smallestUnit was larger than largestUnit');
-    let internalDuration = ES.ToInternalDurationRecordWith24HourDays(this);
-    if (smallestUnit === 'day') {
-      // First convert time units up to days
-      const { quotient, remainder } = internalDuration.time.divmod(ES.DAY_NANOS);
-      let days = internalDuration.date.days + quotient + ES.TotalTimeDuration(remainder, 'day');
-      days = ES.RoundNumberToIncrement(days, roundingIncrement, roundingMode);
-      const dateDuration = { years: 0, months: 0, weeks: 0, days };
-      internalDuration = ES.CombineDateAndTimeDuration(dateDuration, TimeDuration.ZERO);
-    } else {
-      const timeDuration = ES.RoundTimeDuration(internalDuration.time, roundingIncrement, smallestUnit, roundingMode);
-      internalDuration = ES.CombineDateAndTimeDuration(ES.ZeroDateDuration(), timeDuration);
-    }
-    return ES.TemporalDurationFromInternal(internalDuration, largestUnit);
-  }
-  total(optionsParam: Params['total'][0]): Return['total'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-
-    if (optionsParam === undefined) throw new TypeError('options argument is required');
-    const options =
-      typeof optionsParam === 'string'
-        ? (ES.CreateOnePropObject('unit', optionsParam) as Exclude<typeof optionsParam, string>)
-        : ES.GetOptionsObject(optionsParam);
-    let { plainRelativeTo, zonedRelativeTo } = ES.GetTemporalRelativeToOption(options);
-    const unit = ES.GetTemporalUnitValuedOption(options, 'unit', 'datetime', ES.REQUIRED);
-
-    if (zonedRelativeTo) {
-      const duration = ES.ToInternalDurationRecord(this);
-      const timeZone = GetSlot(zonedRelativeTo, TIME_ZONE);
-      const calendar = GetSlot(zonedRelativeTo, CALENDAR);
-      const relativeEpochNs = GetSlot(zonedRelativeTo, EPOCHNANOSECONDS);
-      const targetEpochNs = ES.AddZonedDateTime(relativeEpochNs, timeZone, calendar, duration);
-      return ES.DifferenceZonedDateTimeWithTotal(relativeEpochNs, targetEpochNs, timeZone, calendar, unit);
-    }
-
-    if (plainRelativeTo) {
-      const duration = ES.ToInternalDurationRecordWith24HourDays(this);
-      let targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.time);
-
-      // Delegate the date part addition to the calendar
-      const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
-      const calendar = GetSlot(plainRelativeTo, CALENDAR);
-      const dateDuration = ES.AdjustDateDurationRecord(duration.date, targetTime.deltaDays);
-      const targetDate = ES.CalendarDateAdd(calendar, isoRelativeToDate, dateDuration, 'constrain');
-
-      const isoDateTime = ES.CombineISODateAndTimeRecord(isoRelativeToDate, ES.MidnightTimeRecord());
-      const targetDateTime = ES.CombineISODateAndTimeRecord(targetDate, targetTime);
-      return ES.DifferencePlainDateTimeWithTotal(isoDateTime, targetDateTime, calendar, unit);
-    }
-
-    // No reference date to calculate difference relative to
-    const largestUnit = ES.DefaultTemporalLargestUnit(this);
-    if (ES.IsCalendarUnit(largestUnit)) {
-      throw new RangeError(`a starting point is required for ${largestUnit}s total`);
-    }
-    if (ES.IsCalendarUnit(unit)) {
-      throw new RangeError(`a starting point is required for ${unit}s total`);
-    }
-    const duration = ES.ToInternalDurationRecordWith24HourDays(this);
-    return ES.TotalTimeDuration(duration.time, unit);
-  }
-  toString(options: Params['toString'][0] = undefined): string {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    const resolvedOptions = ES.GetOptionsObject(options);
-    const digits = ES.GetTemporalFractionalSecondDigitsOption(resolvedOptions);
-    const roundingMode = ES.GetRoundingModeOption(resolvedOptions, 'trunc');
-    const smallestUnit = ES.GetTemporalUnitValuedOption(resolvedOptions, 'smallestUnit', 'time', undefined);
-    if (smallestUnit === 'hour' || smallestUnit === 'minute') {
-      throw new RangeError('smallestUnit must be a time unit other than "hours" or "minutes"');
-    }
-    const { precision, unit, increment } = ES.ToSecondsStringPrecisionRecord(smallestUnit, digits);
-    ES.uncheckedAssertNarrowedType<Exclude<typeof precision, 'minute'>>(
-      precision,
-      'Precision cannot be "minute" because of RangeError above'
-    );
-
-    if (unit === 'nanosecond' && increment === 1) return ES.TemporalDurationToString(this, precision);
-
-    const largestUnit = ES.DefaultTemporalLargestUnit(this);
-    let internalDuration = ES.ToInternalDurationRecord(this);
-    const timeDuration = ES.RoundTimeDuration(internalDuration.time, increment, unit, roundingMode);
-    internalDuration = ES.CombineDateAndTimeDuration(internalDuration.date, timeDuration);
-    const roundedDuration = ES.TemporalDurationFromInternal(
-      internalDuration,
-      ES.LargerOfTwoTemporalUnits(largestUnit, 'second')
-    );
-    return ES.TemporalDurationToString(roundedDuration, precision);
-  }
-  toJSON(): Return['toJSON'] {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    return ES.TemporalDurationToString(this, 'auto');
-  }
-  toLocaleString(
-    locales: Params['toLocaleString'][0] = undefined,
-    options: Params['toLocaleString'][1] = undefined
-  ): string {
-    ES.CheckReceiver(this, ES.IsTemporalDuration);
-    if (typeof Intl.DurationFormat === 'function') {
-      const formatter = new Intl.DurationFormat(locales, options as Intl.DurationFormatOptions);
-      return ModifiedIntlDurationFormatPrototypeFormat.call(formatter, this);
-    }
-    console.warn('Temporal.Duration.prototype.toLocaleString() requires Intl.DurationFormat.');
-    return ES.TemporalDurationToString(this, 'auto');
-  }
-  valueOf(): never {
-    ES.ValueOfThrows('Duration');
-  }
-  static from(item: Params['from'][0]): Return['from'] {
-    return ES.ToTemporalDuration(item);
-  }
-  static compare(
-    oneParam: Params['compare'][0],
-    twoParam: Params['compare'][1],
-    options: Params['compare'][2] = undefined
-  ): Return['compare'] {
-    const one = ES.ToTemporalDuration(oneParam);
-    const two = ES.ToTemporalDuration(twoParam);
-    const resolvedOptions = ES.GetOptionsObject(options);
-    const { plainRelativeTo, zonedRelativeTo } = ES.GetTemporalRelativeToOption(resolvedOptions);
-
-    if (
-      GetSlot(one, YEARS) === GetSlot(two, YEARS) &&
-      GetSlot(one, MONTHS) === GetSlot(two, MONTHS) &&
-      GetSlot(one, WEEKS) === GetSlot(two, WEEKS) &&
-      GetSlot(one, DAYS) === GetSlot(two, DAYS) &&
-      GetSlot(one, HOURS) === GetSlot(two, HOURS) &&
-      GetSlot(one, MINUTES) === GetSlot(two, MINUTES) &&
-      GetSlot(one, SECONDS) === GetSlot(two, SECONDS) &&
-      GetSlot(one, MILLISECONDS) === GetSlot(two, MILLISECONDS) &&
-      GetSlot(one, MICROSECONDS) === GetSlot(two, MICROSECONDS) &&
-      GetSlot(one, NANOSECONDS) === GetSlot(two, NANOSECONDS)
-    ) {
-      return 0;
-    }
-
-    const largestUnit1 = ES.DefaultTemporalLargestUnit(one);
-    const largestUnit2 = ES.DefaultTemporalLargestUnit(two);
-    const duration1 = ES.ToInternalDurationRecord(one);
-    const duration2 = ES.ToInternalDurationRecord(two);
-
-    if (
-      zonedRelativeTo &&
-      (ES.TemporalUnitCategory(largestUnit1) === 'date' || ES.TemporalUnitCategory(largestUnit2) === 'date')
-    ) {
-      const timeZone = GetSlot(zonedRelativeTo, TIME_ZONE);
-      const calendar = GetSlot(zonedRelativeTo, CALENDAR);
-      const epochNs = GetSlot(zonedRelativeTo, EPOCHNANOSECONDS);
-
-      const after1 = ES.AddZonedDateTime(epochNs, timeZone, calendar, duration1);
-      const after2 = ES.AddZonedDateTime(epochNs, timeZone, calendar, duration2);
-      return ES.ComparisonResult(JSBI.toNumber(JSBI.subtract(after1, after2)));
-    }
-
-    let d1 = duration1.date.days;
-    let d2 = duration2.date.days;
-    if (ES.IsCalendarUnit(largestUnit1) || ES.IsCalendarUnit(largestUnit2)) {
-      if (!plainRelativeTo) {
-        throw new RangeError('A starting point is required for years, months, or weeks comparison');
-      }
-      d1 = ES.DateDurationDays(duration1.date, plainRelativeTo);
-      d2 = ES.DateDurationDays(duration2.date, plainRelativeTo);
-    }
-    const timeDuration1 = duration1.time.add24HourDays(d1);
-    const timeDuration2 = duration2.time.add24HourDays(d2);
-    return timeDuration1.cmp(timeDuration2);
-  }
-  [Symbol.toStringTag]!: 'Temporal.Duration';
-}
-
-MakeIntrinsicClass(Duration, 'Temporal.Duration');

package/runtime/node_modules/@js-temporal/polyfill/lib/durationformat.d.ts

@@ -1,93 +0,0 @@
-// Ambient declaration file to bridge the gap until Intl.DurationFormat is
-// supported in TypeScript's own type declarations. Note that it is for internal
-// use, meaning that it describes the DurationFormat interface _without_ support
-// for Temporal.Duration objects.
-
-declare namespace Intl {
-  type DurationCalendarUnitStyle = 'long' | 'short' | 'narrow';
-  type DurationDigitalUnitStyle = 'long' | 'short' | 'narrow' | 'numeric' | '2-digit';
-  type DurationFractionalUnitStyle = 'long' | 'short' | 'narrow' | 'numeric';
-  type DurationDisplay = 'auto' | 'always';
-
-  interface DurationFormatOptions {
-    localeMatcher?: 'best fit' | 'basic' | undefined;
-    numberingSystem?: string | undefined;
-    style?: 'long' | 'short' | 'narrow' | 'digital' | undefined;
-    years?: DurationCalendarUnitStyle | undefined;
-    yearsDisplay?: DurationDisplay | undefined;
-    months?: DurationCalendarUnitStyle | undefined;
-    monthsDisplay?: DurationDisplay | undefined;
-    weeks?: DurationCalendarUnitStyle | undefined;
-    weeksDisplay?: DurationDisplay | undefined;
-    days?: DurationCalendarUnitStyle | undefined;
-    daysDisplay?: DurationDisplay | undefined;
-    hours?: DurationDigitalUnitStyle | undefined;
-    hoursDisplay?: DurationDisplay | undefined;
-    minutes?: DurationDigitalUnitStyle | undefined;
-    minutesDisplay?: DurationDisplay | undefined;
-    seconds?: DurationDigitalUnitStyle | undefined;
-    secondsDisplay?: DurationDisplay | undefined;
-    milliseconds?: DurationFractionalUnitStyle | undefined;
-    millisecondsDisplay?: DurationDisplay | undefined;
-    microseconds?: DurationFractionalUnitStyle | undefined;
-    microsecondsDisplay?: DurationDisplay | undefined;
-    nanoseconds?: DurationFractionalUnitStyle | undefined;
-    nanosecondsDisplay?: DurationDisplay | undefined;
-    fractionalDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
-  }
-
-  interface ResolvedDurationFormatOptions {
-    locale: string;
-    numberingSystem: string;
-    style: 'long' | 'short' | 'narrow' | 'digital';
-    years: DurationCalendarUnitStyle;
-    yearsDisplay: DurationDisplay;
-    months: DurationCalendarUnitStyle;
-    monthsDisplay: DurationDisplay;
-    weeks: DurationCalendarUnitStyle;
-    weeksDisplay: DurationDisplay;
-    days: DurationCalendarUnitStyle;
-    daysDisplay: DurationDisplay;
-    hours: DurationDigitalUnitStyle;
-    hoursDisplay: DurationDisplay;
-    minutes: DurationDigitalUnitStyle;
-    minutesDisplay: DurationDisplay;
-    seconds: DurationDigitalUnitStyle;
-    secondsDisplay: DurationDisplay;
-    milliseconds: DurationFractionalUnitStyle;
-    millisecondsDisplay: DurationDisplay;
-    microseconds: DurationFractionalUnitStyle;
-    microsecondsDisplay: DurationDisplay;
-    nanoseconds: DurationFractionalUnitStyle;
-    nanosecondsDisplay: DurationDisplay;
-    fractionalDigits: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
-  }
-
-  interface DurationLike {
-    years?: number;
-    months?: number;
-    weeks?: number;
-    days?: number;
-    hours?: number;
-    minutes?: number;
-    seconds?: number;
-    milliseconds?: number;
-    microseconds?: number;
-    nanoseconds?: number;
-  }
-
-  interface DurationFormatPart {
-    type: string;
-    value: string;
-  }
-
-  class DurationFormat {
-    constructor(locales?: LocalesArgument, options?: DurationFormatOptions);
-
-    static supportedLocalesOf(locales?: LocalesArgument, options?: DurationFormatOptions): LocalesArgument;
-
-    format(duration: DurationLike | string): string;
-    formatToParts(duration: DurationLike | string): DurationFormatPart[];
-    resolvedOptions(): ResolvedDurationFormatOptions;
-  }
-}