@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/temporal/instant.mts

@@ -0,0 +1,174 @@
+import type { TemporalDurationObject } from '../../intrinsics/Temporal/Duration.mts';
+import { type TemporalInstantObject, isTemporalInstantObject } from '../../intrinsics/Temporal/Instant.mts';
+import { isTemporalZonedDateTimeObject } from '../../intrinsics/Temporal/ZonedDateTime.mts';
+import { ParseISODateTime, ParseDateTimeUTCOffset } from '../../parser/TemporalParser.mts';
+import { Decimal } from '../../host-defined/decimal.mts';
+import {
+  GetUTCEpochNanoseconds, RoundingMode, type TimeZoneIdentifier,
+} from './addition.mts';
+import {
+  type FunctionObject, type ValueEvaluator, Assert, surroundingAgent, Q, OrdinaryCreateFromConstructor, type Mutable, Value, ObjectValue, X, ToPrimitive, JSStringValue, Throw, CheckISODaysRange, type TimeDuration, type PlainCompletion, AddTimeDurationToEpochNanoseconds, type TimeUnit, type InternalDurationRecord, TimeDurationFromEpochNanosecondsDifference, RoundTimeDuration, CombineDateAndTimeDuration, ZeroDateDuration, Table21_LengthInNanoSeconds, RoundNumberToIncrementAsIfPositive, GetISODateTimeFor, GetOffsetNanosecondsFor, FormatDateTimeUTCOffsetRounded, GetDifferenceSettings, TemporalUnit, TemporalDurationFromInternal, CreateNegatedTemporalDuration, ToTemporalDuration, DefaultTemporalLargestUnit, isDateUnit, ToInternalDurationRecordWith24HourDays, MinEpochNanoseconds, MaxEpochNanoseconds,
+  BalanceISODateTime,
+  FormatISODateTime,
+  type EpochNanoseconds,
+  type Integer,
+  GetOptionsObject,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-isvalidepochnanoseconds */
+export function IsValidEpochNanoseconds(epochNanoseconds: EpochNanoseconds): boolean {
+  if (epochNanoseconds < MinEpochNanoseconds || epochNanoseconds > MaxEpochNanoseconds) {
+    return false;
+  }
+  return true;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtemporalinstant */
+export function* CreateTemporalInstant(epochNanoseconds: EpochNanoseconds, newTarget?: FunctionObject): ValueEvaluator<TemporalInstantObject> {
+  Assert(IsValidEpochNanoseconds(epochNanoseconds));
+  if (newTarget === undefined) {
+    newTarget = surroundingAgent.intrinsic('%Temporal.Instant%');
+  }
+  const object = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%Temporal.Instant.prototype%', [
+    'InitializedTemporalInstant',
+    'EpochNanoseconds',
+  ])) as Mutable<TemporalInstantObject>;
+  object.EpochNanoseconds = epochNanoseconds;
+  return object;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporalinstant */
+export function* ToTemporalInstant(item: Value): ValueEvaluator<TemporalInstantObject> {
+  if (item instanceof ObjectValue) {
+    if (isTemporalInstantObject(item) || isTemporalZonedDateTimeObject(item)) {
+      return X(CreateTemporalInstant(item.EpochNanoseconds));
+    }
+    item = Q(yield* ToPrimitive(item, 'string'));
+  }
+  if (!(item instanceof JSStringValue)) {
+    return Throw.TypeError('$1 is not a string', item);
+  }
+  const parsed = Q(ParseISODateTime(item.stringValue(), ['TemporalInstantString']));
+  // Assert: Either parsed.[[TimeZone]].[[OffsetString]] is not empty or parsed.[[TimeZone]].[[Z]] is true, but not both.
+  {
+    const a = parsed.TimeZone.OffsetString !== undefined;
+    const b = parsed.TimeZone.Z;
+    Assert((a || b) && !(a && b));
+  }
+  const OffsetString = parsed.TimeZone.OffsetString!;
+  const offsetNanoseconds = parsed.TimeZone.Z ? 0n : X(ParseDateTimeUTCOffset(OffsetString));
+  const time = parsed.Time;
+  Assert(time !== 'start-of-day');
+  const balanced = BalanceISODateTime(parsed.Year!, parsed.Month, parsed.Day, time.Hour, time.Minute, time.Second, time.Millisecond, time.Microsecond, time.Nanosecond - offsetNanoseconds);
+  Q(CheckISODaysRange(balanced.ISODate));
+  const epochNanoseconds = GetUTCEpochNanoseconds(balanced);
+  if (!IsValidEpochNanoseconds(epochNanoseconds)) {
+    return Throw.RangeError('$1 is not a valid epoch nanoseconds', epochNanoseconds);
+  }
+  return X(CreateTemporalInstant(epochNanoseconds));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-compareepochnanoseconds */
+export function CompareEpochNanoseconds(epochNanosecondsOne: EpochNanoseconds, epochNanosecondsTwo: EpochNanoseconds): -1 | 0 | 1 {
+  if (epochNanosecondsOne > epochNanosecondsTwo) {
+    return 1;
+  }
+  if (epochNanosecondsOne < epochNanosecondsTwo) {
+    return -1;
+  }
+  return 0;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-addepochnanoseconds */
+export function AddEpochNanoseconds(epochNanoseconds: EpochNanoseconds, timeDuration: TimeDuration): PlainCompletion<EpochNanoseconds> {
+  const result = AddTimeDurationToEpochNanoseconds(timeDuration, epochNanoseconds);
+  if (!IsValidEpochNanoseconds(result)) {
+    return Throw.RangeError('$1 is not a valid epoch nanoseconds', result);
+  }
+  return result;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differenceinstant */
+export function DifferenceEpochNanoseconds(
+  ns1: EpochNanoseconds,
+  ns2: EpochNanoseconds,
+  roundingIncrement: Integer,
+  smallestUnit: TimeUnit,
+  roundingMode: RoundingMode,
+): InternalDurationRecord {
+  let timeDuration = TimeDurationFromEpochNanosecondsDifference(ns2, ns1);
+  timeDuration = X(RoundTimeDuration(timeDuration, roundingIncrement, smallestUnit, roundingMode));
+  return CombineDateAndTimeDuration(ZeroDateDuration(), timeDuration);
+}
+
+/** https://tc39.es/ecma262/pr/3759/#sec-roundepochnanoseconds */
+export function RoundEpochNanoseconds(
+  epochNanoseconds: EpochNanoseconds,
+  increment: Integer,
+  unit: TimeUnit,
+  roundingMode: RoundingMode,
+): EpochNanoseconds {
+  const unitLength = Table21_LengthInNanoSeconds[unit];
+  const incrementNs = increment * unitLength;
+  return BigInt(RoundNumberToIncrementAsIfPositive(Decimal(epochNanoseconds), incrementNs, roundingMode));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-temporalinstant-tostring */
+export function TemporalInstantToString(
+  instant: TemporalInstantObject,
+  timeZone: TimeZoneIdentifier | undefined,
+  precision: Integer | TemporalUnit.Minute | 'auto',
+): string {
+  let outputTimeZone = timeZone;
+  if (outputTimeZone === undefined) {
+    outputTimeZone = 'UTC' as TimeZoneIdentifier;
+  }
+  const epochNs = instant.EpochNanoseconds;
+  const isoDateTime = GetISODateTimeFor(outputTimeZone, epochNs);
+  const dateTimeString = FormatISODateTime(isoDateTime, 'iso8601', precision, 'never');
+  let timeZoneString;
+  if (timeZone === undefined) {
+    timeZoneString = 'Z';
+  } else {
+    const offsetNanoseconds = GetOffsetNanosecondsFor(outputTimeZone, epochNs);
+    timeZoneString = FormatDateTimeUTCOffsetRounded(offsetNanoseconds);
+  }
+  return dateTimeString + timeZoneString;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalinstant */
+export function* DifferenceTemporalInstant(
+  operation: 'since' | 'until',
+  instant: TemporalInstantObject,
+  _other: Value,
+  options: Value,
+): ValueEvaluator<TemporalDurationObject> {
+  const other = Q(yield* ToTemporalInstant(_other));
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const settings = Q(yield* GetDifferenceSettings(operation, resolvedOptions, 'time', [], TemporalUnit.Nanosecond, TemporalUnit.Second));
+  const internalDuration = DifferenceEpochNanoseconds(instant.EpochNanoseconds, other.EpochNanoseconds, settings.RoundingIncrement, settings.SmallestUnit as TimeUnit, settings.RoundingMode);
+  let result = X(TemporalDurationFromInternal(internalDuration, settings.LargestUnit));
+  if (operation === 'since') {
+    result = CreateNegatedTemporalDuration(result);
+  }
+  return result;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-adddurationtoinstant */
+export function* AddDurationToInstant(
+  operation: 'add' | 'subtract',
+  instant: TemporalInstantObject,
+  temporalDurationLike: Value,
+): ValueEvaluator<TemporalInstantObject> {
+  let duration = Q(yield* ToTemporalDuration(temporalDurationLike));
+  if (operation === 'subtract') {
+    duration = CreateNegatedTemporalDuration(duration);
+  }
+  const largestUnit = DefaultTemporalLargestUnit(duration);
+  if (isDateUnit(largestUnit)) {
+    return Throw.RangeError('Cannot add a date to an instant');
+  }
+  const internalDuration = ToInternalDurationRecordWith24HourDays(duration);
+  const ns = Q(AddEpochNanoseconds(instant.EpochNanoseconds, internalDuration.Time));
+  return X(CreateTemporalInstant(ns));
+}

package/src/abstract-ops/temporal/not-implemented.mts

@@ -0,0 +1,15 @@
+export function mark_TimeZoneAwareNotImplemented() {
+  'Time zone aware operations are not implemented in this engine.';
+}
+
+export function mark_OtherCalendarNotImplemented() {
+  'Other calendar than iso8601 are not implemented in this engine.';
+}
+
+export function unreachable_OtherCalendarNotImplemented(): never {
+  throw new Error('Calendar other than ISO8601 is not supported, but this error should never triggered by the user code.');
+}
+
+export function temporal_todo(): never {
+  throw new Error('This Temporal operation is not implemented yet.');
+}

package/src/abstract-ops/temporal/now.mts

@@ -0,0 +1,46 @@
+import type { ISODateTimeRecord } from '../../intrinsics/Temporal/PlainDateTime.mts';
+import { clamp, floorDiv } from '../math.mts';
+import { SystemTimeZoneIdentifier } from './addition.mts';
+import {
+  ObjectValue, GetGlobalObject, Value, type PlainCompletion, Q, ToTemporalTimeZoneIdentifier, GetISODateTimeFor,
+  surroundingAgent,
+  MinEpochNanoseconds,
+  MaxEpochNanoseconds,
+  type EpochNanoseconds,
+  type IntegralNumber,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-hostsystemutcepochnanoseconds */
+export function HostSystemUTCEpochNanoseconds(global: ObjectValue): EpochNanoseconds {
+  let host = surroundingAgent.hostDefinedOptions.hostHooks?.HostSystemUTCEpochNanoseconds?.(global);
+  if (host === undefined) {
+    host = BigInt(Date.now()) * BigInt(1e6) as EpochNanoseconds;
+  }
+  return clamp(MinEpochNanoseconds, host, MaxEpochNanoseconds);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-systemutcepochmilliseconds */
+export function SystemUTCEpochMilliseconds(): IntegralNumber {
+  const global = GetGlobalObject();
+  const nowNs = HostSystemUTCEpochNanoseconds(global);
+  return Number(floorDiv(nowNs, BigInt(1e6)));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-systemutcepochnanoseconds */
+export function SystemUTCEpochNanoseconds(): EpochNanoseconds {
+  const global = GetGlobalObject();
+  const nowNs = HostSystemUTCEpochNanoseconds(global);
+  return nowNs;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-systemdatetime */
+export function SystemDateTime(temporalTimeZoneLike: Value): PlainCompletion<ISODateTimeRecord> {
+  let timeZone;
+  if (temporalTimeZoneLike === Value.undefined) {
+    timeZone = SystemTimeZoneIdentifier();
+  } else {
+    timeZone = Q(ToTemporalTimeZoneIdentifier(temporalTimeZoneLike));
+  }
+  const epochNs = SystemUTCEpochNanoseconds();
+  return GetISODateTimeFor(timeZone, epochNs);
+}

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

@@ -0,0 +1,242 @@
+import type { TemporalDurationObject } from '../../intrinsics/Temporal/Duration.mts';
+import { type ISODateRecord, isTemporalPlainDateObject } from '../../intrinsics/Temporal/PlainDate.mts';
+import { type ISODateTimeRecord, type TemporalPlainDateTimeObject, isTemporalPlainDateTimeObject } from '../../intrinsics/Temporal/PlainDateTime.mts';
+import { isTemporalZonedDateTimeObject } from '../../intrinsics/Temporal/ZonedDateTime.mts';
+import { ParseISODateTime } from '../../parser/TemporalParser.mts';
+import { abs } from '../math.mts';
+import { Decimal } from '../../host-defined/decimal.mts';
+import {
+  GetUTCEpochNanoseconds, ToZeroPaddedDecimalString, type RoundingMode,
+} from './addition.mts';
+import {
+  CreateISODateRecord, YearFromTime, MonthFromTime, DateFromTime, CreateTimeRecord, HourFromTime, MinFromTime, SecFromTime, MillisecFromTime, type TimeRecord, ISODateToEpochDays, MinEpochNanoseconds, NanosecondsPerDay, MaxEpochNanoseconds, type CalendarType, type CalendarFieldsRecord, type PlainEvaluator, Q, CalendarDateFromFields, RegulateTime, Value, ObjectValue, GetTemporalOverflowOption, X, GetISODateTimeFor, MidnightTimeRecord, GetTemporalCalendarIdentifierWithISODefault, PrepareCalendarFields, JSStringValue, Throw, CanonicalizeCalendar, BalanceTime, AddDaysToISODate, type FunctionObject, surroundingAgent, OrdinaryCreateFromConstructor, type Mutable, PadISOYear, FormatTimeString, FormatCalendarAnnotation, CompareISODate, CompareTimeRecord, type TimeUnit, TemporalUnit, Assert, RoundTime, type InternalDurationRecord, DifferenceTime, TimeDurationSign, Add24HourDaysToTimeDuration, LargerOfTwoTemporalUnits, CalendarDateUntil, type DateUnit, CombineDateAndTimeDuration, type PlainCompletion, ZeroDateDuration, RoundRelativeDuration, TotalRelativeDuration, type ValueEvaluator, CalendarEquals, GetDifferenceSettings, CreateTemporalDuration, TemporalDurationFromInternal, CreateNegatedTemporalDuration, ToTemporalDuration, ToInternalDurationRecordWith24HourDays, AddTime, AdjustDateDurationRecord, CalendarDateAdd,
+  type Integer,
+  type FiniteTimeValue,
+  type MathematicalValue,
+  EpochDaysToEpochMs,
+  EpochTimeToEpochYear,
+  EpochTimeToMonthInYear,
+  EpochTimeToDate,
+  GetOptionsObject,
+} from '#self';
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-timevaluetoisodatetimerecord */
+export function TimeValueToISODateTimeRecord(t: FiniteTimeValue): ISODateTimeRecord {
+  const isoDate = CreateISODateRecord(
+    YearFromTime(t),
+    MonthFromTime(t) + 1n,
+    DateFromTime(t),
+  );
+  const time = CreateTimeRecord(HourFromTime(t), MinFromTime(t), SecFromTime(t), MillisecFromTime(t), 0n, 0n);
+  return { ISODate: isoDate, Time: time };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-combineisodateandtimerecord */
+export function CombineISODateAndTimeRecord(isoDate: ISODateRecord, time: TimeRecord): ISODateTimeRecord {
+  return { ISODate: isoDate, Time: time };
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-isodatetimewithinlimits */
+export function ISODateTimeWithinLimits(isoDateTime: ISODateTimeRecord): boolean {
+  if (abs(ISODateToEpochDays(isoDateTime.ISODate.Year, isoDateTime.ISODate.Month - 1n, isoDateTime.ISODate.Day)) > (1e8 + 1)) {
+    return false;
+  }
+  const epochNanoseconds = GetUTCEpochNanoseconds(isoDateTime);
+  if (epochNanoseconds <= (MinEpochNanoseconds - NanosecondsPerDay)) return false;
+  if (epochNanoseconds >= (MaxEpochNanoseconds + NanosecondsPerDay)) return false;
+  return true;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-interprettemporaldatetimefields */
+export function* InterpretTemporalDateTimeFields(calendar: CalendarType, fields: CalendarFieldsRecord, overflow: 'constrain' | 'reject'): PlainEvaluator<ISODateTimeRecord> {
+  Assert(fields.Hour !== undefined && fields.Minute !== undefined && fields.Second !== undefined && fields.Millisecond !== undefined && fields.Microsecond !== undefined && fields.Nanosecond !== undefined);
+  const isoDate = Q(yield* CalendarDateFromFields(calendar, fields, overflow));
+  const time = Q(RegulateTime(fields.Hour!, fields.Minute!, fields.Second!, fields.Millisecond!, fields.Microsecond!, fields.Nanosecond!, overflow));
+  return CombineISODateAndTimeRecord(isoDate, time);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-totemporaldatetime */
+export function* ToTemporalDateTime(item: Value, options: Value = Value.undefined): PlainEvaluator<TemporalPlainDateTimeObject> {
+  if (item instanceof ObjectValue) {
+    if (isTemporalPlainDateTimeObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalDateTime(item.ISODateTime, item.Calendar));
+    }
+    if (isTemporalZonedDateTimeObject(item)) {
+      const isoDateTime = GetISODateTimeFor(item.TimeZone, item.EpochNanoseconds);
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      return X(CreateTemporalDateTime(isoDateTime, item.Calendar));
+    }
+    if (isTemporalPlainDateObject(item)) {
+      const resolvedOptions = Q(GetOptionsObject(options));
+      Q(yield* GetTemporalOverflowOption(resolvedOptions));
+      const isoDateTime = CombineISODateAndTimeRecord(item.ISODate, MidnightTimeRecord());
+      return Q(yield* CreateTemporalDateTime(isoDateTime, item.Calendar));
+    }
+    const calendar = Q(yield* GetTemporalCalendarIdentifierWithISODefault(item));
+    const fields = Q(yield* PrepareCalendarFields(calendar, item, ['year', 'month', 'month-code', 'day'], ['hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond'], []));
+    const resolvedOptions = Q(GetOptionsObject(options));
+    const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+    const result = Q(yield* InterpretTemporalDateTimeFields(calendar, fields, overflow));
+    return Q(yield* CreateTemporalDateTime(result, calendar));
+  }
+  if (!(item instanceof JSStringValue)) {
+    return Throw.TypeError('$1 is not a string', item);
+  }
+  const result = Q(ParseISODateTime(item.stringValue(), ['TemporalDateTimeString[~Zoned]']));
+  const time = result.Time === 'start-of-day' ? MidnightTimeRecord() : result.Time;
+  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);
+  const isoDateTime = CombineISODateAndTimeRecord(isoDate, time);
+  return Q(yield* CreateTemporalDateTime(isoDateTime, calendarType));
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-balanceisodatetime */
+export function BalanceISODateTime(year: Integer, month: Integer, day: Integer, hour: Integer, minute: Integer, second: Integer, millisecond: Integer, microsecond: Integer, nanosecond: Integer): ISODateTimeRecord {
+  const balancedTime = BalanceTime(hour, minute, second, millisecond, microsecond, nanosecond);
+  const epochDays = ISODateToEpochDays(year, month - 1n, day) + balancedTime.Days;
+  const epochMilliseconds = EpochDaysToEpochMs(epochDays, 0n);
+  const balancedDate = CreateISODateRecord(EpochTimeToEpochYear(epochMilliseconds), EpochTimeToMonthInYear(epochMilliseconds) + 1n, EpochTimeToDate(epochMilliseconds));
+  return CombineISODateAndTimeRecord(balancedDate, balancedTime);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-createtemporaldatetime */
+export function* CreateTemporalDateTime(isoDateTime: ISODateTimeRecord, calendar: CalendarType, newTarget?: FunctionObject): PlainEvaluator<TemporalPlainDateTimeObject> {
+  if (!ISODateTimeWithinLimits(isoDateTime)) {
+    return Throw.RangeError('PlainDateTime outside of range');
+  }
+  if (newTarget === undefined) {
+    newTarget = surroundingAgent.intrinsic('%Temporal.PlainDateTime%');
+  }
+  const object = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%Temporal.PlainDateTime.prototype%', [
+    'InitializedTemporalDateTime',
+    'ISODateTime',
+    'Calendar',
+  ])) as Mutable<TemporalPlainDateTimeObject>;
+  object.ISODateTime = isoDateTime;
+  object.Calendar = calendar;
+  return object;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-formatisodatetime */
+export function FormatISODateTime(isoDateTime: ISODateTimeRecord, calendar: CalendarType, precision: Integer | TemporalUnit.Minute | 'auto', showCalendar: 'auto' | 'always' | 'never' | 'critical'): string {
+  const yearString = PadISOYear(isoDateTime.ISODate.Year);
+  const monthString = ToZeroPaddedDecimalString(isoDateTime.ISODate.Month, 2);
+  const dayString = ToZeroPaddedDecimalString(isoDateTime.ISODate.Day, 2);
+  const subSecondNanoseconds = isoDateTime.Time.Millisecond * BigInt(1e6) + isoDateTime.Time.Microsecond * BigInt(1e3) + isoDateTime.Time.Nanosecond;
+  const timeString = FormatTimeString(isoDateTime.Time.Hour, isoDateTime.Time.Minute, isoDateTime.Time.Second, subSecondNanoseconds, precision);
+  const calendarString = FormatCalendarAnnotation(calendar, showCalendar);
+  return `${yearString}-${monthString}-${dayString}T${timeString}${calendarString}`;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-compareisodatetime */
+export function CompareISODateTime(isoDateTime1: ISODateTimeRecord, isoDateTime2: ISODateTimeRecord): 1n | -1n | 0n {
+  const dateResult = CompareISODate(isoDateTime1.ISODate, isoDateTime2.ISODate);
+  if (dateResult !== 0n) {
+    return dateResult;
+  }
+  return CompareTimeRecord(isoDateTime1.Time, isoDateTime2.Time);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-roundisodatetime */
+export function RoundISODateTime(isoDateTime: ISODateTimeRecord, increment: Integer, unit: TimeUnit | TemporalUnit.Day, roundingMode: RoundingMode): ISODateTimeRecord {
+  Assert(ISODateTimeWithinLimits(isoDateTime));
+  const roundedTime = RoundTime(isoDateTime.Time, increment, unit, roundingMode);
+  const balanceResult = AddDaysToISODate(isoDateTime.ISODate, roundedTime.Days);
+  return CombineISODateAndTimeRecord(balanceResult, roundedTime);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differenceisodatetime */
+export function DifferenceISODateTime(isoDateTime1: ISODateTimeRecord, isoDateTime2: ISODateTimeRecord, calendar: CalendarType, largestUnit: TemporalUnit): InternalDurationRecord {
+  Assert(ISODateTimeWithinLimits(isoDateTime1));
+  Assert(ISODateTimeWithinLimits(isoDateTime2));
+  let timeDuration = DifferenceTime(isoDateTime1.Time, isoDateTime2.Time);
+  const timeSign = TimeDurationSign(timeDuration);
+  const dateSign = CompareISODate(isoDateTime1.ISODate, isoDateTime2.ISODate);
+  let adjustedDate = isoDateTime2.ISODate;
+  if (timeSign === dateSign) {
+    adjustedDate = AddDaysToISODate(adjustedDate, timeSign);
+    timeDuration = X(Add24HourDaysToTimeDuration(timeDuration, -timeSign));
+  }
+  const dateLargestUnit = LargerOfTwoTemporalUnits(TemporalUnit.Day, largestUnit);
+  const dateDifference = CalendarDateUntil(calendar, isoDateTime1.ISODate, adjustedDate, dateLargestUnit as DateUnit);
+  if (largestUnit !== dateLargestUnit) {
+    timeDuration = X(Add24HourDaysToTimeDuration(timeDuration, BigInt(dateDifference.Days)));
+    dateDifference.Days = 0;
+  }
+  return CombineDateAndTimeDuration(dateDifference, timeDuration);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differenceplaindatetimewithrounding */
+export function DifferencePlainDateTimeWithRounding(isoDateTime1: ISODateTimeRecord, isoDateTime2: ISODateTimeRecord, calendar: CalendarType, largestUnit: TemporalUnit, roundingIncrement: Integer, smallestUnit: TemporalUnit, roundingMode: RoundingMode): PlainCompletion<InternalDurationRecord> {
+  if (CompareISODateTime(isoDateTime1, isoDateTime2) === 0n) {
+    return CombineDateAndTimeDuration(ZeroDateDuration(), 0n);
+  }
+  if (!ISODateTimeWithinLimits(isoDateTime1) || !ISODateTimeWithinLimits(isoDateTime2)) {
+    return Throw.RangeError('PlainDateTime outside of range');
+  }
+  const diff = DifferenceISODateTime(isoDateTime1, isoDateTime2, calendar, largestUnit);
+  if (smallestUnit === TemporalUnit.Nanosecond && roundingIncrement === 1n) {
+    return diff;
+  }
+  const originEpochNs = GetUTCEpochNanoseconds(isoDateTime1);
+  const destEpochNs = GetUTCEpochNanoseconds(isoDateTime2);
+  return RoundRelativeDuration(diff, originEpochNs, destEpochNs, isoDateTime1, undefined, calendar, largestUnit, roundingIncrement, smallestUnit, roundingMode);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differenceplaindatetimewithtotal */
+export function DifferencePlainDateTimeWithTotal(isoDateTime1: ISODateTimeRecord, isoDateTime2: ISODateTimeRecord, calendar: CalendarType, unit: TemporalUnit): PlainCompletion<MathematicalValue> {
+  if (CompareISODateTime(isoDateTime1, isoDateTime2) === 0n) {
+    return Decimal(0);
+  }
+  if (!ISODateTimeWithinLimits(isoDateTime1) || !ISODateTimeWithinLimits(isoDateTime2)) {
+    return Throw.RangeError('PlainDateTime outside of range');
+  }
+  const diff = DifferenceISODateTime(isoDateTime1, isoDateTime2, calendar, unit);
+  if (unit === TemporalUnit.Nanosecond) {
+    return Decimal(diff.Time);
+  }
+  const originEpochNs = GetUTCEpochNanoseconds(isoDateTime1);
+  const destEpochNs = GetUTCEpochNanoseconds(isoDateTime2);
+  return TotalRelativeDuration(diff, originEpochNs, destEpochNs, isoDateTime1, undefined, calendar, unit);
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaindatetime */
+export function* DifferenceTemporalPlainDateTime(operation: 'since' | 'until', dateTime: TemporalPlainDateTimeObject, _other: Value, options: Value): ValueEvaluator<TemporalDurationObject> {
+  const other = Q(yield* ToTemporalDateTime(_other));
+  if (!CalendarEquals(dateTime.Calendar, other.Calendar)) {
+    return Throw.RangeError('Calendars are not equal');
+  }
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const settings = Q(yield* GetDifferenceSettings(operation, resolvedOptions, 'datetime', [], TemporalUnit.Nanosecond, TemporalUnit.Day));
+  if (CompareISODateTime(dateTime.ISODateTime, other.ISODateTime) === 0n) {
+    return X(CreateTemporalDuration(0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n));
+  }
+  const internalDuration = Q(DifferencePlainDateTimeWithRounding(dateTime.ISODateTime, other.ISODateTime, dateTime.Calendar, settings.LargestUnit, settings.RoundingIncrement, settings.SmallestUnit, settings.RoundingMode));
+  let result = X(TemporalDurationFromInternal(internalDuration, settings.LargestUnit));
+  if (operation === 'since') {
+    result = CreateNegatedTemporalDuration(result);
+  }
+  return result;
+}
+
+/** https://tc39.es/proposal-temporal/#sec-temporal-adddurationtodatetime */
+export function* AddDurationToDateTime(operation: 'add' | 'subtract', dateTime: TemporalPlainDateTimeObject, temporalDurationLike: Value, options: Value): ValueEvaluator<TemporalPlainDateTimeObject> {
+  let duration = Q(yield* ToTemporalDuration(temporalDurationLike));
+  if (operation === 'subtract') {
+    duration = CreateNegatedTemporalDuration(duration);
+  }
+  const resolvedOptions = Q(GetOptionsObject(options));
+  const overflow = Q(yield* GetTemporalOverflowOption(resolvedOptions));
+  const internalDuration = ToInternalDurationRecordWith24HourDays(duration);
+  const timeResult = AddTime(dateTime.ISODateTime.Time, internalDuration.Time);
+  const dateDuration = Q(AdjustDateDurationRecord(internalDuration.Date, timeResult.Days));
+  const addedDate = Q(CalendarDateAdd(dateTime.Calendar, dateTime.ISODateTime.ISODate, dateDuration, overflow));
+  const result = CombineISODateAndTimeRecord(addedDate, timeResult);
+  return Q(yield* CreateTemporalDateTime(result, dateTime.Calendar));
+}