@nubjs/nub-linux-x64 0.0.7 → 0.0.9

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

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

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

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