Bug 1921551 - React to sync sign in flow correctly r=android-reviewers,matt-tighe

[gecko.git] / js / src / builtin / temporal / Duration.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "builtin/temporal/Duration.h"

#include "mozilla/Assertions.h"
#include "mozilla/Casting.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/EnumSet.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/Maybe.h"

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <initializer_list>
#include <stdint.h>
#include <type_traits>
#include <utility>

#include "jsnum.h"
#include "jspubtd.h"
#include "NamespaceImports.h"

#include "builtin/temporal/Calendar.h"
#include "builtin/temporal/Instant.h"
#include "builtin/temporal/Int128.h"
#include "builtin/temporal/Int96.h"
#include "builtin/temporal/PlainDate.h"
#include "builtin/temporal/PlainDateTime.h"
#include "builtin/temporal/Temporal.h"
#include "builtin/temporal/TemporalFields.h"
#include "builtin/temporal/TemporalParser.h"
#include "builtin/temporal/TemporalRoundingMode.h"
#include "builtin/temporal/TemporalTypes.h"
#include "builtin/temporal/TemporalUnit.h"
#include "builtin/temporal/TimeZone.h"
#include "builtin/temporal/Wrapped.h"
#include "builtin/temporal/ZonedDateTime.h"
#include "gc/AllocKind.h"
#include "gc/Barrier.h"
#include "gc/GCEnum.h"
#include "js/CallArgs.h"
#include "js/CallNonGenericMethod.h"
#include "js/Class.h"
#include "js/Conversions.h"
#include "js/ErrorReport.h"
#include "js/friend/ErrorMessages.h"
#include "js/GCVector.h"
#include "js/Id.h"
#include "js/Printer.h"
#include "js/PropertyDescriptor.h"
#include "js/PropertySpec.h"
#include "js/RootingAPI.h"
#include "js/Value.h"
#include "util/StringBuilder.h"
#include "vm/BytecodeUtil.h"
#include "vm/GlobalObject.h"
#include "vm/JSAtomState.h"
#include "vm/JSContext.h"
#include "vm/JSObject.h"
#include "vm/ObjectOperations.h"
#include "vm/PlainObject.h"
#include "vm/StringType.h"

#include "vm/JSObject-inl.h"
#include "vm/NativeObject-inl.h"
#include "vm/ObjectOperations-inl.h"

using namespace js;
using namespace js::temporal;

static inline bool IsDuration(Handle<Value> v) {
  return v.isObject() && v.toObject().is<DurationObject>();
}

#ifdef DEBUG
static bool IsIntegerOrInfinity(double d) {
  return IsInteger(d) || std::isinf(d);
}

static bool IsIntegerOrInfinityDuration(const Duration& duration) {
  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  // Integers exceeding the Number range are represented as infinity.

  return IsIntegerOrInfinity(years) && IsIntegerOrInfinity(months) &&
         IsIntegerOrInfinity(weeks) && IsIntegerOrInfinity(days) &&
         IsIntegerOrInfinity(hours) && IsIntegerOrInfinity(minutes) &&
         IsIntegerOrInfinity(seconds) && IsIntegerOrInfinity(milliseconds) &&
         IsIntegerOrInfinity(microseconds) && IsIntegerOrInfinity(nanoseconds);
}

static bool IsIntegerDuration(const Duration& duration) {
  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  return IsInteger(years) && IsInteger(months) && IsInteger(weeks) &&
         IsInteger(days) && IsInteger(hours) && IsInteger(minutes) &&
         IsInteger(seconds) && IsInteger(milliseconds) &&
         IsInteger(microseconds) && IsInteger(nanoseconds);
}
#endif

static constexpr bool IsSafeInteger(int64_t x) {
  constexpr int64_t MaxSafeInteger = int64_t(1) << 53;
  constexpr int64_t MinSafeInteger = -MaxSafeInteger;
  return MinSafeInteger < x && x < MaxSafeInteger;
}

/**
 * DurationSign ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
int32_t js::temporal::DurationSign(const Duration& duration) {
  MOZ_ASSERT(IsIntegerOrInfinityDuration(duration));

  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  // Step 1.
  for (auto v : {years, months, weeks, days, hours, minutes, seconds,
                 milliseconds, microseconds, nanoseconds}) {
    // Step 1.a.
    if (v < 0) {
      return -1;
    }

    // Step 1.b.
    if (v > 0) {
      return 1;
    }
  }

  // Step 2.
  return 0;
}

/**
 * DurationSign ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
int32_t js::temporal::DurationSign(const DateDuration& duration) {
  const auto& [years, months, weeks, days] = duration;

  // Step 1.
  for (auto v : {years, months, weeks, days}) {
    // Step 1.a.
    if (v < 0) {
      return -1;
    }

    // Step 1.b.
    if (v > 0) {
      return 1;
    }
  }

  // Step 2.
  return 0;
}

/**
 * DurationSign ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
int32_t js::temporal::DurationSign(const NormalizedDuration& duration) {
  MOZ_ASSERT(IsValidDuration(duration));

  if (int32_t sign = DurationSign(duration.date)) {
    return sign;
  }
  return NormalizedTimeDurationSign(duration.time);
}

/**
 * Normalize a nanoseconds amount into a time duration.
 */
static NormalizedTimeDuration NormalizeNanoseconds(const Int96& nanoseconds) {
  // Split into seconds and nanoseconds.
  auto [seconds, nanos] = nanoseconds / ToNanoseconds(TemporalUnit::Second);

  return {seconds, nanos};
}

/**
 * Normalize a nanoseconds amount into a time duration. Return Nothing if the
 * value is too large.
 */
static mozilla::Maybe<NormalizedTimeDuration> NormalizeNanoseconds(
    double nanoseconds) {
  MOZ_ASSERT(IsInteger(nanoseconds));

  if (auto int96 = Int96::fromInteger(nanoseconds)) {
    // The number of normalized seconds must not exceed `2**53 - 1`.
    constexpr auto limit =
        Int96{uint64_t(1) << 53} * ToNanoseconds(TemporalUnit::Second);

    if (int96->abs() < limit) {
      return mozilla::Some(NormalizeNanoseconds(*int96));
    }
  }
  return mozilla::Nothing();
}

/**
 * Normalize a microseconds amount into a time duration.
 */
static NormalizedTimeDuration NormalizeMicroseconds(const Int96& microseconds) {
  // Split into seconds and microseconds.
  auto [seconds, micros] = microseconds / ToMicroseconds(TemporalUnit::Second);

  // Scale microseconds to nanoseconds.
  int32_t nanos = micros * int32_t(ToNanoseconds(TemporalUnit::Microsecond));

  return {seconds, nanos};
}

/**
 * Normalize a microseconds amount into a time duration. Return Nothing if the
 * value is too large.
 */
static mozilla::Maybe<NormalizedTimeDuration> NormalizeMicroseconds(
    double microseconds) {
  MOZ_ASSERT(IsInteger(microseconds));

  if (auto int96 = Int96::fromInteger(microseconds)) {
    // The number of normalized seconds must not exceed `2**53 - 1`.
    constexpr auto limit =
        Int96{uint64_t(1) << 53} * ToMicroseconds(TemporalUnit::Second);

    if (int96->abs() < limit) {
      return mozilla::Some(NormalizeMicroseconds(*int96));
    }
  }
  return mozilla::Nothing();
}

/**
 * Normalize a duration into a time duration. Return Nothing if any duration
 * value is too large.
 */
static mozilla::Maybe<NormalizedTimeDuration> NormalizeSeconds(
    const Duration& duration) {
  do {
    auto nanoseconds = NormalizeNanoseconds(duration.nanoseconds);
    if (!nanoseconds) {
      break;
    }
    MOZ_ASSERT(IsValidNormalizedTimeDuration(*nanoseconds));

    auto microseconds = NormalizeMicroseconds(duration.microseconds);
    if (!microseconds) {
      break;
    }
    MOZ_ASSERT(IsValidNormalizedTimeDuration(*microseconds));

    // Overflows for millis/seconds/minutes/hours/days always result in an
    // invalid normalized time duration.

    int64_t milliseconds;
    if (!mozilla::NumberEqualsInt64(duration.milliseconds, &milliseconds)) {
      break;
    }

    int64_t seconds;
    if (!mozilla::NumberEqualsInt64(duration.seconds, &seconds)) {
      break;
    }

    int64_t minutes;
    if (!mozilla::NumberEqualsInt64(duration.minutes, &minutes)) {
      break;
    }

    int64_t hours;
    if (!mozilla::NumberEqualsInt64(duration.hours, &hours)) {
      break;
    }

    int64_t days;
    if (!mozilla::NumberEqualsInt64(duration.days, &days)) {
      break;
    }

    // Compute the overall amount of milliseconds.
    mozilla::CheckedInt64 millis = days;
    millis *= 24;
    millis += hours;
    millis *= 60;
    millis += minutes;
    millis *= 60;
    millis += seconds;
    millis *= 1000;
    millis += milliseconds;
    if (!millis.isValid()) {
      break;
    }

    auto milli = NormalizedTimeDuration::fromMilliseconds(millis.value());
    if (!IsValidNormalizedTimeDuration(milli)) {
      break;
    }

    // Compute the overall time duration.
    auto result = milli + *microseconds + *nanoseconds;
    if (!IsValidNormalizedTimeDuration(result)) {
      break;
    }

    return mozilla::Some(result);
  } while (false);

  return mozilla::Nothing();
}

/**
 * Normalize a days amount into a time duration. Return Nothing if the value is
 * too large.
 */
static mozilla::Maybe<NormalizedTimeDuration> NormalizeDays(int64_t days) {
  do {
    // Compute the overall amount of milliseconds.
    auto millis =
        mozilla::CheckedInt64(days) * ToMilliseconds(TemporalUnit::Day);
    if (!millis.isValid()) {
      break;
    }

    auto result = NormalizedTimeDuration::fromMilliseconds(millis.value());
    if (!IsValidNormalizedTimeDuration(result)) {
      break;
    }

    return mozilla::Some(result);
  } while (false);

  return mozilla::Nothing();
}

/**
 * NormalizeTimeDuration ( hours, minutes, seconds, milliseconds, microseconds,
 * nanoseconds )
 */
static NormalizedTimeDuration NormalizeTimeDuration(
    double hours, double minutes, double seconds, double milliseconds,
    double microseconds, double nanoseconds) {
  MOZ_ASSERT(IsInteger(hours));
  MOZ_ASSERT(IsInteger(minutes));
  MOZ_ASSERT(IsInteger(seconds));
  MOZ_ASSERT(IsInteger(milliseconds));
  MOZ_ASSERT(IsInteger(microseconds));
  MOZ_ASSERT(IsInteger(nanoseconds));

  // Steps 1-3.
  mozilla::CheckedInt64 millis = int64_t(hours);
  millis *= 60;
  millis += int64_t(minutes);
  millis *= 60;
  millis += int64_t(seconds);
  millis *= 1000;
  millis += int64_t(milliseconds);
  MOZ_ASSERT(millis.isValid());

  auto normalized = NormalizedTimeDuration::fromMilliseconds(millis.value());

  // Step 4.
  auto micros = Int96::fromInteger(microseconds);
  MOZ_ASSERT(micros);

  normalized += NormalizeMicroseconds(*micros);

  // Step 5.
  auto nanos = Int96::fromInteger(nanoseconds);
  MOZ_ASSERT(nanos);

  normalized += NormalizeNanoseconds(*nanos);

  // Step 6.
  MOZ_ASSERT(IsValidNormalizedTimeDuration(normalized));

  // Step 7.
  return normalized;
}

/**
 * NormalizeTimeDuration ( hours, minutes, seconds, milliseconds, microseconds,
 * nanoseconds )
 */
NormalizedTimeDuration js::temporal::NormalizeTimeDuration(
    int32_t hours, int32_t minutes, int32_t seconds, int32_t milliseconds,
    int32_t microseconds, int32_t nanoseconds) {
  // Steps 1-3.
  mozilla::CheckedInt64 millis = int64_t(hours);
  millis *= 60;
  millis += int64_t(minutes);
  millis *= 60;
  millis += int64_t(seconds);
  millis *= 1000;
  millis += int64_t(milliseconds);
  MOZ_ASSERT(millis.isValid());

  auto normalized = NormalizedTimeDuration::fromMilliseconds(millis.value());

  // Step 4.
  normalized += NormalizeMicroseconds(Int96{microseconds});

  // Step 5.
  normalized += NormalizeNanoseconds(Int96{nanoseconds});

  // Step 6.
  MOZ_ASSERT(IsValidNormalizedTimeDuration(normalized));

  // Step 7.
  return normalized;
}

/**
 * NormalizeTimeDuration ( hours, minutes, seconds, milliseconds, microseconds,
 * nanoseconds )
 */
NormalizedTimeDuration js::temporal::NormalizeTimeDuration(
    const Duration& duration) {
  MOZ_ASSERT(IsValidDuration(duration));

  return ::NormalizeTimeDuration(duration.hours, duration.minutes,
                                 duration.seconds, duration.milliseconds,
                                 duration.microseconds, duration.nanoseconds);
}

/**
 * AddNormalizedTimeDuration ( one, two )
 */
static bool AddNormalizedTimeDuration(JSContext* cx,
                                      const NormalizedTimeDuration& one,
                                      const NormalizedTimeDuration& two,
                                      NormalizedTimeDuration* result) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(one));
  MOZ_ASSERT(IsValidNormalizedTimeDuration(two));

  // Step 1.
  auto sum = one + two;

  // Step 2.
  if (!IsValidNormalizedTimeDuration(sum)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  // Step 3.
  *result = sum;
  return true;
}

/**
 * SubtractNormalizedTimeDuration ( one, two )
 */
static bool SubtractNormalizedTimeDuration(JSContext* cx,
                                           const NormalizedTimeDuration& one,
                                           const NormalizedTimeDuration& two,
                                           NormalizedTimeDuration* result) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(one));
  MOZ_ASSERT(IsValidNormalizedTimeDuration(two));

  // Step 1.
  auto sum = one - two;

  // Step 2.
  if (!IsValidNormalizedTimeDuration(sum)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  // Step 3.
  *result = sum;
  return true;
}

/**
 * Add24HourDaysToNormalizedTimeDuration ( d, days )
 */
bool js::temporal::Add24HourDaysToNormalizedTimeDuration(
    JSContext* cx, const NormalizedTimeDuration& d, int64_t days,
    NormalizedTimeDuration* result) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(d));

  // Step 1.
  auto normalizedDays = NormalizeDays(days);
  if (!normalizedDays) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  // Step 2.
  auto sum = d + *normalizedDays;
  if (!IsValidNormalizedTimeDuration(sum)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  // Step 3.
  *result = sum;
  return true;
}

/**
 * CombineDateAndNormalizedTimeDuration ( dateDurationRecord, norm )
 */
bool js::temporal::CombineDateAndNormalizedTimeDuration(
    JSContext* cx, const DateDuration& date, const NormalizedTimeDuration& time,
    NormalizedDuration* result) {
  MOZ_ASSERT(IsValidDuration(date));
  MOZ_ASSERT(IsValidNormalizedTimeDuration(time));

  // Step 1.
  int32_t dateSign = DurationSign(date);

  // Step 2.
  int32_t timeSign = NormalizedTimeDurationSign(time);

  // Step 3
  if ((dateSign * timeSign) < 0) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_COMBINE_INVALID_SIGN);
    return false;
  }

  // Step 4.
  *result = {date, time};
  return true;
}

/**
 * NormalizedTimeDurationFromEpochNanosecondsDifference ( one, two )
 */
NormalizedTimeDuration
js::temporal::NormalizedTimeDurationFromEpochNanosecondsDifference(
    const Instant& one, const Instant& two) {
  MOZ_ASSERT(IsValidEpochInstant(one));
  MOZ_ASSERT(IsValidEpochInstant(two));

  // Step 1.
  auto result = one - two;

  // Step 2.
  MOZ_ASSERT(IsValidInstantSpan(result));

  // Step 3.
  return result.to<NormalizedTimeDuration>();
}

