@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/Temporal/PlainTime.mts

@@ -0,0 +1,74 @@
+import { bootstrapConstructor } from '../bootstrap.mts';
+import { SnapToInteger } from '../../abstract-ops/type-conversion.mts';
+import { bootstrapTemporalPlainTimePrototype } from './PlainTimePrototype.mts';
+import {
+  Q, Throw, UndefinedValue, Value, type OrdinaryObject, type ValueEvaluator,
+  type Realm,
+  type Arguments,
+  type FunctionCallContext,
+  F,
+  CompareTimeRecord,
+  CreateTemporalTime,
+  CreateTimeRecord,
+  IsValidTime,
+  ToTemporalTime,
+  type TimeRecord,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plaintime-instances */
+export interface TemporalPlainTimeObject extends OrdinaryObject {
+  readonly InitializedTemporalTime: never;
+  readonly Time: TimeRecord;
+}
+
+export function isTemporalPlainTimeObject(value: Value): value is TemporalPlainTimeObject {
+  return 'InitializedTemporalTime' in value;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime */
+function* PlainTimeConstructor([
+  _hour = Value.undefined,
+  _minute = Value.undefined,
+  _second = Value.undefined,
+  _millisecond = Value.undefined,
+  _microsecond = Value.undefined,
+  _nanosecond = Value.undefined,
+]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('Temporal.PlainTime cannot be called without new');
+  }
+  const hour = _hour instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_hour, 'truncate-strict'));
+  const minute = _minute instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_minute, 'truncate-strict'));
+  const second = _second instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_second, 'truncate-strict'));
+  const millisecond = _millisecond instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_millisecond, 'truncate-strict'));
+  const microsecond = _microsecond instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_microsecond, 'truncate-strict'));
+  const nanosecond = _nanosecond instanceof UndefinedValue ? 0n : Q(yield* SnapToInteger(_nanosecond, 'truncate-strict'));
+  if (!IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond)) {
+    return Throw.RangeError('Invalid time');
+  }
+  const time = CreateTimeRecord(hour, minute, second, millisecond, microsecond, nanosecond);
+  return Q(yield* CreateTemporalTime(time, NewTarget));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.from */
+function* PlainTime_from([item = Value.undefined, options = Value.undefined]: Arguments): ValueEvaluator {
+  return Q(yield* ToTemporalTime(item, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.compare */
+function* PlainTime_compare([_one = Value.undefined, _two = Value.undefined]: Arguments): ValueEvaluator {
+  const one = Q(yield* ToTemporalTime(_one));
+  const two = Q(yield* ToTemporalTime(_two));
+  return F(Number(CompareTimeRecord(one.Time, two.Time)));
+}
+
+export function bootstrapTemporalPlainTime(realmRec: Realm) {
+  const prototype = bootstrapTemporalPlainTimePrototype(realmRec);
+
+  const constructor = bootstrapConstructor(realmRec, PlainTimeConstructor, 'PlainTime', 0, prototype, [
+    ['from', PlainTime_from, 1],
+    ['compare', PlainTime_compare, 2],
+  ]);
+  realmRec.Intrinsics['%Temporal.PlainTime%'] = constructor;
+  return constructor;
+}

package/src/intrinsics/Temporal/PlainTimePrototype.mts

@@ -0,0 +1,224 @@
+import { bootstrapPrototype } from '../bootstrap.mts';
+import {
+  GetRoundingIncrementOption, GetRoundingModeOption, RoundingMode,
+} from '../../abstract-ops/temporal/addition.mts';
+import {
+  GetTemporalFractionalSecondDigitsOption,
+  GetTemporalOverflowOption,
+  GetTemporalUnitValuedOption,
+  IsPartialTemporalObject,
+  MaximumTemporalDurationRoundingIncrement,
+  TemporalUnit,
+  ToSecondsStringPrecisionRecord,
+  ValidateTemporalRoundingIncrement,
+  ValidateTemporalUnitValue,
+  type TimeUnit,
+} from '../../abstract-ops/temporal/temporal.mts';
+import {
+  AddDurationToTime,
+  CompareTimeRecord,
+  CreateTemporalTime,
+  DifferenceTemporalPlainTime,
+  RegulateTime,
+  RoundTime,
+  TimeRecordToString,
+  ToTemporalTime,
+  ToTemporalTimeRecord,
+} from '../../abstract-ops/temporal/plain-time.mts';
+import type { TemporalPlainTimeObject } from './PlainTime.mts';
+import {
+  Assert,
+  CreateDataPropertyOrThrow,
+  F,
+  GetOptionsObject,
+  JSStringValue,
+  ObjectValue,
+  OrdinaryObjectCreate,
+  Q,
+  RequireInternalSlot,
+  Throw,
+  UndefinedValue,
+  Value,
+  X,
+  type Arguments,
+  type FunctionCallContext,
+  type PlainCompletion,
+  type Realm,
+  type ValueEvaluator,
+} from '#self';
+
+function thisTemporalTimeValue(value: Value): PlainCompletion<TemporalPlainTimeObject> {
+  Q(RequireInternalSlot(value, 'InitializedTemporalTime'));
+  return value as TemporalPlainTimeObject;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.hour */
+function PlainTimeProto_hourGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Hour));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.minute */
+function PlainTimeProto_minuteGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Minute));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.second */
+function PlainTimeProto_secondGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Second));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.millisecond */
+function PlainTimeProto_millisecondGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Millisecond));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.microsecond */
+function PlainTimeProto_microsecondGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Microsecond));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaintime.prototype.nanosecond */
+function PlainTimeProto_nanosecondGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return F(Number(plainTime.Time.Nanosecond));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.add */
+function* PlainTimeProto_add([temporalDurationLike = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Q(yield* AddDurationToTime('add', plainTime, temporalDurationLike));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.subtract */
+function* PlainTimeProto_subtract([temporalDurationLike = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Q(yield* AddDurationToTime('subtract', plainTime, temporalDurationLike));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.with */
+function* PlainTimeProto_with([temporalTimeLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  if (!Q(yield* IsPartialTemporalObject(temporalTimeLike))) {
+    return Throw.TypeError('$1 is not a partial Temporal object', temporalTimeLike);
+  }
+  const partialTime = Q(yield* ToTemporalTimeRecord(temporalTimeLike as ObjectValue, 'partial'));
+  const hour = partialTime.Hour ?? plainTime.Time.Hour;
+  const minute = partialTime.Minute ?? plainTime.Time.Minute;
+  const second = partialTime.Second ?? plainTime.Time.Second;
+  const millisecond = partialTime.Millisecond ?? plainTime.Time.Millisecond;
+  const microsecond = partialTime.Microsecond ?? plainTime.Time.Microsecond;
+  const nanosecond = partialTime.Nanosecond ?? plainTime.Time.Nanosecond;
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const result = Q(RegulateTime(hour, minute, second, millisecond, microsecond, nanosecond, overflow));
+  return Q(yield* CreateTemporalTime(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.until */
+function* PlainTimeProto_until([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainTime('until', plainTime, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.since */
+function* PlainTimeProto_since([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainTime('since', plainTime, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.round */
+function* PlainTimeProto_round([roundTo = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  if (roundTo instanceof UndefinedValue) {
+    return Throw.TypeError('Options parameter is required');
+  }
+  if (roundTo instanceof JSStringValue) {
+    const paramString = roundTo;
+    roundTo = OrdinaryObjectCreate(Value.null);
+    X(CreateDataPropertyOrThrow(roundTo, Value('smallestUnit'), paramString));
+  } else {
+    roundTo = Q(GetOptionsObject(roundTo));
+  }
+  const roundingIncrement = Q(yield* GetRoundingIncrementOption(roundTo));
+  const roundingMode = Q(yield* GetRoundingModeOption(roundTo, RoundingMode.HalfExpand));
+  const smallestUnit = Q(yield* GetTemporalUnitValuedOption(roundTo, 'smallestUnit', 'required'));
+  Q(ValidateTemporalUnitValue(smallestUnit, 'time'));
+  const maximum = MaximumTemporalDurationRoundingIncrement(smallestUnit as TemporalUnit);
+  Assert(maximum !== 'unset');
+  Q(ValidateTemporalRoundingIncrement(roundingIncrement, maximum, false));
+  const result = RoundTime(plainTime.Time, roundingIncrement, smallestUnit as TimeUnit | TemporalUnit.Day, roundingMode);
+  return Q(yield* CreateTemporalTime(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.equals */
+function* PlainTimeProto_equals([_other = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  const other = Q(yield* ToTemporalTime(_other));
+  return CompareTimeRecord(plainTime.Time, other.Time) === 0n ? Value.true : Value.false;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.tostring */
+function* PlainTimeProto_toString([options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const digits = Q(yield* GetTemporalFractionalSecondDigitsOption(resolvedOptions));
+  const roundingMode = Q(yield* GetRoundingModeOption(resolvedOptions, 3));
+  const smallestUnit = Q(yield* GetTemporalUnitValuedOption(resolvedOptions, 'smallestUnit', 'unset'));
+  Q(ValidateTemporalUnitValue(smallestUnit, 'time'));
+  if (smallestUnit === TemporalUnit.Hour) {
+    return Throw.RangeError('smallestUnit cannot be hour');
+  }
+  const precision = ToSecondsStringPrecisionRecord(
+    smallestUnit as Exclude<TimeUnit, TemporalUnit.Hour> | 'unset',
+    digits,
+  );
+  const roundResult = RoundTime(plainTime.Time, precision.Increment, precision.Unit, roundingMode);
+  return Value(TimeRecordToString(roundResult, precision.Precision));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.tolocalestring */
+function PlainTimeProto_toLocaleString(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Value(Q(TimeRecordToString(plainTime.Time, 'auto')));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.tojson */
+function PlainTimeProto_toJSON(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainTime = Q(thisTemporalTimeValue(thisValue));
+  return Value(Q(TimeRecordToString(plainTime.Time, 'auto')));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaintime.prototype.valueof */
+function PlainTimeProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  Q(thisTemporalTimeValue(thisValue));
+  return Throw.TypeError('Temporal.PlainTime cannot be converted to primitive value. If you are comparing two Temporal.PlainTime objects with > or <, use Temporal.PlainTime.compare() instead.');
+}
+
+export function bootstrapTemporalPlainTimePrototype(realmRec: Realm) {
+  const prototype = bootstrapPrototype(realmRec, [
+    ['hour', [PlainTimeProto_hourGetter]],
+    ['minute', [PlainTimeProto_minuteGetter]],
+    ['second', [PlainTimeProto_secondGetter]],
+    ['millisecond', [PlainTimeProto_millisecondGetter]],
+    ['microsecond', [PlainTimeProto_microsecondGetter]],
+    ['nanosecond', [PlainTimeProto_nanosecondGetter]],
+    ['add', PlainTimeProto_add, 1],
+    ['subtract', PlainTimeProto_subtract, 1],
+    ['with', PlainTimeProto_with, 1],
+    ['until', PlainTimeProto_until, 1],
+    ['since', PlainTimeProto_since, 1],
+    ['round', PlainTimeProto_round, 1],
+    ['equals', PlainTimeProto_equals, 1],
+    ['toString', PlainTimeProto_toString, 0],
+    ['toLocaleString', PlainTimeProto_toLocaleString, 0],
+    ['toJSON', PlainTimeProto_toJSON, 0],
+    ['valueOf', PlainTimeProto_valueOf, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Temporal.PlainTime');
+  realmRec.Intrinsics['%Temporal.PlainTime.prototype%'] = prototype;
+  return prototype;
+}

package/src/intrinsics/Temporal/PlainYearMonth.mts

@@ -0,0 +1,96 @@
+import { bootstrapConstructor } from '../bootstrap.mts';
+import {
+  CanonicalizeCalendar,
+  type CalendarType,
+} from '../../abstract-ops/temporal/calendar.mts';
+import { SnapToInteger } from '../../abstract-ops/type-conversion.mts';
+import { bootstrapTemporalPlainYearMonthPrototype } from './PlainYearMonthPrototype.mts';
+import type { ISODateRecord } from './PlainDate.mts';
+import {
+  JSStringValue,
+  Q,
+  Throw,
+  Value,
+  UndefinedValue,
+  F,
+  type Arguments,
+  type FunctionCallContext,
+  type Realm,
+  type OrdinaryObject,
+  type ValueEvaluator,
+  CompareISODate,
+  CreateISODateRecord,
+  CreateTemporalYearMonth,
+  IsValidISODate,
+  ToTemporalYearMonth,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plainyearmonth-instances */
+export interface TemporalPlainYearMonthObject extends OrdinaryObject {
+  readonly InitializedTemporalYearMonth: never;
+  readonly ISODate: ISODateRecord;
+  readonly Calendar: CalendarType;
+}
+
+export function isTemporalPlainYearMonthObject(o: Value): o is TemporalPlainYearMonthObject {
+  return 'InitializedTemporalYearMonth' in o;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-iso-year-month-records */
+export interface ISOYearMonthRecord {
+  readonly Year: bigint;
+  readonly Month: bigint;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth */
+function* PlainYearMonthConstructor([
+  isoYear = Value.undefined,
+  isoMonth = Value.undefined,
+  _calendar = Value.undefined,
+  referenceISODay = Value.undefined,
+]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('Temporal.PlainYearMonth cannot be called without new');
+  }
+  if (referenceISODay instanceof UndefinedValue) {
+    referenceISODay = F(1);
+  }
+  const y = Q(yield* SnapToInteger(isoYear, 'truncate-strict'));
+  const m = Q(yield* SnapToInteger(isoMonth, 'truncate-strict'));
+  if (_calendar instanceof UndefinedValue) {
+    _calendar = Value('iso8601');
+  }
+  if (!(_calendar instanceof JSStringValue)) {
+    return Throw.TypeError('calendar is not a string');
+  }
+  const calendar = Q(CanonicalizeCalendar(_calendar.stringValue()));
+  const ref = Q(yield* SnapToInteger(referenceISODay, 'truncate-strict'));
+  if (!IsValidISODate(y, m, ref)) {
+    return Throw.RangeError('$1-$2-$3 is not a valid date', y, m, ref);
+  }
+  const isoDate = CreateISODateRecord(y, m, ref);
+  return Q(yield* CreateTemporalYearMonth(isoDate, calendar, NewTarget));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.from */
+function* PlainYearMonth_from([item = Value.undefined, options = Value.undefined]: Arguments): ValueEvaluator {
+  return Q(yield* ToTemporalYearMonth(item, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.compare */
+function* PlainYearMonth_compare([_one = Value.undefined, _two = Value.undefined]: Arguments): ValueEvaluator {
+  const one = Q(yield* ToTemporalYearMonth(_one));
+  const two = Q(yield* ToTemporalYearMonth(_two));
+  return F(Number(CompareISODate(one.ISODate, two.ISODate)));
+}
+
+export function bootstrapTemporalPlainYearMonth(realmRec: Realm) {
+  const prototype = bootstrapTemporalPlainYearMonthPrototype(realmRec);
+
+  const constructor = bootstrapConstructor(realmRec, PlainYearMonthConstructor, 'PlainYearMonth', 2, prototype, [
+    ['from', PlainYearMonth_from, 1],
+    ['compare', PlainYearMonth_compare, 2],
+  ]);
+  realmRec.Intrinsics['%Temporal.PlainYearMonth%'] = constructor;
+  return constructor;
+}

package/src/intrinsics/Temporal/PlainYearMonthPrototype.mts

@@ -0,0 +1,223 @@
+import { bootstrapPrototype } from '../bootstrap.mts';
+import {
+  GetTemporalOverflowOption,
+  GetTemporalShowCalendarNameOption,
+  IsPartialTemporalObject,
+  ISODateToFields,
+} from '../../abstract-ops/temporal/temporal.mts';
+import {
+  CalendarDateFromFields,
+  CalendarEquals,
+  CalendarISOToDate,
+  CalendarMergeFields,
+  CalendarYearMonthFromFields,
+  PrepareCalendarFields,
+} from '../../abstract-ops/temporal/calendar.mts';
+import { CompareISODate, CreateTemporalDate } from '../../abstract-ops/temporal/plain-date.mts';
+import {
+  AddDurationToYearMonth,
+  CreateTemporalYearMonth,
+  DifferenceTemporalPlainYearMonth,
+  TemporalYearMonthToString,
+  ToTemporalYearMonth,
+} from '../../abstract-ops/temporal/plain-year-month.mts';
+import type { TemporalPlainYearMonthObject } from './PlainYearMonth.mts';
+import {
+  F,
+  GetOptionsObject,
+  ObjectValue,
+  Q,
+  RequireInternalSlot,
+  Throw,
+  Value,
+  X,
+  type Arguments,
+  type FunctionCallContext,
+  type PlainCompletion,
+  type Realm,
+  type ValueEvaluator,
+} from '#self';
+
+function thisTemporalYearMonthValue(value: Value): PlainCompletion<TemporalPlainYearMonthObject> {
+  Q(RequireInternalSlot(value, 'InitializedTemporalYearMonth'));
+  return value as TemporalPlainYearMonthObject;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.calendarid */
+function PlainYearMonthProto_calendarIdGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(plainYearMonth.Calendar);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.era */
+function PlainYearMonthProto_eraGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).Era);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.erayear */
+function PlainYearMonthProto_eraYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  const result = CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).EraYear;
+  return result === undefined ? Value.undefined : F(Number(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.year */
+function PlainYearMonthProto_yearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return F(Number(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).Year));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.month */
+function PlainYearMonthProto_monthGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return F(Number(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).Month));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.monthcode */
+function PlainYearMonthProto_monthCodeGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).MonthCode);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.daysinyear */
+function PlainYearMonthProto_daysInYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return F(Number(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).DaysInYear));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.daysinmonth */
+function PlainYearMonthProto_daysInMonthGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return F(Number(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).DaysInMonth));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.monthsinyear */
+function PlainYearMonthProto_monthsInYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return F(Number(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).MonthsInYear));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plainyearmonth.prototype.inleapyear */
+function PlainYearMonthProto_inLeapYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(CalendarISOToDate(plainYearMonth.Calendar, plainYearMonth.ISODate).InLeapYear);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.with */
+function* PlainYearMonthProto_with([temporalYearMonthLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  if (!Q(yield* IsPartialTemporalObject(temporalYearMonthLike))) {
+    return Throw.TypeError('$1 is not a partial Temporal object', temporalYearMonthLike);
+  }
+  const calendar = plainYearMonth.Calendar;
+  let fields = ISODateToFields(calendar, plainYearMonth.ISODate, 'year-month');
+  const partialYearMonth = Q(yield* PrepareCalendarFields(calendar, temporalYearMonthLike as ObjectValue, ['year', 'month', 'month-code'], [], 'partial'));
+  fields = CalendarMergeFields(calendar, fields, partialYearMonth);
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const isoDate = Q(yield* CalendarYearMonthFromFields(calendar, fields, overflow));
+  return X(CreateTemporalYearMonth(isoDate, calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.add */
+function* PlainYearMonthProto_add([temporalDurationLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Q(yield* AddDurationToYearMonth('add', plainYearMonth, temporalDurationLike, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.subtract */
+function* PlainYearMonthProto_subtract([temporalDurationLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Q(yield* AddDurationToYearMonth('subtract', plainYearMonth, temporalDurationLike, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.until */
+function* PlainYearMonthProto_until([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainYearMonth('until', plainYearMonth, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.since */
+function* PlainYearMonthProto_since([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainYearMonth('since', plainYearMonth, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.equals */
+function* PlainYearMonthProto_equals([_other = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  const other = Q(yield* ToTemporalYearMonth(_other));
+  if (CompareISODate(plainYearMonth.ISODate, other.ISODate) !== 0n) {
+    return Value.false;
+  }
+  return Value(CalendarEquals(plainYearMonth.Calendar, other.Calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.tostring */
+function* PlainYearMonthProto_toString([options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const showCalendar = Q(yield* GetTemporalShowCalendarNameOption(resolvedOptions));
+  return Value(TemporalYearMonthToString(plainYearMonth, showCalendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.tolocalestring */
+function PlainYearMonthProto_toLocaleString(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(TemporalYearMonthToString(plainYearMonth, 'auto'));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.tojson */
+function PlainYearMonthProto_toJSON(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  return Value(TemporalYearMonthToString(plainYearMonth, 'auto'));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.valueof */
+function PlainYearMonthProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  Q(thisTemporalYearMonthValue(thisValue));
+  return Throw.TypeError('Temporal.PlainYearMonth cannot be converted to primitive value. If you are comparing two Temporal.PlainYearMonth objects with > or <, use Temporal.PlainYearMonth.compare() instead.');
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth.prototype.toplaindate */
+function* PlainYearMonthProto_toPlainDate([item = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainYearMonth = Q(thisTemporalYearMonthValue(thisValue));
+  if (!(item instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', item);
+  }
+  const calendar = plainYearMonth.Calendar;
+  const fields = ISODateToFields(calendar, plainYearMonth.ISODate, 'year-month');
+  const inputFields = Q(yield* PrepareCalendarFields(calendar, item, ['day'], [], []));
+  const mergedFields = CalendarMergeFields(calendar, fields, inputFields);
+  const isoDate = Q(yield* CalendarDateFromFields(calendar, mergedFields, 'constrain'));
+  return X(CreateTemporalDate(isoDate, calendar));
+}
+
+export function bootstrapTemporalPlainYearMonthPrototype(realmRec: Realm) {
+  const prototype = bootstrapPrototype(realmRec, [
+    ['calendarId', [PlainYearMonthProto_calendarIdGetter]],
+    ['era', [PlainYearMonthProto_eraGetter]],
+    ['eraYear', [PlainYearMonthProto_eraYearGetter]],
+    ['year', [PlainYearMonthProto_yearGetter]],
+    ['month', [PlainYearMonthProto_monthGetter]],
+    ['monthCode', [PlainYearMonthProto_monthCodeGetter]],
+    ['daysInYear', [PlainYearMonthProto_daysInYearGetter]],
+    ['daysInMonth', [PlainYearMonthProto_daysInMonthGetter]],
+    ['monthsInYear', [PlainYearMonthProto_monthsInYearGetter]],
+    ['inLeapYear', [PlainYearMonthProto_inLeapYearGetter]],
+    ['with', PlainYearMonthProto_with, 1],
+    ['add', PlainYearMonthProto_add, 1],
+    ['subtract', PlainYearMonthProto_subtract, 1],
+    ['until', PlainYearMonthProto_until, 1],
+    ['since', PlainYearMonthProto_since, 1],
+    ['equals', PlainYearMonthProto_equals, 1],
+    ['toString', PlainYearMonthProto_toString, 0],
+    ['toLocaleString', PlainYearMonthProto_toLocaleString, 0],
+    ['toJSON', PlainYearMonthProto_toJSON, 0],
+    ['valueOf', PlainYearMonthProto_valueOf, 0],
+    ['toPlainDate', PlainYearMonthProto_toPlainDate, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Temporal.PlainYearMonth');
+  realmRec.Intrinsics['%Temporal.PlainYearMonth.prototype%'] = prototype;
+  return prototype;
+}

package/src/intrinsics/Temporal/Temporal.mts

@@ -0,0 +1,30 @@
+// Using spec: 87c74ec2ae7d55cf10c58674478784d09f323ff1
+
+import { bootstrapPrototype } from '../bootstrap.mts';
+import { bootstrapTemporalDuration } from './Duration.mts';
+import { bootstrapTemporalInstant } from './Instant.mts';
+import { bootstrapTemporalPlainDate } from './PlainDate.mts';
+import { bootstrapTemporalPlainDateTime } from './PlainDateTime.mts';
+import { bootstrapTemporalPlainMonthDay } from './PlainMonthDay.mts';
+import { bootstrapTemporalPlainTime } from './PlainTime.mts';
+import { bootstrapTemporalPlainYearMonth } from './PlainYearMonth.mts';
+import { bootstrapTemporalNow } from './Now.mts';
+import { bootstrapTemporalZonedDateTime } from './ZonedDateTime.mts';
+import { type Realm } from '#self';
+
+export function bootstrapTemporal(realmRec: Realm) {
+  const TemporalObject = bootstrapPrototype(realmRec, [
+    ['Duration', bootstrapTemporalDuration(realmRec)],
+    ['Instant', bootstrapTemporalInstant(realmRec)],
+    ['PlainDateTime', bootstrapTemporalPlainDateTime(realmRec)],
+    ['Now', bootstrapTemporalNow(realmRec)],
+    ['PlainDate', bootstrapTemporalPlainDate(realmRec)],
+    ['PlainTime', bootstrapTemporalPlainTime(realmRec)],
+    ['PlainYearMonth', bootstrapTemporalPlainYearMonth(realmRec)],
+    ['PlainMonthDay', bootstrapTemporalPlainMonthDay(realmRec)],
+    ['ZonedDateTime', bootstrapTemporalZonedDateTime(realmRec)],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Temporal');
+
+  realmRec.Intrinsics['%Temporal%'] = TemporalObject;
+  return TemporalObject;
+}