@nubjs/nub-linux-x64 0.0.7 → 0.0.8

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

@@ -0,0 +1,162 @@
+import type JSBI from 'jsbi';
+import type { Temporal } from '..';
+import type { CalendarImpl } from './calendar';
+import type { BuiltinCalendarId } from './internaltypes';
+import type { DateTimeFormatImpl } from './intl';
+
+import { DEBUG } from './debug';
+import { GetSlot, ORIGINAL } from './slots';
+
+type OmitConstructor<T> = { [P in keyof T as T[P] extends new (...args: any[]) => any ? P : never]: T[P] };
+
+type TemporalIntrinsics = {
+  ['Intl.DateTimeFormat']: typeof globalThis.Intl.DateTimeFormat;
+  ['Temporal.Duration']: typeof Temporal.Duration;
+  ['Temporal.Instant']: OmitConstructor<Temporal.Instant> &
+    (new (epochNanoseconds: JSBI) => Temporal.Instant) & { prototype: typeof Temporal.Instant.prototype };
+  ['Temporal.PlainDate']: typeof Temporal.PlainDate;
+  ['Temporal.PlainDateTime']: typeof Temporal.PlainDateTime;
+  ['Temporal.PlainMonthDay']: typeof Temporal.PlainMonthDay;
+  ['Temporal.PlainTime']: typeof Temporal.PlainTime;
+  ['Temporal.PlainYearMonth']: typeof Temporal.PlainYearMonth;
+  ['Temporal.ZonedDateTime']: OmitConstructor<Temporal.ZonedDateTime> &
+    (new (epochNanoseconds: JSBI, timeZone: string, calendar?: string) => Temporal.ZonedDateTime) & {
+      prototype: typeof Temporal.ZonedDateTime.prototype;
+      from: typeof Temporal.ZonedDateTime.from;
+      compare: typeof Temporal.ZonedDateTime.compare;
+    };
+};
+type TemporalIntrinsicRegistrations = {
+  [key in keyof TemporalIntrinsics]: TemporalIntrinsics[key];
+};
+type TemporalIntrinsicPrototypeRegistrations = {
+  [key in keyof TemporalIntrinsics as `${key}.prototype`]: TemporalIntrinsics[key]['prototype'];
+};
+type TemporalIntrinsicRegisteredKeys = {
+  [key in keyof TemporalIntrinsicRegistrations as `%${key}%`]: TemporalIntrinsicRegistrations[key];
+};
+type TemporalIntrinsicPrototypeRegisteredKeys = {
+  [key in keyof TemporalIntrinsicPrototypeRegistrations as `%${key}%`]: TemporalIntrinsicPrototypeRegistrations[key];
+};
+
+type OtherIntrinsics = {
+  calendarImpl: (id: BuiltinCalendarId) => CalendarImpl;
+};
+type OtherIntrinsicKeys = { [key in keyof OtherIntrinsics as `%${key}%`]: OtherIntrinsics[key] };
+
+const INTRINSICS = {} as TemporalIntrinsicRegisteredKeys &
+  TemporalIntrinsicPrototypeRegisteredKeys &
+  OtherIntrinsicKeys;
+
+type StylizeOption = (value: unknown, type: 'number' | 'special') => string;
+
+type customFormatFunction<T> = (
+  this: T & { _repr_: string }, // _repr_ is present if DEBUG
+  depth: number,
+  options: { stylize: StylizeOption },
+  inspect: (object: T, options?: { depth: number; stylize: StylizeOption }) => string
+) => string;
+const customUtilInspectFormatters: Partial<{
+  [key in keyof TemporalIntrinsicRegistrations]: customFormatFunction<
+    InstanceType<TemporalIntrinsicRegistrations[key]>
+  >;
+}> = {
+  ['Intl.DateTimeFormat'](depth, options, inspect) {
+    return inspect(GetSlot(this as DateTimeFormatImpl, ORIGINAL), { depth, ...options });
+  },
+  ['Temporal.Duration'](depth, options) {
+    const descr = options.stylize(this._repr_, 'special');
+    if (depth < 1) return descr;
+    const entries: string[] = [];
+    const props = [
+      'years',
+      'months',
+      'weeks',
+      'days',
+      'hours',
+      'minutes',
+      'seconds',
+      'milliseconds',
+      'microseconds',
+      'nanoseconds'
+    ] as const;
+    for (let i = 0; i < props.length; i++) {
+      const prop = props[i];
+      if (this[prop] !== 0) {
+        entries.push(`  ${prop}: ${options.stylize(this[prop], 'number')}`);
+      }
+    }
+    return descr + ' {\n' + entries.join(',\n') + '\n}';
+  }
+};
+
+type InspectFormatterOptions = { stylize: (str: string, styleType: string) => string };
+function defaultUtilInspectFormatter(this: any, depth: number, options: InspectFormatterOptions) {
+  return options.stylize(this._repr_, 'special');
+}
+
+export function MakeIntrinsicClass(
+  Class: TemporalIntrinsicRegistrations[typeof name],
+  name: keyof TemporalIntrinsicRegistrations
+) {
+  Object.defineProperty(Class.prototype, Symbol.toStringTag, {
+    value: name,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+  if (DEBUG) {
+    Object.defineProperty(Class.prototype, Symbol.for('nodejs.util.inspect.custom'), {
+      value: customUtilInspectFormatters[name] || defaultUtilInspectFormatter,
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  const staticNames = Object.getOwnPropertyNames(Class);
+  for (let i = 0; i < staticNames.length; i++) {
+    const prop = staticNames[i];
+    // we know that `prop` is present, so the descriptor is never undefined
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const desc = Object.getOwnPropertyDescriptor(Class, prop)!;
+    if (!desc.configurable || !desc.enumerable) continue;
+    desc.enumerable = false;
+    Object.defineProperty(Class, prop, desc);
+  }
+  const protoNames = Object.getOwnPropertyNames(Class.prototype);
+  for (let i = 0; i < protoNames.length; i++) {
+    const prop = protoNames[i];
+    // we know that `prop` is present, so the descriptor is never undefined
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const desc = Object.getOwnPropertyDescriptor(Class.prototype, prop)!;
+    if (!desc.configurable || !desc.enumerable) continue;
+    desc.enumerable = false;
+    Object.defineProperty(Class.prototype, prop, desc);
+  }
+
+  DefineIntrinsic(name, Class);
+  DefineIntrinsic(`${name}.prototype`, Class.prototype);
+}
+
+type IntrinsicDefinitionKeys =
+  | keyof TemporalIntrinsicRegistrations
+  | keyof TemporalIntrinsicPrototypeRegistrations
+  | keyof OtherIntrinsics;
+export function DefineIntrinsic<KeyT extends keyof TemporalIntrinsicRegistrations>(
+  name: KeyT,
+  value: TemporalIntrinsicRegistrations[KeyT]
+): void;
+export function DefineIntrinsic<KeyT extends keyof TemporalIntrinsicPrototypeRegistrations>(
+  name: KeyT,
+  value: TemporalIntrinsicPrototypeRegistrations[KeyT]
+): void;
+export function DefineIntrinsic<KeyT extends keyof OtherIntrinsics>(name: KeyT, value: OtherIntrinsics[KeyT]): void;
+export function DefineIntrinsic<KeyT>(name: KeyT, value: never): void;
+export function DefineIntrinsic<KeyT extends IntrinsicDefinitionKeys>(name: KeyT, value: unknown): void {
+  const key: `%${IntrinsicDefinitionKeys}%` = `%${name}%`;
+  if (INTRINSICS[key] !== undefined) throw new Error(`intrinsic ${name} already exists`);
+  INTRINSICS[key] = value;
+}
+export function GetIntrinsic<KeyT extends keyof typeof INTRINSICS>(intrinsic: KeyT): (typeof INTRINSICS)[KeyT] {
+  return INTRINSICS[intrinsic];
+}

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

@@ -0,0 +1,17 @@
+import * as ES from './ecmascript';
+
+// By default, a plain function can be called as a constructor. A method such as
+// Date.prototype.toTemporalInstant should not be able to. We could check
+// new.target in the body of toTemporalInstant, but that is not sufficient for
+// preventing construction when passing it as the newTarget parameter of
+// Reflect.construct. So we create it as a method of an otherwise unused class,
+// and monkeypatch it onto Date.prototype.
+
+class LegacyDateImpl {
+  toTemporalInstant(this: Date) {
+    const epochNanoseconds = ES.epochMsToNs(Date.prototype.valueOf.call(this));
+    return ES.CreateTemporalInstant(epochNanoseconds);
+  }
+}
+
+export const toTemporalInstant = LegacyDateImpl.prototype.toTemporalInstant;

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

@@ -0,0 +1,96 @@
+import type JSBI from 'jsbi';
+import type { Temporal } from '..';
+
+// Computes trunc(x / 10**p) and x % 10**p, returning { div, mod }, with
+// precision loss only once in the quotient, by string manipulation. If the
+// quotient and remainder are safe integers, then they are exact. x must be an
+// integer. p must be a non-negative integer. Both div and mod have the sign of
+// x.
+export function TruncatingDivModByPowerOf10(xParam: number, p: number) {
+  let x = xParam;
+  if (x === 0) return { div: x, mod: x }; // preserves signed zero
+
+  const sign = Math.sign(x);
+  x = Math.abs(x);
+
+  const xDigits = Math.trunc(1 + Math.log10(x));
+  if (p >= xDigits) return { div: sign * 0, mod: sign * x };
+  if (p === 0) return { div: sign * x, mod: sign * 0 };
+
+  // would perform nearest rounding if x was not an integer:
+  const xStr = x.toPrecision(xDigits);
+  const div = sign * Number.parseInt(xStr.slice(0, xDigits - p), 10);
+  const mod = sign * Number.parseInt(xStr.slice(xDigits - p), 10);
+
+  return { div, mod };
+}
+
+// Computes x * 10**p + z with precision loss only at the end, by string
+// manipulation. If the result is a safe integer, then it is exact. x must be
+// an integer. p must be a non-negative integer. z must have the same sign as
+// x and be less than 10**p.
+export function FMAPowerOf10(xParam: number, p: number, zParam: number) {
+  let x = xParam;
+  let z = zParam;
+  if (x === 0) return z;
+
+  const sign = Math.sign(x) || Math.sign(z);
+  x = Math.abs(x);
+  z = Math.abs(z);
+
+  const xStr = x.toPrecision(Math.trunc(1 + Math.log10(x)));
+
+  if (z === 0) return sign * Number.parseInt(xStr + '0'.repeat(p), 10);
+
+  const zStr = z.toPrecision(Math.trunc(1 + Math.log10(z)));
+
+  const resStr = xStr + zStr.padStart(p, '0');
+  return sign * Number.parseInt(resStr, 10);
+}
+
+type UnsignedRoundingMode = 'half-even' | 'half-infinity' | 'half-zero' | 'infinity' | 'zero';
+
+export function GetUnsignedRoundingMode(
+  mode: Temporal.RoundingMode,
+  sign: 'positive' | 'negative'
+): UnsignedRoundingMode {
+  const isNegative = sign === 'negative';
+  switch (mode) {
+    case 'ceil':
+      return isNegative ? 'zero' : 'infinity';
+    case 'floor':
+      return isNegative ? 'infinity' : 'zero';
+    case 'expand':
+      return 'infinity';
+    case 'trunc':
+      return 'zero';
+    case 'halfCeil':
+      return isNegative ? 'half-zero' : 'half-infinity';
+    case 'halfFloor':
+      return isNegative ? 'half-infinity' : 'half-zero';
+    case 'halfExpand':
+      return 'half-infinity';
+    case 'halfTrunc':
+      return 'half-zero';
+    case 'halfEven':
+      return 'half-even';
+  }
+}
+
+// Omits first step from spec algorithm so that it can be used both for
+// RoundNumberToIncrement and RoundTimeDurationToIncrement
+export function ApplyUnsignedRoundingMode<T extends number | JSBI>(
+  r1: T,
+  r2: T,
+  cmp: -1 | 0 | 1,
+  evenCardinality: boolean,
+  unsignedRoundingMode: UnsignedRoundingMode
+) {
+  if (unsignedRoundingMode === 'zero') return r1;
+  if (unsignedRoundingMode === 'infinity') return r2;
+  if (cmp < 0) return r1;
+  if (cmp > 0) return r2;
+  if (unsignedRoundingMode === 'half-zero') return r1;
+  if (unsignedRoundingMode === 'half-infinity') return r2;
+  return evenCardinality ? r1 : r2;
+}

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

@@ -0,0 +1,48 @@
+import * as ES from './ecmascript';
+import type { Temporal } from '..';
+
+function SystemDateTime(timeZone: string) {
+  return ES.GetISODateTimeFor(timeZone, ES.SystemUTCEpochNanoSeconds());
+}
+
+const instant: (typeof Temporal.Now)['instant'] = () => {
+  return ES.CreateTemporalInstant(ES.SystemUTCEpochNanoSeconds());
+};
+const plainDateTimeISO: (typeof Temporal.Now)['plainDateTimeISO'] = (temporalTimeZoneLike = ES.DefaultTimeZone()) => {
+  const timeZone = ES.ToTemporalTimeZoneIdentifier(temporalTimeZoneLike);
+  const isoDateTime = SystemDateTime(timeZone);
+  return ES.CreateTemporalDateTime(isoDateTime, 'iso8601');
+};
+const zonedDateTimeISO: (typeof Temporal.Now)['zonedDateTimeISO'] = (temporalTimeZoneLike = ES.DefaultTimeZone()) => {
+  const timeZone = ES.ToTemporalTimeZoneIdentifier(temporalTimeZoneLike);
+  return ES.CreateTemporalZonedDateTime(ES.SystemUTCEpochNanoSeconds(), timeZone, 'iso8601');
+};
+const plainDateISO: (typeof Temporal.Now)['plainDateISO'] = (temporalTimeZoneLike = ES.DefaultTimeZone()) => {
+  const timeZone = ES.ToTemporalTimeZoneIdentifier(temporalTimeZoneLike);
+  const isoDateTime = SystemDateTime(timeZone);
+  return ES.CreateTemporalDate(isoDateTime.isoDate, 'iso8601');
+};
+const plainTimeISO: (typeof Temporal.Now)['plainTimeISO'] = (temporalTimeZoneLike = ES.DefaultTimeZone()) => {
+  const timeZone = ES.ToTemporalTimeZoneIdentifier(temporalTimeZoneLike);
+  const isoDateTime = SystemDateTime(timeZone);
+  return ES.CreateTemporalTime(isoDateTime.time);
+};
+const timeZoneId: (typeof Temporal.Now)['timeZoneId'] = () => {
+  return ES.DefaultTimeZone();
+};
+
+export const Now: typeof Temporal.Now = {
+  instant,
+  plainDateTimeISO,
+  plainDateISO,
+  plainTimeISO,
+  timeZoneId,
+  zonedDateTimeISO,
+  [Symbol.toStringTag]: 'Temporal.Now'
+};
+Object.defineProperty(Now, Symbol.toStringTag, {
+  value: 'Temporal.Now',
+  writable: false,
+  enumerable: false,
+  configurable: true
+});

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

@@ -0,0 +1,212 @@
+import * as ES from './ecmascript';
+import { MakeIntrinsicClass } from './intrinsicclass';
+import { CALENDAR, GetSlot, ISO_DATE, TIME } from './slots';
+import type { Temporal } from '..';
+import { DateTimeFormat } from './intl';
+import type { CalendarDateRecord, PlainDateParams as Params, PlainDateReturn as Return } from './internaltypes';
+
+export class PlainDate implements Temporal.PlainDate {
+  constructor(
+    isoYear: Params['constructor'][0],
+    isoMonth: Params['constructor'][1],
+    isoDay: Params['constructor'][2],
+    calendarParam: Params['constructor'][3] = 'iso8601'
+  ) {
+    const year = ES.ToIntegerWithTruncation(isoYear);
+    const month = ES.ToIntegerWithTruncation(isoMonth);
+    const day = ES.ToIntegerWithTruncation(isoDay);
+    const calendar = ES.CanonicalizeCalendar(calendarParam === undefined ? 'iso8601' : ES.RequireString(calendarParam));
+    ES.RejectISODate(year, month, day);
+
+    ES.CreateTemporalDateSlots(this, { year, month, day }, calendar);
+  }
+  get calendarId(): Return['calendarId'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return GetSlot(this, CALENDAR);
+  }
+  get era(): Return['era'] {
+    return getCalendarProperty(this, 'era');
+  }
+  get eraYear(): Return['eraYear'] {
+    return getCalendarProperty(this, 'eraYear');
+  }
+  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 day(): Return['day'] {
+    return getCalendarProperty(this, 'day');
+  }
+  get dayOfWeek(): Return['dayOfWeek'] {
+    return getCalendarProperty(this, 'dayOfWeek');
+  }
+  get dayOfYear(): Return['dayOfYear'] {
+    return getCalendarProperty(this, 'dayOfYear');
+  }
+  get weekOfYear(): Return['weekOfYear'] {
+    return getCalendarProperty(this, 'weekOfYear')?.week;
+  }
+  get yearOfWeek(): Return['yearOfWeek'] {
+    return getCalendarProperty(this, 'weekOfYear')?.year;
+  }
+  get daysInWeek(): Return['daysInWeek'] {
+    return getCalendarProperty(this, 'daysInWeek');
+  }
+  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(temporalDateLike: Params['with'][0], options: Params['with'][1] = undefined): Return['with'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    if (!ES.IsObject(temporalDateLike)) {
+      throw new TypeError('invalid argument');
+    }
+    ES.RejectTemporalLikeObject(temporalDateLike);
+
+    const calendar = GetSlot(this, CALENDAR);
+    let fields = ES.ISODateToFields(calendar, GetSlot(this, ISO_DATE));
+    const partialDate = ES.PrepareCalendarFields(
+      calendar,
+      temporalDateLike,
+      ['year', 'month', 'monthCode', 'day'],
+      [],
+      'partial'
+    );
+    fields = ES.CalendarMergeFields(calendar, fields, partialDate);
+
+    const overflow = ES.GetTemporalOverflowOption(ES.GetOptionsObject(options));
+    const isoDate = ES.CalendarDateFromFields(calendar, fields, overflow);
+    return ES.CreateTemporalDate(isoDate, calendar);
+  }
+  withCalendar(calendarParam: Params['withCalendar'][0]): Return['withCalendar'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    const calendar = ES.ToTemporalCalendarIdentifier(calendarParam);
+    return ES.CreateTemporalDate(GetSlot(this, ISO_DATE), calendar);
+  }
+  add(temporalDurationLike: Params['add'][0], options: Params['add'][1] = undefined): Return['add'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return ES.AddDurationToDate('add', this, temporalDurationLike, options);
+  }
+  subtract(
+    temporalDurationLike: Params['subtract'][0],
+    options: Params['subtract'][1] = undefined
+  ): Return['subtract'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return ES.AddDurationToDate('subtract', this, temporalDurationLike, options);
+  }
+  until(other: Params['until'][0], options: Params['until'][1] = undefined): Return['until'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return ES.DifferenceTemporalPlainDate('until', this, other, options);
+  }
+  since(other: Params['since'][0], options: Params['since'][1] = undefined): Return['since'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return ES.DifferenceTemporalPlainDate('since', this, other, options);
+  }
+  equals(otherParam: Params['equals'][0]): Return['equals'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    const other = ES.ToTemporalDate(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.IsTemporalDate);
+    const resolvedOptions = ES.GetOptionsObject(options);
+    const showCalendar = ES.GetTemporalShowCalendarNameOption(resolvedOptions);
+    return ES.TemporalDateToString(this, showCalendar);
+  }
+  toJSON(): Return['toJSON'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return ES.TemporalDateToString(this);
+  }
+  toLocaleString(
+    locales: Params['toLocaleString'][0] = undefined,
+    options: Params['toLocaleString'][1] = undefined
+  ): string {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    return new DateTimeFormat(locales, options).format(this);
+  }
+  valueOf(): never {
+    ES.ValueOfThrows('PlainDate');
+  }
+  toPlainDateTime(temporalTime: Params['toPlainDateTime'][0] = undefined): Return['toPlainDateTime'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    const time = ES.ToTimeRecordOrMidnight(temporalTime);
+    const isoDateTime = ES.CombineISODateAndTimeRecord(GetSlot(this, ISO_DATE), time);
+    return ES.CreateTemporalDateTime(isoDateTime, GetSlot(this, CALENDAR));
+  }
+  toZonedDateTime(item: Params['toZonedDateTime'][0]): Return['toZonedDateTime'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+
+    let timeZone, temporalTime;
+    if (ES.IsObject(item)) {
+      const timeZoneLike = item.timeZone;
+      if (timeZoneLike === undefined) {
+        timeZone = ES.ToTemporalTimeZoneIdentifier(item);
+      } else {
+        timeZone = ES.ToTemporalTimeZoneIdentifier(timeZoneLike);
+        temporalTime = item.plainTime;
+      }
+    } else {
+      timeZone = ES.ToTemporalTimeZoneIdentifier(item);
+    }
+
+    const isoDate = GetSlot(this, ISO_DATE);
+    let epochNs;
+    if (temporalTime === undefined) {
+      epochNs = ES.GetStartOfDay(timeZone, isoDate);
+    } else {
+      temporalTime = ES.ToTemporalTime(temporalTime);
+      const isoDateTime = ES.CombineISODateAndTimeRecord(isoDate, GetSlot(temporalTime, TIME));
+      epochNs = ES.GetEpochNanosecondsFor(timeZone, isoDateTime, 'compatible');
+    }
+    return ES.CreateTemporalZonedDateTime(epochNs, timeZone, GetSlot(this, CALENDAR));
+  }
+  toPlainYearMonth(): Return['toPlainYearMonth'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    const calendar = GetSlot(this, CALENDAR);
+    const fields = ES.ISODateToFields(calendar, GetSlot(this, ISO_DATE));
+    const isoDate = ES.CalendarYearMonthFromFields(calendar, fields, 'constrain');
+    return ES.CreateTemporalYearMonth(isoDate, calendar);
+  }
+  toPlainMonthDay(): Return['toPlainMonthDay'] {
+    ES.CheckReceiver(this, ES.IsTemporalDate);
+    const calendar = GetSlot(this, CALENDAR);
+    const fields = ES.ISODateToFields(calendar, GetSlot(this, ISO_DATE));
+    const isoDate = ES.CalendarMonthDayFromFields(calendar, fields, 'constrain');
+    return ES.CreateTemporalMonthDay(isoDate, calendar);
+  }
+
+  static from(item: Params['from'][0], options: Params['from'][1] = undefined): Return['from'] {
+    return ES.ToTemporalDate(item, options);
+  }
+  static compare(oneParam: Params['compare'][0], twoParam: Params['compare'][1]): Return['compare'] {
+    const one = ES.ToTemporalDate(oneParam);
+    const two = ES.ToTemporalDate(twoParam);
+    return ES.CompareISODate(GetSlot(one, ISO_DATE), GetSlot(two, ISO_DATE));
+  }
+  [Symbol.toStringTag]!: 'Temporal.PlainDate';
+}
+
+MakeIntrinsicClass(PlainDate, 'Temporal.PlainDate');
+
+function getCalendarProperty<P extends keyof CalendarDateRecord>(
+  date: Temporal.PlainDate,
+  prop: P
+): CalendarDateRecord[P] {
+  ES.CheckReceiver(date, ES.IsTemporalDate);
+  const isoDate = GetSlot(date, ISO_DATE);
+  return ES.calendarImplForObj(date).isoToDate(isoDate, { [prop]: true })[prop];
+}