@nubjs/nub-linux-x64 0.0.7 → 0.0.8

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

@@ -0,0 +1,157 @@
+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/runtime/node_modules/@js-temporal/polyfill/lib/regex.ts

@@ -0,0 +1,59 @@
+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/runtime/node_modules/@js-temporal/polyfill/lib/slots.ts

@@ -0,0 +1,341 @@
+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/runtime/node_modules/@js-temporal/polyfill/lib/temporal.ts

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