@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/temporal/plain-date.mts

@@ -0,0 +1,249 @@
+import type { TemporalDurationObject } from '../../intrinsics/Temporal/Duration.mts';
+import { type ISODateRecord, type TemporalPlainDateObject, isTemporalPlainDateObject } from '../../intrinsics/Temporal/PlainDate.mts';
+import { isTemporalPlainDateTimeObject } from '../../intrinsics/Temporal/PlainDateTime.mts';
+import { isTemporalZonedDateTimeObject } from '../../intrinsics/Temporal/ZonedDateTime.mts';
+import { ParseISODateTime } from '../../parser/TemporalParser.mts';
+import {
+  abs, max, min, truncateDiv,
+} from '../math.mts';
+import { GetUTCEpochNanoseconds, ToZeroPaddedDecimalString } from './addition.mts';
+import {
+  Assert, type CalendarType, type FunctionObject, type ValueEvaluator, Throw, surroundingAgent, Q, OrdinaryCreateFromConstructor, type Mutable, Value, ObjectValue, GetTemporalOverflowOption, X, GetISODateTimeFor, GetTemporalCalendarIdentifierWithISODefault, PrepareCalendarFields, CalendarDateFromFields, JSStringValue, CanonicalizeCalendar, CalendarISOToDate, type PlainCompletion, ISODaysInMonth, ISODateToEpochDays, EpochDaysToEpochMs, EpochTimeToEpochYear, EpochTimeToMonthInYear, EpochTimeToDate, FormatCalendarAnnotation, CalendarEquals, GetDifferenceSettings, TemporalUnit, CreateTemporalDuration, CalendarDateUntil, type DateUnit, CombineDateAndTimeDuration, RoundRelativeDuration, TemporalDurationFromInternal, CreateNegatedTemporalDuration, ToTemporalDuration, CalendarDateAdd,
+  BalanceISOYearMonth,
+  MidnightTimeRecord,
+  NoonTimeRecord,
+  CombineISODateAndTimeRecord,
+  ISODateTimeWithinLimits,
+  ToInternalDurationRecordWith24HourDays,
+  NanosecondsPerDay,
+  CreateDateDurationRecord,
+  type CalendarDateRecord,
+  type Integer,
+  GetOptionsObject,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-create-iso-date-record */
+export function CreateISODateRecord(y: Integer, m: Integer, d: Integer): ISODateRecord {
+  Assert(IsValidISODate(y, m, d));
+  return { Year: y, Month: m, Day: d };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtemporaldate */
+export function* CreateTemporalDate(isoDate: ISODateRecord, calendar: CalendarType, NewTarget?: FunctionObject): ValueEvaluator<TemporalPlainDateObject> {
+  if (!ISODateWithinLimits(isoDate)) {
+    return Throw.RangeError('$1-$2-$3 is not a valid date', isoDate.Year, isoDate.Month, isoDate.Day);
+  }
+  if (NewTarget === undefined) {
+    NewTarget = surroundingAgent.intrinsic('%Temporal.PlainDate%');
+  }
+  const object = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%Temporal.PlainDate.prototype%', [
+    'InitializedTemporalDate',
+    'ISODate',
+    'Calendar',
+  ])) as Mutable<TemporalPlainDateObject>;
+  object.ISODate = isoDate;
+  object.Calendar = calendar;
+  return object;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporaldate */
+export function* ToTemporalDate(item: Value, options: Value = Value.undefined): ValueEvaluator<TemporalPlainDateObject> {
+  if (item instanceof ObjectValue) {
+    if (isTemporalPlainDateObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalDate(item.ISODate, item.Calendar));
+    }
+    if (isTemporalZonedDateTimeObject(item)) {
+      const isoDateTime = GetISODateTimeFor(item.TimeZone, item.EpochNanoseconds);
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalDate(isoDateTime.ISODate, item.Calendar));
+    }
+    if (isTemporalPlainDateTimeObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalDate(item.ISODateTime.ISODate, item.Calendar));
+    }
+    const calendar = Q(yield* GetTemporalCalendarIdentifierWithISODefault(item));
+    const fields = Q(yield* PrepareCalendarFields(calendar, item, ['year', 'month', 'month-code', 'day'], [], []));
+    const resolvedOptions = Q(GetOptionsObject(options));
+    const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+    const isoDate = Q(yield* CalendarDateFromFields(calendar, fields, overflow));
+    return X(CreateTemporalDate(isoDate, calendar));
+  }
+  if (!(item instanceof JSStringValue)) {
+    return Throw.TypeError('$1 is not a string', item);
+  }
+  const result = Q(ParseISODateTime(item.stringValue(), ['TemporalDateTimeString[~Zoned]']));
+  const calendar = result.Calendar ?? 'iso8601';
+  const calendarType = Q(CanonicalizeCalendar(calendar));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const isoDate = CreateISODateRecord(result.Year!, result.Month, result.Day);
+  return Q(yield* CreateTemporalDate(isoDate, calendarType));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-comparesurpasses */
+export function CompareSurpasses(sign: 1n | -1n, year: Integer, monthOrCode: bigint | string, day: Integer, target: CalendarDateRecord): boolean {
+  if (year !== target.Year) {
+    if (sign * (year - target.Year) > 0) {
+      return true;
+    }
+  } else if (typeof monthOrCode === 'string' && monthOrCode !== target.MonthCode) {
+    if (sign > 0) {
+      // If monthOrCode is lexicographically greater than target.[[MonthCode]], return true.
+      if (monthOrCode > target.MonthCode) {
+        return true;
+      }
+    } else if (target.MonthCode > monthOrCode) {
+      // If target.[[MonthCode]] is lexicographically greater than monthOrCode, return true.
+      return true;
+    }
+  } else if (typeof monthOrCode === 'bigint' && monthOrCode !== target.Month) {
+    if (sign * (monthOrCode - target.Month) > 0) {
+      return true;
+    }
+  } else if (day !== target.Day) {
+    if (sign * (day - target.Day) > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-isodatesurpasses */
+export function ISODateSurpasses(sign: 1n | -1n, baseDate: ISODateRecord, isoDate2: ISODateRecord, years: Integer, month: Integer, weeks: Integer, days: Integer): boolean {
+  const parts = CalendarISOToDate('iso8601', baseDate);
+  const target = CalendarISOToDate('iso8601', isoDate2);
+  const y0 = parts.Year + years;
+  if (CompareSurpasses(sign, y0, parts.MonthCode, parts.Day, target)) {
+    return true;
+  }
+  if (month === 0n && weeks === 0n && days === 0n) {
+    return false;
+  }
+  const m0 = parts.Month + month;
+  const monthsAdded = BalanceISOYearMonth(y0, m0);
+  if (CompareSurpasses(sign, monthsAdded.Year, monthsAdded.Month, parts.Day, target)) {
+    return true;
+  }
+  if (weeks === 0n && days === 0n) {
+    return false;
+  }
+  const regulatedDate = X(RegulateISODate(monthsAdded.Year, monthsAdded.Month, parts.Day, 'constrain'));
+  const daysInWeek = 7n;
+  const balancedDate = AddDaysToISODate(regulatedDate, daysInWeek * weeks + days);
+  return CompareSurpasses(sign, balancedDate.Year, balancedDate.Month, balancedDate.Day, target);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-regulateisodate */
+export function RegulateISODate(year: Integer, month: Integer, day: Integer, overflow: 'constrain' | 'reject'): PlainCompletion<ISODateRecord> {
+  if (overflow === 'constrain') {
+    month = max(1n, min(12n, month));
+    const daysInMonth = ISODaysInMonth(year, month);
+    day = max(1n, min(daysInMonth, day));
+  } else {
+    Assert(overflow === 'reject');
+    if (!IsValidISODate(year, month, day)) {
+      return Throw.RangeError('$1-$2-$3 is not a valid date', year, month, day);
+    }
+  }
+  return CreateISODateRecord(year, month, day);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-isvalidisodate */
+export function IsValidISODate(year: Integer, month: Integer, day: Integer): boolean {
+  if (month < 1n || month > 12n) {
+    return false;
+  }
+  const daysInMonth = ISODaysInMonth(year, month);
+  if (day < 1n || day > daysInMonth) {
+    return false;
+  }
+  return true;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-adddaystoisodate */
+export function AddDaysToISODate(isoDate: ISODateRecord, days: Integer): ISODateRecord {
+  const epochDays = ISODateToEpochDays(isoDate.Year, isoDate.Month - 1n, isoDate.Day) + days;
+  const epochMilliseconds = EpochDaysToEpochMs(epochDays, 0n);
+  return CreateISODateRecord(EpochTimeToEpochYear(epochMilliseconds), EpochTimeToMonthInYear(epochMilliseconds) + 1n, EpochTimeToDate(epochMilliseconds));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-padisoyear */
+export function PadISOYear(y: Integer): string {
+  if (y >= 0n && y <= 9999n) {
+    return ToZeroPaddedDecimalString(y, 4);
+  }
+  const yearSign = y > 0n ? '+' : '-';
+  const year = ToZeroPaddedDecimalString(abs(y), 6);
+  return yearSign + year;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-temporaldatetostring */
+export function TemporalDateToString(temporalDate: TemporalPlainDateObject, showCalendar: 'auto' | 'always' | 'never' | 'critical'): string {
+  const year = PadISOYear(temporalDate.ISODate.Year);
+  const month = ToZeroPaddedDecimalString(temporalDate.ISODate.Month, 2);
+  const day = ToZeroPaddedDecimalString(temporalDate.ISODate.Day, 2);
+  const calendar = FormatCalendarAnnotation(temporalDate.Calendar, showCalendar);
+  return `${year}-${month}-${day}${calendar}`;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-isodatewithinlimits */
+export function ISODateWithinLimits(isoDate: ISODateRecord): boolean {
+  const isoDateTime = CombineISODateAndTimeRecord(isoDate, NoonTimeRecord());
+  return ISODateTimeWithinLimits(isoDateTime);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-compareisodate */
+export function CompareISODate(isoDate1: ISODateRecord, isoDate2: ISODateRecord): 1n | -1n | 0n {
+  if (isoDate1.Year > isoDate2.Year) return 1n;
+  if (isoDate1.Year < isoDate2.Year) return -1n;
+  if (isoDate1.Month > isoDate2.Month) return 1n;
+  if (isoDate1.Month < isoDate2.Month) return -1n;
+  if (isoDate1.Day > isoDate2.Day) return 1n;
+  if (isoDate1.Day < isoDate2.Day) return -1n;
+  return 0n;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaindate */
+export function* DifferenceTemporalPlainDate(operation: 'since' | 'until', temporalDate: TemporalPlainDateObject, _other: Value, options: Value): ValueEvaluator<TemporalDurationObject> {
+  const other = Q(yield* ToTemporalDate(_other));
+  if (!CalendarEquals(temporalDate.Calendar, other.Calendar)) {
+    return Throw.RangeError('Calendars are not equal');
+  }
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const settings = Q(yield* GetDifferenceSettings(operation, resolvedOptions, 'date', [], TemporalUnit.Day, TemporalUnit.Day));
+  if (CompareISODate(temporalDate.ISODate, other.ISODate) === 0n) {
+    return X(CreateTemporalDuration(0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n));
+  }
+  const dateDifference = CalendarDateUntil(temporalDate.Calendar, temporalDate.ISODate, other.ISODate, settings.LargestUnit as DateUnit);
+  let duration = CombineDateAndTimeDuration(dateDifference, 0n);
+  if (settings.SmallestUnit !== TemporalUnit.Day || settings.RoundingIncrement !== 1n) {
+    const isoDateTime = CombineISODateAndTimeRecord(temporalDate.ISODate, MidnightTimeRecord());
+    const originEpochNs = GetUTCEpochNanoseconds(isoDateTime);
+    const isoDateTimeOther = CombineISODateAndTimeRecord(other.ISODate, MidnightTimeRecord());
+    const destEpochNs = GetUTCEpochNanoseconds(isoDateTimeOther);
+    duration = Q(RoundRelativeDuration(duration, originEpochNs, destEpochNs, isoDateTime, undefined, temporalDate.Calendar, settings.LargestUnit, settings.RoundingIncrement, settings.SmallestUnit, settings.RoundingMode));
+  }
+  let result = X(TemporalDurationFromInternal(duration, TemporalUnit.Day));
+  if (operation === 'since') {
+    result = CreateNegatedTemporalDuration(result);
+  }
+  return result;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-adddurationtodate */
+export function* AddDurationToDate(operation: 'add' | 'subtract', temporalDate: TemporalPlainDateObject, temporalDurationLike: Value, options: Value): ValueEvaluator<TemporalPlainDateObject> {
+  const calendar = temporalDate.Calendar;
+  let duration = Q(yield* ToTemporalDuration(temporalDurationLike));
+  if (operation === 'subtract') duration = CreateNegatedTemporalDuration(duration);
+  const internalDuration = ToInternalDurationRecordWith24HourDays(duration);
+  const days = truncateDiv(internalDuration.Time, NanosecondsPerDay);
+  const dateDuration = X(CreateDateDurationRecord(BigInt(internalDuration.Date.Years), BigInt(internalDuration.Date.Months), BigInt(internalDuration.Date.Weeks), days));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const result = Q(CalendarDateAdd(calendar, temporalDate.ISODate, dateDuration, overflow));
+  return X(CreateTemporalDate(result, calendar));
+}

package/src/abstract-ops/temporal/plain-month-day.mts

@@ -0,0 +1,86 @@
+import type { ISODateRecord } from '../../intrinsics/Temporal/PlainDate.mts';
+import { type TemporalPlainMonthDayObject, isTemporalPlainMonthDayObject } from '../../intrinsics/Temporal/PlainMonthDay.mts';
+import { ParseISODateTime } from '../../parser/TemporalParser.mts';
+import { ToZeroPaddedDecimalString } from './addition.mts';
+import {
+  Value, type ValueEvaluator, ObjectValue, Q, GetTemporalOverflowOption, X, GetTemporalCalendarIdentifierWithISODefault, PrepareCalendarFields, CalendarMonthDayFromFields, JSStringValue, Throw, CanonicalizeCalendar, CreateISODateRecord, ISODateWithinLimits, ISODateToFields, type CalendarType, type FunctionObject, surroundingAgent, OrdinaryCreateFromConstructor, type Mutable, PadISOYear, FormatCalendarAnnotation,
+  GetOptionsObject,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporalmonthday */
+export function* ToTemporalMonthDay(
+  item: Value,
+  options: Value = Value.undefined,
+): ValueEvaluator<TemporalPlainMonthDayObject> {
+  if (item instanceof ObjectValue) {
+    if (isTemporalPlainMonthDayObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalMonthDay(item.ISODate, item.Calendar));
+    }
+    const calendar = Q(yield* GetTemporalCalendarIdentifierWithISODefault(item));
+    const fields = Q(yield* PrepareCalendarFields(calendar, item, ['year', 'month', 'month-code', 'day'], [], []));
+    const resolvedOptions = Q(GetOptionsObject(options));
+    const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+    const isoDate = Q(yield* CalendarMonthDayFromFields(calendar, fields, overflow));
+    return X(CreateTemporalMonthDay(isoDate, calendar));
+  }
+  if (!(item instanceof JSStringValue)) {
+    return Throw.TypeError('$1 is not a string', item);
+  }
+  const result = Q(ParseISODateTime(item.stringValue(), ['TemporalMonthDayString']));
+  const calendar = result.Calendar ?? 'iso8601';
+  const calendarType = Q(CanonicalizeCalendar(calendar));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  if (calendarType === 'iso8601') {
+    const referenceISOYear = 1972n;
+    const isoDate = CreateISODateRecord(referenceISOYear, result.Month, result.Day);
+    return X(CreateTemporalMonthDay(isoDate, calendarType));
+  }
+  let isoDate = CreateISODateRecord(result.Year!, result.Month, result.Day);
+  if (!ISODateWithinLimits(isoDate)) {
+    return Throw.RangeError('PlainMonthDay out of range');
+  }
+  const result2 = Q(ISODateToFields(calendarType, isoDate, 'month-day'));
+  isoDate = Q(yield* CalendarMonthDayFromFields(calendarType, result2, 'constrain'));
+  return X(CreateTemporalMonthDay(isoDate, calendarType));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtemporalmonthday */
+export function* CreateTemporalMonthDay(
+  isoDate: ISODateRecord,
+  calendar: CalendarType,
+  newTarget?: FunctionObject,
+): ValueEvaluator<TemporalPlainMonthDayObject> {
+  if (!ISODateWithinLimits(isoDate)) {
+    return Throw.RangeError('PlainMonthDay out of range');
+  }
+  if (newTarget === undefined) {
+    newTarget = surroundingAgent.intrinsic('%Temporal.PlainMonthDay%');
+  }
+  const object = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%Temporal.PlainMonthDay.prototype%', [
+    'InitializedTemporalMonthDay',
+    'ISODate',
+    'Calendar',
+  ])) as Mutable<TemporalPlainMonthDayObject>;
+  object.ISODate = isoDate;
+  object.Calendar = calendar;
+  return object;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-temporalmonthdaytostring */
+export function TemporalMonthDayToString(
+  monthDay: TemporalPlainMonthDayObject,
+  showCalendar: 'auto' | 'always' | 'never' | 'critical',
+): string {
+  const month = ToZeroPaddedDecimalString(monthDay.ISODate.Month, 2);
+  const day = ToZeroPaddedDecimalString(monthDay.ISODate.Day, 2);
+  let result = `${month}-${day}`;
+  if ((showCalendar === 'always' || showCalendar === 'critical') || monthDay.Calendar !== 'iso8601') {
+    const year = PadISOYear(monthDay.ISODate.Year);
+    result = `${year}-${result}`;
+  }
+  const calendarString = FormatCalendarAnnotation(monthDay.Calendar, showCalendar);
+  return result + calendarString;
+}

package/src/abstract-ops/temporal/plain-time.mts

@@ -0,0 +1,331 @@
+import type { TemporalDurationObject } from '../../intrinsics/Temporal/Duration.mts';
+import { isTemporalPlainDateTimeObject } from '../../intrinsics/Temporal/PlainDateTime.mts';
+import { type TemporalPlainTimeObject, isTemporalPlainTimeObject } from '../../intrinsics/Temporal/PlainTime.mts';
+import { isTemporalZonedDateTimeObject } from '../../intrinsics/Temporal/ZonedDateTime.mts';
+import { ParseISODateTime } from '../../parser/TemporalParser.mts';
+import {
+  abs, floorDiv, max, min, modulo,
+} from '../math.mts';
+import { SnapToInteger } from '../type-conversion.mts';
+import { Decimal } from '../../host-defined/decimal.mts';
+import { type RoundingMode } from './addition.mts';
+import {
+  Assert, type TimeDuration, TimeDurationFromComponents, NanosecondsPerDay, Value, type ValueEvaluator, ObjectValue, Q, GetTemporalOverflowOption, X, GetISODateTimeFor, JSStringValue, Throw, type PlainEvaluator, UndefinedValue, type PlainCompletion, type FunctionObject, surroundingAgent, OrdinaryCreateFromConstructor, type Mutable, Get, FormatTimeString, type TimeUnit, TemporalUnit, Table21_LengthInNanoSeconds, RoundNumberToIncrement, GetDifferenceSettings, RoundTimeDuration, CombineDateAndTimeDuration, ZeroDateDuration, TemporalDurationFromInternal, CreateNegatedTemporalDuration, ToTemporalDuration, ToInternalDurationRecord,
+  type Integer,
+  GetOptionsObject,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-time-records */
+export interface TimeRecord {
+  readonly Days: Integer;
+  readonly Hour: Integer;
+  readonly Minute: Integer;
+  readonly Second: Integer;
+  readonly Millisecond: Integer;
+  readonly Microsecond: Integer;
+  readonly Nanosecond: Integer;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtimerecord */
+export function CreateTimeRecord(hour: Integer, minute: Integer, second: Integer, millisecond: Integer, microsecond: Integer, nanosecond: Integer, deltaDays: Integer = 0n): TimeRecord {
+  Assert(IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond));
+  return {
+    Days: deltaDays,
+    Hour: hour,
+    Minute: minute,
+    Second: second,
+    Millisecond: millisecond,
+    Microsecond: microsecond,
+    Nanosecond: nanosecond,
+  };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-midnighttimerecord */
+export function MidnightTimeRecord(): TimeRecord {
+  return {
+    Days: 0n,
+    Hour: 0n,
+    Minute: 0n,
+    Second: 0n,
+    Millisecond: 0n,
+    Microsecond: 0n,
+    Nanosecond: 0n,
+  };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-noontimerecord */
+export function NoonTimeRecord(): TimeRecord {
+  return {
+    Days: 0n,
+    Hour: 12n,
+    Minute: 0n,
+    Second: 0n,
+    Millisecond: 0n,
+    Microsecond: 0n,
+    Nanosecond: 0n,
+  };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differencetime */
+export function DifferenceTime(time1: TimeRecord, time2: TimeRecord): TimeDuration {
+  const hours = time2.Hour - time1.Hour;
+  const minutes = time2.Minute - time1.Minute;
+  const seconds = time2.Second - time1.Second;
+  const milliseconds = time2.Millisecond - time1.Millisecond;
+  const microseconds = time2.Microsecond - time1.Microsecond;
+  const nanoseconds = time2.Nanosecond - time1.Nanosecond;
+  const timeDuration = TimeDurationFromComponents(hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
+  Assert(abs(timeDuration) < NanosecondsPerDay);
+  return timeDuration;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporaltime */
+export function* ToTemporalTime(item: Value, options: Value = Value.undefined): ValueEvaluator<TemporalPlainTimeObject> {
+  let result;
+  if (item instanceof ObjectValue) {
+    if (isTemporalPlainTimeObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalTime(item.Time));
+    }
+    if (isTemporalPlainDateTimeObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalTime(item.ISODateTime.Time));
+    }
+    if (isTemporalZonedDateTimeObject(item)) {
+      const isoDateTime = GetISODateTimeFor(item.TimeZone, item.EpochNanoseconds);
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalTime(isoDateTime.Time));
+    }
+    const result2 = Q(yield* ToTemporalTimeRecord(item));
+    const resolvedOptions = Q(GetOptionsObject(options));
+    const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+    result = Q(RegulateTime(result2.Hour!, result2.Minute!, result2.Second!, result2.Millisecond!, result2.Microsecond!, result2.Nanosecond!, overflow));
+  } else {
+    if (!(item instanceof JSStringValue)) {
+      return Throw.TypeError('Invalid time string $1', item);
+    }
+    const parseResult = Q(ParseISODateTime(item.stringValue(), ['TemporalTimeString']));
+    Assert(parseResult.Time !== 'start-of-day');
+    result = parseResult.Time;
+    const resolvedOptions = Q(GetOptionsObject(options));
+    Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  }
+  return X(CreateTemporalTime(result));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totimerecordormidnight */
+export function* ToTimeRecordOrMidnight(item: Value): PlainEvaluator<TimeRecord> {
+  if (item instanceof UndefinedValue) {
+    return MidnightTimeRecord();
+  }
+  const plainTime = Q(yield* ToTemporalTime(item));
+  return plainTime.Time;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-regulatetime */
+export function RegulateTime(hour: Integer, minute: Integer, second: Integer, millisecond: Integer, microsecond: Integer, nanosecond: Integer, overflow: 'constrain' | 'reject'): PlainCompletion<TimeRecord> {
+  if (overflow === 'constrain') {
+    hour = max(0n, min(23n, hour));
+    minute = max(0n, min(59n, minute));
+    second = max(0n, min(59n, second));
+    millisecond = max(0n, min(999n, millisecond));
+    microsecond = max(0n, min(999n, microsecond));
+    nanosecond = max(0n, min(999n, nanosecond));
+  } else {
+    Assert(overflow === 'reject');
+    if (!IsValidTime(hour, minute, second, millisecond, microsecond, nanosecond)) {
+      return Throw.RangeError('Invalid time');
+    }
+  }
+  return CreateTimeRecord(hour, minute, second, millisecond, microsecond, nanosecond);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-isvalidtime */
+export function IsValidTime(hour: Integer, minute: Integer, second: Integer, millisecond: Integer, microsecond: Integer, nanosecond: Integer): boolean {
+  if (hour < 0n || hour > 23n) return false;
+  if (minute < 0n || minute > 59n) return false;
+  if (second < 0n || second > 59n) return false;
+  if (millisecond < 0n || millisecond > 999n) return false;
+  if (microsecond < 0n || microsecond > 999n) return false;
+  if (nanosecond < 0n || nanosecond > 999n) return false;
+  return true;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-balancetime */
+export function BalanceTime(hour: Integer, minute: Integer, second: Integer, millisecond: Integer, microsecond: Integer, nanosecond: Integer): TimeRecord {
+  microsecond += floorDiv(nanosecond, 1000n);
+  nanosecond = modulo(nanosecond, 1000n);
+  millisecond += floorDiv(microsecond, 1000n);
+  microsecond = modulo(microsecond, 1000n);
+  second += floorDiv(millisecond, 1000n);
+  millisecond = modulo(millisecond, 1000n);
+  minute += floorDiv(second, 60n);
+  second = modulo(second, 60n);
+  hour += floorDiv(minute, 60n);
+  minute = modulo(minute, 60n);
+  const deltaDays = floorDiv(hour, 24n);
+  hour = modulo(hour, 24n);
+  return CreateTimeRecord(hour, minute, second, millisecond, microsecond, nanosecond, deltaDays);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtemporaltime */
+export function* CreateTemporalTime(time: TimeRecord, newTarget?: FunctionObject): ValueEvaluator<TemporalPlainTimeObject> {
+  if (newTarget === undefined) {
+    newTarget = surroundingAgent.intrinsic('%Temporal.PlainTime%');
+  }
+  const object = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%Temporal.PlainTime.prototype%', [
+    'InitializedTemporalTime',
+    'Time',
+  ])) as Mutable<TemporalPlainTimeObject>;
+  object.Time = time;
+  return object;
+}
+
+/** https://tc39.es/proposal-temporal/#table-temporal-temporaltimelike-record-fields */
+export interface TemporalTimeLike {
+  Hour: bigint | undefined;
+  Minute: bigint | undefined;
+  Second: bigint | undefined;
+  Millisecond: bigint | undefined;
+  Microsecond: bigint | undefined;
+  Nanosecond: bigint | undefined;
+}
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporaltimerecord */
+export function* ToTemporalTimeRecord(temporalTimeLike: ObjectValue, completeness: 'partial' | 'complete' = 'complete'): PlainEvaluator<TemporalTimeLike> {
+  const result: Mutable<TemporalTimeLike> = {
+    Hour: undefined,
+    Minute: undefined,
+    Second: undefined,
+    Millisecond: undefined,
+    Microsecond: undefined,
+    Nanosecond: undefined,
+  };
+  if (completeness === 'complete') {
+    result.Hour = 0n;
+    result.Minute = 0n;
+    result.Second = 0n;
+    result.Millisecond = 0n;
+    result.Microsecond = 0n;
+    result.Nanosecond = 0n;
+  }
+  let any = false;
+  const hour = Q(yield* Get(temporalTimeLike, Value('hour')));
+  if (!(hour instanceof UndefinedValue)) {
+    result.Hour = Q(yield* SnapToInteger(hour, 'truncate-strict'));
+    any = true;
+  }
+  const microsecond = Q(yield* Get(temporalTimeLike, Value('microsecond')));
+  if (!(microsecond instanceof UndefinedValue)) {
+    result.Microsecond = Q(yield* SnapToInteger(microsecond, 'truncate-strict'));
+    any = true;
+  }
+  const millisecond = Q(yield* Get(temporalTimeLike, Value('millisecond')));
+  if (!(millisecond instanceof UndefinedValue)) {
+    result.Millisecond = Q(yield* SnapToInteger(millisecond, 'truncate-strict'));
+    any = true;
+  }
+  const minute = Q(yield* Get(temporalTimeLike, Value('minute')));
+  if (!(minute instanceof UndefinedValue)) {
+    result.Minute = Q(yield* SnapToInteger(minute, 'truncate-strict'));
+    any = true;
+  }
+  const nanosecond = Q(yield* Get(temporalTimeLike, Value('nanosecond')));
+  if (!(nanosecond instanceof UndefinedValue)) {
+    result.Nanosecond = Q(yield* SnapToInteger(nanosecond, 'truncate-strict'));
+    any = true;
+  }
+  const second = Q(yield* Get(temporalTimeLike, Value('second')));
+  if (!(second instanceof UndefinedValue)) {
+    result.Second = Q(yield* SnapToInteger(second, 'truncate-strict'));
+    any = true;
+  }
+  if (!any) {
+    return Throw.TypeError('$1 does not look like a TemporalTimeLike object', temporalTimeLike);
+  }
+  return result;
+}
+
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-timerecordtostring */
+export function TimeRecordToString(time: TimeRecord, precision: Integer | TemporalUnit.Minute | 'auto'): string {
+  const subSecondNanoseconds = time.Millisecond * BigInt(1e6) + time.Microsecond * BigInt(1e3) + time.Nanosecond;
+  return FormatTimeString(time.Hour, time.Minute, time.Second, subSecondNanoseconds, precision);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-comparetimerecord */
+export function CompareTimeRecord(time1: TimeRecord, time2: TimeRecord): -1n | 0n | 1n {
+  if (time1.Hour > time2.Hour) return 1n;
+  if (time1.Hour < time2.Hour) return -1n;
+  if (time1.Minute > time2.Minute) return 1n;
+  if (time1.Minute < time2.Minute) return -1n;
+  if (time1.Second > time2.Second) return 1n;
+  if (time1.Second < time2.Second) return -1n;
+  if (time1.Millisecond > time2.Millisecond) return 1n;
+  if (time1.Millisecond < time2.Millisecond) return -1n;
+  if (time1.Microsecond > time2.Microsecond) return 1n;
+  if (time1.Microsecond < time2.Microsecond) return -1n;
+  if (time1.Nanosecond > time2.Nanosecond) return 1n;
+  if (time1.Nanosecond < time2.Nanosecond) return -1n;
+  return 0n;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-addtime */
+export function AddTime(time: TimeRecord, timeDuration: TimeDuration): TimeRecord {
+  return BalanceTime(time.Hour, time.Minute, time.Second, time.Millisecond, time.Microsecond, time.Nanosecond + timeDuration);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-roundtime */
+export function RoundTime(time: TimeRecord, increment: Integer, unit: TimeUnit | TemporalUnit.Day, roundingMode: RoundingMode): TimeRecord {
+  let quantity: bigint;
+  if (unit === TemporalUnit.Day || unit === TemporalUnit.Hour) {
+    quantity = (((((time.Hour * 60n + time.Minute) * 60n + time.Second) * 1000n + time.Millisecond) * 1000n + time.Microsecond) * 1000n + time.Nanosecond);
+  } else if (unit === TemporalUnit.Minute) {
+    quantity = ((((time.Minute * 60n + time.Second) * 1000n + time.Millisecond) * 1000n + time.Microsecond) * 1000n + time.Nanosecond);
+  } else if (unit === TemporalUnit.Second) {
+    quantity = (((time.Second * 1000n + time.Millisecond) * 1000n + time.Microsecond) * 1000n + time.Nanosecond);
+  } else if (unit === TemporalUnit.Millisecond) {
+    quantity = ((time.Millisecond * 1000n + time.Microsecond) * 1000n + time.Nanosecond);
+  } else if (unit === TemporalUnit.Microsecond) {
+    quantity = time.Microsecond * 1000n + time.Nanosecond;
+  } else {
+    Assert(unit === TemporalUnit.Nanosecond);
+    quantity = time.Nanosecond;
+  }
+  const unitLength = Table21_LengthInNanoSeconds[unit];
+  const result = RoundNumberToIncrement(Decimal(quantity), increment * unitLength, roundingMode) / unitLength;
+  if (unit === TemporalUnit.Day) return CreateTimeRecord(0n, 0n, 0n, 0n, 0n, 0n, result);
+  if (unit === TemporalUnit.Hour) return BalanceTime(result, 0n, 0n, 0n, 0n, 0n);
+  if (unit === TemporalUnit.Minute) return BalanceTime(time.Hour, result, 0n, 0n, 0n, 0n);
+  if (unit === TemporalUnit.Second) return BalanceTime(time.Hour, time.Minute, result, 0n, 0n, 0n);
+  if (unit === TemporalUnit.Millisecond) return BalanceTime(time.Hour, time.Minute, time.Second, result, 0n, 0n);
+  if (unit === TemporalUnit.Microsecond) return BalanceTime(time.Hour, time.Minute, time.Second, time.Millisecond, result, 0n);
+  Assert(unit === TemporalUnit.Nanosecond);
+  return BalanceTime(time.Hour, time.Minute, time.Second, time.Millisecond, time.Microsecond, result);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaintime */
+export function* DifferenceTemporalPlainTime(operation: 'since' | 'until', temporalTime: TemporalPlainTimeObject, _other: Value, options: Value): ValueEvaluator<TemporalDurationObject> {
+  const other = Q(yield* ToTemporalTime(_other));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const settings = Q(yield* GetDifferenceSettings(operation, resolvedOptions, 'time', [], TemporalUnit.Nanosecond, TemporalUnit.Hour));
+  let timeDuration = DifferenceTime(temporalTime.Time, other.Time);
+  timeDuration = X(RoundTimeDuration(timeDuration, settings.RoundingIncrement, settings.SmallestUnit as TimeUnit, settings.RoundingMode));
+  const duration = CombineDateAndTimeDuration(ZeroDateDuration(), timeDuration);
+  let result = X(TemporalDurationFromInternal(duration, settings.LargestUnit));
+  if (operation === 'since') {
+    result = CreateNegatedTemporalDuration(result);
+  }
+  return result;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-adddurationtotime */
+export function* AddDurationToTime(operation: 'add' | 'subtract', temporalTime: TemporalPlainTimeObject, temporalDurationLike: Value): ValueEvaluator<TemporalPlainTimeObject> {
+  let duration = Q(yield* ToTemporalDuration(temporalDurationLike));
+  if (operation === 'subtract') duration = CreateNegatedTemporalDuration(duration);
+  const internalDuration = ToInternalDurationRecord(duration);
+  const result = AddTime(temporalTime.Time, internalDuration.Time);
+  return X(CreateTemporalTime(result));
+}