/**
 * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
bool js::temporal::IsValidDuration(const Duration& duration) {
  MOZ_ASSERT(IsIntegerOrInfinityDuration(duration));

  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  // Step 1.
  int32_t sign = DurationSign(duration);

  // Step 2.
  for (auto v : {years, months, weeks, days, hours, minutes, seconds,
                 milliseconds, microseconds, nanoseconds}) {
    // Step 2.a.
    if (!std::isfinite(v)) {
      return false;
    }

    // Step 2.b.
    if (v < 0 && sign > 0) {
      return false;
    }

    // Step 2.c.
    if (v > 0 && sign < 0) {
      return false;
    }
  }

  // Step 3.
  if (std::abs(years) >= double(int64_t(1) << 32)) {
    return false;
  }

  // Step 4.
  if (std::abs(months) >= double(int64_t(1) << 32)) {
    return false;
  }

  // Step 5.
  if (std::abs(weeks) >= double(int64_t(1) << 32)) {
    return false;
  }

  // Steps 6-8.
  if (!NormalizeSeconds(duration)) {
    return false;
  }

  // Step 9.
  return true;
}

#ifdef DEBUG
/**
 * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
bool js::temporal::IsValidDuration(const DateDuration& duration) {
  return IsValidDuration(duration.toDuration());
}

/**
 * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
bool js::temporal::IsValidDuration(const NormalizedDuration& duration) {
  if (!IsValidNormalizedTimeDuration(duration.time)) {
    return false;
  }

  auto d = duration.date.toDuration();
  auto [seconds, nanoseconds] = duration.time.denormalize();
  d.seconds = double(seconds);
  d.nanoseconds = double(nanoseconds);

  return IsValidDuration(d);
}
#endif

static bool ThrowInvalidDurationPart(JSContext* cx, double value,
                                     const char* name, unsigned errorNumber) {
  ToCStringBuf cbuf;
  const char* numStr = NumberToCString(&cbuf, value);

  JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, errorNumber, name,
                            numStr);
  return false;
}

/**
 * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
bool js::temporal::ThrowIfInvalidDuration(JSContext* cx,
                                          const Duration& duration) {
  MOZ_ASSERT(IsIntegerOrInfinityDuration(duration));

  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  // Step 1.
  int32_t sign = DurationSign(duration);

  auto throwIfInvalid = [&](double v, const char* name) {
    // Step 2.a.
    if (!std::isfinite(v)) {
      return ThrowInvalidDurationPart(
          cx, v, name, JSMSG_TEMPORAL_DURATION_INVALID_NON_FINITE);
    }

    // Steps 2.b-c.
    if ((v < 0 && sign > 0) || (v > 0 && sign < 0)) {
      return ThrowInvalidDurationPart(cx, v, name,
                                      JSMSG_TEMPORAL_DURATION_INVALID_SIGN);
    }

    return true;
  };

  auto throwIfTooLarge = [&](double v, const char* name) {
    if (std::abs(v) >= double(int64_t(1) << 32)) {
      return ThrowInvalidDurationPart(
          cx, v, name, JSMSG_TEMPORAL_DURATION_INVALID_NON_FINITE);
    }
    return true;
  };

  // Step 2.
  if (!throwIfInvalid(years, "years")) {
    return false;
  }
  if (!throwIfInvalid(months, "months")) {
    return false;
  }
  if (!throwIfInvalid(weeks, "weeks")) {
    return false;
  }
  if (!throwIfInvalid(days, "days")) {
    return false;
  }
  if (!throwIfInvalid(hours, "hours")) {
    return false;
  }
  if (!throwIfInvalid(minutes, "minutes")) {
    return false;
  }
  if (!throwIfInvalid(seconds, "seconds")) {
    return false;
  }
  if (!throwIfInvalid(milliseconds, "milliseconds")) {
    return false;
  }
  if (!throwIfInvalid(microseconds, "microseconds")) {
    return false;
  }
  if (!throwIfInvalid(nanoseconds, "nanoseconds")) {
    return false;
  }

  // Step 3.
  if (!throwIfTooLarge(years, "years")) {
    return false;
  }

  // Step 4.
  if (!throwIfTooLarge(months, "months")) {
    return false;
  }

  // Step 5.
  if (!throwIfTooLarge(weeks, "weeks")) {
    return false;
  }

  // Steps 6-8.
  if (!NormalizeSeconds(duration)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  MOZ_ASSERT(IsValidDuration(duration));

  // Step 9.
  return true;
}

/**
 * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds )
 */
bool js::temporal::ThrowIfInvalidDuration(JSContext* cx,
                                          const DateDuration& duration) {
  const auto& [years, months, weeks, days] = duration;

  // Step 1.
  int32_t sign = DurationSign(duration);

  auto throwIfInvalid = [&](int64_t v, const char* name) {
    // Step 2.a. (Not applicable)

    // Steps 2.b-c.
    if ((v < 0 && sign > 0) || (v > 0 && sign < 0)) {
      return ThrowInvalidDurationPart(cx, double(v), name,
                                      JSMSG_TEMPORAL_DURATION_INVALID_SIGN);
    }

    return true;
  };

  auto throwIfTooLarge = [&](int64_t v, const char* name) {
    if (std::abs(v) >= (int64_t(1) << 32)) {
      return ThrowInvalidDurationPart(
          cx, double(v), name, JSMSG_TEMPORAL_DURATION_INVALID_NON_FINITE);
    }
    return true;
  };

  // Step 2.
  if (!throwIfInvalid(years, "years")) {
    return false;
  }
  if (!throwIfInvalid(months, "months")) {
    return false;
  }
  if (!throwIfInvalid(weeks, "weeks")) {
    return false;
  }
  if (!throwIfInvalid(days, "days")) {
    return false;
  }

  // Step 3.
  if (!throwIfTooLarge(years, "years")) {
    return false;
  }

  // Step 4.
  if (!throwIfTooLarge(months, "months")) {
    return false;
  }

  // Step 5.
  if (!throwIfTooLarge(weeks, "weeks")) {
    return false;
  }

  // Steps 6-8.
  if (std::abs(days) > ((int64_t(1) << 53) / 86400)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  MOZ_ASSERT(IsValidDuration(duration));

  // Step 9.
  return true;
}

/**
 * DefaultTemporalLargestUnit ( years, months, weeks, days, hours, minutes,
 * seconds, milliseconds, microseconds )
 */
static TemporalUnit DefaultTemporalLargestUnit(const Duration& duration) {
  MOZ_ASSERT(IsIntegerDuration(duration));

  // Step 1.
  if (duration.years != 0) {
    return TemporalUnit::Year;
  }

  // Step 2.
  if (duration.months != 0) {
    return TemporalUnit::Month;
  }

  // Step 3.
  if (duration.weeks != 0) {
    return TemporalUnit::Week;
  }

  // Step 4.
  if (duration.days != 0) {
    return TemporalUnit::Day;
  }

  // Step 5.
  if (duration.hours != 0) {
    return TemporalUnit::Hour;
  }

  // Step 6.
  if (duration.minutes != 0) {
    return TemporalUnit::Minute;
  }

  // Step 7.
  if (duration.seconds != 0) {
    return TemporalUnit::Second;
  }

  // Step 8.
  if (duration.milliseconds != 0) {
    return TemporalUnit::Millisecond;
  }

  // Step 9.
  if (duration.microseconds != 0) {
    return TemporalUnit::Microsecond;
  }

  // Step 10.
  return TemporalUnit::Nanosecond;
}

/**
 * CreateTemporalDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds [ , newTarget ] )
 */
static DurationObject* CreateTemporalDuration(JSContext* cx,
                                              const CallArgs& args,
                                              const Duration& duration) {
  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  // Step 1.
  if (!ThrowIfInvalidDuration(cx, duration)) {
    return nullptr;
  }

  // Steps 2-3.
  Rooted<JSObject*> proto(cx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_Duration, &proto)) {
    return nullptr;
  }

  auto* object = NewObjectWithClassProto<DurationObject>(cx, proto);
  if (!object) {
    return nullptr;
  }

  // Steps 4-13.
  // Add zero to convert -0 to +0.
  object->setFixedSlot(DurationObject::YEARS_SLOT, NumberValue(years + (+0.0)));
  object->setFixedSlot(DurationObject::MONTHS_SLOT,
                       NumberValue(months + (+0.0)));
  object->setFixedSlot(DurationObject::WEEKS_SLOT, NumberValue(weeks + (+0.0)));
  object->setFixedSlot(DurationObject::DAYS_SLOT, NumberValue(days + (+0.0)));
  object->setFixedSlot(DurationObject::HOURS_SLOT, NumberValue(hours + (+0.0)));
  object->setFixedSlot(DurationObject::MINUTES_SLOT,
                       NumberValue(minutes + (+0.0)));
  object->setFixedSlot(DurationObject::SECONDS_SLOT,
                       NumberValue(seconds + (+0.0)));
  object->setFixedSlot(DurationObject::MILLISECONDS_SLOT,
                       NumberValue(milliseconds + (+0.0)));
  object->setFixedSlot(DurationObject::MICROSECONDS_SLOT,
                       NumberValue(microseconds + (+0.0)));
  object->setFixedSlot(DurationObject::NANOSECONDS_SLOT,
                       NumberValue(nanoseconds + (+0.0)));

  // Step 14.
  return object;
}

/**
 * CreateTemporalDuration ( years, months, weeks, days, hours, minutes, seconds,
 * milliseconds, microseconds, nanoseconds [ , newTarget ] )
 */
DurationObject* js::temporal::CreateTemporalDuration(JSContext* cx,
                                                     const Duration& duration) {
  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] = duration;

  MOZ_ASSERT(IsInteger(years));
  MOZ_ASSERT(IsInteger(months));
  MOZ_ASSERT(IsInteger(weeks));
  MOZ_ASSERT(IsInteger(days));
  MOZ_ASSERT(IsInteger(hours));
  MOZ_ASSERT(IsInteger(minutes));
  MOZ_ASSERT(IsInteger(seconds));
  MOZ_ASSERT(IsInteger(milliseconds));
  MOZ_ASSERT(IsInteger(microseconds));
  MOZ_ASSERT(IsInteger(nanoseconds));

  // Step 1.
  if (!ThrowIfInvalidDuration(cx, duration)) {
    return nullptr;
  }

  // Steps 2-3.
  auto* object = NewBuiltinClassInstance<DurationObject>(cx);
  if (!object) {
    return nullptr;
  }

  // Steps 4-13.
  // Add zero to convert -0 to +0.
  object->setFixedSlot(DurationObject::YEARS_SLOT, NumberValue(years + (+0.0)));
  object->setFixedSlot(DurationObject::MONTHS_SLOT,
                       NumberValue(months + (+0.0)));
  object->setFixedSlot(DurationObject::WEEKS_SLOT, NumberValue(weeks + (+0.0)));
  object->setFixedSlot(DurationObject::DAYS_SLOT, NumberValue(days + (+0.0)));
  object->setFixedSlot(DurationObject::HOURS_SLOT, NumberValue(hours + (+0.0)));
  object->setFixedSlot(DurationObject::MINUTES_SLOT,
                       NumberValue(minutes + (+0.0)));
  object->setFixedSlot(DurationObject::SECONDS_SLOT,
                       NumberValue(seconds + (+0.0)));
  object->setFixedSlot(DurationObject::MILLISECONDS_SLOT,
                       NumberValue(milliseconds + (+0.0)));
  object->setFixedSlot(DurationObject::MICROSECONDS_SLOT,
                       NumberValue(microseconds + (+0.0)));
  object->setFixedSlot(DurationObject::NANOSECONDS_SLOT,
                       NumberValue(nanoseconds + (+0.0)));

  // Step 14.
  return object;
}

/**
 * ToIntegerIfIntegral ( argument )
 */
static bool ToIntegerIfIntegral(JSContext* cx, const char* name,
                                Handle<Value> argument, double* num) {
  // Step 1.
  double d;
  if (!JS::ToNumber(cx, argument, &d)) {
    return false;
  }

  // Step 2.
  if (!js::IsInteger(d)) {
    ToCStringBuf cbuf;
    const char* numStr = NumberToCString(&cbuf, d);

    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_NOT_INTEGER, numStr,
                              name);
    return false;
  }

  // Step 3.
  *num = d;
  return true;
}

/**
 * ToIntegerIfIntegral ( argument )
 */
static bool ToIntegerIfIntegral(JSContext* cx, Handle<PropertyName*> name,
                                Handle<Value> argument, double* result) {
  // Step 1.
  double d;
  if (!JS::ToNumber(cx, argument, &d)) {
    return false;
  }

  // Step 2.
  if (!js::IsInteger(d)) {
    if (auto nameStr = js::QuoteString(cx, name)) {
      ToCStringBuf cbuf;
      const char* numStr = NumberToCString(&cbuf, d);

      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_DURATION_NOT_INTEGER, numStr,
                                nameStr.get());
    }
    return false;
  }

  // Step 3.
  *result = d;
  return true;
}

/**
 * ToTemporalPartialDurationRecord ( temporalDurationLike )
 */
static bool ToTemporalPartialDurationRecord(
    JSContext* cx, Handle<JSObject*> temporalDurationLike, Duration* result) {
  // Steps 1-3. (Not applicable in our implementation.)

  Rooted<Value> value(cx);
  bool any = false;

  auto getDurationProperty = [&](Handle<PropertyName*> name, double* num) {
    if (!GetProperty(cx, temporalDurationLike, temporalDurationLike, name,
                     &value)) {
      return false;
    }

    if (!value.isUndefined()) {
      any = true;

      if (!ToIntegerIfIntegral(cx, name, value, num)) {
        return false;
      }
    }
    return true;
  };

  // Steps 4-23.
  if (!getDurationProperty(cx->names().days, &result->days)) {
    return false;
  }
  if (!getDurationProperty(cx->names().hours, &result->hours)) {
    return false;
  }
  if (!getDurationProperty(cx->names().microseconds, &result->microseconds)) {
    return false;
  }
  if (!getDurationProperty(cx->names().milliseconds, &result->milliseconds)) {
    return false;
  }
  if (!getDurationProperty(cx->names().minutes, &result->minutes)) {
    return false;
  }
  if (!getDurationProperty(cx->names().months, &result->months)) {
    return false;
  }
  if (!getDurationProperty(cx->names().nanoseconds, &result->nanoseconds)) {
    return false;
  }
  if (!getDurationProperty(cx->names().seconds, &result->seconds)) {
    return false;
  }
  if (!getDurationProperty(cx->names().weeks, &result->weeks)) {
    return false;
  }
  if (!getDurationProperty(cx->names().years, &result->years)) {
    return false;
  }

  // Step 24.
  if (!any) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_MISSING_UNIT);
    return false;
  }

  // Step 25.
  return true;
}

/**
 * ToTemporalDurationRecord ( temporalDurationLike )
 */
bool js::temporal::ToTemporalDurationRecord(JSContext* cx,
                                            Handle<Value> temporalDurationLike,
                                            Duration* result) {
  // Step 1.
  if (!temporalDurationLike.isObject()) {
    // Step 1.a.
    if (!temporalDurationLike.isString()) {
      ReportValueError(cx, JSMSG_UNEXPECTED_TYPE, JSDVG_IGNORE_STACK,
                       temporalDurationLike, nullptr, "not a string");
      return false;
    }
    Rooted<JSString*> string(cx, temporalDurationLike.toString());

    // Step 1.b.
    return ParseTemporalDurationString(cx, string, result);
  }

  Rooted<JSObject*> durationLike(cx, &temporalDurationLike.toObject());

  // Step 2.
  if (auto* duration = durationLike->maybeUnwrapIf<DurationObject>()) {
    *result = ToDuration(duration);
    return true;
  }

  // Step 3.
  Duration duration = {};

  // Steps 4-14.
  if (!ToTemporalPartialDurationRecord(cx, durationLike, &duration)) {
    return false;
  }

  // Step 15.
  if (!ThrowIfInvalidDuration(cx, duration)) {
    return false;
  }

  // Step 16.
  *result = duration;
  return true;
}

/**
 * ToTemporalDuration ( item )
 */
Wrapped<DurationObject*> js::temporal::ToTemporalDuration(JSContext* cx,
                                                          Handle<Value> item) {
  // Step 1.
  if (item.isObject()) {
    JSObject* itemObj = &item.toObject();
    if (itemObj->canUnwrapAs<DurationObject>()) {
      return itemObj;
    }
  }

  // Step 2.
  Duration result;
  if (!ToTemporalDurationRecord(cx, item, &result)) {
    return nullptr;
  }

  // Step 3.
  return CreateTemporalDuration(cx, result);
}

/**
 * ToTemporalDuration ( item )
 */
bool js::temporal::ToTemporalDuration(JSContext* cx, Handle<Value> item,
                                      Duration* result) {
  auto obj = ToTemporalDuration(cx, item);
  if (!obj) {
    return false;
  }

  *result = ToDuration(&obj.unwrap());
  return true;
}

/**
 * DaysUntil ( earlier, later )
 */
int32_t js::temporal::DaysUntil(const PlainDate& earlier,
                                const PlainDate& later) {
  MOZ_ASSERT(ISODateTimeWithinLimits(earlier));
  MOZ_ASSERT(ISODateTimeWithinLimits(later));

  // Steps 1-2.
  int32_t epochDaysEarlier = MakeDay(earlier);
  MOZ_ASSERT(MinEpochDay <= epochDaysEarlier &&
             epochDaysEarlier <= MaxEpochDay);

  // Steps 3-4.
  int32_t epochDaysLater = MakeDay(later);
  MOZ_ASSERT(MinEpochDay <= epochDaysLater && epochDaysLater <= MaxEpochDay);

  // Step 5.
  return epochDaysLater - epochDaysEarlier;
}

/**
 * CreateTimeDurationRecord ( days, hours, minutes, seconds, milliseconds,
 * microseconds, nanoseconds )
 */
static TimeDuration CreateTimeDurationRecord(int64_t days, int64_t hours,
                                             int64_t minutes, int64_t seconds,
                                             int64_t milliseconds,
                                             int64_t microseconds,
                                             int64_t nanoseconds) {
  // Step 1.
  MOZ_ASSERT(IsValidDuration(
      {0, 0, 0, double(days), double(hours), double(minutes), double(seconds),
       double(milliseconds), double(microseconds), double(nanoseconds)}));

  // All values are safe integers, so we don't need to convert to `double` and
  // back for the `ℝ(𝔽(x))` conversion.
  MOZ_ASSERT(IsSafeInteger(days));
  MOZ_ASSERT(IsSafeInteger(hours));
  MOZ_ASSERT(IsSafeInteger(minutes));
  MOZ_ASSERT(IsSafeInteger(seconds));
  MOZ_ASSERT(IsSafeInteger(milliseconds));
  MOZ_ASSERT(IsSafeInteger(microseconds));
  MOZ_ASSERT(IsSafeInteger(nanoseconds));

  // Step 2.
  return {
      days,
      hours,
      minutes,
      seconds,
      milliseconds,
      double(microseconds),
      double(nanoseconds),
  };
}

/**
 * CreateTimeDurationRecord ( days, hours, minutes, seconds, milliseconds,
 * microseconds, nanoseconds )
 */
static TimeDuration CreateTimeDurationRecord(int64_t milliseconds,
                                             const Int128& microseconds,
                                             const Int128& nanoseconds) {
  // Step 1.
  MOZ_ASSERT(IsValidDuration({0, 0, 0, 0, 0, 0, 0, double(milliseconds),
                              double(microseconds), double(nanoseconds)}));

  // Step 2.
  return {
      0, 0, 0, 0, milliseconds, double(microseconds), double(nanoseconds),
  };
}

