@emiliosp/pi-maestro 0.17.0 → 0.18.0

package/node_modules/@js-temporal/polyfill/lib/plainyearmonth.ts

@@ -1,157 +0,0 @@
-import * as ES from './ecmascript';
-import { MakeIntrinsicClass } from './intrinsicclass';
-import { CALENDAR, GetSlot, ISO_DATE } from './slots';
-import type { Temporal } from '..';
-import { DateTimeFormat } from './intl';
-import type {
-  CalendarDateRecord,
-  PlainYearMonthParams as Params,
-  PlainYearMonthReturn as Return
-} from './internaltypes';
-
-export class PlainYearMonth implements Temporal.PlainYearMonth {
-  constructor(
-    isoYear: Params['constructor'][0],
-    isoMonth: Params['constructor'][1],
-    calendarParam: Params['constructor'][2] = 'iso8601',
-    referenceISODay: Params['constructor'][3] = 1
-  ) {
-    const year = ES.ToIntegerWithTruncation(isoYear);
-    const month = ES.ToIntegerWithTruncation(isoMonth);
-    const calendar = ES.CanonicalizeCalendar(calendarParam === undefined ? 'iso8601' : ES.RequireString(calendarParam));
-    const day = ES.ToIntegerWithTruncation(referenceISODay);
-
-    ES.RejectISODate(year, month, day);
-    ES.CreateTemporalYearMonthSlots(this, { year, month, day }, calendar);
-  }
-  get year(): Return['year'] {
-    return getCalendarProperty(this, 'year');
-  }
-  get month(): Return['month'] {
-    return getCalendarProperty(this, 'month');
-  }
-  get monthCode(): Return['monthCode'] {
-    return getCalendarProperty(this, 'monthCode');
-  }
-  get calendarId(): Return['calendarId'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return GetSlot(this, CALENDAR);
-  }
-  get era(): Return['era'] {
-    return getCalendarProperty(this, 'era');
-  }
-  get eraYear(): Return['eraYear'] {
-    return getCalendarProperty(this, 'eraYear');
-  }
-  get daysInMonth(): Return['daysInMonth'] {
-    return getCalendarProperty(this, 'daysInMonth');
-  }
-  get daysInYear(): Return['daysInYear'] {
-    return getCalendarProperty(this, 'daysInYear');
-  }
-  get monthsInYear(): Return['monthsInYear'] {
-    return getCalendarProperty(this, 'monthsInYear');
-  }
-  get inLeapYear(): Return['inLeapYear'] {
-    return getCalendarProperty(this, 'inLeapYear');
-  }
-  with(temporalYearMonthLike: Params['with'][0], options: Params['with'][1] = undefined): Return['with'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    if (!ES.IsObject(temporalYearMonthLike)) {
-      throw new TypeError('invalid argument');
-    }
-    ES.RejectTemporalLikeObject(temporalYearMonthLike);
-
-    const calendar = GetSlot(this, CALENDAR);
-    let fields = ES.ISODateToFields(calendar, GetSlot(this, ISO_DATE), 'year-month');
-    const partialYearMonth = ES.PrepareCalendarFields(
-      calendar,
-      temporalYearMonthLike,
-      ['year', 'month', 'monthCode'],
-      [],
-      'partial'
-    );
-    fields = ES.CalendarMergeFields(calendar, fields, partialYearMonth);
-
-    const overflow = ES.GetTemporalOverflowOption(ES.GetOptionsObject(options));
-    const isoDate = ES.CalendarYearMonthFromFields(calendar, fields, overflow);
-    return ES.CreateTemporalYearMonth(isoDate, calendar);
-  }
-  add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return ES.AddDurationToYearMonth('add', this, temporalDurationLike, options);
-  }
-  subtract(
-    temporalDurationLike: Params['subtract'][0],
-    options: Params['subtract'][1] = undefined
-  ): Return['subtract'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return ES.AddDurationToYearMonth('subtract', this, temporalDurationLike, options);
-  }
-  until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return ES.DifferenceTemporalPlainYearMonth('until', this, other, options);
-  }
-  since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return ES.DifferenceTemporalPlainYearMonth('since', this, other, options);
-  }
-  equals(otherParam: Params['equals'][0]): Return['equals'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    const other = ES.ToTemporalYearMonth(otherParam);
-    if (ES.CompareISODate(GetSlot(this, ISO_DATE), GetSlot(other, ISO_DATE)) !== 0) return false;
-    return ES.CalendarEquals(GetSlot(this, CALENDAR), GetSlot(other, CALENDAR));
-  }
-  toString(options: Params['toString'][0] = undefined): string {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    const resolvedOptions = ES.GetOptionsObject(options);
-    const showCalendar = ES.GetTemporalShowCalendarNameOption(resolvedOptions);
-    return ES.TemporalYearMonthToString(this, showCalendar);
-  }
-  toJSON(): Return['toJSON'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return ES.TemporalYearMonthToString(this);
-  }
-  toLocaleString(
-    locales: Params['toLocaleString'][0] = undefined,
-    options: Params['toLocaleString'][1] = undefined
-  ): string {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    return new DateTimeFormat(locales, options).format(this);
-  }
-  valueOf(): never {
-    ES.ValueOfThrows('PlainYearMonth');
-  }
-  toPlainDate(item: Params['toPlainDate'][0]): Return['toPlainDate'] {
-    ES.CheckReceiver(this, ES.IsTemporalYearMonth);
-    if (!ES.IsObject(item)) throw new TypeError('argument should be an object');
-    const calendar = GetSlot(this, CALENDAR);
-
-    const fields = ES.ISODateToFields(calendar, GetSlot(this, ISO_DATE), 'year-month');
-    const inputFields = ES.PrepareCalendarFields(calendar, item, ['day'], [], []);
-    const mergedFields = ES.CalendarMergeFields(calendar, fields, inputFields);
-    const isoDate = ES.CalendarDateFromFields(calendar, mergedFields, 'constrain');
-    return ES.CreateTemporalDate(isoDate, calendar);
-  }
-
-  static from(item: Params['from'][0], options: Params['from'][1] = undefined): Return['from'] {
-    return ES.ToTemporalYearMonth(item, options);
-  }
-  static compare(oneParam: Params['compare'][0], twoParam: Params['compare'][1]): Return['compare'] {
-    const one = ES.ToTemporalYearMonth(oneParam);
-    const two = ES.ToTemporalYearMonth(twoParam);
-    return ES.CompareISODate(GetSlot(one, ISO_DATE), GetSlot(two, ISO_DATE));
-  }
-  [Symbol.toStringTag]!: 'Temporal.PlainYearMonth';
-}
-
-MakeIntrinsicClass(PlainYearMonth, 'Temporal.PlainYearMonth');
-
-function getCalendarProperty<P extends keyof CalendarDateRecord>(
-  ym: Temporal.PlainYearMonth,
-  prop: P
-): CalendarDateRecord[P] {
-  ES.CheckReceiver(ym, ES.IsTemporalYearMonth);
-  const isoDate = GetSlot(ym, ISO_DATE);
-  return ES.calendarImplForObj(ym).isoToDate(isoDate, { [prop]: true })[prop];
-}

