@nubjs/nub-linux-x64 0.0.5 → 0.0.8

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

@@ -0,0 +1,758 @@
+import { assert } from './assert';
+import * as ES from './ecmascript';
+import { MakeIntrinsicClass } from './intrinsicclass';
+import {
+  CAL_ID,
+  CALENDAR,
+  CreateSlots,
+  DATE,
+  DATETIME,
+  DAYS,
+  EPOCHNANOSECONDS,
+  GetSlot,
+  HasSlot,
+  HOURS,
+  INST,
+  ISO_DATE,
+  ISO_DATE_TIME,
+  LOCALE,
+  MD,
+  MICROSECONDS,
+  MILLISECONDS,
+  MINUTES,
+  MONTHS,
+  NANOSECONDS,
+  OPTIONS,
+  ORIGINAL,
+  ResetSlot,
+  SECONDS,
+  SetSlot,
+  TIME,
+  TIME_FMT,
+  TZ_CANONICAL,
+  TZ_ORIGINAL,
+  WEEKS,
+  YEARS,
+  YM
+} from './slots';
+import type { Temporal } from '..';
+import type { DateTimeFormatParams as Params, DateTimeFormatReturn as Return } from './internaltypes';
+
+// Save the original Intl.DateTimeFormat, it will likely be overwritten
+const OriginalIntlDateTimeFormat = Intl.DateTimeFormat;
+
+type LazySlot = typeof DATE | typeof YM | typeof MD | typeof TIME_FMT | typeof DATETIME | typeof INST;
+
+// Construction of built-in Intl.DateTimeFormat objects is sloooooow,
+// so we'll only create those instances when we need them.
+// See https://bugs.chromium.org/p/v8/issues/detail?id=6528
+function getSlotLazy(obj: DateTimeFormatImpl, slot: LazySlot) {
+  let val = GetSlot(obj, slot);
+  if (typeof val === 'function') {
+    // If we get here, `val` is an "amender function". It will take the user's
+    // options and transform them into suitable options to be passed into the
+    // built-in (non-polyfill) Intl.DateTimeFormat constructor. These options
+    // will vary depending on the Temporal type, so that's why we store separate
+    // formatters in separate props on the polyfill's DateTimeFormat instances.
+    // The efficiency happens because we don't create an (expensive) formatter
+    // until the user calls toLocaleString for that Temporal type.
+    val = new OriginalIntlDateTimeFormat(GetSlot(obj, LOCALE), val(GetSlot(obj, OPTIONS)));
+    ResetSlot(obj, slot, val);
+  }
+  return val;
+}
+
+function createDateTimeFormat(
+  dtf: DateTimeFormatImpl,
+  locale: Params['constructor'][0],
+  optionsParam: Params['constructor'][1]
+) {
+  const hasOptions = typeof optionsParam !== 'undefined';
+  let options: Intl.DateTimeFormatOptions;
+  if (hasOptions) {
+    // Read all the options in the expected order and copy them to a
+    // null-prototype object with which we can do further operations
+    // unobservably
+    const props: (keyof Intl.DateTimeFormatOptions)[] = [
+      'localeMatcher',
+      'calendar',
+      'numberingSystem',
+      'hour12',
+      'hourCycle',
+      'timeZone',
+      'weekday',
+      'era',
+      'year',
+      'month',
+      'day',
+      'dayPeriod',
+      'hour',
+      'minute',
+      'second',
+      'fractionalSecondDigits',
+      'timeZoneName',
+      'formatMatcher',
+      'dateStyle',
+      'timeStyle'
+    ];
+    options = ES.ToObject(optionsParam);
+    const newOptions = Object.create(null);
+    for (let i = 0; i < props.length; i++) {
+      const prop = props[i];
+      if (Object.prototype.hasOwnProperty.call(options, prop)) {
+        newOptions[prop] = options[prop];
+      }
+    }
+    options = newOptions;
+  } else {
+    options = Object.create(null);
+  }
+  const original = new OriginalIntlDateTimeFormat(locale, options);
+  const ro = original.resolvedOptions();
+
+  CreateSlots(dtf);
+
+  // DateTimeFormat instances are very expensive to create. Therefore, they will
+  // be lazily created only when needed, using the locale and options provided.
+  // But it's possible for callers to mutate those inputs before lazy creation
+  // happens. For this reason, we clone the inputs instead of caching the
+  // original objects. To avoid the complexity of deep cloning any inputs that
+  // are themselves objects (e.g. the locales array, or options property values
+  // that will be coerced to strings), we rely on `resolvedOptions()` to do the
+  // coercion and cloning for us. Unfortunately, we can't just use the resolved
+  // options as-is because our options-amending logic adds additional fields if
+  // the user doesn't supply any unit fields like year, month, day, hour, etc.
+  // Therefore, we limit the properties in the clone to properties that were
+  // present in the original input.
+  if (hasOptions) {
+    const clonedResolved = Object.assign(Object.create(null), ro);
+    for (const prop in clonedResolved) {
+      if (!Object.prototype.hasOwnProperty.call(options, prop)) {
+        delete clonedResolved[prop as keyof typeof clonedResolved];
+      }
+    }
+    // hour12/hourCycle don't show up in resolvedOptions() unless the chosen
+    // format includes an hour component, so copy them explicitly in case they
+    // would otherwise be lost
+    clonedResolved.hour12 = options.hour12;
+    clonedResolved.hourCycle = options.hourCycle;
+    SetSlot(dtf, OPTIONS, clonedResolved);
+  } else {
+    SetSlot(dtf, OPTIONS, options);
+  }
+
+  SetSlot(dtf, LOCALE, ro.locale);
+  SetSlot(dtf, ORIGINAL, original);
+  SetSlot(dtf, TZ_CANONICAL, ro.timeZone);
+  SetSlot(dtf, CAL_ID, ro.calendar);
+  SetSlot(dtf, DATE, dateAmend);
+  SetSlot(dtf, YM, yearMonthAmend);
+  SetSlot(dtf, MD, monthDayAmend);
+  SetSlot(dtf, TIME_FMT, timeAmend);
+  SetSlot(dtf, DATETIME, datetimeAmend);
+  SetSlot(dtf, INST, instantAmend);
+
+  // Save the original time zone, for a few reasons:
+  // - Clearer error messages
+  // - More clearly follows the spec for InitializeDateTimeFormat
+  // - Because it follows the spec more closely, will make it easier to integrate
+  //   support of offset strings and other potential changes like proposal-canonical-tz.
+  const timeZoneOption = hasOptions ? options.timeZone : undefined;
+  if (timeZoneOption === undefined) {
+    SetSlot(dtf, TZ_ORIGINAL, ro.timeZone);
+  } else {
+    const id = ES.ToString(timeZoneOption);
+    if (id.startsWith('−')) {
+      // The initial (Node 23) implementation of offset time zones allowed use
+      // of the Unicode minus sign, which was disallowed by a later spec change.
+      throw new RangeError('Unicode minus (U+2212) is not supported in time zone offsets');
+    }
+    // store a normalized identifier
+    SetSlot(dtf, TZ_ORIGINAL, ES.ToTemporalTimeZoneIdentifier(id));
+  }
+  return undefined; // TODO: I couldn't satisfy TS without adding this. Is there another way?
+}
+
+function IsPatchedDateTimeFormat(item: unknown): item is DateTimeFormatImpl {
+  return HasSlot(item, ORIGINAL);
+}
+
+class DateTimeFormatImpl {
+  constructor(locales: Params['constructor'][0] = undefined, options: Params['constructor'][1] = undefined) {
+    createDateTimeFormat(this, locales, options);
+  }
+
+  get format() {
+    ES.CheckReceiver(this, IsPatchedDateTimeFormat);
+    const boundFormat = format.bind(this);
+    Object.defineProperties(boundFormat, {
+      length: { value: 1, enumerable: false, writable: false, configurable: true },
+      name: { value: '', enumerable: false, writable: false, configurable: true }
+    });
+    return boundFormat;
+  }
+
+  formatRange(a: Params['formatRange'][0], b: Params['formatRange'][1]): Return['formatRange'] {
+    ES.CheckReceiver(this, IsPatchedDateTimeFormat);
+    return formatRange.call(this, a, b);
+  }
+
+  formatToParts?<P extends readonly unknown[]>(
+    datetime: Params['formatToParts'][0],
+    ...rest: P
+  ): Return['formatToParts'] {
+    ES.CheckReceiver(this, IsPatchedDateTimeFormat);
+    return formatToParts.call(this, datetime, ...rest);
+  }
+
+  formatRangeToParts?(
+    a: Params['formatRangeToParts'][0],
+    b: Params['formatRangeToParts'][1]
+  ): Return['formatRangeToParts'] {
+    ES.CheckReceiver(this, IsPatchedDateTimeFormat);
+    return formatRangeToParts.call(this, a, b);
+  }
+
+  resolvedOptions(): Return['resolvedOptions'] {
+    ES.CheckReceiver(this, IsPatchedDateTimeFormat);
+    return resolvedOptions.call(this);
+  }
+}
+
+if (!('formatToParts' in OriginalIntlDateTimeFormat.prototype)) {
+  delete DateTimeFormatImpl.prototype.formatToParts;
+}
+
+if (!('formatRangeToParts' in OriginalIntlDateTimeFormat.prototype)) {
+  delete DateTimeFormatImpl.prototype.formatRangeToParts;
+}
+export type { DateTimeFormatImpl };
+
+interface DateTimeFormatInterface {
+  (locales: Params['constructor'][0], options: Params['constructor'][1]): DateTimeFormatImpl;
+  new (locales: Params['constructor'][0], options: Params['constructor'][1]): DateTimeFormatImpl;
+  supportedLocalesOf: typeof Intl.DateTimeFormat.supportedLocalesOf;
+}
+
+// A non-class constructor is needed because Intl.DateTimeFormat must be able to
+// be called without 'new'
+export const DateTimeFormat = function (
+  locales: Params['constructor'][0] = undefined,
+  options: Params['constructor'][1] = undefined
+): DateTimeFormatImpl {
+  return new DateTimeFormatImpl(locales, options);
+} as unknown as DateTimeFormatInterface;
+DateTimeFormatImpl.prototype.constructor = DateTimeFormat;
+
+Object.defineProperty(DateTimeFormat, 'prototype', {
+  value: DateTimeFormatImpl.prototype,
+  writable: false,
+  enumerable: false,
+  configurable: false
+});
+DateTimeFormat.supportedLocalesOf = OriginalIntlDateTimeFormat.supportedLocalesOf;
+MakeIntrinsicClass(DateTimeFormat as unknown as typeof Intl.DateTimeFormat, 'Intl.DateTimeFormat');
+
+function resolvedOptions(this: DateTimeFormatImpl): Return['resolvedOptions'] {
+  const resolved = GetSlot(this, ORIGINAL).resolvedOptions();
+  resolved.timeZone = GetSlot(this, TZ_ORIGINAL);
+  return resolved;
+}
+
+// TODO: investigate why there's a rest parameter here. Does this function really need to accept extra params?
+// And if so, why doesn't formatRange also accept extra params?
+function format<P extends readonly unknown[]>(
+  this: DateTimeFormatImpl,
+  datetime: Params['format'][0],
+  ...rest: P
+): Return['format'] {
+  let overrides = extractOverrides(datetime, this);
+  let formatter, formatArgs: [Params['format'][0], ...unknown[]];
+  if (overrides.formatter) {
+    formatter = overrides.formatter;
+    formatArgs = [ES.epochNsToMs(overrides.epochNs, 'floor')];
+  } else {
+    formatter = GetSlot(this, ORIGINAL);
+    formatArgs = [datetime, ...rest];
+  }
+  return formatter.format(...(formatArgs as [number | Date | undefined]));
+}
+
+function formatToParts<P extends readonly unknown[]>(
+  this: DateTimeFormatImpl,
+  datetime: Params['formatToParts'][0],
+  ...rest: P
+): Return['formatToParts'] {
+  let overrides = extractOverrides(datetime, this);
+  let formatter, formatArgs;
+  if (overrides.formatter) {
+    formatter = overrides.formatter;
+    formatArgs = [ES.epochNsToMs(overrides.epochNs, 'floor')];
+  } else {
+    formatter = GetSlot(this, ORIGINAL);
+    formatArgs = [datetime, ...rest];
+  }
+  return formatter.formatToParts(...(formatArgs as [number | Date | undefined]));
+}
+
+function formatRange(this: DateTimeFormatImpl, aParam: Params['formatRange'][0], bParam: Params['formatRange'][1]) {
+  if (aParam === undefined || bParam === undefined) {
+    throw new TypeError('Intl.DateTimeFormat.formatRange requires two values');
+  }
+  const a = toDateTimeFormattable(aParam);
+  const b = toDateTimeFormattable(bParam);
+  let formatArgs = [a, b] as const;
+  let formatter;
+  if (isTemporalObject(a) !== isTemporalObject(b)) {
+    throw new TypeError('Intl.DateTimeFormat.formatRange accepts two values of the same type');
+  }
+  if (isTemporalObject(a)) {
+    if (!sameTemporalType(a, b)) {
+      throw new TypeError('Intl.DateTimeFormat.formatRange accepts two values of the same type');
+    }
+    const { epochNs: aa, formatter: aformatter } = extractOverrides(a, this);
+    const { epochNs: bb, formatter: bformatter } = extractOverrides(b, this);
+    if (aformatter) {
+      assert(bformatter == aformatter, 'formatters for same Temporal type should be identical');
+      formatter = aformatter;
+      formatArgs = [ES.epochNsToMs(aa, 'floor'), ES.epochNsToMs(bb, 'floor')];
+    }
+  }
+  if (!formatter) {
+    formatter = GetSlot(this, ORIGINAL);
+  }
+  return formatter.formatRange(...(formatArgs as [number, number]));
+}
+
+function formatRangeToParts(
+  this: DateTimeFormatImpl,
+  aParam: Params['formatRangeToParts'][0],
+  bParam: Params['formatRangeToParts'][1]
+) {
+  if (aParam === undefined || bParam === undefined) {
+    throw new TypeError('Intl.DateTimeFormat.formatRange requires two values');
+  }
+  const a = toDateTimeFormattable(aParam);
+  const b = toDateTimeFormattable(bParam);
+  let formatArgs = [a, b] as const;
+  let formatter;
+  if (isTemporalObject(a) !== isTemporalObject(b)) {
+    throw new TypeError('Intl.DateTimeFormat.formatRangeToParts accepts two values of the same type');
+  }
+  if (isTemporalObject(a)) {
+    if (!sameTemporalType(a, b)) {
+      throw new TypeError('Intl.DateTimeFormat.formatRangeToParts accepts two values of the same type');
+    }
+    const { epochNs: aa, formatter: aformatter } = extractOverrides(a, this);
+    const { epochNs: bb, formatter: bformatter } = extractOverrides(b, this);
+    if (aformatter) {
+      assert(bformatter == aformatter, 'formatters for same Temporal type should be identical');
+      formatter = aformatter;
+      formatArgs = [ES.epochNsToMs(aa, 'floor'), ES.epochNsToMs(bb, 'floor')];
+    }
+  }
+  if (!formatter) {
+    formatter = GetSlot(this, ORIGINAL);
+  }
+  return formatter.formatRangeToParts(...(formatArgs as [number, number]));
+}
+
+// "false" is a signal to delete this option
+type MaybeFalseOptions = {
+  [K in keyof Intl.DateTimeFormatOptions]?: Intl.DateTimeFormatOptions[K] | false;
+};
+
+function amend(optionsParam: Intl.DateTimeFormatOptions = {}, amended: MaybeFalseOptions = {}) {
+  const options = Object.assign({}, optionsParam);
+  const props = [
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'weekday',
+    'dayPeriod',
+    'timeZoneName',
+    'dateStyle',
+    'timeStyle'
+  ] as const;
+  for (let i = 0; i < props.length; i++) {
+    const opt = props[i];
+    // TODO: can this be typed more cleanly?
+    type OptionMaybeFalse = (typeof options)[typeof opt] | false;
+    (options[opt] as OptionMaybeFalse) = opt in amended ? amended[opt] : options[opt];
+    if ((options[opt] as OptionMaybeFalse) === false || options[opt] === undefined) delete options[opt];
+  }
+  return options;
+}
+
+type OptionsType<T extends TypesWithToLocaleString> = NonNullable<Parameters<T['toLocaleString']>[1]>;
+
+function timeAmend(originalOptions: OptionsType<Temporal.PlainTime>) {
+  const options = amend(originalOptions, {
+    year: false,
+    month: false,
+    day: false,
+    weekday: false,
+    timeZoneName: false,
+    dateStyle: false
+  });
+  if (options.timeStyle === 'long' || options.timeStyle === 'full') {
+    // Try to fake what timeStyle should do if not printing the time zone name
+    delete options.timeStyle;
+    Object.assign(options, { hour: 'numeric', minute: '2-digit', second: '2-digit' });
+  }
+  if (!hasTimeOptions(options)) {
+    if (hasAnyDateTimeOptions(originalOptions)) {
+      throw new TypeError(`cannot format Temporal.PlainTime with options [${Object.keys(originalOptions)}]`);
+    }
+    Object.assign(options, {
+      hour: 'numeric',
+      minute: 'numeric',
+      second: 'numeric'
+    });
+  }
+  return options;
+}
+
+function yearMonthAmend(originalOptions: OptionsType<Temporal.PlainYearMonth>) {
+  // Try to fake what dateStyle should do for dates without a day. This is not
+  // accurate for locales that always print the era
+  const dateStyleHacks = {
+    short: { year: '2-digit', month: 'numeric' },
+    medium: { year: 'numeric', month: 'short' },
+    long: { year: 'numeric', month: 'long' },
+    full: { year: 'numeric', month: 'long' }
+  };
+  const options = amend(originalOptions, {
+    day: false,
+    hour: false,
+    minute: false,
+    second: false,
+    weekday: false,
+    dayPeriod: false,
+    timeZoneName: false,
+    timeStyle: false
+  });
+  if ('dateStyle' in options && options.dateStyle) {
+    const style = options.dateStyle;
+    delete options.dateStyle;
+    Object.assign(options, dateStyleHacks[style]);
+  }
+  if (!('year' in options || 'month' in options || 'era' in options)) {
+    if (hasAnyDateTimeOptions(originalOptions)) {
+      throw new TypeError(`cannot format PlainYearMonth with options [${Object.keys(originalOptions)}]`);
+    }
+    Object.assign(options, { year: 'numeric', month: 'numeric' });
+  }
+  return options;
+}
+
+function monthDayAmend(originalOptions: OptionsType<Temporal.PlainMonthDay>) {
+  // Try to fake what dateStyle should do for dates without a day
+  const dateStyleHacks = {
+    short: { month: 'numeric', day: 'numeric' },
+    medium: { month: 'short', day: 'numeric' },
+    long: { month: 'long', day: 'numeric' },
+    full: { month: 'long', day: 'numeric' }
+  };
+  const options = amend(originalOptions, {
+    year: false,
+    hour: false,
+    minute: false,
+    second: false,
+    weekday: false,
+    dayPeriod: false,
+    timeZoneName: false,
+    timeStyle: false
+  });
+  if ('dateStyle' in options && options.dateStyle) {
+    const style = options.dateStyle;
+    delete options.dateStyle;
+    Object.assign(options, dateStyleHacks[style]);
+  }
+  if (!('month' in options || 'day' in options)) {
+    if (hasAnyDateTimeOptions(originalOptions)) {
+      throw new TypeError(`cannot format PlainMonthDay with options [${Object.keys(originalOptions)}]`);
+    }
+    Object.assign(options, { month: 'numeric', day: 'numeric' });
+  }
+  return options;
+}
+
+function dateAmend(originalOptions: OptionsType<Temporal.PlainDate>) {
+  const options = amend(originalOptions, {
+    hour: false,
+    minute: false,
+    second: false,
+    dayPeriod: false,
+    timeZoneName: false,
+    timeStyle: false
+  });
+  if (!hasDateOptions(options)) {
+    if (hasAnyDateTimeOptions(originalOptions)) {
+      throw new TypeError(`cannot format PlainDate with options [${Object.keys(originalOptions)}]`);
+    }
+    Object.assign(options, {
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric'
+    });
+  }
+  return options;
+}
+
+function datetimeAmend(originalOptions: OptionsType<Temporal.PlainDateTime>) {
+  const options = amend(originalOptions, { timeZoneName: false });
+  if (options.timeStyle === 'long' || options.timeStyle === 'full') {
+    // Try to fake what timeStyle should do if not printing the time zone name
+    delete options.timeStyle;
+    Object.assign(options, { hour: 'numeric', minute: '2-digit', second: '2-digit' });
+
+    // If moving to a fake timeStyle while dateStyle is present, we also have to
+    // move to a fake dateStyle. dateStyle is mutually exclusive with hour etc.
+    if (options.dateStyle) {
+      const dateStyleHacks = {
+        short: { year: 'numeric', month: 'numeric', day: 'numeric' },
+        medium: { year: 'numeric', month: 'short', day: 'numeric' },
+        long: { year: 'numeric', month: 'long', day: 'numeric' },
+        full: { year: 'numeric', month: 'long', day: 'numeric', weekday: 'long' }
+      };
+      Object.assign(options, dateStyleHacks[options.dateStyle]);
+      delete options.dateStyle;
+    }
+  }
+  if (!hasTimeOptions(options) && !hasDateOptions(options)) {
+    if (hasAnyDateTimeOptions(originalOptions)) {
+      throw new TypeError(`cannot format PlainDateTime with options [${Object.keys(originalOptions)}]`);
+    }
+    Object.assign(options, {
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: 'numeric',
+      second: 'numeric'
+    });
+  }
+  return options;
+}
+
+function instantAmend(optionsParam: OptionsType<Temporal.Instant>) {
+  let options = optionsParam;
+  if (!hasTimeOptions(options) && !hasDateOptions(options)) {
+    options = Object.assign({}, options, {
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: 'numeric',
+      second: 'numeric'
+    });
+  }
+  return options;
+}
+
+function hasDateOptions(options: OptionsType<TypesWithToLocaleString>) {
+  return (
+    'year' in options ||
+    'month' in options ||
+    'day' in options ||
+    'weekday' in options ||
+    'dateStyle' in options ||
+    'era' in options
+  );
+}
+
+function hasTimeOptions(options: OptionsType<TypesWithToLocaleString>) {
+  return (
+    'hour' in options ||
+    'minute' in options ||
+    'second' in options ||
+    'timeStyle' in options ||
+    'dayPeriod' in options ||
+    'fractionalSecondDigits' in options
+  );
+}
+
+function hasAnyDateTimeOptions(originalOptions: OptionsType<TypesWithToLocaleString>) {
+  return (
+    hasDateOptions(originalOptions) ||
+    hasTimeOptions(originalOptions) ||
+    'dateStyle' in originalOptions ||
+    'timeStyle' in originalOptions ||
+    'timeZoneName' in originalOptions
+  );
+}
+
+function isTemporalObject(
+  obj: unknown
+): obj is
+  | Temporal.PlainDate
+  | Temporal.PlainTime
+  | Temporal.PlainDateTime
+  | Temporal.ZonedDateTime
+  | Temporal.PlainYearMonth
+  | Temporal.PlainMonthDay
+  | Temporal.Instant {
+  return (
+    ES.IsTemporalDate(obj) ||
+    ES.IsTemporalTime(obj) ||
+    ES.IsTemporalDateTime(obj) ||
+    ES.IsTemporalZonedDateTime(obj) ||
+    ES.IsTemporalYearMonth(obj) ||
+    ES.IsTemporalMonthDay(obj) ||
+    ES.IsTemporalInstant(obj)
+  );
+}
+
+function toDateTimeFormattable(value: unknown) {
+  if (isTemporalObject(value)) return value;
+  return ES.ToNumber(value);
+}
+
+function sameTemporalType(x: unknown, y: unknown) {
+  if (!isTemporalObject(x) || !isTemporalObject(y)) return false;
+  if (ES.IsTemporalTime(x) && !ES.IsTemporalTime(y)) return false;
+  if (ES.IsTemporalDate(x) && !ES.IsTemporalDate(y)) return false;
+  if (ES.IsTemporalDateTime(x) && !ES.IsTemporalDateTime(y)) return false;
+  if (ES.IsTemporalZonedDateTime(x) && !ES.IsTemporalZonedDateTime(y)) return false;
+  if (ES.IsTemporalYearMonth(x) && !ES.IsTemporalYearMonth(y)) return false;
+  if (ES.IsTemporalMonthDay(x) && !ES.IsTemporalMonthDay(y)) return false;
+  if (ES.IsTemporalInstant(x) && !ES.IsTemporalInstant(y)) return false;
+  return true;
+}
+
+type TypesWithToLocaleString =
+  | Temporal.PlainDateTime
+  | Temporal.PlainDate
+  | Temporal.PlainTime
+  | Temporal.PlainYearMonth
+  | Temporal.PlainMonthDay
+  | Temporal.ZonedDateTime
+  | Temporal.Instant;
+
+function extractOverrides(temporalObj: Params['format'][0], main: DateTimeFormatImpl) {
+  if (ES.IsTemporalTime(temporalObj)) {
+    const isoDateTime = {
+      isoDate: { year: 1970, month: 1, day: 1 },
+      time: GetSlot(temporalObj, TIME)
+    };
+    return {
+      epochNs: ES.GetEpochNanosecondsFor(GetSlot(main, TZ_CANONICAL), isoDateTime, 'compatible'),
+      formatter: getSlotLazy(main, TIME_FMT)
+    };
+  }
+
+  if (ES.IsTemporalYearMonth(temporalObj)) {
+    const calendar = GetSlot(temporalObj, CALENDAR);
+    const mainCalendar = GetSlot(main, CAL_ID);
+    if (calendar !== mainCalendar) {
+      throw new RangeError(
+        `cannot format PlainYearMonth with calendar ${calendar} in locale with calendar ${mainCalendar}`
+      );
+    }
+    const isoDateTime = ES.CombineISODateAndTimeRecord(GetSlot(temporalObj, ISO_DATE), ES.NoonTimeRecord());
+    return {
+      epochNs: ES.GetEpochNanosecondsFor(GetSlot(main, TZ_CANONICAL), isoDateTime, 'compatible'),
+      formatter: getSlotLazy(main, YM)
+    };
+  }
+
+  if (ES.IsTemporalMonthDay(temporalObj)) {
+    const calendar = GetSlot(temporalObj, CALENDAR);
+    const mainCalendar = GetSlot(main, CAL_ID);
+    if (calendar !== mainCalendar) {
+      throw new RangeError(
+        `cannot format PlainMonthDay with calendar ${calendar} in locale with calendar ${mainCalendar}`
+      );
+    }
+    const isoDateTime = ES.CombineISODateAndTimeRecord(GetSlot(temporalObj, ISO_DATE), ES.NoonTimeRecord());
+    return {
+      epochNs: ES.GetEpochNanosecondsFor(GetSlot(main, TZ_CANONICAL), isoDateTime, 'compatible'),
+      formatter: getSlotLazy(main, MD)
+    };
+  }
+
+  if (ES.IsTemporalDate(temporalObj)) {
+    const calendar = GetSlot(temporalObj, CALENDAR);
+    const mainCalendar = GetSlot(main, CAL_ID);
+    if (calendar !== 'iso8601' && calendar !== mainCalendar) {
+      throw new RangeError(`cannot format PlainDate with calendar ${calendar} in locale with calendar ${mainCalendar}`);
+    }
+    const isoDateTime = ES.CombineISODateAndTimeRecord(GetSlot(temporalObj, ISO_DATE), ES.NoonTimeRecord());
+    return {
+      epochNs: ES.GetEpochNanosecondsFor(GetSlot(main, TZ_CANONICAL), isoDateTime, 'compatible'),
+      formatter: getSlotLazy(main, DATE)
+    };
+  }
+
+  if (ES.IsTemporalDateTime(temporalObj)) {
+    const calendar = GetSlot(temporalObj, CALENDAR);
+    const mainCalendar = GetSlot(main, CAL_ID);
+    if (calendar !== 'iso8601' && calendar !== mainCalendar) {
+      throw new RangeError(
+        `cannot format PlainDateTime with calendar ${calendar} in locale with calendar ${mainCalendar}`
+      );
+    }
+    const isoDateTime = GetSlot(temporalObj, ISO_DATE_TIME);
+    return {
+      epochNs: ES.GetEpochNanosecondsFor(GetSlot(main, TZ_CANONICAL), isoDateTime, 'compatible'),
+      formatter: getSlotLazy(main, DATETIME)
+    };
+  }
+
+  if (ES.IsTemporalZonedDateTime(temporalObj)) {
+    throw new TypeError(
+      'Temporal.ZonedDateTime not supported in DateTimeFormat methods. Use toLocaleString() instead.'
+    );
+  }
+
+  if (ES.IsTemporalInstant(temporalObj)) {
+    return {
+      epochNs: GetSlot(temporalObj, EPOCHNANOSECONDS),
+      formatter: getSlotLazy(main, INST)
+    };
+  }
+
+  return {};
+}
+
+function temporalDurationToCompatibilityRecord(duration: Temporal.Duration) {
+  const record = Object.create(null);
+  record.years = GetSlot(duration, YEARS);
+  record.months = GetSlot(duration, MONTHS);
+  record.weeks = GetSlot(duration, WEEKS);
+  record.days = GetSlot(duration, DAYS);
+  record.hours = GetSlot(duration, HOURS);
+  record.minutes = GetSlot(duration, MINUTES);
+  record.seconds = GetSlot(duration, SECONDS);
+  record.milliseconds = GetSlot(duration, MILLISECONDS);
+  record.microseconds = GetSlot(duration, MICROSECONDS);
+  record.nanoseconds = GetSlot(duration, NANOSECONDS);
+  return record;
+}
+
+const { format: IntlDurationFormatPrototypeFormat, formatToParts: IntlDurationFormatPrototypeFormatToParts } =
+  Intl.DurationFormat?.prototype ?? Object.create(null);
+
+export function ModifiedIntlDurationFormatPrototypeFormat(
+  this: Intl.DurationFormat,
+  durationLike: Temporal.DurationLike
+) {
+  Intl.DurationFormat.prototype.resolvedOptions.call(this); // brand check
+  const duration = ES.ToTemporalDuration(durationLike);
+  const record = temporalDurationToCompatibilityRecord(duration);
+  return IntlDurationFormatPrototypeFormat.call(this, record);
+}
+
+if (Intl.DurationFormat?.prototype) {
+  Intl.DurationFormat.prototype.format = ModifiedIntlDurationFormatPrototypeFormat;
+  Intl.DurationFormat.prototype.formatToParts = function formatToParts(durationLike: Temporal.DurationLike) {
+    Intl.DurationFormat.prototype.resolvedOptions.call(this); // brand check
+    const duration = ES.ToTemporalDuration(durationLike);
+    const record = temporalDurationToCompatibilityRecord(duration);
+    return IntlDurationFormatPrototypeFormatToParts.call(this, record);
+  };
+}