/**
 * BalanceTimeDuration ( norm, largestUnit )
 */
TimeDuration js::temporal::BalanceTimeDuration(
    const NormalizedTimeDuration& duration, TemporalUnit largestUnit) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(duration));
  MOZ_ASSERT(largestUnit <= TemporalUnit::Second,
             "fallible fractional seconds units");

  auto [seconds, nanoseconds] = duration.denormalize();

  // Step 1.
  int64_t days = 0;
  int64_t hours = 0;
  int64_t minutes = 0;
  int64_t milliseconds = 0;
  int64_t microseconds = 0;

  // Steps 2-3. (Not applicable in our implementation.)
  //
  // We don't need to convert to positive numbers, because integer division
  // truncates and the %-operator has modulo semantics.

  // Steps 4-10.
  switch (largestUnit) {
    // Step 4.
    case TemporalUnit::Year:
    case TemporalUnit::Month:
    case TemporalUnit::Week:
    case TemporalUnit::Day: {
      // Step 4.a.
      microseconds = nanoseconds / 1000;

      // Step 4.b.
      nanoseconds = nanoseconds % 1000;

      // Step 4.c.
      milliseconds = microseconds / 1000;

      // Step 4.d.
      microseconds = microseconds % 1000;

      // Steps 4.e-f. (Not applicable)
      MOZ_ASSERT(std::abs(milliseconds) <= 999);

      // Step 4.g.
      minutes = seconds / 60;

      // Step 4.h.
      seconds = seconds % 60;

      // Step 4.i.
      hours = minutes / 60;

      // Step 4.j.
      minutes = minutes % 60;

      // Step 4.k.
      days = hours / 24;

      // Step 4.l.
      hours = hours % 24;

      break;
    }

      // Step 5.
    case TemporalUnit::Hour: {
      // Step 5.a.
      microseconds = nanoseconds / 1000;

      // Step 5.b.
      nanoseconds = nanoseconds % 1000;

      // Step 5.c.
      milliseconds = microseconds / 1000;

      // Step 5.d.
      microseconds = microseconds % 1000;

      // Steps 5.e-f. (Not applicable)
      MOZ_ASSERT(std::abs(milliseconds) <= 999);

      // Step 5.g.
      minutes = seconds / 60;

      // Step 5.h.
      seconds = seconds % 60;

      // Step 5.i.
      hours = minutes / 60;

      // Step 5.j.
      minutes = minutes % 60;

      break;
    }

    case TemporalUnit::Minute: {
      // Step 6.a.
      microseconds = nanoseconds / 1000;

      // Step 6.b.
      nanoseconds = nanoseconds % 1000;

      // Step 6.c.
      milliseconds = microseconds / 1000;

      // Step 6.d.
      microseconds = microseconds % 1000;

      // Steps 6.e-f. (Not applicable)
      MOZ_ASSERT(std::abs(milliseconds) <= 999);

      // Step 6.g.
      minutes = seconds / 60;

      // Step 6.h.
      seconds = seconds % 60;

      break;
    }

    // Step 7.
    case TemporalUnit::Second: {
      // Step 7.a.
      microseconds = nanoseconds / 1000;

      // Step 7.b.
      nanoseconds = nanoseconds % 1000;

      // Step 7.c.
      milliseconds = microseconds / 1000;

      // Step 7.d.
      microseconds = microseconds % 1000;

      // Steps 7.e-f. (Not applicable)
      MOZ_ASSERT(std::abs(milliseconds) <= 999);

      break;
    }

    case TemporalUnit::Millisecond:
    case TemporalUnit::Microsecond:
    case TemporalUnit::Nanosecond:
    case TemporalUnit::Auto:
      MOZ_CRASH("Unexpected temporal unit");
  }

  // Step 11.
  return CreateTimeDurationRecord(days, hours, minutes, seconds, milliseconds,
                                  microseconds, nanoseconds);
}

/**
 * BalanceTimeDuration ( norm, largestUnit )
 */