package/node_modules/@js-temporal/polyfill/lib/regex.ts

@@ -1,59 +0,0 @@
-const offsetIdentifierNoCapture = /(?:[+-](?:[01][0-9]|2[0-3])(?::?[0-5][0-9])?)/;
-const tzComponent = /[A-Za-z._][A-Za-z._0-9+-]*/;
-export const timeZoneID = new RegExp(
-  `(?:${offsetIdentifierNoCapture.source}|(?:${tzComponent.source})(?:\\/(?:${tzComponent.source}))*)`
-);
-
-const yearpart = /(?:[+-]\d{6}|\d{4})/;
-const monthpart = /(?:0[1-9]|1[0-2])/;
-const daypart = /(?:0[1-9]|[12]\d|3[01])/;
-const datesplit = new RegExp(
-  `(${yearpart.source})(?:-(${monthpart.source})-(${daypart.source})|(${monthpart.source})(${daypart.source}))`
-);
-const timesplit = /(\d{2})(?::(\d{2})(?::(\d{2})(?:[.,](\d{1,9}))?)?|(\d{2})(?:(\d{2})(?:[.,](\d{1,9}))?)?)?/;
-export const offsetWithParts = /([+-])([01][0-9]|2[0-3])(?::?([0-5][0-9])(?::?([0-5][0-9])(?:[.,](\d{1,9}))?)?)?/;
-export const offset = /((?:[+-])(?:[01][0-9]|2[0-3])(?::?(?:[0-5][0-9])(?::?(?:[0-5][0-9])(?:[.,](?:\d{1,9}))?)?)?)/;
-const offsetpart = new RegExp(`([zZ])|${offset.source}?`);
-export const offsetIdentifier = /([+-])([01][0-9]|2[0-3])(?::?([0-5][0-9])?)?/;
-export const annotation = /\[(!)?([a-z_][a-z0-9_-]*)=([A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)\]/g;
-
-export const zoneddatetime = new RegExp(
-  [
-    `^${datesplit.source}`,
-    `(?:(?:[tT]|\\s+)${timesplit.source}(?:${offsetpart.source})?)?`,
-    `(?:\\[!?(${timeZoneID.source})\\])?`,
-    `((?:${annotation.source})*)$`
-  ].join('')
-);
-
-export const time = new RegExp(
-  [
-    `^[tT]?${timesplit.source}`,
-    `(?:${offsetpart.source})?`,
-    `(?:\\[!?${timeZoneID.source}\\])?`,
-    `((?:${annotation.source})*)$`
-  ].join('')
-);
-
-// The short forms of YearMonth and MonthDay are only for the ISO calendar, but
-// annotations are still allowed, and will throw if the calendar annotation is
-// not ISO.
-// Non-ISO calendar YearMonth and MonthDay have to parse as a Temporal.PlainDate,
-// with the reference fields.
-// YYYYMM forbidden by ISO 8601 because ambiguous with YYMMDD, but allowed by
-// RFC 3339 and we don't allow 2-digit years, so we allow it.
-// Not ambiguous with HHMMSS because that requires a 'T' prefix
-// UTC offsets are not allowed, because they are not allowed with any date-only
-// format; also, YYYY-MM-UU is ambiguous with YYYY-MM-DD
-export const yearmonth = new RegExp(
-  `^(${yearpart.source})-?(${monthpart.source})(?:\\[!?${timeZoneID.source}\\])?((?:${annotation.source})*)$`
-);
-export const monthday = new RegExp(
-  `^(?:--)?(${monthpart.source})-?(${daypart.source})(?:\\[!?${timeZoneID.source}\\])?((?:${annotation.source})*)$`
-);
-
-const fraction = /(\d+)(?:[.,](\d{1,9}))?/;
-
-const durationDate = /(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?/;
-const durationTime = new RegExp(`(?:${fraction.source}H)?(?:${fraction.source}M)?(?:${fraction.source}S)?`);
-export const duration = new RegExp(`^([+-])?P${durationDate.source}(?:T(?!$)${durationTime.source})?$`, 'i');

package/node_modules/@js-temporal/polyfill/lib/slots.ts

@@ -1,341 +0,0 @@
-import type JSBI from 'jsbi';
-import type { Temporal } from '..';
-import type {
-  BuiltinCalendarId,
-  AnySlottedType,
-  FormatterOrAmender,
-  ISODate,
-  ISODateTime,
-  TimeRecord
-} from './internaltypes';
-import type { DateTimeFormatImpl } from './intl';
-
-// Instant
-export const EPOCHNANOSECONDS = 'slot-epochNanoSeconds';
-
-// DateTime, Date, Time, YearMonth, MonthDay
-export const ISO_DATE = 'slot-iso-date';
-export const ISO_DATE_TIME = 'slot-iso-date-time';
-export const TIME = 'slot-time';
-export const CALENDAR = 'slot-calendar';
-// Date, YearMonth, and MonthDay all have the same slots, disambiguation needed:
-export const DATE_BRAND = 'slot-date-brand';
-export const YEAR_MONTH_BRAND = 'slot-year-month-brand';
-export const MONTH_DAY_BRAND = 'slot-month-day-brand';
-
-// ZonedDateTime
-export const TIME_ZONE = 'slot-time-zone';
-
-// Duration
-export const YEARS = 'slot-years';
-export const MONTHS = 'slot-months';
-export const WEEKS = 'slot-weeks';
-export const DAYS = 'slot-days';
-export const HOURS = 'slot-hours';
-export const MINUTES = 'slot-minutes';
-export const SECONDS = 'slot-seconds';
-export const MILLISECONDS = 'slot-milliseconds';
-export const MICROSECONDS = 'slot-microseconds';
-export const NANOSECONDS = 'slot-nanoseconds';
-
-// DateTimeFormatImpl
-export const DATE = 'date';
-export const YM = 'ym';
-export const MD = 'md';
-export const TIME_FMT = 'time';
-export const DATETIME = 'datetime';
-export const INST = 'instant';
-export const ORIGINAL = 'original';
-export const TZ_CANONICAL = 'timezone-canonical';
-export const TZ_ORIGINAL = 'timezone-original';
-export const CAL_ID = 'calendar-id';
-export const LOCALE = 'locale';
-export const OPTIONS = 'options';
-
-interface SlotInfo<ValueType, UsedByType extends AnySlottedType> {
-  value: ValueType;
-  usedBy: UsedByType;
-}
-
-interface SlotInfoRecord {
-  [k: string]: SlotInfo<unknown, AnySlottedType>;
-}
-
-interface Slots extends SlotInfoRecord {
-  // Instant
-  [EPOCHNANOSECONDS]: SlotInfo<JSBI, Temporal.Instant | Temporal.ZonedDateTime>; // number? JSBI?
-
-  // DateTime, Date, Time, YearMonth, MonthDay
-  [ISO_DATE]: SlotInfo<ISODate, Temporal.PlainDate | Temporal.PlainMonthDay | Temporal.PlainYearMonth>;
-  [ISO_DATE_TIME]: SlotInfo<ISODateTime, Temporal.PlainDateTime>;
-  [TIME]: SlotInfo<TimeRecord, Temporal.PlainTime>;
-  [CALENDAR]: SlotInfo<BuiltinCalendarId, TypesWithCalendarUnits>;
-
-  // Date, YearMonth, MonthDay common slots
-  [DATE_BRAND]: SlotInfo<true, Temporal.PlainDate>;
-  [YEAR_MONTH_BRAND]: SlotInfo<true, Temporal.PlainYearMonth>;
-  [MONTH_DAY_BRAND]: SlotInfo<true, Temporal.PlainMonthDay>;
-
-  // ZonedDateTime
-  [TIME_ZONE]: SlotInfo<string, Temporal.ZonedDateTime>;
-
-  // Duration
-  [YEARS]: SlotInfo<number, Temporal.Duration>;
-  [MONTHS]: SlotInfo<number, Temporal.Duration>;
-  [WEEKS]: SlotInfo<number, Temporal.Duration>;
-  [DAYS]: SlotInfo<number, Temporal.Duration>;
-  [HOURS]: SlotInfo<number, Temporal.Duration>;
-  [MINUTES]: SlotInfo<number, Temporal.Duration>;
-  [SECONDS]: SlotInfo<number, Temporal.Duration>;
-  [MILLISECONDS]: SlotInfo<number, Temporal.Duration>;
-  [MICROSECONDS]: SlotInfo<number, Temporal.Duration>;
-  [NANOSECONDS]: SlotInfo<number, Temporal.Duration>;
-
-  // DateTimeFormatImpl
-  [DATE]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [YM]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [MD]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [TIME_FMT]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [DATETIME]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [INST]: SlotInfo<FormatterOrAmender, DateTimeFormatImpl>;
-  [ORIGINAL]: SlotInfo<globalThis.Intl.DateTimeFormat, DateTimeFormatImpl>;
-  [TZ_CANONICAL]: SlotInfo<string, DateTimeFormatImpl>;
-  [TZ_ORIGINAL]: SlotInfo<string, DateTimeFormatImpl>;
-  [CAL_ID]: SlotInfo<globalThis.Intl.ResolvedDateTimeFormatOptions['calendar'], DateTimeFormatImpl>;
-  [LOCALE]: SlotInfo<globalThis.Intl.ResolvedDateTimeFormatOptions['locale'], DateTimeFormatImpl>;
-  [OPTIONS]: SlotInfo<Intl.DateTimeFormatOptions, DateTimeFormatImpl>;
-}
-
-type TypesWithCalendarUnits =
-  | Temporal.PlainDateTime
-  | Temporal.PlainDate
-  | Temporal.PlainYearMonth
-  | Temporal.PlainMonthDay
-  | Temporal.ZonedDateTime;
-
-interface SlotsToTypes {
-  // Instant
-  [EPOCHNANOSECONDS]: Temporal.Instant;
-
-  // DateTime, Date, Time, YearMonth, MonthDay
-  [ISO_DATE]: Temporal.PlainDate | Temporal.PlainYearMonth | Temporal.PlainMonthDay;
-  [ISO_DATE_TIME]: Temporal.PlainDateTime;
-  [TIME]: Temporal.PlainTime;
-  [CALENDAR]: TypesWithCalendarUnits;
-
-  // Date, YearMonth, MonthDay common slots
-  [DATE_BRAND]: Temporal.PlainDate;
-  [YEAR_MONTH_BRAND]: Temporal.PlainYearMonth;
-  [MONTH_DAY_BRAND]: Temporal.PlainMonthDay;
-
-  // ZonedDateTime
-  [TIME_ZONE]: Temporal.ZonedDateTime;
-
-  // Duration
-  [YEARS]: Temporal.Duration;
-  [MONTHS]: Temporal.Duration;
-  [WEEKS]: Temporal.Duration;
-  [DAYS]: Temporal.Duration;
-  [HOURS]: Temporal.Duration;
-  [MINUTES]: Temporal.Duration;
-  [SECONDS]: Temporal.Duration;
-  [MILLISECONDS]: Temporal.Duration;
-  [MICROSECONDS]: Temporal.Duration;
-  [NANOSECONDS]: Temporal.Duration;
-
-  // DateTimeFormatImpl
-  [DATE]: DateTimeFormatImpl;
-  [YM]: DateTimeFormatImpl;
-  [MD]: DateTimeFormatImpl;
-  [TIME_FMT]: DateTimeFormatImpl;
-  [DATETIME]: DateTimeFormatImpl;
-  [INST]: DateTimeFormatImpl;
-  [ORIGINAL]: DateTimeFormatImpl;
-  [TZ_CANONICAL]: DateTimeFormatImpl;
-  [TZ_ORIGINAL]: DateTimeFormatImpl;
-  [CAL_ID]: DateTimeFormatImpl;
-  [LOCALE]: DateTimeFormatImpl;
-  [OPTIONS]: DateTimeFormatImpl;
-}
-
-type SlotKey = keyof SlotsToTypes;
-
-const globalSlots = new WeakMap<Slots[keyof Slots]['usedBy'], Record<keyof Slots, Slots[keyof Slots]['value']>>();
-
-function _GetSlots(container: Slots[keyof Slots]['usedBy']) {
-  return globalSlots.get(container);
-}
-
-const GetSlotsSymbol = Symbol.for('@@Temporal__GetSlots');
-
-// expose GetSlots to avoid dual package hazards
-(globalThis as any)[GetSlotsSymbol] ||= _GetSlots;
-
-const GetSlots = (globalThis as any)[GetSlotsSymbol] as typeof _GetSlots;
-
-function _CreateSlots(container: Slots[keyof Slots]['usedBy']): void {
-  globalSlots.set(container, Object.create(null));
-}
-
-const CreateSlotsSymbol = Symbol.for('@@Temporal__CreateSlots');
-
-// expose CreateSlots to avoid dual package hazards
-(globalThis as any)[CreateSlotsSymbol] ||= _CreateSlots;
-
-export const CreateSlots = (globalThis as any)[CreateSlotsSymbol] as typeof _CreateSlots;
-
-// TODO: is there a better way than 9 overloads to make HasSlot into a type
-// guard that takes a variable number of parameters?
-export function HasSlot<ID1 extends SlotKey>(container: unknown, id1: ID1): container is Slots[ID1]['usedBy'];
-export function HasSlot<ID1 extends SlotKey, ID2 extends SlotKey>(
-  container: unknown,
-  id1: ID1,
-  id2: ID2
-): container is Slots[ID1]['usedBy'] | Slots[ID2]['usedBy'];
-export function HasSlot<ID1 extends SlotKey, ID2 extends SlotKey, ID3 extends SlotKey>(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3
-): container is Slots[ID1]['usedBy'] | Slots[ID2]['usedBy'] | Slots[ID3]['usedBy'];
-export function HasSlot<ID1 extends SlotKey, ID2 extends SlotKey, ID3 extends SlotKey, ID4 extends SlotKey>(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4
-): container is Slots[ID1 | ID2 | ID3 | ID4]['usedBy'];
-export function HasSlot<
-  ID1 extends SlotKey,
-  ID2 extends SlotKey,
-  ID3 extends SlotKey,
-  ID4 extends SlotKey,
-  ID5 extends SlotKey
->(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4,
-  id5: ID5
-): container is Slots[ID1 | ID2 | ID3 | ID4 | ID5]['usedBy'];
-export function HasSlot<
-  ID1 extends SlotKey,
-  ID2 extends SlotKey,
-  ID3 extends SlotKey,
-  ID4 extends SlotKey,
-  ID5 extends SlotKey,
-  ID6 extends SlotKey
->(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4,
-  id5: ID5,
-  id6: ID6
-): container is Slots[ID1 | ID2 | ID3 | ID4 | ID5 | ID6]['usedBy'];
-export function HasSlot<
-  ID1 extends SlotKey,
-  ID2 extends SlotKey,
-  ID3 extends SlotKey,
-  ID4 extends SlotKey,
-  ID5 extends SlotKey,
-  ID6 extends SlotKey,
-  ID7 extends SlotKey
->(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4,
-  id5: ID5,
-  id6: ID6,
-  id7: ID7
-): container is Slots[ID1 | ID2 | ID3 | ID4 | ID5 | ID6 | ID7]['usedBy'];
-export function HasSlot<
-  ID1 extends SlotKey,
-  ID2 extends SlotKey,
-  ID3 extends SlotKey,
-  ID4 extends SlotKey,
-  ID5 extends SlotKey,
-  ID6 extends SlotKey,
-  ID7 extends SlotKey,
-  ID8 extends SlotKey
->(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4,
-  id5: ID5,
-  id6: ID6,
-  id7: ID7,
-  id8: ID8
-): container is Slots[ID1 | ID2 | ID3 | ID4 | ID5 | ID6 | ID7 | ID8]['usedBy'];
-export function HasSlot<
-  ID1 extends SlotKey,
-  ID2 extends SlotKey,
-  ID3 extends SlotKey,
-  ID4 extends SlotKey,
-  ID5 extends SlotKey,
-  ID6 extends SlotKey,
-  ID7 extends SlotKey,
-  ID8 extends SlotKey,
-  ID9 extends SlotKey
->(
-  container: unknown,
-  id1: ID1,
-  id2: ID2,
-  id3: ID3,
-  id4: ID4,
-  id5: ID5,
-  id6: ID6,
-  id7: ID7,
-  id8: ID8,
-  id9: ID9
-): container is Slots[ID1 | ID2 | ID3 | ID4 | ID5 | ID6 | ID7 | ID8 | ID9]['usedBy'];
-export function HasSlot(container: unknown, ...ids: (keyof Slots)[]): boolean {
-  if (!container || 'object' !== typeof container) return false;
-  const myslots = GetSlots(container as AnySlottedType);
-  return !!myslots && ids.every((id) => id in myslots);
-}
-export function GetSlot<KeyT extends keyof Slots>(
-  container: Slots[typeof id]['usedBy'],
-  id: KeyT
-): Slots[KeyT]['value'] {
-  const value = GetSlots(container)?.[id];
-  if (value === undefined) throw new TypeError(`Missing internal slot ${id}`);
-  return value;
-}
-export function SetSlot<KeyT extends SlotKey>(
-  container: Slots[KeyT]['usedBy'],
-  id: KeyT,
-  value: Slots[KeyT]['value']
-): void {
-  const slots = GetSlots(container);
-
-  if (slots === undefined) throw new TypeError('Missing slots for the given container');
-
-  const existingSlot = slots[id];
-
-  if (existingSlot) throw new TypeError(`${id} already has set`);
-
-  slots[id] = value;
-}
-
-export function ResetSlot<KeyT extends SlotKey>(
-  container: DateTimeFormatImpl,
-  id: KeyT,
-  value: Slots[KeyT]['value']
-): void {
-  const slots = GetSlots(container);
-
-  if (slots === undefined) throw new TypeError('Missing slots for the given container');
-
-  const existingSlot = slots[id];
-
-  if (existingSlot === undefined) throw new TypeError(`tried to reset ${id} which was not set`);
-
-  slots[id] = value;
-}

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

@@ -1,10 +0,0 @@
-import './calendar';
-export { Instant } from './instant';
-export { PlainDate } from './plaindate';
-export { PlainDateTime } from './plaindatetime';
-export { Duration } from './duration';
-export { PlainMonthDay } from './plainmonthday';
-export { Now } from './now';
-export { PlainTime } from './plaintime';
-export { PlainYearMonth } from './plainyearmonth';
-export { ZonedDateTime } from './zoneddatetime';