@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/Temporal/PlainDatePrototype.mts

@@ -0,0 +1,331 @@
+import { bootstrapPrototype } from '../bootstrap.mts';
+import type { TimeZoneIdentifier } from '../../abstract-ops/temporal/addition.mts';
+import type { TemporalPlainDateObject } from './PlainDate.mts';
+import {
+  AddDurationToDate,
+  CalendarDateFromFields,
+  CalendarEquals,
+  CalendarISOToDate,
+  CalendarMergeFields,
+  CalendarMonthDayFromFields,
+  CalendarYearMonthFromFields,
+  CompareISODate,
+  CombineISODateAndTimeRecord,
+  CreateTemporalDate,
+  CreateTemporalDateTime,
+  CreateTemporalMonthDay,
+  CreateTemporalYearMonth,
+  CreateTemporalZonedDateTime,
+  DifferenceTemporalPlainDate,
+  Get,
+  GetEpochNanosecondsFor,
+  GetStartOfDay,
+  GetTemporalOverflowOption,
+  GetTemporalShowCalendarNameOption,
+  ISODateTimeWithinLimits,
+  ISODateToFields,
+  IsPartialTemporalObject,
+  PrepareCalendarFields,
+  Q,
+  RequireInternalSlot,
+  Throw,
+  ToTemporalCalendarIdentifier,
+  ToTemporalDate,
+  ToTemporalTime,
+  ToTemporalTimeZoneIdentifier,
+  ToTimeRecordOrMidnight,
+  Value,
+  X,
+  F,
+  type Arguments,
+  type FunctionCallContext,
+  type PlainCompletion,
+  type Realm,
+  type ValueEvaluator,
+  ObjectValue,
+  TemporalDateToString,
+  GetOptionsObject,
+} from '#self';
+
+function thisTemporalDateValue(value: Value): PlainCompletion<TemporalPlainDateObject> {
+  Q(RequireInternalSlot(value, 'InitializedTemporalDate'));
+  return value as TemporalPlainDateObject;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.calendarid */
+function PlainDateProto_calendarIdGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(plainDate.Calendar);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.era */
+function PlainDateProto_eraGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).Era);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.erayear */
+function PlainDateProto_eraYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const result = CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).EraYear;
+  return result === undefined ? Value.undefined : F(Number(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.year */
+function PlainDateProto_yearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).Year));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.month */
+function PlainDateProto_monthGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).Month));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.monthcode */
+function PlainDateProto_monthCodeGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).MonthCode);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.day */
+function PlainDateProto_dayGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).Day));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.dayofweek */
+function PlainDateProto_dayOfWeekGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).DayOfWeek));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.dayofyear */
+function PlainDateProto_dayOfYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).DayOfYear));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.weekofyear */
+function PlainDateProto_weekOfYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const result = CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).WeekOfYear.Week;
+  return result === undefined ? Value.undefined : F(Number(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.yearofweek */
+function PlainDateProto_yearOfWeekGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const result = CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).WeekOfYear.Year;
+  return result === undefined ? Value.undefined : F(Number(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.daysinweek */
+function PlainDateProto_daysInWeekGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).DaysInWeek));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.daysinmonth */
+function PlainDateProto_daysInMonthGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).DaysInMonth));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.daysinyear */
+function PlainDateProto_daysInYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).DaysInYear));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.monthsinyear */
+function PlainDateProto_monthsInYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return F(Number(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).MonthsInYear));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-get-temporal.plaindate.prototype.inleapyear */
+function PlainDateProto_inLeapYearGetter(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(CalendarISOToDate(plainDate.Calendar, plainDate.ISODate).InLeapYear);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.toplainyearmonth */
+function* PlainDateProto_toPlainYearMonth(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const calendar = plainDate.Calendar;
+  const fields = ISODateToFields(calendar, plainDate.ISODate, 'date');
+  const isoDate = Q(yield* CalendarYearMonthFromFields(calendar, fields, 'constrain'));
+  return X(CreateTemporalYearMonth(isoDate, calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.toplainmonthday */
+function* PlainDateProto_toPlainMonthDay(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const calendar = plainDate.Calendar;
+  const fields = ISODateToFields(calendar, plainDate.ISODate, 'date');
+  const isoDate = Q(yield* CalendarMonthDayFromFields(calendar, fields, 'constrain'));
+  return X(CreateTemporalMonthDay(isoDate, calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.add */
+function* PlainDateProto_add([temporalDurationLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Q(yield* AddDurationToDate('add', plainDate, temporalDurationLike, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.subtract */
+function* PlainDateProto_subtract([temporalDurationLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Q(yield* AddDurationToDate('subtract', plainDate, temporalDurationLike, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.with */
+function* PlainDateProto_with([temporalDateLike = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  if (!Q(yield* IsPartialTemporalObject(temporalDateLike))) {
+    return Throw.TypeError('$1 is not a partial Temporal object', temporalDateLike);
+  }
+  const calendar = plainDate.Calendar;
+  let fields = ISODateToFields(calendar, plainDate.ISODate, 'date');
+  const partialDate = Q(yield* PrepareCalendarFields(calendar, temporalDateLike as ObjectValue, ['year', 'month', 'month-code', 'day'], [], 'partial'));
+  fields = CalendarMergeFields(calendar, fields, partialDate);
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const isoDate = Q(yield* CalendarDateFromFields(calendar, fields, overflow));
+  return X(CreateTemporalDate(isoDate, calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.withcalendar */
+function PlainDateProto_withCalendar([calendarLike = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const calendar = Q(ToTemporalCalendarIdentifier(calendarLike));
+  return X(CreateTemporalDate(plainDate.ISODate, calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.until */
+function* PlainDateProto_until([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainDate('until', plainDate, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.since */
+function* PlainDateProto_since([other = Value.undefined, options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Q(yield* DifferenceTemporalPlainDate('since', plainDate, other, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.equals */
+function* PlainDateProto_equals([_other = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const other = Q(yield* ToTemporalDate(_other));
+  if (CompareISODate(plainDate.ISODate, other.ISODate) !== 0n) {
+    return Value.false;
+  }
+  return Value(CalendarEquals(plainDate.Calendar, other.Calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.toplaindatetime */
+function* PlainDateProto_toPlainDateTime([temporalTime = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const time = Q(yield* ToTimeRecordOrMidnight(temporalTime));
+  const isoDateTime = CombineISODateAndTimeRecord(plainDate.ISODate, time);
+  return Q(yield* CreateTemporalDateTime(isoDateTime, plainDate.Calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.tozoneddatetime */
+function* PlainDateProto_toZonedDateTime([item = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  let timeZone: TimeZoneIdentifier;
+  let temporalTime: Value;
+  if (item instanceof ObjectValue) {
+    const timeZoneLike = Q(yield* Get(item, Value('timeZone')));
+    if (timeZoneLike === Value.undefined) {
+      timeZone = Q(ToTemporalTimeZoneIdentifier(item));
+      temporalTime = Value.undefined;
+    } else {
+      timeZone = Q(ToTemporalTimeZoneIdentifier(timeZoneLike));
+      temporalTime = Q(yield* Get(item, Value('plainTime')));
+    }
+  } else {
+    timeZone = Q(ToTemporalTimeZoneIdentifier(item));
+    temporalTime = Value.undefined;
+  }
+  let epochNs: bigint;
+  if (temporalTime === Value.undefined) {
+    epochNs = Q(GetStartOfDay(timeZone, plainDate.ISODate));
+  } else {
+    const temporalTime2 = Q(yield* ToTemporalTime(temporalTime));
+    const isoDateTime = CombineISODateAndTimeRecord(plainDate.ISODate, temporalTime2.Time);
+    if (!ISODateTimeWithinLimits(isoDateTime)) {
+      return Throw.RangeError('DateTime outside of range');
+    }
+    epochNs = Q(GetEpochNanosecondsFor(timeZone, isoDateTime, 'compatible'));
+  }
+  return X(CreateTemporalZonedDateTime(epochNs, timeZone, plainDate.Calendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.tostring */
+function* PlainDateProto_toString([options = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const showCalendar = Q(yield* GetTemporalShowCalendarNameOption(resolvedOptions));
+  return Value(TemporalDateToString(plainDate, showCalendar));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.tolocalestring */
+function PlainDateProto_toLocaleString(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(TemporalDateToString(plainDate, 'auto'));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.tojson */
+function PlainDateProto_toJSON(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  const plainDate = Q(thisTemporalDateValue(thisValue));
+  return Value(TemporalDateToString(plainDate, 'auto'));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindate.prototype.valueof */
+function PlainDateProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): PlainCompletion<Value> {
+  Q(thisTemporalDateValue(thisValue));
+  return Throw.TypeError('Temporal.PlainDate cannot be converted to primitive value. If you are comparing two Temporal.PlainDate objects with > or <, use Temporal.PlainDate.compare() instead.');
+}
+
+export function bootstrapTemporalPlainDatePrototype(realmRec: Realm) {
+  const prototype = bootstrapPrototype(realmRec, [
+    ['calendarId', [PlainDateProto_calendarIdGetter]],
+    ['era', [PlainDateProto_eraGetter]],
+    ['eraYear', [PlainDateProto_eraYearGetter]],
+    ['year', [PlainDateProto_yearGetter]],
+    ['month', [PlainDateProto_monthGetter]],
+    ['monthCode', [PlainDateProto_monthCodeGetter]],
+    ['day', [PlainDateProto_dayGetter]],
+    ['dayOfWeek', [PlainDateProto_dayOfWeekGetter]],
+    ['dayOfYear', [PlainDateProto_dayOfYearGetter]],
+    ['weekOfYear', [PlainDateProto_weekOfYearGetter]],
+    ['yearOfWeek', [PlainDateProto_yearOfWeekGetter]],
+    ['daysInWeek', [PlainDateProto_daysInWeekGetter]],
+    ['daysInMonth', [PlainDateProto_daysInMonthGetter]],
+    ['daysInYear', [PlainDateProto_daysInYearGetter]],
+    ['monthsInYear', [PlainDateProto_monthsInYearGetter]],
+    ['inLeapYear', [PlainDateProto_inLeapYearGetter]],
+    ['toPlainYearMonth', PlainDateProto_toPlainYearMonth, 0],
+    ['toPlainMonthDay', PlainDateProto_toPlainMonthDay, 0],
+    ['add', PlainDateProto_add, 1],
+    ['subtract', PlainDateProto_subtract, 1],
+    ['with', PlainDateProto_with, 1],
+    ['withCalendar', PlainDateProto_withCalendar, 1],
+    ['until', PlainDateProto_until, 1],
+    ['since', PlainDateProto_since, 1],
+    ['equals', PlainDateProto_equals, 1],
+    ['toPlainDateTime', PlainDateProto_toPlainDateTime, 0],
+    ['toZonedDateTime', PlainDateProto_toZonedDateTime, 1],
+    ['toString', PlainDateProto_toString, 0],
+    ['toLocaleString', PlainDateProto_toLocaleString, 0],
+    ['toJSON', PlainDateProto_toJSON, 0],
+    ['valueOf', PlainDateProto_valueOf, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Temporal.PlainDate');
+  realmRec.Intrinsics['%Temporal.PlainDate.prototype%'] = prototype;
+  return prototype;
+}

package/src/intrinsics/Temporal/PlainDateTime.mts

@@ -0,0 +1,113 @@
+import { bootstrapConstructor } from '../bootstrap.mts';
+import {
+  CanonicalizeCalendar,
+  type CalendarType,
+} from '../../abstract-ops/temporal/calendar.mts';
+import { SnapToInteger } from '../../abstract-ops/type-conversion.mts';
+import { bootstrapTemporalPlainDateTimePrototype } from './PlainDateTimePrototype.mts';
+import type { ISODateRecord } from './PlainDate.mts';
+import {
+  JSStringValue,
+  Q,
+  Throw,
+  Value,
+  type OrdinaryObject,
+  type ValueEvaluator,
+  type Realm,
+  type Arguments,
+  type FunctionCallContext,
+  UndefinedValue,
+  F,
+  CombineISODateAndTimeRecord,
+  CompareISODateTime,
+  CreateISODateRecord,
+  CreateTemporalDateTime,
+  CreateTimeRecord,
+  IsValidISODate,
+  IsValidTime,
+  ToTemporalDateTime,
+  type TimeRecord,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plaindatetime-instances */
+export interface TemporalPlainDateTimeObject extends OrdinaryObject {
+  readonly InitializedTemporalDateTime: never;
+  readonly ISODateTime: ISODateTimeRecord;
+  readonly Calendar: CalendarType;
+}
+export function isTemporalPlainDateTimeObject(o: Value): o is TemporalPlainDateTimeObject {
+  return 'InitializedTemporalDateTime' in o;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-iso-date-time-records */
+export interface ISODateTimeRecord {
+  readonly ISODate: ISODateRecord;
+  readonly Time: TimeRecord;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindatetime */
+function* PlainDateTimeConstructor([
+  _isoYear = Value.undefined,
+  _isoMonth = Value.undefined,
+  _isoDay = Value.undefined,
+  _hour = Value.undefined,
+  _minute = Value.undefined,
+  _second = Value.undefined,
+  _millisecond = Value.undefined,
+  _microsecond = Value.undefined,
+  _nanosecond = Value.undefined,
+  _calendar = Value.undefined,
+]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('Temporal.PlainDateTime cannot be called without new');
+  }
+  const isoYear = Q(yield* SnapToInteger(_isoYear, 'truncate-strict'));
+  const isoMonth = Q(yield* SnapToInteger(_isoMonth, 'truncate-strict'));
+  const isoDay = Q(yield* SnapToInteger(_isoDay, 'truncate-strict'));
+  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 (_calendar instanceof UndefinedValue) {
+    _calendar = Value('iso8601');
+  }
+  if (!(_calendar instanceof JSStringValue)) {
+    return Throw.TypeError('calendar is not a string');
+  }
+  const calendar = Q(CanonicalizeCalendar(_calendar.stringValue()));
+  if (!IsValidISODate(isoYear, isoMonth, isoDay)) {
+    return Throw.RangeError('$1-$2-$3 is not a valid date', isoYear, isoMonth, isoDay);
+  }
+  const isoDate = CreateISODateRecord(isoYear, isoMonth, isoDay);
+  if (!IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond)) {
+    return Throw.RangeError('Invalid time');
+  }
+  const time = CreateTimeRecord(hour, minute, second, millisecond, microsecond, nanosecond);
+  const isoDateTime = CombineISODateAndTimeRecord(isoDate, time);
+  return Q(yield* CreateTemporalDateTime(isoDateTime, calendar, NewTarget));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindatetime.from */
+function* PlainDateTime_from([item = Value.undefined, options = Value.undefined]: Arguments): ValueEvaluator {
+  return Q(yield* ToTemporalDateTime(item, options));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal.plaindatetime.compare */
+function* PlainDateTime_compare([_one = Value.undefined, _two = Value.undefined]: Arguments): ValueEvaluator {
+  const one = Q(yield* ToTemporalDateTime(_one));
+  const two = Q(yield* ToTemporalDateTime(_two));
+  return F(Number(CompareISODateTime(one.ISODateTime, two.ISODateTime)));
+}
+
+export function bootstrapTemporalPlainDateTime(realmRec: Realm) {
+  const prototype = bootstrapTemporalPlainDateTimePrototype(realmRec);
+
+  const constructor = bootstrapConstructor(realmRec, PlainDateTimeConstructor, 'PlainDateTime', 3, prototype, [
+    ['from', PlainDateTime_from, 1],
+    ['compare', PlainDateTime_compare, 2],
+  ]);
+  realmRec.Intrinsics['%Temporal.PlainDateTime%'] = constructor;
+  return constructor;
+}