bool js::temporal::BalanceTimeDuration(JSContext* cx,
                                       const NormalizedTimeDuration& duration,
                                       TemporalUnit largestUnit,
                                       TimeDuration* result) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(duration));

  auto [seconds, nanoseconds] = duration.denormalize();

  // Steps 1-3. (Not applicable in our implementation.)
  //
  // We don't need to convert to positive numbers, because integer division
  // truncates and the %-operator has modulo semantics.

  // Steps 4-10.
  switch (largestUnit) {
    // Steps 4-7.
    case TemporalUnit::Year:
    case TemporalUnit::Month:
    case TemporalUnit::Week:
    case TemporalUnit::Day:
    case TemporalUnit::Hour:
    case TemporalUnit::Minute:
    case TemporalUnit::Second:
      *result = BalanceTimeDuration(duration, largestUnit);
      return true;

    // Step 8.
    case TemporalUnit::Millisecond: {
      // The number of normalized seconds must not exceed `2**53 - 1`.
      constexpr auto limit =
          (int64_t(1) << 53) * ToMilliseconds(TemporalUnit::Second);

      // The largest possible milliseconds value whose double representation
      // doesn't exceed the normalized seconds limit.
      constexpr auto max = int64_t(0x7cff'ffff'ffff'fdff);

      // Assert |max| is the maximum allowed milliseconds value.
      static_assert(double(max) < double(limit));
      static_assert(double(max + 1) >= double(limit));

      static_assert((NormalizedTimeDuration::max().seconds + 1) *
                            ToMilliseconds(TemporalUnit::Second) <=
                        INT64_MAX,
                    "total number duration milliseconds fits into int64");

      // Step 8.a.
      int64_t microseconds = nanoseconds / 1000;

      // Step 8.b.
      nanoseconds = nanoseconds % 1000;

      // Step 8.c.
      int64_t milliseconds = microseconds / 1000;
      MOZ_ASSERT(std::abs(milliseconds) <= 999);

      // Step 8.d.
      microseconds = microseconds % 1000;

      auto millis =
          (seconds * ToMilliseconds(TemporalUnit::Second)) + milliseconds;
      if (std::abs(millis) > max) {
        JS_ReportErrorNumberASCII(
            cx, GetErrorMessage, nullptr,
            JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
        return false;
      }

      // Step 11.
      *result = CreateTimeDurationRecord(millis, Int128{microseconds},
                                         Int128{nanoseconds});
      return true;
    }

    // Step 9.
    case TemporalUnit::Microsecond: {
      // The number of normalized seconds must not exceed `2**53 - 1`.
      constexpr auto limit = Uint128{int64_t(1) << 53} *
                             Uint128{ToMicroseconds(TemporalUnit::Second)};

      // The largest possible microseconds value whose double representation
      // doesn't exceed the normalized seconds limit.
      constexpr auto max =
          (Uint128{0x1e8} << 64) + Uint128{0x47ff'ffff'fff7'ffff};
      static_assert(max < limit);

      // Assert |max| is the maximum allowed microseconds value.
      MOZ_ASSERT(double(max) < double(limit));
      MOZ_ASSERT(double(max + Uint128{1}) >= double(limit));

      // Step 9.a.
      int64_t microseconds = nanoseconds / 1000;
      MOZ_ASSERT(std::abs(microseconds) <= 999'999);

      // Step 9.b.
      nanoseconds = nanoseconds % 1000;

      auto micros =
          (Int128{seconds} * Int128{ToMicroseconds(TemporalUnit::Second)}) +
          Int128{microseconds};
      if (micros.abs() > max) {
        JS_ReportErrorNumberASCII(
            cx, GetErrorMessage, nullptr,
            JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
        return false;
      }

      // Step 11.
      *result = CreateTimeDurationRecord(0, micros, Int128{nanoseconds});
      return true;
    }

    // Step 10.
    case TemporalUnit::Nanosecond: {
      // The number of normalized seconds must not exceed `2**53 - 1`.
      constexpr auto limit = Uint128{int64_t(1) << 53} *
                             Uint128{ToNanoseconds(TemporalUnit::Second)};

      // The largest possible nanoseconds value whose double representation
      // doesn't exceed the normalized seconds limit.
      constexpr auto max =
          (Uint128{0x77359} << 64) + Uint128{0x3fff'ffff'dfff'ffff};
      static_assert(max < limit);

      // Assert |max| is the maximum allowed nanoseconds value.
      MOZ_ASSERT(double(max) < double(limit));
      MOZ_ASSERT(double(max + Uint128{1}) >= double(limit));

      MOZ_ASSERT(std::abs(nanoseconds) <= 999'999'999);

      auto nanos =
          (Int128{seconds} * Int128{ToNanoseconds(TemporalUnit::Second)}) +
          Int128{nanoseconds};
      if (nanos.abs() > max) {
        JS_ReportErrorNumberASCII(
            cx, GetErrorMessage, nullptr,
            JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
        return false;
      }

      // Step 11.
      *result = CreateTimeDurationRecord(0, Int128{}, nanos);
      return true;
    }

    case TemporalUnit::Auto:
      break;
  }
  MOZ_CRASH("Unexpected temporal unit");
}

/**
 * UnbalanceDateDurationRelative ( years, months, weeks, days, plainRelativeTo,
 * calendarRec )
 */
static bool UnbalanceDateDurationRelative(
    JSContext* cx, const DateDuration& duration,
    Handle<Wrapped<PlainDateObject*>> plainRelativeTo,
    Handle<CalendarRecord> calendar, int64_t* result) {
  MOZ_ASSERT(IsValidDuration(duration));

  auto [years, months, weeks, days] = duration;

  // Step 1.
  if (years == 0 && months == 0 && weeks == 0) {
    *result = days;
    return true;
  }

  // Step 2.
  MOZ_ASSERT(
      CalendarMethodsRecordHasLookedUp(calendar, CalendarMethod::DateAdd));

  // Step 3.
  auto yearsMonthsWeeksDuration = DateDuration{years, months, weeks};

  // Step 4.
  auto later =
      CalendarDateAdd(cx, calendar, plainRelativeTo, yearsMonthsWeeksDuration);
  if (!later) {
    return false;
  }
  auto laterDate = ToPlainDate(&later.unwrap());

  auto* unwrappedRelativeTo = plainRelativeTo.unwrap(cx);
  if (!unwrappedRelativeTo) {
    return false;
  }
  auto relativeToDate = ToPlainDate(unwrappedRelativeTo);

  // Step 5.
  int32_t yearsMonthsWeeksInDay = DaysUntil(relativeToDate, laterDate);

  // Step 6.
  *result = days + yearsMonthsWeeksInDay;
  return true;
}

static bool NumberToStringBuilder(JSContext* cx, double num,
                                  JSStringBuilder& sb) {
  MOZ_ASSERT(IsInteger(num));
  MOZ_ASSERT(num >= 0);
  MOZ_ASSERT(num < DOUBLE_INTEGRAL_PRECISION_LIMIT);

  ToCStringBuf cbuf;
  size_t length;
  const char* numStr = NumberToCString(&cbuf, num, &length);

  return sb.append(numStr, length);
}

static Duration AbsoluteDuration(const Duration& duration) {
  return {
      std::abs(duration.years),        std::abs(duration.months),
      std::abs(duration.weeks),        std::abs(duration.days),
      std::abs(duration.hours),        std::abs(duration.minutes),
      std::abs(duration.seconds),      std::abs(duration.milliseconds),
      std::abs(duration.microseconds), std::abs(duration.nanoseconds),
  };
}

/**
 * FormatFractionalSeconds ( subSecondNanoseconds, precision )
 */
[[nodiscard]] static bool FormatFractionalSeconds(JSStringBuilder& result,
                                                  int32_t subSecondNanoseconds,
                                                  Precision precision) {
  MOZ_ASSERT(0 <= subSecondNanoseconds && subSecondNanoseconds < 1'000'000'000);
  MOZ_ASSERT(precision != Precision::Minute());

  // Steps 1-2.
  if (precision == Precision::Auto()) {
    // Step 1.a.
    if (subSecondNanoseconds == 0) {
      return true;
    }

    // Step 3. (Reordered)
    if (!result.append('.')) {
      return false;
    }

    // Steps 1.b-c.
    int32_t k = 100'000'000;
    do {
      if (!result.append(char('0' + (subSecondNanoseconds / k)))) {
        return false;
      }
      subSecondNanoseconds %= k;
      k /= 10;
    } while (subSecondNanoseconds);
  } else {
    // Step 2.a.
    uint8_t p = precision.value();
    if (p == 0) {
      return true;
    }

    // Step 3. (Reordered)
    if (!result.append('.')) {
      return false;
    }

    // Steps 2.b-c.
    int32_t k = 100'000'000;
    for (uint8_t i = 0; i < precision.value(); i++) {
      if (!result.append(char('0' + (subSecondNanoseconds / k)))) {
        return false;
      }
      subSecondNanoseconds %= k;
      k /= 10;
    }
  }

  return true;
}

/**
 * TemporalDurationToString ( years, months, weeks, days, hours, minutes,
 * normSeconds, precision )
 */
static JSString* TemporalDurationToString(JSContext* cx,
                                          const Duration& duration,
                                          Precision precision) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(precision != Precision::Minute());

  // Fast path for zero durations.
  if (duration == Duration{} &&
      (precision == Precision::Auto() || precision.value() == 0)) {
    return NewStringCopyZ<CanGC>(cx, "PT0S");
  }

  // Convert to absolute values up front. This is okay to do, because when the
  // duration is valid, all components have the same sign.
  const auto& [years, months, weeks, days, hours, minutes, seconds,
               milliseconds, microseconds, nanoseconds] =
      AbsoluteDuration(duration);

  // Years to seconds parts are all safe integers for valid durations.
  MOZ_ASSERT(years < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(months < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(weeks < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(days < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(hours < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(minutes < DOUBLE_INTEGRAL_PRECISION_LIMIT);
  MOZ_ASSERT(seconds < DOUBLE_INTEGRAL_PRECISION_LIMIT);

  auto secondsDuration = NormalizeTimeDuration(0.0, 0.0, seconds, milliseconds,
                                               microseconds, nanoseconds);

  // Step 1.
  int32_t sign = DurationSign(duration);

  // Steps 2 and 7.
  JSStringBuilder result(cx);

  // Step 13. (Reordered)
  if (sign < 0) {
    if (!result.append('-')) {
      return nullptr;
    }
  }

  // Step 14. (Reordered)
  if (!result.append('P')) {
    return nullptr;
  }

  // Step 3.
  if (years != 0) {
    if (!NumberToStringBuilder(cx, years, result)) {
      return nullptr;
    }
    if (!result.append('Y')) {
      return nullptr;
    }
  }

  // Step 4.
  if (months != 0) {
    if (!NumberToStringBuilder(cx, months, result)) {
      return nullptr;
    }
    if (!result.append('M')) {
      return nullptr;
    }
  }

  // Step 5.
  if (weeks != 0) {
    if (!NumberToStringBuilder(cx, weeks, result)) {
      return nullptr;
    }
    if (!result.append('W')) {
      return nullptr;
    }
  }

  // Step 6.
  if (days != 0) {
    if (!NumberToStringBuilder(cx, days, result)) {
      return nullptr;
    }
    if (!result.append('D')) {
      return nullptr;
    }
  }

  // Step 7. (Moved above)

  // Steps 10-11. (Reordered)
  bool zeroMinutesAndHigher = years == 0 && months == 0 && weeks == 0 &&
                              days == 0 && hours == 0 && minutes == 0;

  // Steps 8-9, 12, and 15.
  bool hasSecondsPart = (secondsDuration != NormalizedTimeDuration{}) ||
                        zeroMinutesAndHigher || precision != Precision::Auto();
  if (hours != 0 || minutes != 0 || hasSecondsPart) {
    // Step 15. (Reordered)
    if (!result.append('T')) {
      return nullptr;
    }

    // Step 8.
    if (hours != 0) {
      if (!NumberToStringBuilder(cx, hours, result)) {
        return nullptr;
      }
      if (!result.append('H')) {
        return nullptr;
      }
    }

    // Step 9.
    if (minutes != 0) {
      if (!NumberToStringBuilder(cx, minutes, result)) {
        return nullptr;
      }
      if (!result.append('M')) {
        return nullptr;
      }
    }

    // Step 12.
    if (hasSecondsPart) {
      // Step 12.a.
      if (!NumberToStringBuilder(cx, double(secondsDuration.seconds), result)) {
        return nullptr;
      }

      // Step 12.b.
      if (!FormatFractionalSeconds(result, secondsDuration.nanoseconds,
                                   precision)) {
        return nullptr;
      }

      // Step 12.c.
      if (!result.append('S')) {
        return nullptr;
      }
    }
  }

  // Steps 13-15. (Moved above)

  // Step 16.
  return result.finishString();
}

/**
 * GetTemporalRelativeToOption ( options )
 */
static bool GetTemporalRelativeToOption(
    JSContext* cx, Handle<JSObject*> options,
    MutableHandle<Wrapped<PlainDateObject*>> plainRelativeTo,
    MutableHandle<ZonedDateTime> zonedRelativeTo,
    MutableHandle<TimeZoneRecord> timeZoneRecord) {
  // Step 1.
  Rooted<Value> value(cx);
  if (!GetProperty(cx, options, options, cx->names().relativeTo, &value)) {
    return false;
  }

  // Step 2.
  if (value.isUndefined()) {
    plainRelativeTo.set(nullptr);
    zonedRelativeTo.set(ZonedDateTime{});
    timeZoneRecord.set(TimeZoneRecord{});
    return true;
  }

  // Step 3.
  auto offsetBehaviour = OffsetBehaviour::Option;

  // Step 4.
  auto matchBehaviour = MatchBehaviour::MatchExactly;

  // Steps 5-6.
  PlainDateTime dateTime;
  Rooted<CalendarValue> calendar(cx);
  Rooted<TimeZoneValue> timeZone(cx);
  int64_t offsetNs;
  if (value.isObject()) {
    Rooted<JSObject*> obj(cx, &value.toObject());

    // Step 5.a.
    if (auto* zonedDateTime = obj->maybeUnwrapIf<ZonedDateTimeObject>()) {
      auto instant = ToInstant(zonedDateTime);
      Rooted<TimeZoneValue> timeZone(cx, zonedDateTime->timeZone());
      Rooted<CalendarValue> calendar(cx, zonedDateTime->calendar());

      if (!timeZone.wrap(cx)) {
        return false;
      }
      if (!calendar.wrap(cx)) {
        return false;
      }

      // Step 5.a.i.
      Rooted<TimeZoneRecord> timeZoneRec(cx);
      if (!CreateTimeZoneMethodsRecord(
              cx, timeZone,
              {
                  TimeZoneMethod::GetOffsetNanosecondsFor,
                  TimeZoneMethod::GetPossibleInstantsFor,
              },
              &timeZoneRec)) {
        return false;
      }

      // Step 5.a.ii.
      plainRelativeTo.set(nullptr);
      zonedRelativeTo.set(ZonedDateTime{instant, timeZone, calendar});
      timeZoneRecord.set(timeZoneRec);
      return true;
    }

    // Step 5.b.
    if (obj->canUnwrapAs<PlainDateObject>()) {
      plainRelativeTo.set(obj);
      zonedRelativeTo.set(ZonedDateTime{});
      timeZoneRecord.set(TimeZoneRecord{});
      return true;
    }

    // Step 5.c.
    if (auto* dateTime = obj->maybeUnwrapIf<PlainDateTimeObject>()) {
      auto plainDateTime = ToPlainDate(dateTime);

      Rooted<CalendarValue> calendar(cx, dateTime->calendar());
      if (!calendar.wrap(cx)) {
        return false;
      }

      // Step 5.c.i.
      auto* plainDate = CreateTemporalDate(cx, plainDateTime, calendar);
      if (!plainDate) {
        return false;
      }

      // Step 5.c.ii.
      plainRelativeTo.set(plainDate);
      zonedRelativeTo.set(ZonedDateTime{});
      timeZoneRecord.set(TimeZoneRecord{});
      return true;
    }

    // Step 5.d.
    if (!GetTemporalCalendarWithISODefault(cx, obj, &calendar)) {
      return false;
    }

    // Step 5.e.
    Rooted<CalendarRecord> calendarRec(cx);
    if (!CreateCalendarMethodsRecord(cx, calendar,
                                     {
                                         CalendarMethod::DateFromFields,
                                         CalendarMethod::Fields,
                                     },
                                     &calendarRec)) {
      return false;
    }

    // Step 5.f.
    Rooted<PlainObject*> fields(
        cx, PrepareCalendarFields(cx, calendarRec, obj,
                                  {
                                      CalendarField::Day,
                                      CalendarField::Month,
                                      CalendarField::MonthCode,
                                      CalendarField::Year,
                                  },
                                  {
                                      TemporalField::Hour,
                                      TemporalField::Microsecond,
                                      TemporalField::Millisecond,
                                      TemporalField::Minute,
                                      TemporalField::Nanosecond,
                                      TemporalField::Offset,
                                      TemporalField::Second,
                                      TemporalField::TimeZone,
                                  }));
    if (!fields) {
      return false;
    }

    // Step 5.g.
    Rooted<PlainObject*> dateOptions(cx, NewPlainObjectWithProto(cx, nullptr));
    if (!dateOptions) {
      return false;
    }

    // Step 5.h.
    Rooted<Value> overflow(cx, StringValue(cx->names().constrain));
    if (!DefineDataProperty(cx, dateOptions, cx->names().overflow, overflow)) {
      return false;
    }

    // Step 5.i.
    if (!InterpretTemporalDateTimeFields(cx, calendarRec, fields, dateOptions,
                                         &dateTime)) {
      return false;
    }

    // Step 5.j.
    Rooted<Value> offset(cx);
    if (!GetProperty(cx, fields, fields, cx->names().offset, &offset)) {
      return false;
    }

    // Step 5.k.
    Rooted<Value> timeZoneValue(cx);
    if (!GetProperty(cx, fields, fields, cx->names().timeZone,
                     &timeZoneValue)) {
      return false;
    }

    // Step 5.l.
    if (!timeZoneValue.isUndefined()) {
      if (!ToTemporalTimeZone(cx, timeZoneValue, &timeZone)) {
        return false;
      }
    }

    // Step 5.m.
    if (offset.isUndefined()) {
      offsetBehaviour = OffsetBehaviour::Wall;
    }

    // Steps 8-9.
    if (timeZone) {
      if (offsetBehaviour == OffsetBehaviour::Option) {
        MOZ_ASSERT(!offset.isUndefined());
        MOZ_ASSERT(offset.isString());

        // Step 8.a.
        Rooted<JSString*> offsetString(cx, offset.toString());
        if (!offsetString) {
          return false;
        }

        // Step 8.b.
        if (!ParseDateTimeUTCOffset(cx, offsetString, &offsetNs)) {
          return false;
        }
      } else {
        // Step 9.
        offsetNs = 0;
      }
    }
  } else {
    // Step 6.a.
    if (!value.isString()) {
      ReportValueError(cx, JSMSG_UNEXPECTED_TYPE, JSDVG_IGNORE_STACK, value,
                       nullptr, "not a string");
      return false;
    }
    Rooted<JSString*> string(cx, value.toString());

    // Step 6.b.
    bool isUTC;
    bool hasOffset;
    int64_t timeZoneOffset;
    Rooted<ParsedTimeZone> timeZoneAnnotation(cx);
    Rooted<JSString*> calendarString(cx);
    if (!ParseTemporalRelativeToString(cx, string, &dateTime, &isUTC,
                                       &hasOffset, &timeZoneOffset,
                                       &timeZoneAnnotation, &calendarString)) {
      return false;
    }

    // Step 6.c. (Not applicable in our implementation.)

    // Steps 6.e-f.
    if (timeZoneAnnotation) {
      // Step 6.f.i.
      if (!ToTemporalTimeZone(cx, timeZoneAnnotation, &timeZone)) {
        return false;
      }

      // Steps 6.f.ii-iii.
      if (isUTC) {
        offsetBehaviour = OffsetBehaviour::Exact;
      } else if (!hasOffset) {
        offsetBehaviour = OffsetBehaviour::Wall;
      }

      // Step 6.f.iv.
      matchBehaviour = MatchBehaviour::MatchMinutes;
    } else {
      MOZ_ASSERT(!timeZone);
    }

    // Steps 6.g-j.
    if (calendarString) {
      if (!ToBuiltinCalendar(cx, calendarString, &calendar)) {
        return false;
      }
    } else {
      calendar.set(CalendarValue(CalendarId::ISO8601));
    }

    // Steps 8-9.
    if (timeZone) {
      if (offsetBehaviour == OffsetBehaviour::Option) {
        MOZ_ASSERT(hasOffset);

        // Step 8.a.
        offsetNs = timeZoneOffset;
      } else {
        // Step 9.
        offsetNs = 0;
      }
    }
  }

  // Step 7.
  if (!timeZone) {
    // Step 7.a.
    auto* plainDate = CreateTemporalDate(cx, dateTime.date, calendar);
    if (!plainDate) {
      return false;
    }

    plainRelativeTo.set(plainDate);
    zonedRelativeTo.set(ZonedDateTime{});
    timeZoneRecord.set(TimeZoneRecord{});
    return true;
  }

  // Steps 8-9. (Moved above)

  // Step 10.
  Rooted<TimeZoneRecord> timeZoneRec(cx);
  if (!CreateTimeZoneMethodsRecord(cx, timeZone,
                                   {
                                       TimeZoneMethod::GetOffsetNanosecondsFor,
                                       TimeZoneMethod::GetPossibleInstantsFor,
                                   },
                                   &timeZoneRec)) {
    return false;
  }

  // Step 11.
  Instant epochNanoseconds;
  if (!InterpretISODateTimeOffset(
          cx, dateTime, offsetBehaviour, offsetNs, timeZoneRec,
          TemporalDisambiguation::Compatible, TemporalOffset::Reject,
          matchBehaviour, &epochNanoseconds)) {
    return false;
  }
  MOZ_ASSERT(IsValidEpochInstant(epochNanoseconds));

  // Step 12.
  plainRelativeTo.set(nullptr);
  zonedRelativeTo.set(ZonedDateTime{epochNanoseconds, timeZone, calendar});
  timeZoneRecord.set(timeZoneRec);
  return true;
}

/**
 * CreateCalendarMethodsRecordFromRelativeTo ( plainRelativeTo, zonedRelativeTo,
 * methods )
 */
static bool CreateCalendarMethodsRecordFromRelativeTo(
    JSContext* cx, Handle<Wrapped<PlainDateObject*>> plainRelativeTo,
    Handle<ZonedDateTime> zonedRelativeTo,
    mozilla::EnumSet<CalendarMethod> methods,
    MutableHandle<CalendarRecord> result) {
  // Step 1.
  if (zonedRelativeTo) {
    return CreateCalendarMethodsRecord(cx, zonedRelativeTo.calendar(), methods,
                                       result);
  }

  // Step 2.
  if (plainRelativeTo) {
    auto* unwrapped = plainRelativeTo.unwrap(cx);
    if (!unwrapped) {
      return false;
    }

    Rooted<CalendarValue> calendar(cx, unwrapped->calendar());
    if (!calendar.wrap(cx)) {
      return false;
    }

    return CreateCalendarMethodsRecord(cx, calendar, methods, result);
  }

  // Step 3.
  return true;
}

/**
 * RoundNormalizedTimeDurationToIncrement ( d, increment, roundingMode )
 */
static NormalizedTimeDuration RoundNormalizedTimeDurationToIncrement(
    const NormalizedTimeDuration& duration, const TemporalUnit unit,
    Increment increment, TemporalRoundingMode roundingMode) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(duration));
  MOZ_ASSERT(unit >= TemporalUnit::Day);
  MOZ_ASSERT_IF(unit >= TemporalUnit::Hour,
                increment <= MaximumTemporalDurationRoundingIncrement(unit));

  auto divisor = Int128{ToNanoseconds(unit)} * Int128{increment.value()};
  MOZ_ASSERT(divisor > Int128{0});
  MOZ_ASSERT_IF(unit >= TemporalUnit::Hour,
                divisor <= Int128{ToNanoseconds(TemporalUnit::Day)});

  auto totalNanoseconds = duration.toNanoseconds();
  auto rounded =
      RoundNumberToIncrement(totalNanoseconds, divisor, roundingMode);
  return NormalizedTimeDuration::fromNanoseconds(rounded);
}

/**
 * RoundNormalizedTimeDurationToIncrement ( d, increment, roundingMode )
 */
static bool RoundNormalizedTimeDurationToIncrement(
    JSContext* cx, const NormalizedTimeDuration& duration,
    const TemporalUnit unit, Increment increment,
    TemporalRoundingMode roundingMode, NormalizedTimeDuration* result) {
  // Step 1.
  auto rounded = RoundNormalizedTimeDurationToIncrement(
      duration, unit, increment, roundingMode);

  // Step 2.
  if (!IsValidNormalizedTimeDuration(rounded)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }

  // Step 3.
  *result = rounded;
  return true;
}

/**
 * DivideNormalizedTimeDuration ( d, divisor )
 */
double js::temporal::DivideNormalizedTimeDuration(
    const NormalizedTimeDuration& duration, TemporalUnit unit) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(duration));
  MOZ_ASSERT(unit >= TemporalUnit::Day);

  auto numerator = duration.toNanoseconds();
  auto denominator = Int128{ToNanoseconds(unit)};
  return FractionToDouble(numerator, denominator);
}

enum class ComputeRemainder : bool { No, Yes };

#ifdef DEBUG
// Valid duration days are smaller than ⌈(2**53) / (24 * 60 * 60)⌉.
static constexpr int64_t MaxDurationDays = (int64_t(1) << 53) / (24 * 60 * 60);
#endif

struct FractionalDays final {
  int64_t days = 0;
  int64_t time = 0;

  explicit FractionalDays(const NormalizedDuration& duration) {
    MOZ_ASSERT(IsValidDuration(duration));

    auto [seconds, nanoseconds] = duration.time.denormalize();

    int64_t days = seconds / ToSeconds(TemporalUnit::Day);
    seconds = seconds % ToSeconds(TemporalUnit::Day);

    int64_t time = seconds * ToNanoseconds(TemporalUnit::Second) + nanoseconds;
    MOZ_ASSERT(std::abs(time) < ToNanoseconds(TemporalUnit::Day));

    days += duration.date.days;
    MOZ_ASSERT(std::abs(days) <= MaxDurationDays);

    this->days = days;
    this->time = time;
  }
};

struct RoundedDays final {
  int64_t rounded = 0;
  double total = 0;
};

static RoundedDays RoundNumberToIncrement(const FractionalDays& fractionalDays,
                                          Increment increment,
                                          TemporalRoundingMode roundingMode,
                                          ComputeRemainder computeRemainder) {
  MOZ_ASSERT(std::abs(fractionalDays.days) <= MaxDurationDays);
  MOZ_ASSERT(std::abs(fractionalDays.time) < ToNanoseconds(TemporalUnit::Day));
  MOZ_ASSERT(increment <= Increment::max());

  constexpr int64_t dayLength = ToNanoseconds(TemporalUnit::Day);

  // Fast-path when no time components are present. Multiplying and later
  // dividing by |dayLength| cancel each other out.
  if (fractionalDays.time == 0) {
    int64_t totalDays = fractionalDays.days;

    if (computeRemainder == ComputeRemainder::Yes) {
      constexpr int64_t rounded = 0;
      double total = FractionToDouble(totalDays, 1);
      return {rounded, total};
    }

    auto rounded =
        RoundNumberToIncrement(totalDays, 1, increment, roundingMode);
    MOZ_ASSERT(Int128{INT64_MIN} <= rounded && rounded <= Int128{INT64_MAX},
               "rounded days fits in int64");
    constexpr double total = 0;
    return {int64_t(rounded), total};
  }

  // Fast-path when |totalNanoseconds| fits into int64.
  do {
    auto totalNanoseconds =
        mozilla::CheckedInt64(dayLength) * fractionalDays.days;
    totalNanoseconds += fractionalDays.time;
    if (!totalNanoseconds.isValid()) {
      break;
    }

    if (computeRemainder == ComputeRemainder::Yes) {
      constexpr int64_t rounded = 0;
      double total = FractionToDouble(totalNanoseconds.value(), dayLength);
      return {rounded, total};
    }

    auto rounded = RoundNumberToIncrement(totalNanoseconds.value(), dayLength,
                                          increment, roundingMode);
    MOZ_ASSERT(Int128{INT64_MIN} <= rounded && rounded <= Int128{INT64_MAX},
               "rounded days fits in int64");
    constexpr double total = 0;
    return {int64_t(rounded), total};
  } while (false);

  auto totalNanoseconds = Int128{dayLength} * Int128{fractionalDays.days};
  totalNanoseconds += Int128{fractionalDays.time};

  if (computeRemainder == ComputeRemainder::Yes) {
    constexpr int64_t rounded = 0;
    double total = FractionToDouble(totalNanoseconds, Int128{dayLength});
    return {rounded, total};
  }

  auto rounded = RoundNumberToIncrement(totalNanoseconds, Int128{dayLength},
                                        increment, roundingMode);
  MOZ_ASSERT(Int128{INT64_MIN} <= rounded && rounded <= Int128{INT64_MAX},
             "rounded days fits in int64");
  constexpr double total = 0;
  return {int64_t(rounded), total};
}

struct RoundedDuration final {
  NormalizedDuration duration;
  double total = 0;
};

/**
 * RoundTimeDuration ( days, norm, increment, unit, roundingMode )
 */
static RoundedDuration RoundTimeDuration(const NormalizedDuration& duration,
                                         Increment increment, TemporalUnit unit,
                                         TemporalRoundingMode roundingMode,
                                         ComputeRemainder computeRemainder) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(unit > TemporalUnit::Day);

  // The remainder is only needed when called from |Duration_total|. And `total`
  // always passes |increment=1| and |roundingMode=trunc|.
  MOZ_ASSERT_IF(computeRemainder == ComputeRemainder::Yes,
                increment == Increment{1});
  MOZ_ASSERT_IF(computeRemainder == ComputeRemainder::Yes,
                roundingMode == TemporalRoundingMode::Trunc);

  // Step 1.
  MOZ_ASSERT(unit > TemporalUnit::Day);

  // Step 2. (Not applicable)

  // Steps 3.a-d.
  NormalizedTimeDuration time;
  double total = 0;
  if (computeRemainder == ComputeRemainder::No) {
    time = RoundNormalizedTimeDurationToIncrement(duration.time, unit,
                                                  increment, roundingMode);
  } else {
    total = DivideNormalizedTimeDuration(duration.time, unit);
  }

  // Step 4.
  return {NormalizedDuration{duration.date, time}, total};
}

/**
 * RoundTimeDuration ( days, norm, increment, unit, roundingMode )
 */
static bool RoundTimeDuration(JSContext* cx, const NormalizedDuration& duration,
                              Increment increment, TemporalUnit unit,
                              TemporalRoundingMode roundingMode,
                              ComputeRemainder computeRemainder,
                              RoundedDuration* result) {
  MOZ_ASSERT(IsValidDuration(duration));

  // The remainder is only needed when called from |Duration_total|. And `total`
  // always passes |increment=1| and |roundingMode=trunc|.
  MOZ_ASSERT_IF(computeRemainder == ComputeRemainder::Yes,
                increment == Increment{1});
  MOZ_ASSERT_IF(computeRemainder == ComputeRemainder::Yes,
                roundingMode == TemporalRoundingMode::Trunc);

  // Step 1.
  MOZ_ASSERT(unit >= TemporalUnit::Day);

  // Steps 2-3.
  if (unit == TemporalUnit::Day) {
    // Step 2.a.
    auto fractionalDays = FractionalDays{duration};

    // Steps 2.b-c.
    auto [days, total] = RoundNumberToIncrement(fractionalDays, increment,
                                                roundingMode, computeRemainder);

    // Step 2.d
    constexpr auto time = NormalizedTimeDuration{};

    // Step 4.
    auto date = DateDuration{0, 0, 0, days};
    if (!ThrowIfInvalidDuration(cx, date)) {
      return false;
    }

    auto normalized = NormalizedDuration{date, time};
    MOZ_ASSERT(IsValidDuration(normalized));

    *result = {normalized, total};
    return true;
  }

  // Steps 3.a-d.
  auto rounded = RoundTimeDuration(duration, increment, unit, roundingMode,
                                   computeRemainder);
  if (!IsValidNormalizedTimeDuration(rounded.duration.time)) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_INVALID_NORMALIZED_TIME);
    return false;
  }
  MOZ_ASSERT(IsValidDuration(rounded.duration));

  // Step 4.
  *result = rounded;
  return true;
}

/**
 * RoundTimeDuration ( days, norm, increment, unit, roundingMode )
 */
static bool RoundTimeDuration(JSContext* cx,
                              const NormalizedTimeDuration& duration,
                              Increment increment, TemporalUnit unit,
                              TemporalRoundingMode roundingMode,
                              NormalizedTimeDuration* result) {
  auto normalized = NormalizedDuration{{}, duration};

  RoundedDuration rounded;
  if (!RoundTimeDuration(cx, normalized, increment, unit, roundingMode,
                         ComputeRemainder::No, &rounded)) {
    return false;
  }
  *result = rounded.duration.time;
  return true;
}

/**
 * RoundTimeDuration ( days, norm, increment, unit, roundingMode )
 */
NormalizedTimeDuration js::temporal::RoundTimeDuration(
    const NormalizedTimeDuration& duration, Increment increment,
    TemporalUnit unit, TemporalRoundingMode roundingMode) {
  MOZ_ASSERT(IsValidNormalizedTimeDuration(duration));
  MOZ_ASSERT(unit > TemporalUnit::Day);

  auto normalized = NormalizedDuration{{}, duration};
  auto result = ::RoundTimeDuration(normalized, increment, unit, roundingMode,
                                    ComputeRemainder::No);
  MOZ_ASSERT(IsValidNormalizedTimeDuration(result.duration.time));

  return result.duration.time;
}

enum class UnsignedRoundingMode {
  Zero,
  Infinity,
  HalfZero,
  HalfInfinity,
  HalfEven
};

/**
 * GetUnsignedRoundingMode ( roundingMode, sign )
 */
static UnsignedRoundingMode GetUnsignedRoundingMode(
    TemporalRoundingMode roundingMode, bool isNegative) {
  switch (roundingMode) {
    case TemporalRoundingMode::Ceil:
      return isNegative ? UnsignedRoundingMode::Zero
                        : UnsignedRoundingMode::Infinity;
    case TemporalRoundingMode::Floor:
      return isNegative ? UnsignedRoundingMode::Infinity
                        : UnsignedRoundingMode::Zero;
    case TemporalRoundingMode::Expand:
      return UnsignedRoundingMode::Infinity;
    case TemporalRoundingMode::Trunc:
      return UnsignedRoundingMode::Zero;
    case TemporalRoundingMode::HalfCeil:
      return isNegative ? UnsignedRoundingMode::HalfZero
                        : UnsignedRoundingMode::HalfInfinity;
    case TemporalRoundingMode::HalfFloor:
      return isNegative ? UnsignedRoundingMode::HalfInfinity
                        : UnsignedRoundingMode::HalfZero;
    case TemporalRoundingMode::HalfExpand:
      return UnsignedRoundingMode::HalfInfinity;
    case TemporalRoundingMode::HalfTrunc:
      return UnsignedRoundingMode::HalfZero;
    case TemporalRoundingMode::HalfEven:
      return UnsignedRoundingMode::HalfEven;
  }
  MOZ_CRASH("invalid rounding mode");
}

struct DurationNudge {
  NormalizedDuration duration;
  Instant epochNs;
  double total = 0;
  bool didExpandCalendarUnit = false;
};

/**
 * NudgeToCalendarUnit ( sign, duration, destEpochNs, dateTime, calendarRec,
 * timeZoneRec, increment, unit, roundingMode )
 */
static bool NudgeToCalendarUnit(
    JSContext* cx, const NormalizedDuration& duration,
    const Instant& destEpochNs, const PlainDateTime& dateTime,
    Handle<CalendarRecord> calendar, Handle<TimeZoneRecord> timeZone,
    Increment increment, TemporalUnit unit, TemporalRoundingMode roundingMode,
    DurationNudge* result) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(IsValidEpochInstant(destEpochNs));
  MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));
  MOZ_ASSERT(unit <= TemporalUnit::Day);

  int32_t sign = DurationSign(duration) < 0 ? -1 : 1;

  // Steps 1-4.
  int64_t r1;
  int64_t r2;
  DateDuration startDuration;
  DateDuration endDuration;
  if (unit == TemporalUnit::Year) {
    // Step 1.a.
    int64_t years = RoundNumberToIncrement(duration.date.years, increment,
                                           TemporalRoundingMode::Trunc);

    // Step 1.b.
    r1 = years;

    // Step 1.c.
    r2 = years + int64_t(increment.value()) * sign;

    // Step 1.d.
    startDuration = {r1};

    // Step 1.e.
    endDuration = {r2};
  } else if (unit == TemporalUnit::Month) {
    // Step 2.a.
    int64_t months = RoundNumberToIncrement(duration.date.months, increment,
                                            TemporalRoundingMode::Trunc);

    // Step 2.b.
    r1 = months;

    // Step 2.c.
    r2 = months + int64_t(increment.value()) * sign;

    // Step 2.d.
    startDuration = {duration.date.years, r1};

    // Step 2.e.
    endDuration = {duration.date.years, r2};
  } else if (unit == TemporalUnit::Week) {
    // FIXME: spec bug - CreateTemporalDate is fallible. Also possibly incorrect
    // to call BalanceISODate. Just use AddDate for now.
    // https://github.com/tc39/proposal-temporal/issues/2881

    // Steps 3.a and 3.c.
    PlainDate weeksStart;
    if (!AddDate(cx, calendar, dateTime.date,
                 {duration.date.years, duration.date.months}, &weeksStart)) {
      return false;
    }

    // Steps 3.b and 3.d.
    PlainDate weeksEnd;
    if (!AddDate(
            cx, calendar, dateTime.date,
            {duration.date.years, duration.date.months, 0, duration.date.days},
            &weeksEnd)) {
      return false;
    }

    // Steps 3.e-g.
    DateDuration untilResult;
    if (!DifferenceDate(cx, calendar, weeksStart, weeksEnd, TemporalUnit::Week,
                        &untilResult)) {
      return false;
    }

    // Step 3.h.
    int64_t weeks =
        RoundNumberToIncrement(duration.date.weeks + untilResult.weeks,
                               increment, TemporalRoundingMode::Trunc);

    // Step 3.i.
    r1 = weeks;

    // Step 3.j.
    r2 = weeks + int64_t(increment.value()) * sign;

    // Step 3.k.
    startDuration = {duration.date.years, duration.date.months, r1};

    // Step 3.l.
    endDuration = {duration.date.years, duration.date.months, r2};
  } else {
    // Step 4.a.
    MOZ_ASSERT(unit == TemporalUnit::Day);

    // Step 4.b.
    int64_t days = RoundNumberToIncrement(duration.date.days, increment,
                                          TemporalRoundingMode::Trunc);

    // Step 4.c.
    r1 = days;

    // Step 4.d.
    r2 = days + int64_t(increment.value()) * sign;

    // Step 4.e.
    startDuration = {duration.date.years, duration.date.months,
                     duration.date.weeks, r1};

    // Step 4.f.
    endDuration = {duration.date.years, duration.date.months,
                   duration.date.weeks, r2};
  }
  MOZ_ASSERT_IF(sign > 0, r1 >= 0 && r1 < r2);
  MOZ_ASSERT_IF(sign < 0, r1 <= 0 && r1 > r2);

  // Step 5.
  PlainDate start;
  if (!AddDate(cx, calendar, dateTime.date, startDuration, &start)) {
    return false;
  }

  // Step 6.
  PlainDate end;
  if (!AddDate(cx, calendar, dateTime.date, endDuration, &end)) {
    return false;
  }

  // Steps 7-8.
  Instant startEpochNs;
  Instant endEpochNs;
  if (!timeZone.receiver()) {
    // Step 7.a.
    startEpochNs = GetUTCEpochNanoseconds({start, dateTime.time});

    // Step 7.b.
    endEpochNs = GetUTCEpochNanoseconds({end, dateTime.time});
  } else {
    // Step 8.a.
    Rooted<PlainDateTimeWithCalendar> startDateTime(
        cx,
        PlainDateTimeWithCalendar{{start, dateTime.time}, calendar.receiver()});

    // Steps 8.b-c.
    if (!GetInstantFor(cx, timeZone, startDateTime,
                       TemporalDisambiguation::Compatible, &startEpochNs)) {
      return false;
    }

    // Step 8.d.
    Rooted<PlainDateTimeWithCalendar> endDateTime(
        cx,
        PlainDateTimeWithCalendar{{end, dateTime.time}, calendar.receiver()});

    // Steps 8.e-f.
    if (!GetInstantFor(cx, timeZone, endDateTime,
                       TemporalDisambiguation::Compatible, &endEpochNs)) {
      return false;
    }
  }

  if (sign > 0) {
    if (startEpochNs > destEpochNs || destEpochNs >= endEpochNs) {
      JS_ReportErrorNumberASCII(
          cx, GetErrorMessage, nullptr,
          JSMSG_TEMPORAL_ZONED_DATE_TIME_INCONSISTENT_INSTANT);
      return false;
    }
    MOZ_ASSERT(startEpochNs <= destEpochNs && destEpochNs < endEpochNs);
  } else {
    if (endEpochNs >= destEpochNs || destEpochNs > startEpochNs) {
      JS_ReportErrorNumberASCII(
          cx, GetErrorMessage, nullptr,
          JSMSG_TEMPORAL_ZONED_DATE_TIME_INCONSISTENT_INSTANT);
      return false;
    }
    MOZ_ASSERT(endEpochNs < destEpochNs && destEpochNs <= startEpochNs);
  }
  MOZ_ASSERT(startEpochNs != endEpochNs);

  // Steps 10-11.
  auto unsignedRoundingMode = GetUnsignedRoundingMode(roundingMode, sign < 0);

  // Step 12.
  auto numerator = (destEpochNs - startEpochNs).toNanoseconds();
  auto denominator = (endEpochNs - startEpochNs).toNanoseconds();
  MOZ_ASSERT(denominator != Int128{0});
  MOZ_ASSERT(numerator.abs() < denominator.abs());
  MOZ_ASSERT_IF(denominator > Int128{0}, numerator >= Int128{0});
  MOZ_ASSERT_IF(denominator < Int128{0}, numerator <= Int128{0});

  // Ensure |numerator| and |denominator| are both non-negative to simplify the
  // following computations.
  if (denominator < Int128{0}) {
    numerator = -numerator;
    denominator = -denominator;
  }

  // |total| must only be computed when called from Duration.prototype.total,
  // which always passes "trunc" rounding mode with an increment of one.
  double total = mozilla::UnspecifiedNaN<double>();
  if (roundingMode == TemporalRoundingMode::Trunc &&
      increment == Increment{1}) {
    // total = r1 + progress × increment × sign
    //       = r1 + (numerator / denominator) × increment × sign
    //       = r1 + (numerator × increment × sign) / denominator
    //       = (r1 × denominator + numerator × increment × sign) / denominator
    //
    // Computing `n` can't overflow, because:
    // - For years, months, and weeks, `abs(r1) ≤ 2^32`.
    // - For days, `abs(r1) < ⌈(2^53) / (24 * 60 * 60)⌉`.
    // - `denominator` and `numerator` are below-or-equal `2 × 8.64 × 10^21`.
    // - And finally `increment ≤ 10^9`.
    auto n = Int128{r1} * denominator + numerator * Int128{sign};
    total = FractionToDouble(n, denominator);
  }

  // Step 15. (Inlined ApplyUnsignedRoundingMode)
  //
  // clang-format off
  //
  // ApplyUnsignedRoundingMode, steps 1-16.
  //
  // `total = r1` iff `progress = 0`. And `progress = 0` iff `numerator = 0`.
  //
  // d1 = total - r1
  //    = (r1 × denominator + numerator × increment × sign) / denominator - r1
  //    = (numerator × increment × sign) / denominator
  //
  // d2 = r2 - total
  //    = r1 + increment - (r1 × denominator + numerator × increment × sign) / denominator
  //    = (increment × denominator - numerator × increment × sign) / denominator
  //
  // d1 < d2
  // ⇔ (numerator × increment × sign) / denominator < (increment × denominator - numerator × increment × sign) / denominator
  // ⇔ (numerator × increment × sign) < (increment × denominator - numerator × increment × sign)
  // ⇔ (numerator × sign) < (denominator - numerator × sign)
  // ⇔ (2 × numerator × sign) < denominator
  //
  // cardinality = (r1 / (r2 – r1)) modulo 2
  //             = (r1 / (r1 + increment - r1)) modulo 2
  //             = (r1 / increment) modulo 2
  //
  // clang-format on
  bool didExpandCalendarUnit;
  if (numerator == Int128{0}) {
    didExpandCalendarUnit = false;
  } else if (unsignedRoundingMode == UnsignedRoundingMode::Zero) {
    didExpandCalendarUnit = false;
  } else if (unsignedRoundingMode == UnsignedRoundingMode::Infinity) {
    didExpandCalendarUnit = true;
  } else if (numerator + numerator < denominator) {
    didExpandCalendarUnit = false;
  } else if (numerator + numerator > denominator) {
    didExpandCalendarUnit = true;
  } else if (unsignedRoundingMode == UnsignedRoundingMode::HalfZero) {
    didExpandCalendarUnit = false;
  } else if (unsignedRoundingMode == UnsignedRoundingMode::HalfInfinity) {
    didExpandCalendarUnit = true;
  } else if ((r1 / increment.value()) % 2 == 0) {
    didExpandCalendarUnit = false;
  } else {
    didExpandCalendarUnit = true;
  }

  // FIXME: spec bug - zero progress case incorrect
  // https://github.com/tc39/proposal-temporal/issues/2893

  // Steps 16-19.
  auto resultDuration = didExpandCalendarUnit ? endDuration : startDuration;
  auto resultEpochNs = didExpandCalendarUnit ? endEpochNs : startEpochNs;
  *result = {{resultDuration, {}}, resultEpochNs, total, didExpandCalendarUnit};
  return true;
}

/**
 * NudgeToZonedTime ( sign, duration, dateTime, calendarRec, timeZoneRec,
 * increment, unit, roundingMode )
 */
static bool NudgeToZonedTime(JSContext* cx, const NormalizedDuration& duration,
                             const PlainDateTime& dateTime,
                             Handle<CalendarRecord> calendar,
                             Handle<TimeZoneRecord> timeZone,
                             Increment increment, TemporalUnit unit,
                             TemporalRoundingMode roundingMode,
                             DurationNudge* result) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));

  int32_t sign = DurationSign(duration) < 0 ? -1 : 1;

  // Step 1.
  MOZ_ASSERT(unit >= TemporalUnit::Hour);

  // Step 2.
  PlainDate start;
  if (!AddDate(cx, calendar, dateTime.date, duration.date, &start)) {
    return false;
  }

  // Step 3.
  Rooted<PlainDateTimeWithCalendar> startDateTime(
      cx,
      PlainDateTimeWithCalendar{{start, dateTime.time}, calendar.receiver()});
  MOZ_ASSERT(ISODateTimeWithinLimits(startDateTime));

  // Step 4.
  PlainDate end;
  if (!BalanceISODate(cx, start, sign, &end)) {
    return false;
  }

  // Step 5.
  Rooted<PlainDateTimeWithCalendar> endDateTime(cx);
  if (!CreateTemporalDateTime(cx, {end, dateTime.time}, calendar.receiver(),
                              &endDateTime)) {
    return false;
  }

  // Steps 6-7.
  Instant startEpochNs;
  if (!GetInstantFor(cx, timeZone, startDateTime,
                     TemporalDisambiguation::Compatible, &startEpochNs)) {
    return false;
  }

  // Steps 8-9.
  Instant endEpochNs;
  if (!GetInstantFor(cx, timeZone, endDateTime,
                     TemporalDisambiguation::Compatible, &endEpochNs)) {
    return false;
  }

  // Step 10.
  auto daySpan = NormalizedTimeDurationFromEpochNanosecondsDifference(
      endEpochNs, startEpochNs);

  // FIXME: spec bug - how can this assert be valid for custom time zones?

  // Step 11.
  MOZ_ASSERT(NormalizedTimeDurationSign(daySpan) == sign);

  // FIXME: spec issue - Use DifferenceInstant?
  // FIXME: spec issue - Is this call really fallible?

  // Steps 12-13.
  NormalizedTimeDuration roundedTime;
  if (!RoundNormalizedTimeDurationToIncrement(
          cx, duration.time, unit, increment, roundingMode, &roundedTime)) {
    return false;
  }

  // Step 14.
  NormalizedTimeDuration beyondDaySpan;
  if (!SubtractNormalizedTimeDuration(cx, roundedTime, daySpan,
                                      &beyondDaySpan)) {
    return false;
  }

  // Steps 15-16.
  bool didRoundBeyondDay;
  int32_t dayDelta;
  Instant nudgedEpochNs;
  if (NormalizedTimeDurationSign(beyondDaySpan) != -sign) {
    // Step 15.a.
    didRoundBeyondDay = true;

    // Step 15.b.
    dayDelta = sign;

    // Step 15.c.
    if (!RoundNormalizedTimeDurationToIncrement(
            cx, beyondDaySpan, unit, increment, roundingMode, &roundedTime)) {
      return false;
    }

    // Step 15.d. (Inlined AddNormalizedTimeDurationToEpochNanoseconds)
    nudgedEpochNs = endEpochNs + roundedTime.to<InstantSpan>();
  } else {
    // Step 16.a.
    didRoundBeyondDay = false;

    // Step 16.b.
    dayDelta = 0;

    // Step 16.c. (Inlined AddNormalizedTimeDurationToEpochNanoseconds)
    nudgedEpochNs = startEpochNs + roundedTime.to<InstantSpan>();
  }

  // Step 17.
  NormalizedDuration resultDuration;
  if (!CreateNormalizedDurationRecord(cx,
                                      {
                                          duration.date.years,
                                          duration.date.months,
                                          duration.date.weeks,
                                          duration.date.days + dayDelta,
                                      },
                                      roundedTime, &resultDuration)) {
    return false;
  }

  // Step 18.
  *result = {
      resultDuration,
      nudgedEpochNs,
      mozilla::UnspecifiedNaN<double>(),
      didRoundBeyondDay,
  };
  return true;
}

/**
 * NudgeToDayOrTime ( duration, destEpochNs, largestUnit, increment,
 * smallestUnit, roundingMode )
 */
static bool NudgeToDayOrTime(JSContext* cx, const NormalizedDuration& duration,
                             const Instant& destEpochNs,
                             TemporalUnit largestUnit, Increment increment,
                             TemporalUnit smallestUnit,
                             TemporalRoundingMode roundingMode,
                             DurationNudge* result) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(IsValidEpochInstant(destEpochNs));

  // FIXME: spec bug - incorrect assertion
  // https://github.com/tc39/proposal-temporal/issues/2897

  // Step 1.
  MOZ_ASSERT(smallestUnit >= TemporalUnit::Day);

  // Step 2.
  NormalizedTimeDuration withDays;
  if (!Add24HourDaysToNormalizedTimeDuration(cx, duration.time,
                                             duration.date.days, &withDays)) {
    return false;
  }

  // Steps 3-5.
  double total = DivideNormalizedTimeDuration(withDays, smallestUnit);
  NormalizedTimeDuration roundedTime;
  if (!RoundNormalizedTimeDurationToIncrement(
          cx, withDays, smallestUnit, increment, roundingMode, &roundedTime)) {
    return false;
  }

  // Step 6.
  NormalizedTimeDuration diffTime;
  if (!SubtractNormalizedTimeDuration(cx, roundedTime, withDays, &diffTime)) {
    return false;
  }

  constexpr int64_t secPerDay = ToSeconds(TemporalUnit::Day);

  // Step 7.
  int64_t wholeDays = withDays.toSeconds() / secPerDay;

  // Steps 8-9.
  int64_t roundedWholeDays = roundedTime.toSeconds() / secPerDay;

  // Step 10.
  int64_t dayDelta = roundedWholeDays - wholeDays;

  // Step 11.
  int32_t dayDeltaSign = dayDelta < 0 ? -1 : dayDelta > 0 ? 1 : 0;

  // Step 12.
  bool didExpandDays = dayDeltaSign == NormalizedTimeDurationSign(withDays);

  // Step 13. (Inlined AddNormalizedTimeDurationToEpochNanoseconds)
  auto nudgedEpochNs = destEpochNs + diffTime.to<InstantSpan>();

  // Step 14.
  int64_t days = 0;

  // Step 15.
  auto remainder = roundedTime;

  // Step 16.
  if (largestUnit <= TemporalUnit::Day) {
    // Step 16.a.
    days = roundedWholeDays;

    // Step 16.b.
    remainder = roundedTime - NormalizedTimeDuration::fromSeconds(
                                  roundedWholeDays * secPerDay);
  }

  // Step 17.
  NormalizedDuration resultDuration;
  if (!CreateNormalizedDurationRecord(cx,
                                      {
                                          duration.date.years,
                                          duration.date.months,
                                          duration.date.weeks,
                                          days,
                                      },
                                      remainder, &resultDuration)) {
    return false;
  }

  // Step 18.
  *result = {resultDuration, nudgedEpochNs, total, didExpandDays};
  return true;
}

/**
 * BubbleRelativeDuration ( sign, duration, nudgedEpochNs, dateTime,
 * calendarRec, timeZoneRec, largestUnit, smallestUnit )
 */
static bool BubbleRelativeDuration(
    JSContext* cx, const NormalizedDuration& duration,
    const DurationNudge& nudge, const PlainDateTime& dateTime,
    Handle<CalendarRecord> calendar, Handle<TimeZoneRecord> timeZone,
    TemporalUnit largestUnit, TemporalUnit smallestUnit,
    NormalizedDuration* result) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(IsValidDuration(nudge.duration));
  MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));
  MOZ_ASSERT(largestUnit <= smallestUnit);

  int32_t sign = DurationSign(duration) < 0 ? -1 : 1;

  // Step 1.
  MOZ_ASSERT(largestUnit <= TemporalUnit::Day);

  // Step 2.
  MOZ_ASSERT(smallestUnit <= TemporalUnit::Day);

  // FIXME: spec issue - directly return when `smallestUnit == largestUnit`.
  // https://github.com/tc39/proposal-temporal/issues/2890

  // Step 3.
  if (smallestUnit == largestUnit) {
    *result = nudge.duration;
    return true;
  }
  MOZ_ASSERT(smallestUnit != TemporalUnit::Year);

  // FIXME: spec bug - wrong loop condition and "day" case not reachable
  // https://github.com/tc39/proposal-temporal/issues/2890

  // Steps 4-8.
  auto dateDuration = nudge.duration.date;
  auto timeDuration = nudge.duration.time;
  auto unit = smallestUnit;
  while (unit > largestUnit) {
    // Steps 6 and 8.c.
    using TemporalUnitType = std::underlying_type_t<TemporalUnit>;

    static_assert(static_cast<TemporalUnitType>(TemporalUnit::Auto) == 0,
                  "TemporalUnit::Auto has value zero");
    MOZ_ASSERT(unit > TemporalUnit::Auto, "can subtract unit by one");

    unit = static_cast<TemporalUnit>(static_cast<TemporalUnitType>(unit) - 1);

    MOZ_ASSERT(TemporalUnit::Year <= unit && unit <= TemporalUnit::Week);

    // Step 8.a. (Not applicable in our implementation.)

    // Step 8.b.
    if (unit != TemporalUnit::Week || largestUnit == TemporalUnit::Week) {
      // Steps 8.b.i-iv.
      DateDuration endDuration;
      if (unit == TemporalUnit::Year) {
        // Step 8.b.i.1.
        int64_t years = dateDuration.years + sign;

        // Step 8.b.i.2.
        endDuration = {years};
      } else if (unit == TemporalUnit::Month) {
        // Step 8.b.ii.1.
        int64_t months = dateDuration.months + sign;

        // Step 8.b.ii.2.
        endDuration = {dateDuration.years, months};
      } else if (unit == TemporalUnit::Week) {
        // Step 8.b.iii.1.
        int64_t weeks = dateDuration.weeks + sign;

        // Step 8.b.iii.2.
        endDuration = {dateDuration.years, dateDuration.months, weeks};
      } else {
        // Step 8.b.iv.1.
        MOZ_ASSERT(unit == TemporalUnit::Day);

        // Step 8.b.iv.2.
        int64_t days = dateDuration.days + sign;

        // Step 8.b.iv.2.
        endDuration = {dateDuration.years, dateDuration.months,
                       dateDuration.weeks, days};
      }

      // Step 8.b.v.
      PlainDate end;
      if (!AddDate(cx, calendar, dateTime.date, endDuration, &end)) {
        return false;
      }

      // Steps 8.b.vi-vii.
      Instant endEpochNs;
      if (!timeZone.receiver()) {
        // Step 8.b.vi.1.
        endEpochNs = GetUTCEpochNanoseconds({end, dateTime.time});
      } else {
        // Step 8.b.vii.1.
        Rooted<PlainDateTimeWithCalendar> endDateTime(
            cx, PlainDateTimeWithCalendar{{end, dateTime.time},
                                          calendar.receiver()});

        // Steps 8.b.vii.2-3.
        if (!GetInstantFor(cx, timeZone, endDateTime,
                           TemporalDisambiguation::Compatible, &endEpochNs)) {
          return false;
        }
      }

      // Step 8.b.viii.
      //
      // NB: |nudge.epochNs| can be outside the valid epoch nanoseconds limits.
      auto beyondEnd = nudge.epochNs - endEpochNs;

      // Step 8.b.ix.
      int32_t beyondEndSign = beyondEnd < InstantSpan{}   ? -1
                              : beyondEnd > InstantSpan{} ? 1
                                                          : 0;

      // Steps 8.b.x-xi.
      if (beyondEndSign != -sign) {
        dateDuration = endDuration;
        timeDuration = {};
      } else {
        break;
      }
    }

    // Step 8.c. (Moved above)
  }

  // Step 9.
  *result = {dateDuration, timeDuration};
  return true;
}

/**
 * RoundRelativeDuration ( duration, destEpochNs, dateTime, calendarRec,
 * timeZoneRec, largestUnit, increment, smallestUnit, roundingMode )
 */
bool js::temporal::RoundRelativeDuration(
    JSContext* cx, const NormalizedDuration& duration,
    const Instant& destEpochNs, const PlainDateTime& dateTime,
    Handle<CalendarRecord> calendar, Handle<TimeZoneRecord> timeZone,
    TemporalUnit largestUnit, Increment increment, TemporalUnit smallestUnit,
    TemporalRoundingMode roundingMode, RoundedRelativeDuration* result) {
  MOZ_ASSERT(IsValidDuration(duration));
  MOZ_ASSERT(IsValidEpochInstant(destEpochNs));
  MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));
  MOZ_ASSERT(largestUnit <= smallestUnit);

  // Steps 1-3.
  bool irregularLengthUnit =
      (smallestUnit < TemporalUnit::Day) ||
      (timeZone.receiver() && smallestUnit == TemporalUnit::Day);

  // Step 4. (Not applicable in our implementation.)

  // Steps 5-7.
  DurationNudge nudge;
  if (irregularLengthUnit) {
    // Step 5.a.
    if (!NudgeToCalendarUnit(cx, duration, destEpochNs, dateTime, calendar,
                             timeZone, increment, smallestUnit, roundingMode,
                             &nudge)) {
      return false;
    }
  } else if (timeZone.receiver()) {
    // Step 6.a.
    if (!NudgeToZonedTime(cx, duration, dateTime, calendar, timeZone, increment,
                          smallestUnit, roundingMode, &nudge)) {
      return false;
    }
  } else {
    // Step 7.a.
    if (!NudgeToDayOrTime(cx, duration, destEpochNs, largestUnit, increment,
                          smallestUnit, roundingMode, &nudge)) {
      return false;
    }
  }

  // Step 8.
  auto nudgedDuration = nudge.duration;

  // Step 9.
  if (nudge.didExpandCalendarUnit && smallestUnit != TemporalUnit::Week) {
    // Step 9.a. (Inlined LargerOfTwoTemporalUnits)
    auto startUnit = std::min(smallestUnit, TemporalUnit::Day);

    // Step 9.b.
    if (!BubbleRelativeDuration(cx, duration, nudge, dateTime, calendar,
                                timeZone, largestUnit, startUnit,
                                &nudgedDuration)) {
      return false;
    }
  }

  // Step 10.
  largestUnit = std::max(largestUnit, TemporalUnit::Hour);

  // Step 11.
  TimeDuration balanced;
  if (!BalanceTimeDuration(cx, nudgedDuration.time, largestUnit, &balanced)) {
    return false;
  }

  // Step 12.
  auto resultDuration = Duration{
      double(nudgedDuration.date.years),
      double(nudgedDuration.date.months),
      double(nudgedDuration.date.weeks),
      double(nudgedDuration.date.days),
      double(balanced.hours),
      double(balanced.minutes),
      double(balanced.seconds),
      double(balanced.milliseconds),
      balanced.microseconds,
      balanced.nanoseconds,
  };
  MOZ_ASSERT(IsValidDuration(resultDuration));

  *result = {resultDuration, nudge.total};
  return true;
}

enum class DurationOperation { Add, Subtract };

/**
 * AddDurations ( operation, duration, other )
 */
static bool AddDurations(JSContext* cx, DurationOperation operation,
                         const CallArgs& args) {
  auto* durationObj = &args.thisv().toObject().as<DurationObject>();
  auto duration = ToDuration(durationObj);

  // Step 1. (Not applicable in our implementation.)

  // Step 2.
  Duration other;
  if (!ToTemporalDurationRecord(cx, args.get(0), &other)) {
    return false;
  }

  // Steps 3-12. (Not applicable in our implementation.)

  // Steps 13-22.
  if (operation == DurationOperation::Subtract) {
    other = other.negate();
  }

  // Step 23.
  auto largestUnit1 = DefaultTemporalLargestUnit(duration);

  // Step 24.
  auto largestUnit2 = DefaultTemporalLargestUnit(other);

  // Step 25.
  auto largestUnit = std::min(largestUnit1, largestUnit2);

  // Step 26.
  auto normalized1 = NormalizeTimeDuration(duration);

  // Step 27.
  auto normalized2 = NormalizeTimeDuration(other);

  // Step 28.
  if (largestUnit <= TemporalUnit::Week) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_DURATION_UNCOMPARABLE,
                              "relativeTo");
    return false;
  }

  // Step 29.
  NormalizedTimeDuration normalized;
  if (!AddNormalizedTimeDuration(cx, normalized1, normalized2, &normalized)) {
    return false;
  }

  // Step 30.
  int64_t days1 = mozilla::AssertedCast<int64_t>(duration.days);
  int64_t days2 = mozilla::AssertedCast<int64_t>(other.days);
  auto totalDays = mozilla::CheckedInt64(days1) + days2;
  MOZ_ASSERT(totalDays.isValid(), "adding two duration days can't overflow");

  if (!Add24HourDaysToNormalizedTimeDuration(cx, normalized, totalDays.value(),
                                             &normalized)) {
    return false;
  }

  // Step 31.
  TimeDuration balanced;
  if (!temporal::BalanceTimeDuration(cx, normalized, largestUnit, &balanced)) {
    return false;
  }

  // Step 32.
  auto* obj = CreateTemporalDuration(cx, balanced.toDuration());
  if (!obj) {
    return false;
  }

  args.rval().setObject(*obj);
  return true;
}

/**
 * Temporal.Duration ( [ years [ , months [ , weeks [ , days [ , hours [ ,
 * minutes [ , seconds [ , milliseconds [ , microseconds [ , nanoseconds ] ] ] ]
 * ] ] ] ] ] ] )
 */
static bool DurationConstructor(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);

  // Step 1.
  if (!ThrowIfNotConstructing(cx, args, "Temporal.Duration")) {
    return false;
  }

  // Step 2.
  double years = 0;
  if (args.hasDefined(0) &&
      !ToIntegerIfIntegral(cx, "years", args[0], &years)) {
    return false;
  }

  // Step 3.
  double months = 0;
  if (args.hasDefined(1) &&
      !ToIntegerIfIntegral(cx, "months", args[1], &months)) {
    return false;
  }

  // Step 4.
  double weeks = 0;
  if (args.hasDefined(2) &&
      !ToIntegerIfIntegral(cx, "weeks", args[2], &weeks)) {
    return false;
  }

  // Step 5.
  double days = 0;
  if (args.hasDefined(3) && !ToIntegerIfIntegral(cx, "days", args[3], &days)) {
    return false;
  }

  // Step 6.
  double hours = 0;
  if (args.hasDefined(4) &&
      !ToIntegerIfIntegral(cx, "hours", args[4], &hours)) {
    return false;
  }

  // Step 7.
  double minutes = 0;
  if (args.hasDefined(5) &&
      !ToIntegerIfIntegral(cx, "minutes", args[5], &minutes)) {
    return false;
  }

  // Step 8.
  double seconds = 0;
  if (args.hasDefined(6) &&
      !ToIntegerIfIntegral(cx, "seconds", args[6], &seconds)) {
    return false;
  }

  // Step 9.
  double milliseconds = 0;
  if (args.hasDefined(7) &&
      !ToIntegerIfIntegral(cx, "milliseconds", args[7], &milliseconds)) {
    return false;
  }

  // Step 10.
  double microseconds = 0;
  if (args.hasDefined(8) &&
      !ToIntegerIfIntegral(cx, "microseconds", args[8], &microseconds)) {
    return false;
  }

  // Step 11.
  double nanoseconds = 0;
  if (args.hasDefined(9) &&
      !ToIntegerIfIntegral(cx, "nanoseconds", args[9], &nanoseconds)) {
    return false;
  }

  // Step 12.
  auto* duration = CreateTemporalDuration(
      cx, args,
      {years, months, weeks, days, hours, minutes, seconds, milliseconds,
       microseconds, nanoseconds});
  if (!duration) {
    return false;
  }

  args.rval().setObject(*duration);
  return true;
}

/**
 * Temporal.Duration.from ( item )
 */
static bool Duration_from(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);

  Handle<Value> item = args.get(0);

  // Step 1.
  if (item.isObject()) {
    if (auto* duration = item.toObject().maybeUnwrapIf<DurationObject>()) {
      auto* result = CreateTemporalDuration(cx, ToDuration(duration));
      if (!result) {
        return false;
      }

      args.rval().setObject(*result);
      return true;
    }
  }

  // Step 2.
  auto result = ToTemporalDuration(cx, item);
  if (!result) {
    return false;
  }

  args.rval().setObject(*result);
  return true;
}

/**
 * Temporal.Duration.compare ( one, two [ , options ] )
 */
static bool Duration_compare(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);

  // Step 1.
  Duration one;
  if (!ToTemporalDuration(cx, args.get(0), &one)) {
    return false;
  }

  // Step 2.
  Duration two;
  if (!ToTemporalDuration(cx, args.get(1), &two)) {
    return false;
  }

  // Step 3.
  Rooted<JSObject*> options(cx);
  if (args.hasDefined(2)) {
    options = RequireObjectArg(cx, "options", "compare", args[2]);
    if (!options) {
      return false;
    }
  }

  // Step 4.
  if (one == two) {
    args.rval().setInt32(0);
    return true;
  }

  // Steps 5-8.
  Rooted<Wrapped<PlainDateObject*>> plainRelativeTo(cx);
  Rooted<ZonedDateTime> zonedRelativeTo(cx);
  Rooted<TimeZoneRecord> timeZone(cx);
  if (options) {
    if (!GetTemporalRelativeToOption(cx, options, &plainRelativeTo,
                                     &zonedRelativeTo, &timeZone)) {
      return false;
    }
    MOZ_ASSERT(!plainRelativeTo || !zonedRelativeTo);
    MOZ_ASSERT_IF(zonedRelativeTo, timeZone.receiver());
  }

  // Steps 9-10.
  auto hasCalendarUnit = [](const auto& d) {
    return d.years != 0 || d.months != 0 || d.weeks != 0;
  };
  bool calendarUnitsPresent = hasCalendarUnit(one) || hasCalendarUnit(two);

  // Step 11.
  Rooted<CalendarRecord> calendar(cx);
  if (!CreateCalendarMethodsRecordFromRelativeTo(cx, plainRelativeTo,
                                                 zonedRelativeTo,
                                                 {
                                                     CalendarMethod::DateAdd,
                                                 },
                                                 &calendar)) {
    return false;
  }

  // Step 12.
  if (zonedRelativeTo &&
      (calendarUnitsPresent || one.days != 0 || two.days != 0)) {
    // Step 12.a.
    const auto& instant = zonedRelativeTo.instant();

    // Step 12.b.
    PlainDateTime dateTime;
    if (!GetPlainDateTimeFor(cx, timeZone, instant, &dateTime)) {
      return false;
    }

    // Step 12.c.
    auto normalized1 = CreateNormalizedDurationRecord(one);

    // Step 12.d.
    auto normalized2 = CreateNormalizedDurationRecord(two);

    // Step 12.e.
    Instant after1;
    if (!AddZonedDateTime(cx, instant, timeZone, calendar, normalized1,
                          dateTime, &after1)) {
      return false;
    }

    // Step 12.f.
    Instant after2;
    if (!AddZonedDateTime(cx, instant, timeZone, calendar, normalized2,
                          dateTime, &after2)) {
      return false;
    }

    // Steps 12.g-i.
    args.rval().setInt32(after1 < after2 ? -1 : after1 > after2 ? 1 : 0);
    return true;
  }

  // Steps 13-14.
  int64_t days1, days2;
  if (calendarUnitsPresent) {
    // Step 13.a.
    if (!plainRelativeTo) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_DURATION_UNCOMPARABLE,
                                "relativeTo");
      return false;
    }

    // Step 13.b.
    if (!UnbalanceDateDurationRelative(cx, one.toDateDuration(),
                                       plainRelativeTo, calendar, &days1)) {
      return false;
    }

    // Step 13.c.
    if (!UnbalanceDateDurationRelative(cx, two.toDateDuration(),
                                       plainRelativeTo, calendar, &days2)) {
      return false;
    }
  } else {
    // Step 14.a.
    days1 = mozilla::AssertedCast<int64_t>(one.days);

    // Step 14.b.
    days2 = mozilla::AssertedCast<int64_t>(two.days);
  }

  // Step 15.
  auto normalized1 = NormalizeTimeDuration(one);

  // Step 16.
  if (!Add24HourDaysToNormalizedTimeDuration(cx, normalized1, days1,
                                             &normalized1)) {
    return false;
  }

  // Step 17.
  auto normalized2 = NormalizeTimeDuration(two);

  // Step 18.
  if (!Add24HourDaysToNormalizedTimeDuration(cx, normalized2, days2,
                                             &normalized2)) {
    return false;
  }

  // Step 19.
  args.rval().setInt32(CompareNormalizedTimeDuration(normalized1, normalized2));
  return true;
}

/**
 * get Temporal.Duration.prototype.years
 */
static bool Duration_years(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->years());
  return true;
}

/**
 * get Temporal.Duration.prototype.years
 */
static bool Duration_years(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_years>(cx, args);
}

/**
 * get Temporal.Duration.prototype.months
 */
static bool Duration_months(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->months());
  return true;
}

/**
 * get Temporal.Duration.prototype.months
 */
static bool Duration_months(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_months>(cx, args);
}

/**
 * get Temporal.Duration.prototype.weeks
 */
static bool Duration_weeks(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->weeks());
  return true;
}

/**
 * get Temporal.Duration.prototype.weeks
 */
static bool Duration_weeks(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_weeks>(cx, args);
}

/**
 * get Temporal.Duration.prototype.days
 */
static bool Duration_days(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->days());
  return true;
}

/**
 * get Temporal.Duration.prototype.days
 */
static bool Duration_days(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_days>(cx, args);
}

/**
 * get Temporal.Duration.prototype.hours
 */
static bool Duration_hours(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->hours());
  return true;
}

/**
 * get Temporal.Duration.prototype.hours
 */
static bool Duration_hours(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_hours>(cx, args);
}

/**
 * get Temporal.Duration.prototype.minutes
 */
static bool Duration_minutes(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->minutes());
  return true;
}

/**
 * get Temporal.Duration.prototype.minutes
 */
static bool Duration_minutes(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_minutes>(cx, args);
}

/**
 * get Temporal.Duration.prototype.seconds
 */
static bool Duration_seconds(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->seconds());
  return true;
}

/**
 * get Temporal.Duration.prototype.seconds
 */
static bool Duration_seconds(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_seconds>(cx, args);
}

/**
 * get Temporal.Duration.prototype.milliseconds
 */
static bool Duration_milliseconds(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->milliseconds());
  return true;
}

/**
 * get Temporal.Duration.prototype.milliseconds
 */
static bool Duration_milliseconds(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_milliseconds>(cx, args);
}

/**
 * get Temporal.Duration.prototype.microseconds
 */
static bool Duration_microseconds(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->microseconds());
  return true;
}

/**
 * get Temporal.Duration.prototype.microseconds
 */
static bool Duration_microseconds(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_microseconds>(cx, args);
}

/**
 * get Temporal.Duration.prototype.nanoseconds
 */
static bool Duration_nanoseconds(JSContext* cx, const CallArgs& args) {
  // Step 3.
  auto* duration = &args.thisv().toObject().as<DurationObject>();
  args.rval().setNumber(duration->nanoseconds());
  return true;
}

/**
 * get Temporal.Duration.prototype.nanoseconds
 */
static bool Duration_nanoseconds(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_nanoseconds>(cx, args);
}

/**
 * get Temporal.Duration.prototype.sign
 */
static bool Duration_sign(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Step 3.
  args.rval().setInt32(DurationSign(duration));
  return true;
}

/**
 * get Temporal.Duration.prototype.sign
 */
static bool Duration_sign(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_sign>(cx, args);
}

/**
 * get Temporal.Duration.prototype.blank
 */
static bool Duration_blank(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Steps 3-5.
  args.rval().setBoolean(duration == Duration{});
  return true;
}

/**
 * get Temporal.Duration.prototype.blank
 */
static bool Duration_blank(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_blank>(cx, args);
}

/**
 * Temporal.Duration.prototype.with ( temporalDurationLike )
 *
 * ToPartialDuration ( temporalDurationLike )
 */
static bool Duration_with(JSContext* cx, const CallArgs& args) {
  // Absent values default to the corresponding values of |this| object.
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Steps 3-23.
  Rooted<JSObject*> temporalDurationLike(
      cx, RequireObjectArg(cx, "temporalDurationLike", "with", args.get(0)));
  if (!temporalDurationLike) {
    return false;
  }
  if (!ToTemporalPartialDurationRecord(cx, temporalDurationLike, &duration)) {
    return false;
  }

  // Step 24.
  auto* result = CreateTemporalDuration(cx, duration);
  if (!result) {
    return false;
  }

  args.rval().setObject(*result);
  return true;
}

/**
 * Temporal.Duration.prototype.with ( temporalDurationLike )
 */
static bool Duration_with(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_with>(cx, args);
}

/**
 * Temporal.Duration.prototype.negated ( )
 */
static bool Duration_negated(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Step 3.
  auto* result = CreateTemporalDuration(cx, duration.negate());
  if (!result) {
    return false;
  }

  args.rval().setObject(*result);
  return true;
}

/**
 * Temporal.Duration.prototype.negated ( )
 */
static bool Duration_negated(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_negated>(cx, args);
}

/**
 * Temporal.Duration.prototype.abs ( )
 */
static bool Duration_abs(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Step 3.
  auto* result = CreateTemporalDuration(cx, AbsoluteDuration(duration));
  if (!result) {
    return false;
  }

  args.rval().setObject(*result);
  return true;
}

/**
 * Temporal.Duration.prototype.abs ( )
 */
static bool Duration_abs(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_abs>(cx, args);
}

/**
 * Temporal.Duration.prototype.add ( other )
 */
static bool Duration_add(JSContext* cx, const CallArgs& args) {
  // Step 3.
  return AddDurations(cx, DurationOperation::Add, args);
}

/**
 * Temporal.Duration.prototype.add ( other )
 */
static bool Duration_add(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_add>(cx, args);
}

/**
 * Temporal.Duration.prototype.subtract ( other )
 */
static bool Duration_subtract(JSContext* cx, const CallArgs& args) {
  // Step 3.
  return AddDurations(cx, DurationOperation::Subtract, args);
}

/**
 * Temporal.Duration.prototype.subtract ( other )
 */
static bool Duration_subtract(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_subtract>(cx, args);
}

/**
 * Temporal.Duration.prototype.round ( roundTo )
 */
static bool Duration_round(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Step 18. (Reordered)
  auto existingLargestUnit = DefaultTemporalLargestUnit(duration);

  // Steps 3-25.
  auto smallestUnit = TemporalUnit::Auto;
  TemporalUnit largestUnit;
  auto roundingMode = TemporalRoundingMode::HalfExpand;
  auto roundingIncrement = Increment{1};
  Rooted<JSObject*> relativeTo(cx);
  Rooted<Wrapped<PlainDateObject*>> plainRelativeTo(cx);
  Rooted<ZonedDateTime> zonedRelativeTo(cx);
  Rooted<TimeZoneRecord> timeZone(cx);
  if (args.get(0).isString()) {
    // Step 4. (Not applicable in our implementation.)

    // Steps 6-15. (Not applicable)

    // Step 16.
    Rooted<JSString*> paramString(cx, args[0].toString());
    if (!GetTemporalUnitValuedOption(
            cx, paramString, TemporalUnitKey::SmallestUnit,
            TemporalUnitGroup::DateTime, &smallestUnit)) {
      return false;
    }

    // Step 17. (Not applicable)

    // Step 18. (Moved above)

    // Step 19.
    auto defaultLargestUnit = std::min(existingLargestUnit, smallestUnit);

    // Step 20. (Not applicable)

    // Step 20.a. (Not applicable)

    // Step 20.b.
    largestUnit = defaultLargestUnit;

    // Steps 21-25. (Not applicable)
  } else {
    // Steps 3 and 5.
    Rooted<JSObject*> options(
        cx, RequireObjectArg(cx, "roundTo", "round", args.get(0)));
    if (!options) {
      return false;
    }

    // Step 6.
    bool smallestUnitPresent = true;

    // Step 7.
    bool largestUnitPresent = true;

    // Steps 8-9.
    //
    // Inlined GetTemporalUnitValuedOption and GetOption so we can more easily
    // detect an absent "largestUnit" value.
    Rooted<Value> largestUnitValue(cx);
    if (!GetProperty(cx, options, options, cx->names().largestUnit,
                     &largestUnitValue)) {
      return false;
    }

    if (!largestUnitValue.isUndefined()) {
      Rooted<JSString*> largestUnitStr(cx, JS::ToString(cx, largestUnitValue));
      if (!largestUnitStr) {
        return false;
      }

      largestUnit = TemporalUnit::Auto;
      if (!GetTemporalUnitValuedOption(
              cx, largestUnitStr, TemporalUnitKey::LargestUnit,
              TemporalUnitGroup::DateTime, &largestUnit)) {
        return false;
      }
    }

    // Steps 10-13.
    if (!GetTemporalRelativeToOption(cx, options, &plainRelativeTo,
                                     &zonedRelativeTo, &timeZone)) {
      return false;
    }
    MOZ_ASSERT(!plainRelativeTo || !zonedRelativeTo);
    MOZ_ASSERT_IF(zonedRelativeTo, timeZone.receiver());

    // Step 14.
    if (!GetRoundingIncrementOption(cx, options, &roundingIncrement)) {
      return false;
    }

    // Step 15.
    if (!GetRoundingModeOption(cx, options, &roundingMode)) {
      return false;
    }

    // Step 16.
    if (!GetTemporalUnitValuedOption(cx, options, TemporalUnitKey::SmallestUnit,
                                     TemporalUnitGroup::DateTime,
                                     &smallestUnit)) {
      return false;
    }

    // Step 17.
    if (smallestUnit == TemporalUnit::Auto) {
      // Step 17.a.
      smallestUnitPresent = false;

      // Step 17.b.
      smallestUnit = TemporalUnit::Nanosecond;
    }

    // Step 18. (Moved above)

    // Step 19.
    auto defaultLargestUnit = std::min(existingLargestUnit, smallestUnit);

    // Steps 20-21.
    if (largestUnitValue.isUndefined()) {
      // Step 20.a.
      largestUnitPresent = false;

      // Step 20.b.
      largestUnit = defaultLargestUnit;
    } else if (largestUnit == TemporalUnit::Auto) {
      // Step 21.a
      largestUnit = defaultLargestUnit;
    }

    // Step 22.
    if (!smallestUnitPresent && !largestUnitPresent) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_DURATION_MISSING_UNIT_SPECIFIER);
      return false;
    }

    // Step 23.
    if (largestUnit > smallestUnit) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_INVALID_UNIT_RANGE);
      return false;
    }

    // Steps 24-25.
    if (smallestUnit > TemporalUnit::Day) {
      // Step 24.
      auto maximum = MaximumTemporalDurationRoundingIncrement(smallestUnit);

      // Step 25.
      if (!ValidateTemporalRoundingIncrement(cx, roundingIncrement, maximum,
                                             false)) {
        return false;
      }
    }
  }

  // Step 26.
  bool hoursToDaysConversionMayOccur = false;

  // Step 27.
  if (duration.days != 0 && zonedRelativeTo) {
    hoursToDaysConversionMayOccur = true;
  }

  // Step 28.
  else if (std::abs(duration.hours) >= 24) {
    hoursToDaysConversionMayOccur = true;
  }

  // Step 29.
  bool roundingGranularityIsNoop = smallestUnit == TemporalUnit::Nanosecond &&
                                   roundingIncrement == Increment{1};

  // Step 30.
  bool calendarUnitsPresent =
      duration.years != 0 || duration.months != 0 || duration.weeks != 0;

  // Step 31.
  if (roundingGranularityIsNoop && largestUnit == existingLargestUnit &&
      !calendarUnitsPresent && !hoursToDaysConversionMayOccur &&
      std::abs(duration.minutes) < 60 && std::abs(duration.seconds) < 60 &&
      std::abs(duration.milliseconds) < 1000 &&
      std::abs(duration.microseconds) < 1000 &&
      std::abs(duration.nanoseconds) < 1000) {
    // Steps 31.a-b.
    auto* obj = CreateTemporalDuration(cx, duration);
    if (!obj) {
      return false;
    }

    args.rval().setObject(*obj);
    return true;
  }

  // Step 32.
  mozilla::Maybe<const PlainDateTime&> precalculatedPlainDateTime{};

  // Step 33.
  bool plainDateTimeOrRelativeToWillBeUsed = largestUnit <= TemporalUnit::Day ||
                                             calendarUnitsPresent ||
                                             duration.days != 0;

  // Step 34.
  PlainDateTime relativeToDateTime;
  if (zonedRelativeTo && plainDateTimeOrRelativeToWillBeUsed) {
    // Steps 34.a-b.
    const auto& instant = zonedRelativeTo.instant();

    // Step 34.c.
    if (!GetPlainDateTimeFor(cx, timeZone, instant, &relativeToDateTime)) {
      return false;
    }
    precalculatedPlainDateTime =
        mozilla::SomeRef<const PlainDateTime>(relativeToDateTime);

    // FIXME: spec issue - Unnecessary CreateTemporalDate call
    //
    // https://github.com/tc39/proposal-temporal/issues/2873
  }

  // Step 35.
  Rooted<CalendarRecord> calendar(cx);
  if (!CreateCalendarMethodsRecordFromRelativeTo(cx, plainRelativeTo,
                                                 zonedRelativeTo,
                                                 {
                                                     CalendarMethod::DateAdd,
                                                     CalendarMethod::DateUntil,
                                                 },
                                                 &calendar)) {
    return false;
  }

  // Step 36.
  auto normDuration = CreateNormalizedDurationRecord(duration);

  // Step 37. (Not applicable in our implementation.)

  // Steps 38-40.
  Duration roundResult;
  if (zonedRelativeTo) {
    // Step 38.a.
    auto relativeEpochNs = zonedRelativeTo.instant();

    // Step 38.b.
    const auto& relativeInstant = relativeEpochNs;

    // Steps 38.c-d.
    if (precalculatedPlainDateTime) {
      // Step 38.c.
      Instant targetEpochNs;
      if (!AddZonedDateTime(cx, relativeInstant, timeZone, calendar,
                            normDuration, *precalculatedPlainDateTime,
                            &targetEpochNs)) {
        return false;
      }

      // Step 38.d.
      if (!DifferenceZonedDateTimeWithRounding(
              cx, relativeEpochNs, targetEpochNs, timeZone, calendar,
              *precalculatedPlainDateTime,
              {
                  smallestUnit,
                  largestUnit,
                  roundingMode,
                  roundingIncrement,
              },
              &roundResult)) {
        return false;
      }
    } else {
      // Step 38.c.
      Instant targetEpochNs;
      if (!AddZonedDateTime(cx, relativeInstant, timeZone, calendar,
                            normDuration, &targetEpochNs)) {
        return false;
      }

      // Step 38.d.
      if (!DifferenceZonedDateTimeWithRounding(cx, relativeEpochNs,
                                               targetEpochNs,
                                               {
                                                   smallestUnit,
                                                   largestUnit,
                                                   roundingMode,
                                                   roundingIncrement,
                                               },
                                               &roundResult)) {
        return false;
      }
    }
  } else if (plainRelativeTo) {
    // Step 39.a.
    auto targetTime = AddTime(PlainTime{}, normDuration.time);

    // Step 39.b.
    auto dateDuration = DateDuration{
        normDuration.date.years,
        normDuration.date.months,
        normDuration.date.weeks,
        normDuration.date.days + targetTime.days,
    };
    MOZ_ASSERT(IsValidDuration(dateDuration));

    // Step 39.c.
    PlainDate targetDate;
    if (!AddDate(cx, calendar, plainRelativeTo, dateDuration, &targetDate)) {
      return false;
    }
    auto targetDateTime = PlainDateTime{targetDate, targetTime.time};

    auto* unwrappedRelativeTo = plainRelativeTo.unwrap(cx);
    if (!unwrappedRelativeTo) {
      return false;
    }
    auto sourceDateTime = PlainDateTime{ToPlainDate(unwrappedRelativeTo), {}};

    // Step 39.d.
    if (!DifferencePlainDateTimeWithRounding(cx, sourceDateTime, targetDateTime,
                                             calendar,
                                             {
                                                 smallestUnit,
                                                 largestUnit,
                                                 roundingMode,
                                                 roundingIncrement,
                                             },
                                             &roundResult)) {
      return false;
    }
  } else {
    // Step 40.a.
    if (calendarUnitsPresent || largestUnit < TemporalUnit::Day) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_DURATION_UNCOMPARABLE,
                                "relativeTo");
      return false;
    }

    // Step 40.b.
    MOZ_ASSERT(smallestUnit >= TemporalUnit::Day);

    // FIXME: spec issue - can with switch the call order, so that
    // Add24HourDaysToNormalizedTimeDuration is first called. That way we don't
    // have to add the additional `days` parameter to RoundTimeDuration.

    // Step 40.c.
    RoundedDuration rounded;
    if (!::RoundTimeDuration(cx, normDuration, roundingIncrement, smallestUnit,
                             roundingMode, ComputeRemainder::No, &rounded)) {
      return false;
    }

    // Step 40.d.
    NormalizedTimeDuration withDays;
    if (!Add24HourDaysToNormalizedTimeDuration(
            cx, rounded.duration.time, rounded.duration.date.days, &withDays)) {
      return false;
    }

    // Step 40.e.
    TimeDuration balanceResult;
    if (!temporal::BalanceTimeDuration(cx, withDays, largestUnit,
                                       &balanceResult)) {
      return false;
    }

    // Step 40.f.
    roundResult = balanceResult.toDuration();
  }

  // Step 41.
  auto* obj = CreateTemporalDuration(cx, roundResult);
  if (!obj) {
    return false;
  }

  args.rval().setObject(*obj);
  return true;
}

/**
 * Temporal.Duration.prototype.round ( options )
 */
static bool Duration_round(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_round>(cx, args);
}

/**
 * Temporal.Duration.prototype.total ( totalOf )
 */
static bool Duration_total(JSContext* cx, const CallArgs& args) {
  auto* durationObj = &args.thisv().toObject().as<DurationObject>();
  auto duration = ToDuration(durationObj);

  // Steps 3-11.
  Rooted<JSObject*> relativeTo(cx);
  Rooted<Wrapped<PlainDateObject*>> plainRelativeTo(cx);
  Rooted<ZonedDateTime> zonedRelativeTo(cx);
  Rooted<TimeZoneRecord> timeZone(cx);
  auto unit = TemporalUnit::Auto;
  if (args.get(0).isString()) {
    // Step 4. (Not applicable in our implementation.)

    // Steps 6-10. (Implicit)
    MOZ_ASSERT(!plainRelativeTo && !zonedRelativeTo);

    // Step 11.
    Rooted<JSString*> paramString(cx, args[0].toString());
    if (!GetTemporalUnitValuedOption(cx, paramString, TemporalUnitKey::Unit,
                                     TemporalUnitGroup::DateTime, &unit)) {
      return false;
    }
  } else {
    // Steps 3 and 5.
    Rooted<JSObject*> totalOf(
        cx, RequireObjectArg(cx, "totalOf", "total", args.get(0)));
    if (!totalOf) {
      return false;
    }

    // Steps 6-10.
    if (!GetTemporalRelativeToOption(cx, totalOf, &plainRelativeTo,
                                     &zonedRelativeTo, &timeZone)) {
      return false;
    }
    MOZ_ASSERT(!plainRelativeTo || !zonedRelativeTo);
    MOZ_ASSERT_IF(zonedRelativeTo, timeZone.receiver());

    // Step 11.
    if (!GetTemporalUnitValuedOption(cx, totalOf, TemporalUnitKey::Unit,
                                     TemporalUnitGroup::DateTime, &unit)) {
      return false;
    }

    if (unit == TemporalUnit::Auto) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_MISSING_OPTION, "unit");
      return false;
    }
  }

  // Step 12.
  mozilla::Maybe<const PlainDateTime&> precalculatedPlainDateTime{};

  // Step 13.
  bool plainDateTimeOrRelativeToWillBeUsed =
      unit <= TemporalUnit::Day || duration.toDateDuration() != DateDuration{};

  // Step 14.
  PlainDateTime relativeToDateTime;
  if (zonedRelativeTo && plainDateTimeOrRelativeToWillBeUsed) {
    // Steps 14.a-b.
    const auto& instant = zonedRelativeTo.instant();

    // Step 14.c.
    if (!GetPlainDateTimeFor(cx, timeZone, instant, &relativeToDateTime)) {
      return false;
    }
    precalculatedPlainDateTime =
        mozilla::SomeRef<const PlainDateTime>(relativeToDateTime);

    // FIXME: spec issue - Unnecessary CreateTemporalDate call
    //
    // https://github.com/tc39/proposal-temporal/issues/2873
  }

  // Step 15.
  Rooted<CalendarRecord> calendar(cx);
  if (!CreateCalendarMethodsRecordFromRelativeTo(cx, plainRelativeTo,
                                                 zonedRelativeTo,
                                                 {
                                                     CalendarMethod::DateAdd,
                                                     CalendarMethod::DateUntil,
                                                 },
                                                 &calendar)) {
    return false;
  }

  // Step 16.
  auto normDuration = CreateNormalizedDurationRecord(duration);

  // Step 17. (Not applicable in our implementation.)

  // Steps 18-20.
  double total;
  if (zonedRelativeTo) {
    // Step 18.a.
    auto relativeEpochNs = zonedRelativeTo.instant();

    // Step 18.b.
    const auto& relativeInstant = relativeEpochNs;

    // Step 18.c.
    Instant targetEpochNs;
    if (precalculatedPlainDateTime) {
      if (!AddZonedDateTime(cx, relativeInstant, timeZone, calendar,
                            normDuration, *precalculatedPlainDateTime,
                            &targetEpochNs)) {
        return false;
      }
    } else {
      if (!AddZonedDateTime(cx, relativeInstant, timeZone, calendar,
                            normDuration, &targetEpochNs)) {
        return false;
      }
    }

    // Step 18.d.
    if (unit <= TemporalUnit::Day) {
      if (!DifferenceZonedDateTimeWithRounding(
              cx, relativeEpochNs, targetEpochNs, timeZone, calendar,
              *precalculatedPlainDateTime, unit, &total)) {
        return false;
      }
    } else {
      total = DifferenceZonedDateTimeWithRounding(targetEpochNs,
                                                  relativeEpochNs, unit);
    }
  } else if (plainRelativeTo) {
    // Step 19.a.
    auto targetTime = AddTime(PlainTime{}, normDuration.time);

    // Step 19.b.
    auto dateDuration = DateDuration{
        normDuration.date.years,
        normDuration.date.months,
        normDuration.date.weeks,
        normDuration.date.days + targetTime.days,
    };
    MOZ_ASSERT(IsValidDuration(dateDuration));

    // Step 19.c.
    PlainDate targetDate;
    if (!AddDate(cx, calendar, plainRelativeTo, dateDuration, &targetDate)) {
      return false;
    }
    auto targetDateTime = PlainDateTime{targetDate, targetTime.time};

    auto* unwrappedRelativeTo = plainRelativeTo.unwrap(cx);
    if (!unwrappedRelativeTo) {
      return false;
    }
    auto sourceDateTime = PlainDateTime{ToPlainDate(unwrappedRelativeTo), {}};

    // Step 19.d.
    if (!::DifferencePlainDateTimeWithRounding(
            cx, sourceDateTime, targetDateTime, calendar, unit, &total)) {
      return false;
    }
  } else {
    // Step 20.a.
    if (normDuration.date.years || normDuration.date.months ||
        normDuration.date.weeks || unit < TemporalUnit::Day) {
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_DURATION_UNCOMPARABLE,
                                "relativeTo");
      return false;
    }

    // FIXME: spec issue - Add24HourDaysToNormalizedTimeDuration and
    // RoundTimeDuration are probably both infallible

    // Step 20.b.
    NormalizedTimeDuration withDays;
    if (!Add24HourDaysToNormalizedTimeDuration(
            cx, normDuration.time, normDuration.date.days, &withDays)) {
      return false;
    }

    // Step 20.c.
    auto roundInput = NormalizedDuration{{}, withDays};
    RoundedDuration rounded;
    if (!::RoundTimeDuration(cx, roundInput, Increment{1}, unit,
                             TemporalRoundingMode::Trunc, ComputeRemainder::Yes,
                             &rounded)) {
      return false;
    }
    total = rounded.total;
  }

  // Step 21.
  MOZ_ASSERT(!std::isnan(total));

  // Step 22.
  args.rval().setNumber(total);
  return true;
}

/**
 * Temporal.Duration.prototype.total ( totalOf )
 */
static bool Duration_total(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_total>(cx, args);
}

/**
 * Temporal.Duration.prototype.toString ( [ options ] )
 */
static bool Duration_toString(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Steps 3-9.
  SecondsStringPrecision precision = {Precision::Auto(),
                                      TemporalUnit::Nanosecond, Increment{1}};
  auto roundingMode = TemporalRoundingMode::Trunc;
  if (args.hasDefined(0)) {
    // Step 3.
    Rooted<JSObject*> options(
        cx, RequireObjectArg(cx, "options", "toString", args[0]));
    if (!options) {
      return false;
    }

    // Steps 4-5.
    auto digits = Precision::Auto();
    if (!GetTemporalFractionalSecondDigitsOption(cx, options, &digits)) {
      return false;
    }

    // Step 6.
    if (!GetRoundingModeOption(cx, options, &roundingMode)) {
      return false;
    }

    // Step 7.
    auto smallestUnit = TemporalUnit::Auto;
    if (!GetTemporalUnitValuedOption(cx, options, TemporalUnitKey::SmallestUnit,
                                     TemporalUnitGroup::Time, &smallestUnit)) {
      return false;
    }

    // Step 8.
    if (smallestUnit == TemporalUnit::Hour ||
        smallestUnit == TemporalUnit::Minute) {
      const char* smallestUnitStr =
          smallestUnit == TemporalUnit::Hour ? "hour" : "minute";
      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                JSMSG_TEMPORAL_INVALID_UNIT_OPTION,
                                smallestUnitStr, "smallestUnit");
      return false;
    }

    // Step 9.
    precision = ToSecondsStringPrecision(smallestUnit, digits);
  }

  // Steps 10-11.
  Duration result;
  if (precision.unit != TemporalUnit::Nanosecond ||
      precision.increment != Increment{1}) {
    // Step 10.a.
    auto timeDuration = NormalizeTimeDuration(duration);

    // Step 10.b.
    auto largestUnit = DefaultTemporalLargestUnit(duration);

    // Steps 10.c-d.
    NormalizedTimeDuration rounded;
    if (!RoundTimeDuration(cx, timeDuration, precision.increment,
                           precision.unit, roundingMode, &rounded)) {
      return false;
    }

    // Step 10.e.
    auto balanced = BalanceTimeDuration(
        rounded, std::min(largestUnit, TemporalUnit::Second));

    // Step 10.f.
    result = {
        duration.years,           duration.months,
        duration.weeks,           duration.days + double(balanced.days),
        double(balanced.hours),   double(balanced.minutes),
        double(balanced.seconds), double(balanced.milliseconds),
        balanced.microseconds,    balanced.nanoseconds,
    };
    MOZ_ASSERT(IsValidDuration(duration));
  } else {
    // Step 11.
    result = duration;
  }

  // Steps 12-13.
  JSString* str = TemporalDurationToString(cx, result, precision.precision);
  if (!str) {
    return false;
  }

  args.rval().setString(str);
  return true;
}

/**
 * Temporal.Duration.prototype.toString ( [ options ] )
 */
static bool Duration_toString(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_toString>(cx, args);
}

/**
 * Temporal.Duration.prototype.toJSON ( )
 */
static bool Duration_toJSON(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Steps 3-4.
  JSString* str = TemporalDurationToString(cx, duration, Precision::Auto());
  if (!str) {
    return false;
  }

  args.rval().setString(str);
  return true;
}

/**
 * Temporal.Duration.prototype.toJSON ( )
 */
static bool Duration_toJSON(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_toJSON>(cx, args);
}

/**
 * Temporal.Duration.prototype.toLocaleString ( [ locales [ , options ] ] )
 */
static bool Duration_toLocaleString(JSContext* cx, const CallArgs& args) {
  auto duration = ToDuration(&args.thisv().toObject().as<DurationObject>());

  // Steps 3-4.
  JSString* str = TemporalDurationToString(cx, duration, Precision::Auto());
  if (!str) {
    return false;
  }

  args.rval().setString(str);
  return true;
}

/**
 * Temporal.Duration.prototype.toLocaleString ( [ locales [ , options ] ] )
 */
static bool Duration_toLocaleString(JSContext* cx, unsigned argc, Value* vp) {
  // Steps 1-2.
  CallArgs args = CallArgsFromVp(argc, vp);
  return CallNonGenericMethod<IsDuration, Duration_toLocaleString>(cx, args);
}

/**
 * Temporal.Duration.prototype.valueOf ( )
 */
static bool Duration_valueOf(JSContext* cx, unsigned argc, Value* vp) {
  JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CANT_CONVERT_TO,
                            "Duration", "primitive type");
  return false;
}

const JSClass DurationObject::class_ = {
    "Temporal.Duration",
    JSCLASS_HAS_RESERVED_SLOTS(DurationObject::SLOT_COUNT) |
        JSCLASS_HAS_CACHED_PROTO(JSProto_Duration),
    JS_NULL_CLASS_OPS,
    &DurationObject::classSpec_,
};

const JSClass& DurationObject::protoClass_ = PlainObject::class_;

static const JSFunctionSpec Duration_methods[] = {
    JS_FN("from", Duration_from, 1, 0),
    JS_FN("compare", Duration_compare, 2, 0),
    JS_FS_END,
};

static const JSFunctionSpec Duration_prototype_methods[] = {
    JS_FN("with", Duration_with, 1, 0),
    JS_FN("negated", Duration_negated, 0, 0),
    JS_FN("abs", Duration_abs, 0, 0),
    JS_FN("add", Duration_add, 1, 0),
    JS_FN("subtract", Duration_subtract, 1, 0),
    JS_FN("round", Duration_round, 1, 0),
    JS_FN("total", Duration_total, 1, 0),
    JS_FN("toString", Duration_toString, 0, 0),
    JS_FN("toJSON", Duration_toJSON, 0, 0),
    JS_FN("toLocaleString", Duration_toLocaleString, 0, 0),
    JS_FN("valueOf", Duration_valueOf, 0, 0),
    JS_FS_END,
};

static const JSPropertySpec Duration_prototype_properties[] = {
    JS_PSG("years", Duration_years, 0),
    JS_PSG("months", Duration_months, 0),
    JS_PSG("weeks", Duration_weeks, 0),
    JS_PSG("days", Duration_days, 0),
    JS_PSG("hours", Duration_hours, 0),
    JS_PSG("minutes", Duration_minutes, 0),
    JS_PSG("seconds", Duration_seconds, 0),
    JS_PSG("milliseconds", Duration_milliseconds, 0),
    JS_PSG("microseconds", Duration_microseconds, 0),
    JS_PSG("nanoseconds", Duration_nanoseconds, 0),
    JS_PSG("sign", Duration_sign, 0),
    JS_PSG("blank", Duration_blank, 0),
    JS_STRING_SYM_PS(toStringTag, "Temporal.Duration", JSPROP_READONLY),
    JS_PS_END,
};

const ClassSpec DurationObject::classSpec_ = {
    GenericCreateConstructor<DurationConstructor, 0, gc::AllocKind::FUNCTION>,
    GenericCreatePrototype<DurationObject>,
    Duration_methods,
    nullptr,
    Duration_prototype_methods,
    Duration_prototype_properties,
    nullptr,
    ClassSpec::DontDefineConstructor,
};