/* 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/TemporalParser.h"

#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "mozilla/Result.h"
#include "mozilla/Span.h"
#include "mozilla/TextUtils.h"
#include "mozilla/Try.h"

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

#include "NamespaceImports.h"

#include "builtin/Number.h"
#include "builtin/temporal/Calendar.h"
#include "builtin/temporal/Duration.h"
#include "builtin/temporal/PlainDate.h"
#include "builtin/temporal/PlainTime.h"
#include "builtin/temporal/TemporalTypes.h"
#include "builtin/temporal/TemporalUnit.h"
#include "gc/Barrier.h"
#include "gc/Tracer.h"
#include "js/ErrorReport.h"
#include "js/friend/ErrorMessages.h"
#include "js/GCAPI.h"
#include "js/RootingAPI.h"
#include "js/TypeDecls.h"
#include "util/Text.h"
#include "vm/JSAtomState.h"
#include "vm/JSContext.h"
#include "vm/StringType.h"

using namespace js;
using namespace js::temporal;

struct StringName final {
  // Start position and length of this name.
  size_t start = 0;
  size_t length = 0;

  bool present() const { return length > 0; }
};

static JSLinearString* ToString(JSContext* cx, JSString* string,
                                const StringName& name) {
  MOZ_ASSERT(name.present());
  return NewDependentString(cx, string, name.start, name.length);
}

template <typename CharT>
bool EqualCharIgnoreCaseAscii(CharT c1, char c2) {
  if constexpr (sizeof(CharT) > sizeof(char)) {
    if (!mozilla::IsAscii(c1)) {
      return false;
    }
  }

  static constexpr auto toLower = 0x20;
  static_assert('a' - 'A' == toLower);

  // Convert both characters to lower case before the comparison.
  char c = c1;
  if (mozilla::IsAsciiUppercaseAlpha(c1)) {
    c = char(c + toLower);
  }
  char d = c2;
  if (mozilla::IsAsciiUppercaseAlpha(c2)) {
    d = char(d + toLower);
  }
  return c == d;
}

using CalendarName = StringName;
using AnnotationKey = StringName;
using AnnotationValue = StringName;
using TimeZoneName = StringName;

struct Annotation final {
  AnnotationKey key;
  AnnotationValue value;
  bool critical = false;
};

struct TimeSpec final {
  Time time;
};

struct TimeZoneUTCOffset final {
  // ±1 for time zones with an offset, otherwise 0.
  int32_t sign = 0;

  // An integer in the range [0, 23].
  int32_t hour = 0;

  // An integer in the range [0, 59].
  int32_t minute = 0;
};

struct DateTimeUTCOffset final {
  // ±1 for time zones with an offset, otherwise 0.
  int32_t sign = 0;

  // An integer in the range [0, 23].
  int32_t hour = 0;

  // An integer in the range [0, 59].
  int32_t minute = 0;

  // An integer in the range [0, 59].
  int32_t second = 0;

  // An integer in the range [0, 999'999].
  int32_t fractionalPart = 0;

  // Time zone with sub-minute precision.
  bool subMinutePrecision = false;

  // Convert to a TimeZoneUTCOffset.
  TimeZoneUTCOffset toTimeZoneUTCOffset() const {
    MOZ_ASSERT(!subMinutePrecision, "unexpected sub-minute precision");
    return {sign, hour, minute};
  }
};

/**
 * ParseDateTimeUTCOffset ( offsetString )
 */
static auto ParseDateTimeUTCOffset(const DateTimeUTCOffset& offset) {
  constexpr int64_t nanoPerSec = 1'000'000'000;

  MOZ_ASSERT(offset.sign == -1 || offset.sign == +1);
  MOZ_ASSERT(0 <= offset.hour && offset.hour < 24);
  MOZ_ASSERT(0 <= offset.minute && offset.minute < 60);
  MOZ_ASSERT(0 <= offset.second && offset.second < 60);
  MOZ_ASSERT(0 <= offset.fractionalPart && offset.fractionalPart < nanoPerSec);

  // sign × (((hours × 60 + minutes) × 60 + seconds) × 10^9 + nanoseconds).
  int64_t seconds = (offset.hour * 60 + offset.minute) * 60 + offset.second;
  int64_t nanos = (seconds * nanoPerSec) + offset.fractionalPart;
  int64_t result = offset.sign * nanos;

  MOZ_ASSERT(std::abs(result) < ToNanoseconds(TemporalUnit::Day),
             "time zone offset is less than 24:00 hours");

  return OffsetTimeZone{result, offset.subMinutePrecision};
}

static int32_t ParseTimeZoneOffset(const TimeZoneUTCOffset& offset) {
  MOZ_ASSERT(offset.sign == -1 || offset.sign == +1);
  MOZ_ASSERT(0 <= offset.hour && offset.hour < 24);
  MOZ_ASSERT(0 <= offset.minute && offset.minute < 60);

  // sign × (hour × 60 + minute).
  int32_t result = offset.sign * (offset.hour * 60 + offset.minute);

  MOZ_ASSERT(std::abs(result) < UnitsPerDay(TemporalUnit::Minute),
             "time zone offset is less than 24:00 hours");

  return result;
}

/**
 * Struct to hold time zone annotations.
 */
struct TimeZoneAnnotation final {
  // Time zone offset.
  TimeZoneUTCOffset offset;

  // Time zone name.
  TimeZoneName name;

  /**
   * Returns true iff the time zone has an offset part, e.g. "+01:00".
   */
  bool hasOffset() const { return offset.sign != 0; }

  /**
   * Returns true iff the time zone has an IANA name, e.g. "Asia/Tokyo".
   */
  bool hasName() const { return name.present(); }
};

/**
 * Struct to hold any time zone parts of a parsed string.
 */
struct TimeZoneString final {
  // Date-time UTC offset.
  DateTimeUTCOffset offset;

  // Time zone annotation;
  TimeZoneAnnotation annotation;

  // UTC time zone.
  bool utc = false;

  static auto from(DateTimeUTCOffset offset) {
    TimeZoneString timeZone{};
    timeZone.offset = offset;
    return timeZone;
  }

  static auto from(TimeZoneUTCOffset offset) {
    TimeZoneString timeZone{};
    timeZone.annotation.offset = offset;
    return timeZone;
  }

  static auto from(TimeZoneName name) {
    TimeZoneString timeZone{};
    timeZone.annotation.name = name;
    return timeZone;
  }

  static auto UTC() {
    TimeZoneString timeZone{};
    timeZone.utc = true;
    return timeZone;
  }

  /**
   * Returns true iff the time zone has an offset part, e.g. "+01:00".
   */
  bool hasOffset() const { return offset.sign != 0; }

  /**
   * Returns true iff the time zone has an annotation.
   */
  bool hasAnnotation() const {
    return annotation.hasName() || annotation.hasOffset();
  }

  /**
   * Returns true iff the time zone uses the "Z" abbrevation to denote UTC time.
   */
  bool isUTC() const { return utc; }
};

/**
 * Struct to hold the parsed date, time, time zone, and calendar components.
 */
struct ZonedDateTimeString final {
  ISODate date;
  Time time;
  TimeZoneString timeZone;
  CalendarName calendar;
  bool startOfDay;
};

template <typename CharT>
static bool IsISO8601Calendar(mozilla::Span<const CharT> calendar) {
  static constexpr std::string_view iso8601 = "iso8601";

  if (calendar.size() != iso8601.length()) {
    return false;
  }

  for (size_t i = 0; i < iso8601.length(); i++) {
    if (!EqualCharIgnoreCaseAscii(calendar[i], iso8601[i])) {
      return false;
    }
  }
  return true;
}

static constexpr int32_t AbsentYear = INT32_MAX;

/**
 * ParseISODateTime ( isoString )
 */
static bool ParseISODateTime(JSContext* cx, const ZonedDateTimeString& parsed,
                             ISODateTime* result) {
  // Steps 1-7, 9, 11-16 (Not applicable here).

  ISODateTime dateTime = {parsed.date, parsed.time};

  // NOTE: ToIntegerOrInfinity("") is 0.
  if (dateTime.date.year == AbsentYear) {
    dateTime.date.year = 0;
  }

  // Step 8.
  if (dateTime.date.month == 0) {
    dateTime.date.month = 1;
  }

  // Step 10.
  if (dateTime.date.day == 0) {
    dateTime.date.day = 1;
  }

  // Step 17.b.
  if (dateTime.time.second == 60) {
    dateTime.time.second = 59;
  }

  // ParseISODateTime, steps 18-19 (Not applicable in our implementation).

  // Perform early error checks now that absent |day| and |month| values were
  // handled:
  // `IsValidDate(DateSpec)` and `IsValidMonthDay(DateSpecMonthDay)` validate
  // that |day| doesn't exceed the number of days in |month|. This check can be
  // implemented by calling `ThrowIfInvalidISODate`.
  //
  // All other values are already in-bounds.
  MOZ_ASSERT(std::abs(dateTime.date.year) <= 999'999);
  MOZ_ASSERT(1 <= dateTime.date.month && dateTime.date.month <= 12);
  MOZ_ASSERT(1 <= dateTime.date.day && dateTime.date.day <= 31);

  if (!ThrowIfInvalidISODate(cx, dateTime.date)) {
    return false;
  }

  // Step 20.
  MOZ_ASSERT(IsValidISODate(dateTime.date));

  // Step 21.
  MOZ_ASSERT(IsValidTime(dateTime.time));

  // Steps 22-28. (Handled in caller.)

  *result = dateTime;
  return true;
}

static bool ParseTimeZoneAnnotation(JSContext* cx,
                                    const TimeZoneAnnotation& annotation,
                                    JSLinearString* linear,
                                    MutableHandle<ParsedTimeZone> result) {
  MOZ_ASSERT(annotation.hasOffset() || annotation.hasName());

  if (annotation.hasOffset()) {
    int32_t offset = ParseTimeZoneOffset(annotation.offset);
    result.set(ParsedTimeZone::fromOffset(offset));
    return true;
  }

  auto* str = ToString(cx, linear, annotation.name);
  if (!str) {
    return false;
  }
  result.set(ParsedTimeZone::fromName(str));
  return true;
}

/**
 * Struct for the parsed duration components.
 */
struct TemporalDurationString final {
  // A non-negative integer or +Infinity.
  double years = 0;

  // A non-negative integer or +Infinity.
  double months = 0;

  // A non-negative integer or +Infinity.
  double weeks = 0;

  // A non-negative integer or +Infinity.
  double days = 0;

  // A non-negative integer or +Infinity.
  double hours = 0;

  // A non-negative integer or +Infinity.
  double minutes = 0;

  // A non-negative integer or +Infinity.
  double seconds = 0;

  // An integer in the range [0, 999'999].
  int32_t hoursFraction = 0;

  // An integer in the range [0, 999'999].
  int32_t minutesFraction = 0;

  // An integer in the range [0, 999'999].
  int32_t secondsFraction = 0;

  // ±1 when an offset is present, otherwise 0.
  int32_t sign = 0;
};

class ParserError final {
  JSErrNum error_ = JSMSG_NOT_AN_ERROR;

 public:
  constexpr ParserError() = default;

  constexpr MOZ_IMPLICIT ParserError(JSErrNum error) : error_(error) {}

  constexpr JSErrNum error() const { return error_; }

  constexpr operator JSErrNum() const { return error(); }
};

namespace mozilla::detail {
// Zero is used for tagging, so it mustn't be an error.
static_assert(static_cast<JSErrNum>(0) == JSMSG_NOT_AN_ERROR);

// Ensure efficient packing of the error type.
template <>
struct UnusedZero<::ParserError> {
 private:
  using Error = ::ParserError;
  using ErrorKind = JSErrNum;

 public:
  using StorageType = std::underlying_type_t<ErrorKind>;

  static constexpr bool value = true;
  static constexpr StorageType nullValue = 0;

  static constexpr Error Inspect(const StorageType& aValue) {
    return Error(static_cast<ErrorKind>(aValue));
  }
  static constexpr Error Unwrap(StorageType aValue) {
    return Error(static_cast<ErrorKind>(aValue));
  }
  static constexpr StorageType Store(Error aValue) {
    return static_cast<StorageType>(aValue.error());
  }
};
}  // namespace mozilla::detail

static_assert(mozilla::Result<ZonedDateTimeString, ParserError>::Strategy !=
              mozilla::detail::PackingStrategy::Variant);

/**
 * Track the error and reader index of the last largest successful parse.
 */
class LikelyError final {
  size_t index_ = 0;
  ParserError error_;

 public:
  template <typename V>
  void update(const mozilla::Result<V, ParserError>& result, size_t index) {
    MOZ_ASSERT(result.isErr());

    if (index >= index_) {
      index_ = index;
      error_ = result.inspectErr();
    }
  }

  size_t index() const { return index_; }

  auto propagate() const { return mozilla::Err(error_); }
};

template <typename CharT>
class StringReader final {
  mozilla::Span<const CharT> string_;

  // Current position in the string.
  size_t index_ = 0;

 public:
  explicit StringReader(mozilla::Span<const CharT> string) : string_(string) {}

  /**
   * Returns the input string.
   */
  mozilla::Span<const CharT> string() const { return string_; }

  /**
   * Returns a substring of the input string.
   */
  mozilla::Span<const CharT> substring(const StringName& name) const {
    MOZ_ASSERT(name.present());
    return string_.Subspan(name.start, name.length);
  }

  /**
   * Returns the current parse position.
   */
  size_t index() const { return index_; }

  /**
   * Returns the length of the input string-
   */
  size_t length() const { return string_.size(); }

  /**
   * Returns true iff the whole string has been parsed.
   */
  bool atEnd() const { return index() == length(); }

  /**
   * Reset the parser to a previous parse position.
   */
  void reset(size_t index = 0) {
    MOZ_ASSERT(index <= length());
    index_ = index;
  }

  /**
   * Returns true if at least `amount` characters can be read from the current
   * parse position.
   */
  bool hasMore(size_t amount) const { return index() + amount <= length(); }

  /**
   * Advances the parse position by `amount` characters.
   */
  void advance(size_t amount) {
    MOZ_ASSERT(hasMore(amount));
    index_ += amount;
  }

  /**
   * Returns the character at the current parse position.
   */
  CharT current() const { return string()[index()]; }

  /**
   * Returns the character at the next parse position.
   */
  CharT next() const { return string()[index() + 1]; }

  /**
   * Returns the character at position `index`.
   */
  CharT at(size_t index) const { return string()[index]; }
};

template <typename CharT>
class TemporalParser final {
  StringReader<CharT> reader_;

  /**
   * Read an unlimited amount of decimal digits, returning `Nothing` if no
   * digits were read.
   */
  mozilla::Maybe<double> digits(JSContext* cx);

  /**
   * Read exactly `length` digits, returning `Nothing` on failure.
   */
  mozilla::Maybe<int32_t> digits(size_t length) {
    MOZ_ASSERT(length > 0, "can't read zero digits");
    MOZ_ASSERT(length <= std::numeric_limits<int32_t>::digits10,
               "can't read more than digits10 digits without overflow");

    if (!reader_.hasMore(length)) {
      return mozilla::Nothing();
    }
    int32_t num = 0;
    size_t index = reader_.index();
    for (size_t i = 0; i < length; i++) {
      auto ch = reader_.at(index + i);
      if (!mozilla::IsAsciiDigit(ch)) {
        return mozilla::Nothing();
      }
      num = num * 10 + AsciiDigitToNumber(ch);
    }
    reader_.advance(length);
    return mozilla::Some(num);
  }

  // TemporalDecimalFraction :::
  //   TemporalDecimalSeparator DecimalDigit{1,9}
  mozilla::Maybe<int32_t> fraction() {
    if (!reader_.hasMore(2)) {
      return mozilla::Nothing();
    }
    if (!hasDecimalSeparator() || !mozilla::IsAsciiDigit(reader_.next())) {
      return mozilla::Nothing();
    }

    // Consume the decimal separator.
    MOZ_ALWAYS_TRUE(decimalSeparator());

    // Maximal nine fractional digits are supported.
    constexpr size_t maxFractions = 9;

    // Read up to |maxFractions| digits.
    int32_t num = 0;
    size_t index = reader_.index();
    size_t i = 0;
    for (; i < std::min(reader_.length() - index, maxFractions); i++) {
      CharT ch = reader_.at(index + i);
      if (!mozilla::IsAsciiDigit(ch)) {
        break;
      }
      num = num * 10 + AsciiDigitToNumber(ch);
    }

    // Skip past the read digits.
    reader_.advance(i);

    // Normalize the fraction to |maxFractions| digits.
    for (; i < maxFractions; i++) {
      num *= 10;
    }
    return mozilla::Some(num);
  }

  /**
   * Returns true iff the current character is `ch`.
   */
  bool hasCharacter(CharT ch) const {
    return reader_.hasMore(1) && reader_.current() == ch;
  }

  /**
   * Consumes the current character if it's equal to `ch` and then returns
   * `true`. Otherwise returns `false`.
   */
  bool character(CharT ch) {
    if (!hasCharacter(ch)) {
      return false;
    }
    reader_.advance(1);
    return true;
  }

  /**
   * Consumes the next characters if they're equal to `str` and then returns
   * `true`. Otherwise returns `false`.
   */
  template <size_t N>
  bool string(const char (&str)[N]) {
    static_assert(N > 2, "use character() for one element strings");

    if (!reader_.hasMore(N - 1)) {
      return false;
    }
    size_t index = reader_.index();
    for (size_t i = 0; i < N - 1; i++) {
      if (reader_.at(index + i) != str[i]) {
        return false;
      }
    }
    reader_.advance(N - 1);
    return true;
  }

  /**
   * Returns true if the next two characters are ASCII alphabetic characters.
   */
  bool hasTwoAsciiAlpha() {
    if (!reader_.hasMore(2)) {
      return false;
    }
    size_t index = reader_.index();
    return mozilla::IsAsciiAlpha(reader_.at(index)) &&
           mozilla::IsAsciiAlpha(reader_.at(index + 1));
  }

  /**
   * Returns true iff the current character is one of `chars`.
   */
  bool hasOneOf(std::initializer_list<char> chars) const {
    if (!reader_.hasMore(1)) {
      return false;
    }
    auto ch = reader_.current();
    return std::find(chars.begin(), chars.end(), ch) != chars.end();
  }

  /**
   * Consumes the current character if it's in `chars` and then returns `true`.
   * Otherwise returns `false`.
   */
  bool oneOf(std::initializer_list<char> chars) {
    if (!hasOneOf(chars)) {
      return false;
    }
    reader_.advance(1);
    return true;
  }

  /**
   * Consumes the current character if it matches the predicate and then returns
   * `true`. Otherwise returns `false`.
   */
  template <typename Predicate>
  bool matches(Predicate&& predicate) {
    if (!reader_.hasMore(1)) {
      return false;
    }

    CharT ch = reader_.current();
    if (!predicate(ch)) {
      return false;
    }

    reader_.advance(1);
    return true;
  }

  // ASCIISign ::: one of
  //   + -
  bool hasSign() const { return hasOneOf({'+', '-'}); }

  /**
   * Consumes the current character, which must be a sign character, and returns
   * its numeric value.
   */
  int32_t sign() {
    MOZ_ASSERT(hasSign());
    int32_t plus = hasCharacter('+');
    reader_.advance(1);
    return plus ? 1 : -1;
  }

  // DateSeparator[Extended] :::
  //   [+Extended] -
  //   [~Extended] [empty]
  bool dateSeparator() { return character('-'); }

  // TimeSeparator[Extended] :::
  //   [+Extended] :
  //   [~Extended] [empty]
  bool hasTimeSeparator() const { return hasCharacter(':'); }

  bool timeSeparator() { return character(':'); }

  // TemporalDecimalSeparator ::: one of
  //   . ,
  bool hasDecimalSeparator() const { return hasOneOf({'.', ','}); }

  bool decimalSeparator() { return oneOf({'.', ','}); }

  // DaysDesignator ::: one of
  //   D d
  bool daysDesignator() { return oneOf({'D', 'd'}); }

  // HoursDesignator ::: one of
  //   H h
  bool hoursDesignator() { return oneOf({'H', 'h'}); }

  // MinutesDesignator ::: one of
  //   M m
  bool minutesDesignator() { return oneOf({'M', 'm'}); }

  // MonthsDesignator ::: one of
  //   M m
  bool monthsDesignator() { return oneOf({'M', 'm'}); }

  // DurationDesignator ::: one of
  //   P p
  bool durationDesignator() { return oneOf({'P', 'p'}); }

  // SecondsDesignator ::: one of
  //   S s
  bool secondsDesignator() { return oneOf({'S', 's'}); }

  // DateTimeSeparator :::
  //   <SP>
  //   T
  //   t
  bool dateTimeSeparator() { return oneOf({' ', 'T', 't'}); }

  // TimeDesignator ::: one of
  //   T t
  bool hasTimeDesignator() const { return hasOneOf({'T', 't'}); }

  bool timeDesignator() { return oneOf({'T', 't'}); }

  // WeeksDesignator ::: one of
  //   W w
  bool weeksDesignator() { return oneOf({'W', 'w'}); }

  // YearsDesignator ::: one of
  //   Y y
  bool yearsDesignator() { return oneOf({'Y', 'y'}); }

  // UTCDesignator ::: one of
  //   Z z
  bool utcDesignator() { return oneOf({'Z', 'z'}); }

  // TZLeadingChar :::
  //   Alpha
  //   .
  //   _
  bool tzLeadingChar() {
    return matches([](auto ch) {
      return mozilla::IsAsciiAlpha(ch) || ch == '.' || ch == '_';
    });
  }

  // TZChar :::
  //   TZLeadingChar
  //   DecimalDigit
  //   -
  //   +
  bool tzChar() {
    return matches([](auto ch) {
      return mozilla::IsAsciiAlphanumeric(ch) || ch == '.' || ch == '_' ||
             ch == '-' || ch == '+';
    });
  }

  // AnnotationCriticalFlag :::
  //   !
  bool annotationCriticalFlag() { return character('!'); }

  // AKeyLeadingChar :::
  //   LowercaseAlpha
  //   _
  bool aKeyLeadingChar() {
    return matches([](auto ch) {
      return mozilla::IsAsciiLowercaseAlpha(ch) || ch == '_';
    });
  }

  // AKeyChar :::
  //   AKeyLeadingChar
  //   DecimalDigit
  //   -
  bool aKeyChar() {
    return matches([](auto ch) {
      return mozilla::IsAsciiLowercaseAlpha(ch) || mozilla::IsAsciiDigit(ch) ||
             ch == '-' || ch == '_';
    });
  }

  // AnnotationValueComponent :::
  //   Alpha AnnotationValueComponent?
  //   DecimalDigit AnnotationValueComponent?
  bool annotationValueComponent() {
    size_t index = reader_.index();
    size_t i = 0;
    for (; index + i < reader_.length(); i++) {
      auto ch = reader_.at(index + i);
      if (!mozilla::IsAsciiAlphanumeric(ch)) {
        break;
      }
    }
    if (i == 0) {
      return false;
    }
    reader_.advance(i);
    return true;
  }

  template <typename T>
  static constexpr bool inBounds(const T& x, const T& min, const T& max) {
    return min <= x && x <= max;
  }

  static auto err(JSErrNum error) {
    // Explicitly create |ParserError| when JSErrNum is auto-convertible to the
    // success type.
    return mozilla::Err(ParserError{error});
  }

  mozilla::Result<int32_t, ParserError> dateYear();
  mozilla::Result<int32_t, ParserError> dateMonth();
  mozilla::Result<int32_t, ParserError> dateDay();
  mozilla::Result<int32_t, ParserError> hour();
  mozilla::Result<mozilla::Maybe<int32_t>, ParserError> minute(bool required);
  mozilla::Result<mozilla::Maybe<int32_t>, ParserError> second(bool required);
  mozilla::Result<mozilla::Maybe<int32_t>, ParserError> timeSecond(
      bool required);

  mozilla::Result<ISODate, ParserError> date();

  mozilla::Result<Time, ParserError> time();

  mozilla::Result<ZonedDateTimeString, ParserError> dateTime(bool allowZ);

  mozilla::Result<ISODate, ParserError> dateSpecYearMonth();

  mozilla::Result<ISODate, ParserError> dateSpecMonthDay();

  // Return true when |Annotation| can start at the current position.
  bool hasAnnotationStart() const { return hasCharacter('['); }

  // Return true when |TimeZoneAnnotation| can start at the current position.
  bool hasTimeZoneAnnotationStart() const {
    if (!hasCharacter('[')) {
      return false;
    }

    // Ensure no '=' is found before the closing ']', otherwise the opening '['
    // may actually start an |Annotation| instead of a |TimeZoneAnnotation|.
    for (size_t i = reader_.index() + 1; i < reader_.length(); i++) {
      CharT ch = reader_.at(i);
      if (ch == '=') {
        return false;
      }
      if (ch == ']') {
        break;
      }
    }
    return true;
  }

  // Return true when |DateTimeUTCOffset| can start at the current position.
  bool hasDateTimeUTCOffsetStart() { return hasOneOf({'Z', 'z', '+', '-'}); }

  mozilla::Result<TimeZoneString, ParserError> dateTimeUTCOffset(bool allowZ);

  mozilla::Result<DateTimeUTCOffset, ParserError> utcOffsetSubMinutePrecision();

  mozilla::Result<TimeZoneUTCOffset, ParserError> timeZoneUTCOffsetName();

  mozilla::Result<TimeZoneAnnotation, ParserError> timeZoneIdentifier();

  mozilla::Result<TimeZoneAnnotation, ParserError> timeZoneAnnotation();

  mozilla::Result<TimeZoneName, ParserError> timeZoneIANAName();

  mozilla::Result<AnnotationKey, ParserError> annotationKey();
  mozilla::Result<AnnotationValue, ParserError> annotationValue();
  mozilla::Result<Annotation, ParserError> annotation();
  mozilla::Result<CalendarName, ParserError> annotations();

  mozilla::Result<ZonedDateTimeString, ParserError> annotatedTime();

  mozilla::Result<ZonedDateTimeString, ParserError> annotatedDateTime();

  mozilla::Result<ZonedDateTimeString, ParserError>
  annotatedDateTimeTimeRequired();

  mozilla::Result<ZonedDateTimeString, ParserError> annotatedYearMonth();

  mozilla::Result<ZonedDateTimeString, ParserError> annotatedMonthDay();

  mozilla::Result<double, ParserError> durationDigits(JSContext* cx);

  template <typename T>
  mozilla::Result<T, ParserError> parse(
      mozilla::Result<T, ParserError>&& result) const;

  template <typename T>
  mozilla::Result<T, ParserError> complete(const T& value) const;

  mozilla::Result<mozilla::Ok, ParserError> nonempty() const;

 public:
  explicit TemporalParser(mozilla::Span<const CharT> str) : reader_(str) {}

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalInstantString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalTimeZoneString();

  mozilla::Result<TimeZoneAnnotation, ParserError> parseTimeZoneIdentifier();

  mozilla::Result<DateTimeUTCOffset, ParserError> parseDateTimeUTCOffset();

  mozilla::Result<TemporalDurationString, ParserError>
  parseTemporalDurationString(JSContext* cx);

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalCalendarString();

  mozilla::Result<ZonedDateTimeString, ParserError> parseTemporalTimeString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalMonthDayString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalYearMonthString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalDateTimeString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalZonedDateTimeString();

  mozilla::Result<ZonedDateTimeString, ParserError>
  parseTemporalRelativeToString();
};

template <typename CharT>
template <typename T>
mozilla::Result<T, ParserError> TemporalParser<CharT>::parse(
    mozilla::Result<T, ParserError>&& result) const {
  if (result.isOk() && !reader_.atEnd()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_UNEXPECTED_CHARACTERS_AT_END);
  }
  return std::move(result);
}

template <typename CharT>
template <typename T>
mozilla::Result<T, ParserError> TemporalParser<CharT>::complete(
    const T& value) const {
  if (!reader_.atEnd()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_UNEXPECTED_CHARACTERS_AT_END);
  }
  return value;
}

template <typename CharT>
mozilla::Result<mozilla::Ok, ParserError> TemporalParser<CharT>::nonempty()
    const {
  if (reader_.length() == 0) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_EMPTY_STRING);
  }
  return mozilla::Ok{};
}

template <typename CharT>
mozilla::Result<int32_t, ParserError> TemporalParser<CharT>::dateYear() {
  // DateYear :::
  //  DecimalDigit{4}
  //  ASCIISign DecimalDigit{6}

  if (auto year = digits(4)) {
    return year.value();
  }
  if (hasSign()) {
    int32_t yearSign = sign();
    if (auto year = digits(6)) {
      int32_t result = yearSign * year.value();
      if (yearSign < 0 && result == 0) {
        return err(JSMSG_TEMPORAL_PARSER_NEGATIVE_ZERO_YEAR);
      }
      return result;
    }
    return err(JSMSG_TEMPORAL_PARSER_MISSING_EXTENDED_YEAR);
  }
  return err(JSMSG_TEMPORAL_PARSER_MISSING_YEAR);
}

template <typename CharT>
mozilla::Result<int32_t, ParserError> TemporalParser<CharT>::dateMonth() {
  // DateMonth :::
  //   0 NonzeroDigit
  //   10
  //   11
  //   12
  if (auto month = digits(2)) {
    int32_t result = month.value();
    if (!inBounds(result, 1, 12)) {
      return err(JSMSG_TEMPORAL_PARSER_INVALID_MONTH);
    }
    return result;
  }
  return err(JSMSG_TEMPORAL_PARSER_MISSING_MONTH);
}

template <typename CharT>
mozilla::Result<int32_t, ParserError> TemporalParser<CharT>::dateDay() {
  // DateDay :::
  //   0 NonzeroDigit
  //   1 DecimalDigit
  //   2 DecimalDigit
  //   30
  //   31
  if (auto day = digits(2)) {
    int32_t result = day.value();
    if (!inBounds(result, 1, 31)) {
      return err(JSMSG_TEMPORAL_PARSER_INVALID_DAY);
    }
    return result;
  }
  return err(JSMSG_TEMPORAL_PARSER_MISSING_DAY);
}

template <typename CharT>
mozilla::Result<int32_t, ParserError> TemporalParser<CharT>::hour() {
  // Hour :::
  //   0 DecimalDigit
  //   1 DecimalDigit
  //   20
  //   21
  //   22
  //   23
  if (auto hour = digits(2)) {
    int32_t result = hour.value();
    if (!inBounds(result, 0, 23)) {
      return err(JSMSG_TEMPORAL_PARSER_INVALID_HOUR);
    }
    return result;
  }
  return err(JSMSG_TEMPORAL_PARSER_MISSING_HOUR);
}

template <typename CharT>
mozilla::Result<mozilla::Maybe<int32_t>, ParserError>
TemporalParser<CharT>::minute(bool required) {
  // MinuteSecond :::
  //   0 DecimalDigit
  //   1 DecimalDigit
  //   2 DecimalDigit
  //   3 DecimalDigit
  //   4 DecimalDigit
  //   5 DecimalDigit
  if (auto minute = digits(2)) {
    if (!inBounds(minute.value(), 0, 59)) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_MINUTE);
    }
    return minute;
  }
  if (!required) {
    return mozilla::Maybe<int32_t>{mozilla::Nothing{}};
  }
  return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_MINUTE);
}

template <typename CharT>
mozilla::Result<mozilla::Maybe<int32_t>, ParserError>
TemporalParser<CharT>::second(bool required) {
  // MinuteSecond :::
  //   0 DecimalDigit
  //   1 DecimalDigit
  //   2 DecimalDigit
  //   3 DecimalDigit
  //   4 DecimalDigit
  //   5 DecimalDigit
  if (auto minute = digits(2)) {
    if (!inBounds(minute.value(), 0, 59)) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_SECOND);
    }
    return minute;
  }
  if (!required) {
    return mozilla::Maybe<int32_t>{mozilla::Nothing{}};
  }
  return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_SECOND);
}

template <typename CharT>
mozilla::Result<mozilla::Maybe<int32_t>, ParserError>
TemporalParser<CharT>::timeSecond(bool required) {
  // TimeSecond :::
  //   MinuteSecond
  //   60
  //
  // MinuteSecond :::
  //   0 DecimalDigit
  //   1 DecimalDigit
  //   2 DecimalDigit
  //   3 DecimalDigit
  //   4 DecimalDigit
  //   5 DecimalDigit
  if (auto minute = digits(2)) {
    if (!inBounds(minute.value(), 0, 60)) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_LEAPSECOND);
    }
    return minute;
  }
  if (!required) {
    return mozilla::Maybe<int32_t>{mozilla::Nothing{}};
  }
  return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_SECOND);
}

template <typename CharT>
mozilla::Result<ISODate, ParserError> TemporalParser<CharT>::date() {
  // clang-format off
  //
  // Date :::
  //   DateSpec[+Extended]
  //   DateSpec[~Extended]
  //
  // DateSpec[Extended] :::
  //   DateYear DateSeparator[?Extended] DateMonth DateSeparator[?Extended] DateDay
  //
  // clang-format on

  ISODate result{};

  result.year = MOZ_TRY(dateYear());

  // Optional |DateSeparator|.
  bool hasMonthSeparator = dateSeparator();

  result.month = MOZ_TRY(dateMonth());

  // Optional |DateSeparator|.
  bool hasDaySeparator = dateSeparator();

  // Date separators must be consistent.
  if (hasMonthSeparator != hasDaySeparator) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_INCONSISTENT_DATE_SEPARATOR);
  }

  result.day = MOZ_TRY(dateDay());

  return result;
}

template <typename CharT>
mozilla::Result<Time, ParserError> TemporalParser<CharT>::time() {
  // clang-format off
  //
  // Time :::
  //   TimeSpec[+Extended]
  //   TimeSpec[~Extended]
  //
  // TimeSpec[Extended] :::
  //   Hour
  //   Hour TimeSeparator[?Extended] MinuteSecond
  //   Hour TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] TimeSecond TemporalDecimalFraction?
  //
  // clang-format on

  Time result{};

  result.hour = MOZ_TRY(hour());

  // Optional |TimeSeparator|.
  bool hasMinuteSeparator = timeSeparator();

  mozilla::Maybe<int32_t> minutes = MOZ_TRY(minute(hasMinuteSeparator));
  if (minutes) {
    result.minute = minutes.value();

    // Optional |TimeSeparator|.
    bool hasSecondSeparator = timeSeparator();

    mozilla::Maybe<int32_t> seconds = MOZ_TRY(timeSecond(hasSecondSeparator));
    if (seconds) {
      result.second = seconds.value();

      // Time separators must be consistent.
      if (hasMinuteSeparator != hasSecondSeparator) {
        return mozilla::Err(JSMSG_TEMPORAL_PARSER_INCONSISTENT_TIME_SEPARATOR);
      }

      // TemporalDecimalFraction :::
      //   TemporalDecimalSeparator DecimalDigit{1,9}
      if (auto f = fraction()) {
        int32_t fractionalPart = f.value();
        result.millisecond = fractionalPart / 1'000'000;
        result.microsecond = (fractionalPart % 1'000'000) / 1'000;
        result.nanosecond = fractionalPart % 1'000;
      }
    }
  }

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::dateTime(bool allowZ) {
  // DateTime[Z, TimeRequired] :::
  //   [~TimeRequired] Date
  //   Date DateTimeSeparator Time DateTimeUTCOffset[?Z]?
  //
  // When called as `DateTime[?Z, ~TimeRequired]`.

  ZonedDateTimeString result{};

  result.date = MOZ_TRY(date());

  if (dateTimeSeparator()) {
    result.time = MOZ_TRY(time());

    if (hasDateTimeUTCOffsetStart()) {
      result.timeZone = MOZ_TRY(dateTimeUTCOffset(allowZ));
    }
  } else {
    result.startOfDay = true;
  }

  return result;
}

template <typename CharT>
mozilla::Result<TimeZoneString, ParserError>
TemporalParser<CharT>::dateTimeUTCOffset(bool allowZ) {
  // DateTimeUTCOffset[Z] :::
  //   [+Z] UTCDesignator
  //   UTCOffset[+SubMinutePrecision]

  if (utcDesignator()) {
    if (!allowZ) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_UTC_DESIGNATOR);
    }
    return TimeZoneString::UTC();
  }

  if (hasSign()) {
    DateTimeUTCOffset offset = MOZ_TRY(utcOffsetSubMinutePrecision());

    return TimeZoneString::from(offset);
  }

  return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_TIMEZONE);
}

template <typename CharT>
mozilla::Result<TimeZoneUTCOffset, ParserError>
TemporalParser<CharT>::timeZoneUTCOffsetName() {
  // clang-format off
  //
  // UTCOffset[SubMinutePrecision] :::
  //   ASCIISign Hour
  //   ASCIISign Hour TimeSeparator[+Extended] MinuteSecond
  //   ASCIISign Hour TimeSeparator[~Extended] MinuteSecond
  //   [+SubMinutePrecision] ASCIISign Hour TimeSeparator[+Extended] MinuteSecond TimeSeparator[+Extended] MinuteSecond TemporalDecimalFraction?
  //   [+SubMinutePrecision] ASCIISign Hour TimeSeparator[~Extended] MinuteSecond TimeSeparator[~Extended] MinuteSecond TemporalDecimalFraction?
  //
  // When called as `UTCOffset[~SubMinutePrecision]`.
  //
  // clang-format on

  TimeZoneUTCOffset result{};

  if (!hasSign()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_TIMEZONE_SIGN);
  }
  result.sign = sign();

  result.hour = MOZ_TRY(hour());

  // Optional |TimeSeparator|.
  bool hasMinuteSeparator = timeSeparator();

  mozilla::Maybe<int32_t> minutes = MOZ_TRY(minute(hasMinuteSeparator));
  if (minutes) {
    result.minute = minutes.value();

    if (hasTimeSeparator()) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_SUBMINUTE_TIMEZONE);
    }
  }

  return result;
}

template <typename CharT>
mozilla::Result<DateTimeUTCOffset, ParserError>
TemporalParser<CharT>::utcOffsetSubMinutePrecision() {
  // clang-format off
  //
  // UTCOffset[SubMinutePrecision] :::
  //   ASCIISign Hour
  //   ASCIISign Hour TimeSeparator[+Extended] MinuteSecond
  //   ASCIISign Hour TimeSeparator[~Extended] MinuteSecond
  //   [+SubMinutePrecision] ASCIISign Hour TimeSeparator[+Extended] MinuteSecond TimeSeparator[+Extended] MinuteSecond TemporalDecimalFraction?
  //   [+SubMinutePrecision] ASCIISign Hour TimeSeparator[~Extended] MinuteSecond TimeSeparator[~Extended] MinuteSecond TemporalDecimalFraction?
  //
  // When called as `UTCOffset[+SubMinutePrecision]`.
  //
  // clang-format on

  DateTimeUTCOffset result{};

  if (!hasSign()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_TIMEZONE_SIGN);
  }
  result.sign = sign();

  result.hour = MOZ_TRY(hour());

  // Optional |TimeSeparator|.
  bool hasMinuteSeparator = timeSeparator();

  mozilla::Maybe<int32_t> minutes = MOZ_TRY(minute(hasMinuteSeparator));
  if (minutes) {
    result.minute = minutes.value();

    // Optional |TimeSeparator|.
    bool hasSecondSeparator = timeSeparator();

    mozilla::Maybe<int32_t> seconds = MOZ_TRY(second(hasSecondSeparator));
    if (seconds) {
      result.second = seconds.value();

      // Time separators must be consistent.
      if (hasMinuteSeparator != hasSecondSeparator) {
        return mozilla::Err(JSMSG_TEMPORAL_PARSER_INCONSISTENT_TIME_SEPARATOR);
      }

      if (auto fractionalPart = fraction()) {
        result.fractionalPart = fractionalPart.value();
      }

      result.subMinutePrecision = true;
    }
  }

  return result;
}

template <typename CharT>
mozilla::Result<TimeZoneAnnotation, ParserError>
TemporalParser<CharT>::timeZoneIdentifier() {
  // TimeZoneIdentifier :::
  //   UTCOffset[~SubMinutePrecision]
  //   TimeZoneIANAName

  TimeZoneAnnotation result{};
  if (hasSign()) {
    result.offset = MOZ_TRY(timeZoneUTCOffsetName());
  } else {
    result.name = MOZ_TRY(timeZoneIANAName());
  }

  return result;
}

template <typename CharT>
mozilla::Result<TimeZoneAnnotation, ParserError>
TemporalParser<CharT>::timeZoneAnnotation() {
  // TimeZoneAnnotation :::
  //   [ AnnotationCriticalFlag? TimeZoneIdentifier ]

  if (!character('[')) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_BRACKET_BEFORE_TIMEZONE);
  }

  // Skip over the optional critical flag.
  annotationCriticalFlag();

  auto result = timeZoneIdentifier();
  if (result.isErr()) {
    return result.propagateErr();
  }

  if (!character(']')) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_BRACKET_AFTER_TIMEZONE);
  }

  return result;
}

template <typename CharT>
mozilla::Result<TimeZoneName, ParserError>
TemporalParser<CharT>::timeZoneIANAName() {
  // TimeZoneIANAName :::
  //   TimeZoneIANANameComponent
  //   TimeZoneIANAName / TimeZoneIANANameComponent
  //
  // TimeZoneIANANameComponent :::
  //   TZLeadingChar
  //   TimeZoneIANANameComponent TZChar

  size_t start = reader_.index();

  do {
    if (!tzLeadingChar()) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_TIMEZONE_NAME);
    }

    // Optionally followed by a sequence of |TZChar|.
    while (tzChar()) {
    }
  } while (character('/'));

  return TimeZoneName{start, reader_.index() - start};
}

template <typename CharT>
mozilla::Maybe<double> TemporalParser<CharT>::digits(JSContext* cx) {
  auto span = reader_.string().Subspan(reader_.index());

  // GetPrefixInteger can't fail when integer separator handling is disabled.
  const CharT* endp = nullptr;
  double num;
  MOZ_ALWAYS_TRUE(GetPrefixInteger(span.data(), span.data() + span.size(), 10,
                                   IntegerSeparatorHandling::None, &endp,
                                   &num));

  size_t len = endp - span.data();
  if (len == 0) {
    return mozilla::Nothing();
  }
  reader_.advance(len);
  return mozilla::Some(num);
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalInstantString() {
  MOZ_TRY(nonempty());

  // Initialize all fields to zero.
  ZonedDateTimeString result{};

  // clang-format off
  //
  // TemporalInstantString :::
  //   Date DateTimeSeparator Time DateTimeUTCOffset[+Z] TimeZoneAnnotation? Annotations?
  //
  // clang-format on

  result.date = MOZ_TRY(date());

  if (!dateTimeSeparator()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_DATE_TIME_SEPARATOR);
  }

  result.time = MOZ_TRY(time());

  result.timeZone = MOZ_TRY(dateTimeUTCOffset(/* allowZ = */ true));

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    MOZ_TRY(annotations());
  }

  return complete(result);
}

/**
 * ParseTemporalInstantString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalInstantString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalInstantString();
}

/**
 * ParseTemporalInstantString ( isoString )
 */
static auto ParseTemporalInstantString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalInstantString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalInstantString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalInstantString ( isoString )
 */
bool js::temporal::ParseTemporalInstantString(JSContext* cx,
                                              Handle<JSString*> str,
                                              ISODateTime* result,
                                              int64_t* offset) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Step 1.
  auto parseResult = ::ParseTemporalInstantString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "instant");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 2.
  if (!ParseISODateTime(cx, parsed, result)) {
    return false;
  }

  // Steps 3-4.
  if (parsed.timeZone.hasOffset()) {
    *offset = ParseDateTimeUTCOffset(parsed.timeZone.offset).offset;
  } else {
    MOZ_ASSERT(parsed.timeZone.isUTC());
    *offset = 0;
  }
  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalTimeZoneString() {
  MOZ_TRY(nonempty());

  // Handle the common case of a standalone time zone identifier first.
  if (auto tz = parse(timeZoneIdentifier()); tz.isOk()) {
    auto timeZone = tz.unwrap();

    ZonedDateTimeString result{};
    if (timeZone.hasOffset()) {
      result.timeZone = TimeZoneString::from(timeZone.offset);
    } else {
      MOZ_ASSERT(timeZone.hasName());
      result.timeZone = TimeZoneString::from(timeZone.name);
    }
    return result;
  }

  LikelyError likelyError{};

  // Try all five parse goals from ParseISODateTime in order.
  //
  // TemporalDateTimeString
  // TemporalInstantString
  // TemporalTimeString
  // TemporalMonthDayString
  // TemporalYearMonthString

  // Restart parsing from the start of the string.
  reader_.reset();

  auto dateTime = parseTemporalDateTimeString();
  if (dateTime.isOk()) {
    return dateTime;
  }
  likelyError.update(dateTime, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto instant = parseTemporalInstantString();
  if (instant.isOk()) {
    return instant;
  }
  likelyError.update(instant, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto time = parseTemporalTimeString();
  if (time.isOk()) {
    return time;
  }
  likelyError.update(time, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto monthDay = parseTemporalMonthDayString();
  if (monthDay.isOk()) {
    return monthDay;
  }
  likelyError.update(monthDay, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto yearMonth = parseTemporalYearMonthString();
  if (yearMonth.isOk()) {
    return yearMonth;
  }
  likelyError.update(yearMonth, reader_.index());

  return likelyError.propagate();
}

/**
 * ParseTemporalTimeZoneString ( timeZoneString )
 */
template <typename CharT>
static auto ParseTemporalTimeZoneString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalTimeZoneString();
}

/**
 * ParseTemporalTimeZoneString ( timeZoneString )
 */
static auto ParseTemporalTimeZoneString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalTimeZoneString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalTimeZoneString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalTimeZoneString ( timeZoneString )
 */
bool js::temporal::ParseTemporalTimeZoneString(
    JSContext* cx, Handle<JSString*> str,
    MutableHandle<ParsedTimeZone> result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-4.
  auto parseResult = ::ParseTemporalTimeZoneString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "time zone");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();
  const auto& timeZone = parsed.timeZone;

  // Step 3.
  ISODateTime unused;
  if (!ParseISODateTime(cx, parsed, &unused)) {
    return false;
  }

  if (timeZone.hasAnnotation()) {
    // Case 1: 19700101T00:00Z[+02:00]
    // Case 2: 19700101T00:00+00:00[+02:00]
    // Case 3: 19700101T00:00[+02:00]
    // Case 4: 19700101T00:00Z[Europe/Berlin]
    // Case 5: 19700101T00:00+00:00[Europe/Berlin]
    // Case 6: 19700101T00:00[Europe/Berlin]

    if (!ParseTimeZoneAnnotation(cx, timeZone.annotation, linear, result)) {
      return false;
    }
  } else if (timeZone.isUTC()) {
    result.set(ParsedTimeZone::fromName(cx->names().UTC));
  } else if (timeZone.hasOffset()) {
    // ToTemporalTimeZoneSlotValue, step 7.
    //
    // Error reporting for sub-minute precision moved here.
    if (timeZone.offset.subMinutePrecision) {
      JS_ReportErrorNumberASCII(
          cx, GetErrorMessage, nullptr,
          JSMSG_TEMPORAL_PARSER_INVALID_SUBMINUTE_TIMEZONE, "time zone");
      return false;
    }

    int32_t offset = ParseTimeZoneOffset(timeZone.offset.toTimeZoneUTCOffset());
    result.set(ParsedTimeZone::fromOffset(offset));
  } else {
    // Step 5.
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              JSMSG_TEMPORAL_PARSER_MISSING_TIMEZONE,
                              "time zone");
    return false;
  }

  // Step 6.
  return true;
}

template <typename CharT>
mozilla::Result<TimeZoneAnnotation, ParserError>
TemporalParser<CharT>::parseTimeZoneIdentifier() {
  MOZ_TRY(nonempty());
  return parse(timeZoneIdentifier());
}

/**
 * ParseTimeZoneIdentifier ( identifier )
 */
template <typename CharT>
static auto ParseTimeZoneIdentifier(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTimeZoneIdentifier();
}

/**
 * ParseTimeZoneIdentifier ( identifier )
 */
static auto ParseTimeZoneIdentifier(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTimeZoneIdentifier<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTimeZoneIdentifier<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTimeZoneIdentifier ( identifier )
 */
bool js::temporal::ParseTimeZoneIdentifier(
    JSContext* cx, Handle<JSString*> str,
    MutableHandle<ParsedTimeZone> result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTimeZoneIdentifier(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "time zone identifier");
    return false;
  }
  auto timeZone = parseResult.unwrap();

  // Steps 3-4.
  return ParseTimeZoneAnnotation(cx, timeZone, linear, result);
}

template <typename CharT>
mozilla::Result<DateTimeUTCOffset, ParserError>
TemporalParser<CharT>::parseDateTimeUTCOffset() {
  MOZ_TRY(nonempty());
  return parse(utcOffsetSubMinutePrecision());
}

/**
 * ParseDateTimeUTCOffset ( offsetString )
 */
template <typename CharT>
static auto ParseDateTimeUTCOffset(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseDateTimeUTCOffset();
}

/**
 * ParseDateTimeUTCOffset ( offsetString )
 */
static auto ParseDateTimeUTCOffset(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseDateTimeUTCOffset<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseDateTimeUTCOffset<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseDateTimeUTCOffset ( offsetString )
 */
bool js::temporal::ParseDateTimeUTCOffset(JSContext* cx, Handle<JSString*> str,
                                          int64_t* result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseDateTimeUTCOffset(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "UTC offset");
    return false;
  }

  // Steps 3-21.
  *result = ParseDateTimeUTCOffset(parseResult.unwrap()).offset;
  return true;
}

template <typename CharT>
mozilla::Result<double, ParserError> TemporalParser<CharT>::durationDigits(
    JSContext* cx) {
  auto d = digits(cx);
  if (!d) {
    return err(JSMSG_TEMPORAL_PARSER_MISSING_DURATION_DIGITS);
  }
  return *d;
}

template <typename CharT>
mozilla::Result<TemporalDurationString, ParserError>
TemporalParser<CharT>::parseTemporalDurationString(JSContext* cx) {
  MOZ_TRY(nonempty());

  // Initialize all fields to zero.
  TemporalDurationString result{};

  // TemporalDurationString :::
  //   Duration
  //
  // Duration :::
  //   ASCIISign? DurationDesignator DurationDate
  //   ASCIISign? DurationDesignator DurationTime

  if (hasSign()) {
    result.sign = sign();
  }

  if (!durationDesignator()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_DURATION_DESIGNATOR);
  }

  // DurationDate :::
  //   DurationYearsPart DurationTime?
  //   DurationMonthsPart DurationTime?
  //   DurationWeeksPart DurationTime?
  //   DurationDaysPart DurationTime?

  do {
    if (hasTimeDesignator()) {
      break;
    }

    double num = MOZ_TRY(durationDigits(cx));

    // DurationYearsPart :::
    //   DecimalDigits[~Sep] YearsDesignator DurationMonthsPart
    //   DecimalDigits[~Sep] YearsDesignator DurationWeeksPart
    //   DecimalDigits[~Sep] YearsDesignator DurationDaysPart?
    if (yearsDesignator()) {
      result.years = num;
      if (reader_.atEnd()) {
        return result;
      }
      if (hasTimeDesignator()) {
        break;
      }
      num = MOZ_TRY(durationDigits(cx));
    }

    // DurationMonthsPart :::
    //   DecimalDigits[~Sep] MonthsDesignator DurationWeeksPart
    //   DecimalDigits[~Sep] MonthsDesignator DurationDaysPart?
    if (monthsDesignator()) {
      result.months = num;
      if (reader_.atEnd()) {
        return result;
      }
      if (hasTimeDesignator()) {
        break;
      }
      num = MOZ_TRY(durationDigits(cx));
    }

    // DurationWeeksPart :::
    //   DecimalDigits[~Sep] WeeksDesignator DurationDaysPart?
    if (weeksDesignator()) {
      result.weeks = num;
      if (reader_.atEnd()) {
        return result;
      }
      if (hasTimeDesignator()) {
        break;
      }
      num = MOZ_TRY(durationDigits(cx));
    }

    // DurationDaysPart :::
    //   DecimalDigits[~Sep] DaysDesignator
    if (daysDesignator()) {
      result.days = num;
      if (reader_.atEnd()) {
        return result;
      }
      if (hasTimeDesignator()) {
        break;
      }
    }

    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_DURATION_UNIT_DESIGNATOR);
  } while (false);

  // DurationTime :::
  //   TimeDesignator DurationHoursPart
  //   TimeDesignator DurationMinutesPart
  //   TimeDesignator DurationSecondsPart
  if (!timeDesignator()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_TIME_DESIGNATOR);
  }

  double num = MOZ_TRY(durationDigits(cx));

  auto frac = fraction();

  // DurationHoursPart :::
  //   DecimalDigits[~Sep] TemporalDecimalFraction HoursDesignator
  //   DecimalDigits[~Sep] HoursDesignator DurationMinutesPart
  //   DecimalDigits[~Sep] HoursDesignator DurationSecondsPart?
  bool hasHoursFraction = false;
  if (hoursDesignator()) {
    hasHoursFraction = bool(frac);
    result.hours = num;
    result.hoursFraction = frac.valueOr(0);
    if (reader_.atEnd()) {
      return result;
    }

    num = MOZ_TRY(durationDigits(cx));
    frac = fraction();
  }

  // DurationMinutesPart :::
  //   DecimalDigits[~Sep] TemporalDecimalFraction MinutesDesignator
  //   DecimalDigits[~Sep] MinutesDesignator DurationSecondsPart?
  bool hasMinutesFraction = false;
  if (minutesDesignator()) {
    if (hasHoursFraction) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_DURATION_MINUTES);
    }
    hasMinutesFraction = bool(frac);
    result.minutes = num;
    result.minutesFraction = frac.valueOr(0);
    if (reader_.atEnd()) {
      return result;
    }

    num = MOZ_TRY(durationDigits(cx));
    frac = fraction();
  }

  // DurationSecondsPart :::
  //   DecimalDigits[~Sep] TemporalDecimalFraction? SecondsDesignator
  if (secondsDesignator()) {
    if (hasHoursFraction || hasMinutesFraction) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_DURATION_SECONDS);
    }
    result.seconds = num;
    result.secondsFraction = frac.valueOr(0);
    if (reader_.atEnd()) {
      return result;
    }
  }

  return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_DURATION_UNIT_DESIGNATOR);
}

/**
 * ParseTemporalDurationString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalDurationString(JSContext* cx,
                                        mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalDurationString(cx);
}

/**
 * ParseTemporalDurationString ( isoString )
 */
static auto ParseTemporalDurationString(JSContext* cx,
                                        Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalDurationString<Latin1Char>(cx, str->latin1Range(nogc));
  }
  return ParseTemporalDurationString<char16_t>(cx, str->twoByteRange(nogc));
}

/**
 * ParseTemporalDurationString ( isoString )
 */
bool js::temporal::ParseTemporalDurationString(JSContext* cx,
                                               Handle<JSString*> str,
                                               Duration* result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-3.
  auto parseResult = ::ParseTemporalDurationString(cx, linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "duration");
    return false;
  }
  TemporalDurationString parsed = parseResult.unwrap();

  // Steps 4-8.
  double years = parsed.years;
  double months = parsed.months;
  double weeks = parsed.weeks;
  double days = parsed.days;
  double hours = parsed.hours;

  // Steps 9-17.
  double minutes, seconds, milliseconds, microseconds, nanoseconds;
  if (parsed.hoursFraction) {
    MOZ_ASSERT(parsed.hoursFraction > 0);
    MOZ_ASSERT(parsed.hoursFraction < 1'000'000'000);

    // Step 9.a.
    MOZ_ASSERT(parsed.minutes == 0);
    MOZ_ASSERT(parsed.minutesFraction == 0);
    MOZ_ASSERT(parsed.seconds == 0);
    MOZ_ASSERT(parsed.secondsFraction == 0);

    // Steps 9.b-d.
    int64_t h = int64_t(parsed.hoursFraction) * 60;
    minutes = double(h / 1'000'000'000);

    // Steps 13 and 15-17.
    int64_t min = (h % 1'000'000'000) * 60;
    seconds = double(min / 1'000'000'000);
    milliseconds = double((min % 1'000'000'000) / 1'000'000);
    microseconds = double((min % 1'000'000) / 1'000);
    nanoseconds = double(min % 1'000);
  }

  // Step 11.
  else if (parsed.minutesFraction) {
    MOZ_ASSERT(parsed.minutesFraction > 0);
    MOZ_ASSERT(parsed.minutesFraction < 1'000'000'000);

    // Step 11.a.
    MOZ_ASSERT(parsed.seconds == 0);
    MOZ_ASSERT(parsed.secondsFraction == 0);

    // Step 10.
    minutes = parsed.minutes;

    // Steps 11.b-d and 15-17.
    int64_t min = int64_t(parsed.minutesFraction) * 60;
    seconds = double(min / 1'000'000'000);
    milliseconds = double((min % 1'000'000'000) / 1'000'000);
    microseconds = double((min % 1'000'000) / 1'000);
    nanoseconds = double(min % 1'000);
  }

  // Step 14.
  else if (parsed.secondsFraction) {
    MOZ_ASSERT(parsed.secondsFraction > 0);
    MOZ_ASSERT(parsed.secondsFraction < 1'000'000'000);

    // Step 10.
    minutes = parsed.minutes;

    // Step 12.
    seconds = parsed.seconds;

    // Steps 14, 16-17
    milliseconds = double(parsed.secondsFraction / 1'000'000);
    microseconds = double((parsed.secondsFraction % 1'000'000) / 1'000);
    nanoseconds = double(parsed.secondsFraction % 1'000);
  } else {
    // Step 10.
    minutes = parsed.minutes;

    // Step 12.
    seconds = parsed.seconds;

    // Steps 15-17
    milliseconds = 0;
    microseconds = 0;
    nanoseconds = 0;
  }

  // Steps 18-19.
  int32_t factor = parsed.sign ? parsed.sign : 1;
  MOZ_ASSERT(factor == -1 || factor == 1);

  // Steps 20-29.
  *result = {
      (years * factor) + (+0.0),        (months * factor) + (+0.0),
      (weeks * factor) + (+0.0),        (days * factor) + (+0.0),
      (hours * factor) + (+0.0),        (minutes * factor) + (+0.0),
      (seconds * factor) + (+0.0),      (milliseconds * factor) + (+0.0),
      (microseconds * factor) + (+0.0), (nanoseconds * factor) + (+0.0),
  };

  // Steps 30-31.
  return ThrowIfInvalidDuration(cx, *result);
}

template <typename CharT>
mozilla::Result<AnnotationKey, ParserError>
TemporalParser<CharT>::annotationKey() {
  // AnnotationKey :::
  //    AKeyLeadingChar
  //    AnnotationKey AKeyChar

  size_t start = reader_.index();

  if (!aKeyLeadingChar()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_ANNOTATION_KEY);
  }

  // Optionally followed by a sequence of |AKeyChar|.
  while (aKeyChar()) {
  }

  return AnnotationKey{start, reader_.index() - start};
}

template <typename CharT>
mozilla::Result<AnnotationValue, ParserError>
TemporalParser<CharT>::annotationValue() {
  // AnnotationValue :::
  //   AnnotationValueComponent
  //   AnnotationValueComponent - AnnotationValue

  size_t start = reader_.index();

  do {
    if (!annotationValueComponent()) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_ANNOTATION_VALUE);
    }
  } while (character('-'));

  return AnnotationValue{start, reader_.index() - start};
}

template <typename CharT>
mozilla::Result<Annotation, ParserError> TemporalParser<CharT>::annotation() {
  // Annotation :::
  //   [ AnnotationCriticalFlag? AnnotationKey = AnnotationValue ]

  if (!character('[')) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_BRACKET_BEFORE_ANNOTATION);
  }

  Annotation result{};

  result.critical = annotationCriticalFlag();

  result.key = MOZ_TRY(annotationKey());

  if (!character('=')) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_ASSIGNMENT_IN_ANNOTATION);
  }

  result.value = MOZ_TRY(annotationValue());

  if (!character(']')) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_BRACKET_AFTER_ANNOTATION);
  }

  return result;
}

template <typename CharT>
mozilla::Result<CalendarName, ParserError>
TemporalParser<CharT>::annotations() {
  // Annotations :::
  //   Annotation Annotations?

  MOZ_ASSERT(hasAnnotationStart());

  CalendarName calendar;
  bool calendarWasCritical = false;
  while (hasAnnotationStart()) {
    Annotation anno = MOZ_TRY(annotation());

    auto [key, value, critical] = anno;

    static constexpr std::string_view ca = "u-ca";

    auto keySpan = reader_.substring(key);
    if (keySpan.size() == ca.length() &&
        std::equal(ca.begin(), ca.end(), keySpan.data())) {
      if (!calendar.present()) {
        calendar = value;
        calendarWasCritical = critical;
      } else if (critical || calendarWasCritical) {
        return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_CRITICAL_ANNOTATION);
      }
    } else if (critical) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_INVALID_CRITICAL_ANNOTATION);
    }
  }
  return calendar;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::annotatedTime() {
  // clang-format off
  //
  // AnnotatedTime :::
  //   TimeDesignator Time DateTimeUTCOffset[~Z]? TimeZoneAnnotation? Annotations?
  //   Time DateTimeUTCOffset[~Z]? TimeZoneAnnotation? Annotations?
  //
  // clang-format on

  ZonedDateTimeString result{};

  size_t start = reader_.index();
  bool hasTimeDesignator = timeDesignator();

  result.time = MOZ_TRY(time());

  if (hasDateTimeUTCOffsetStart()) {
    result.timeZone = MOZ_TRY(dateTimeUTCOffset(/* allowZ = */ false));
  }

  // Early error if `Time DateTimeUTCOffset[~Z]` can be parsed as either
  // `DateSpecMonthDay` or `DateSpecYearMonth`.
  if (!hasTimeDesignator) {
    size_t end = reader_.index();

    auto isValidMonthDay = [](const ISODate& date) {
      MOZ_ASSERT(date.year == AbsentYear);
      MOZ_ASSERT(1 <= date.month && date.month <= 12);
      MOZ_ASSERT(1 <= date.day && date.day <= 31);

      constexpr int32_t leapYear = 0;
      return date.day <= ISODaysInMonth(leapYear, date.month);
    };

    // Reset and check if the input can also be parsed as DateSpecMonthDay.
    reader_.reset(start);

    if (auto monthDay = dateSpecMonthDay(); monthDay.isOk()) {
      if (reader_.index() == end && isValidMonthDay(monthDay.unwrap())) {
        return mozilla::Err(JSMSG_TEMPORAL_PARSER_AMBIGUOUS_TIME_MONTH_DAY);
      }
    }

    // Reset and check if the input can also be parsed as DateSpecYearMonth.
    reader_.reset(start);

    if (dateSpecYearMonth().isOk()) {
      if (reader_.index() == end) {
        return mozilla::Err(JSMSG_TEMPORAL_PARSER_AMBIGUOUS_TIME_YEAR_MONTH);
      }
    }

    // Input can neither be parsed as DateSpecMonthDay nor DateSpecYearMonth.
    reader_.reset(end);
  }

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::annotatedDateTime() {
  // AnnotatedDateTime[Zoned, TimeRequired] :::
  //  [~Zoned] DateTime[~Z, ?TimeRequired] TimeZoneAnnotation? Annotations?
  //  [+Zoned] DateTime[+Z, ?TimeRequired] TimeZoneAnnotation Annotations?
  //
  // When called as `AnnotatedDateTime[~Zoned, ~TimeRequired]`.

  ZonedDateTimeString result = MOZ_TRY(dateTime(/* allowZ = */ false));

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::annotatedDateTimeTimeRequired() {
  // AnnotatedDateTime[Zoned, TimeRequired] :::
  //  [~Zoned] DateTime[~Z, ?TimeRequired] TimeZoneAnnotation? Annotations?
  //  [+Zoned] DateTime[+Z, ?TimeRequired] TimeZoneAnnotation Annotations?
  //
  // DateTime[Z, TimeRequired] :::
  //   [~TimeRequired] Date
  //   Date DateTimeSeparator Time DateTimeUTCOffset[?Z]?
  //
  // When called as `AnnotatedDateTime[~Zoned, +TimeRequired]`.

  ZonedDateTimeString result{};

  result.date = MOZ_TRY(date());

  if (!dateTimeSeparator()) {
    return mozilla::Err(JSMSG_TEMPORAL_PARSER_MISSING_DATE_TIME_SEPARATOR);
  }

  result.time = MOZ_TRY(time());

  if (hasDateTimeUTCOffsetStart()) {
    result.timeZone = MOZ_TRY(dateTimeUTCOffset(/* allowZ = */ false));
  }

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::annotatedYearMonth() {
  // AnnotatedYearMonth :::
  //   DateSpecYearMonth TimeZoneAnnotation? Annotations?

  ZonedDateTimeString result{};

  result.date = MOZ_TRY(dateSpecYearMonth());

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::annotatedMonthDay() {
  // AnnotatedMonthDay :::
  //   DateSpecMonthDay TimeZoneAnnotation? Annotations?

  ZonedDateTimeString result{};

  result.date = MOZ_TRY(dateSpecMonthDay());

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return result;
}

template <typename CharT>
mozilla::Result<ISODate, ParserError>
TemporalParser<CharT>::dateSpecYearMonth() {
  // DateSpecYearMonth :::
  //   DateYear DateSeparator[+Extended] DateMonth
  //   DateYear DateSeparator[~Extended] DateMonth

  ISODate result{};

  result.year = MOZ_TRY(dateYear());

  // Optional |DateSeparator|.
  dateSeparator();

  result.month = MOZ_TRY(dateMonth());

  return result;
}

template <typename CharT>
mozilla::Result<ISODate, ParserError>
TemporalParser<CharT>::dateSpecMonthDay() {
  // DateSpecMonthDay :::
  //   --? DateMonth DateSeparator[+Extended] DateDay
  //   --? DateMonth DateSeparator[~Extended] DateDay

  ISODate result{};

  // Optional: --
  string("--");

  result.year = AbsentYear;

  result.month = MOZ_TRY(dateMonth());

  // Optional |DateSeparator|.
  dateSeparator();

  result.day = MOZ_TRY(dateDay());

  return result;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalCalendarString() {
  MOZ_TRY(nonempty());

  // Handle the common case of a standalone calendar name first.
  //
  // All valid calendar names start with two alphabetic characters and none of
  // the ParseISODateTime parse goals can start with two alphabetic characters.
  // TemporalTimeString can start with 'T', so we can't only check the first
  // character.
  if (hasTwoAsciiAlpha()) {
    ZonedDateTimeString result{};

    result.calendar = MOZ_TRY(parse(annotationValue()));

    return result;
  }

  LikelyError likelyError{};

  // Try all five parse goals from ParseISODateTime in order.
  //
  // TemporalDateTimeString
  // TemporalInstantString
  // TemporalTimeString
  // TemporalMonthDayString
  // TemporalYearMonthString

  auto dateTime = parseTemporalDateTimeString();
  if (dateTime.isOk()) {
    return dateTime;
  }
  likelyError.update(dateTime, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto instant = parseTemporalInstantString();
  if (instant.isOk()) {
    return instant;
  }
  likelyError.update(instant, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto time = parseTemporalTimeString();
  if (time.isOk()) {
    return time;
  }
  likelyError.update(time, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto monthDay = parseTemporalMonthDayString();
  if (monthDay.isOk()) {
    return monthDay;
  }
  likelyError.update(monthDay, reader_.index());

  // Restart parsing from the start of the string.
  reader_.reset();

  auto yearMonth = parseTemporalYearMonthString();
  if (yearMonth.isOk()) {
    return yearMonth;
  }
  likelyError.update(yearMonth, reader_.index());

  return likelyError.propagate();
}

/**
 * ParseTemporalCalendarString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalCalendarString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalCalendarString();
}

/**
 * ParseTemporalCalendarString ( isoString )
 */
static auto ParseTemporalCalendarString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalCalendarString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalCalendarString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalCalendarString ( isoString )
 */
JSLinearString* js::temporal::ParseTemporalCalendarString(
    JSContext* cx, Handle<JSString*> str) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return nullptr;
  }

  // Steps 1 and 3.a.
  auto parseResult = ::ParseTemporalCalendarString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "calendar");
    return nullptr;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  ISODateTime unused;
  if (!ParseISODateTime(cx, parsed, &unused)) {
    return nullptr;
  }

  // Step 2.b.
  if (!parsed.calendar.present()) {
    return cx->names().iso8601;
  }

  // Steps 2.c and 3.c
  return ToString(cx, linear, parsed.calendar);
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalTimeString() {
  MOZ_TRY(nonempty());

  // TemporalTimeString :::
  //   AnnotatedTime
  //   AnnotatedDateTime[~Zoned, +TimeRequired]

  LikelyError likelyError{};

  auto time = parse(annotatedTime());
  if (time.isOk()) {
    return time;
  }
  likelyError.update(time, reader_.index());

  // Reset and try the next option.
  reader_.reset();

  auto dateTime = parse(annotatedDateTimeTimeRequired());
  if (dateTime.isOk()) {
    return dateTime;
  }
  likelyError.update(time, reader_.index());

  // Set current index to the likely error index to give better error messages
  // when called from parserTemporal{Calendar,TimeZone}String.
  reader_.reset(likelyError.index());

  return likelyError.propagate();
}

/**
 * ParseTemporalTimeString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalTimeString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalTimeString();
}

/**
 * ParseTemporalTimeString ( isoString )
 */
static auto ParseTemporalTimeString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalTimeString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalTimeString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalTimeString ( isoString )
 */
bool js::temporal::ParseTemporalTimeString(JSContext* cx, Handle<JSString*> str,
                                           Time* result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTemporalTimeString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "time");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 3.
  ISODateTime dateTime;
  if (!ParseISODateTime(cx, parsed, &dateTime)) {
    return false;
  }
  *result = dateTime.time;

  // Step 4.
  MOZ_ASSERT(!parsed.startOfDay);

  // Step 5.
  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalMonthDayString() {
  MOZ_TRY(nonempty());

  // TemporalMonthDayString :::
  //   AnnotatedMonthDay
  //   AnnotatedDateTime[~Zoned, ~TimeRequired]

  LikelyError likelyError{};

  auto monthDay = parse(annotatedMonthDay());
  if (monthDay.isOk()) {
    auto result = monthDay.unwrap();

    // ParseISODateTime, step 3.
    if (result.calendar.present() &&
        !IsISO8601Calendar(reader_.substring(result.calendar))) {
      return mozilla::Err(JSMSG_TEMPORAL_PARSER_MONTH_DAY_CALENDAR_NOT_ISO8601);
    }
    return result;
  }
  likelyError.update(monthDay, reader_.index());

  // Reset and try the next option.
  reader_.reset();

  auto dateTime = parse(annotatedDateTime());
  if (dateTime.isOk()) {
    return dateTime;
  }
  likelyError.update(dateTime, reader_.index());

  // Set current index to the likely error index to give better error messages
  // when called from parserTemporal{Calendar,TimeZone}String.
  reader_.reset(likelyError.index());

  return likelyError.propagate();
}

/**
 * ParseTemporalMonthDayString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalMonthDayString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalMonthDayString();
}

/**
 * ParseTemporalMonthDayString ( isoString )
 */
static auto ParseTemporalMonthDayString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalMonthDayString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalMonthDayString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalMonthDayString ( isoString )
 */
bool js::temporal::ParseTemporalMonthDayString(
    JSContext* cx, Handle<JSString*> str, ISODate* result, bool* hasYear,
    MutableHandle<JSString*> calendar) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTemporalMonthDayString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "month-day");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 3.
  ISODateTime dateTime;
  if (!ParseISODateTime(cx, parsed, &dateTime)) {
    return false;
  }
  *result = dateTime.date;

  // Steps 4-5.
  *hasYear = parsed.date.year != AbsentYear;

  if (parsed.calendar.present()) {
    calendar.set(ToString(cx, linear, parsed.calendar));
    if (!calendar) {
      return false;
    }
  }

  // Step 6.
  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalYearMonthString() {
  MOZ_TRY(nonempty());

  // TemporalYearMonthString :::
  //   AnnotatedYearMonth
  //   AnnotatedDateTime[~Zoned, ~TimeRequired]

  LikelyError likelyError{};

  auto yearMonth = parse(annotatedYearMonth());
  if (yearMonth.isOk()) {
    auto result = yearMonth.unwrap();

    // ParseISODateTime, step 3.
    if (result.calendar.present() &&
        !IsISO8601Calendar(reader_.substring(result.calendar))) {
      return mozilla::Err(
          JSMSG_TEMPORAL_PARSER_YEAR_MONTH_CALENDAR_NOT_ISO8601);
    }
    return result;
  }
  likelyError.update(yearMonth, reader_.index());

  // Reset and try the next option.
  reader_.reset();

  auto dateTime = parse(annotatedDateTime());
  if (dateTime.isOk()) {
    return dateTime;
  }
  likelyError.update(dateTime, reader_.index());

  // Set current index to the likely error index to give better error messages
  // when called from parserTemporal{Calendar,TimeZone}String.
  reader_.reset(likelyError.index());

  return likelyError.propagate();
}

/**
 * ParseTemporalYearMonthString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalYearMonthString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalYearMonthString();
}

/**
 * ParseTemporalYearMonthString ( isoString )
 */
static auto ParseTemporalYearMonthString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalYearMonthString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalYearMonthString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalYearMonthString ( isoString )
 */
bool js::temporal::ParseTemporalYearMonthString(
    JSContext* cx, Handle<JSString*> str, ISODate* result,
    MutableHandle<JSString*> calendar) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTemporalYearMonthString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "year-month");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 3.
  ISODateTime dateTime;
  if (!ParseISODateTime(cx, parsed, &dateTime)) {
    return false;
  }
  *result = dateTime.date;

  if (parsed.calendar.present()) {
    calendar.set(ToString(cx, linear, parsed.calendar));
    if (!calendar) {
      return false;
    }
  }

  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalDateTimeString() {
  MOZ_TRY(nonempty());

  // TemporalDateTimeString[Zoned] :::
  //   AnnotatedDateTime[?Zoned, ~TimeRequired]

  return parse(annotatedDateTime());
}

/**
 * ParseTemporalDateTimeString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalDateTimeString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalDateTimeString();
}

/**
 * ParseTemporalDateTimeString ( isoString )
 */
static auto ParseTemporalDateTimeString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalDateTimeString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalDateTimeString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalDateTimeString ( isoString )
 */
bool js::temporal::ParseTemporalDateTimeString(
    JSContext* cx, Handle<JSString*> str, ISODateTime* result,
    MutableHandle<JSString*> calendar) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTemporalDateTimeString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "date-time");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 3.
  if (!ParseISODateTime(cx, parsed, result)) {
    return false;
  }

  if (parsed.calendar.present()) {
    calendar.set(ToString(cx, linear, parsed.calendar));
    if (!calendar) {
      return false;
    }
  }

  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalZonedDateTimeString() {
  MOZ_TRY(nonempty());

  // Parse goal: TemporalDateTimeString[+Zoned]
  //
  // TemporalDateTimeString[Zoned] :::
  //   AnnotatedDateTime[?Zoned, ~TimeRequired]
  //
  // AnnotatedDateTime[Zoned, TimeRequired] :::
  //   [~Zoned] DateTime[~Z, ?TimeRequired] TimeZoneAnnotation? Annotations?
  //   [+Zoned] DateTime[+Z, ?TimeRequired] TimeZoneAnnotation Annotations?

  ZonedDateTimeString result{};

  result = MOZ_TRY(dateTime(/* allowZ = */ true));

  result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return complete(result);
}

/**
 * ParseTemporalZonedDateTimeString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalZonedDateTimeString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalZonedDateTimeString();
}

/**
 * ParseTemporalZonedDateTimeString ( isoString )
 */
static auto ParseTemporalZonedDateTimeString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalZonedDateTimeString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalZonedDateTimeString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalZonedDateTimeString ( isoString )
 */
bool js::temporal::ParseTemporalZonedDateTimeString(
    JSContext* cx, Handle<JSString*> str,
    JS::MutableHandle<ParsedZonedDateTime> result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Step 1.
  auto parseResult = ::ParseTemporalZonedDateTimeString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "zoned date-time");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 2. (ParseISODateTime, steps 2-3.)
  Rooted<JSLinearString*> calendar(cx);
  if (parsed.calendar.present()) {
    calendar = ToString(cx, linear, parsed.calendar);
    if (!calendar) {
      return false;
    }
  }

  // Step 2. (ParseISODateTime, steps 4-21.)
  ISODateTime dateTime;
  if (!ParseISODateTime(cx, parsed, &dateTime)) {
    return false;
  }

  // Step 2. (ParseISODateTime, steps 22-23.)
  bool isStartOfDay = parsed.startOfDay;

  // Step 2. (ParseISODateTime, steps 24-27.)
  Rooted<ParsedTimeZone> timeZoneAnnotation(cx);
  mozilla::MaybeOneOf<UTCTimeZone, OffsetTimeZone> timeZone;
  {
    MOZ_ASSERT(parsed.timeZone.hasAnnotation());

    // Case 1: 19700101T00:00Z[+02:00]
    // { [[Z]]: true, [[OffsetString]]: undefined, [[Name]]: "+02:00" }
    //
    // Case 2: 19700101T00:00+02:00[+02:00]
    // { [[Z]]: false, [[OffsetString]]: "+02:00", [[Name]]: "+02:00" }
    //
    // Case 3: 19700101[+02:00]
    // { [[Z]]: false, [[OffsetString]]: undefined, [[Name]]: "+02:00" }
    //
    // Case 4: 19700101T00:00Z[Europe/Berlin]
    // { [[Z]]: true, [[OffsetString]]: undefined, [[Name]]: "Europe/Berlin" }
    //
    // Case 5: 19700101T00:00+01:00[Europe/Berlin]
    // { [[Z]]: false, [[OffsetString]]: "+01:00", [[Name]]: "Europe/Berlin" }
    //
    // Case 6: 19700101[Europe/Berlin]
    // { [[Z]]: false, [[OffsetString]]: undefined, [[Name]]: "Europe/Berlin" }

    const auto& annotation = parsed.timeZone.annotation;
    if (!ParseTimeZoneAnnotation(cx, annotation, linear, &timeZoneAnnotation)) {
      return false;
    }

    if (parsed.timeZone.isUTC()) {
      timeZone.construct<UTCTimeZone>();
    } else if (parsed.timeZone.hasOffset()) {
      timeZone.construct<OffsetTimeZone>(
          ParseDateTimeUTCOffset(parsed.timeZone.offset));
    }
  }

  // Step 2. (ParseISODateTime, step 28.)
  result.set(ParsedZonedDateTime{
      dateTime,
      calendar,
      timeZoneAnnotation.get(),
      std::move(timeZone),
      isStartOfDay,
  });
  return true;
}

template <typename CharT>
mozilla::Result<ZonedDateTimeString, ParserError>
TemporalParser<CharT>::parseTemporalRelativeToString() {
  MOZ_TRY(nonempty());

  // Parse goals:
  // TemporalDateTimeString[+Zoned] and TemporalDateTimeString[~Zoned]
  //
  // TemporalDateTimeString[Zoned] :::
  //   AnnotatedDateTime[?Zoned, ~TimeRequired]
  //
  // AnnotatedDateTime[Zoned, TimeRequired] :::
  //   [~Zoned] DateTime[~Z, ?TimeRequired] TimeZoneAnnotation? Annotations?
  //   [+Zoned] DateTime[+Z, ?TimeRequired] TimeZoneAnnotation Annotations?

  ZonedDateTimeString result{};

  result = MOZ_TRY(dateTime(/* allowZ = */ true));

  if (hasTimeZoneAnnotationStart()) {
    result.timeZone.annotation = MOZ_TRY(timeZoneAnnotation());
  }

  if (hasAnnotationStart()) {
    result.calendar = MOZ_TRY(annotations());
  }

  return complete(result);
}

/**
 * ParseTemporalRelativeToString ( isoString )
 */
template <typename CharT>
static auto ParseTemporalRelativeToString(mozilla::Span<const CharT> str) {
  TemporalParser<CharT> parser(str);
  return parser.parseTemporalRelativeToString();
}

/**
 * ParseTemporalRelativeToString ( isoString )
 */
static auto ParseTemporalRelativeToString(Handle<JSLinearString*> str) {
  JS::AutoCheckCannotGC nogc;
  if (str->hasLatin1Chars()) {
    return ParseTemporalRelativeToString<Latin1Char>(str->latin1Range(nogc));
  }
  return ParseTemporalRelativeToString<char16_t>(str->twoByteRange(nogc));
}

/**
 * ParseTemporalRelativeToString ( isoString )
 */
bool js::temporal::ParseTemporalRelativeToString(
    JSContext* cx, Handle<JSString*> str,
    MutableHandle<ParsedZonedDateTime> result) {
  Rooted<JSLinearString*> linear(cx, str->ensureLinear(cx));
  if (!linear) {
    return false;
  }

  // Steps 1-2.
  auto parseResult = ::ParseTemporalRelativeToString(linear);
  if (parseResult.isErr()) {
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                              parseResult.unwrapErr(), "relative date-time");
    return false;
  }
  ZonedDateTimeString parsed = parseResult.unwrap();

  // Step 3.
  if (parsed.timeZone.isUTC() && !parsed.timeZone.hasAnnotation()) {
    JS_ReportErrorNumberASCII(
        cx, GetErrorMessage, nullptr,
        JSMSG_TEMPORAL_PARSER_INVALID_UTC_DESIGNATOR_WITHOUT_NAME,
        "relative date-time");
    return false;
  }

  // Step 4. (ParseISODateTime, steps 1-18.)
  ISODateTime dateTime;
  if (!ParseISODateTime(cx, parsed, &dateTime)) {
    return false;
  }
  bool isStartOfDay = parsed.startOfDay;

  // Step 4. (ParseISODateTime, steps 19-22.)
  Rooted<ParsedTimeZone> timeZoneAnnotation(cx);
  mozilla::MaybeOneOf<UTCTimeZone, OffsetTimeZone> timeZone;
  if (parsed.timeZone.hasAnnotation()) {
    // Case 1: 19700101Z[+02:00]
    // { [[Z]]: true, [[OffsetString]]: undefined, [[Name]]: "+02:00" }
    //
    // Case 2: 19700101+00:00[+02:00]
    // { [[Z]]: false, [[OffsetString]]: "+00:00", [[Name]]: "+02:00" }
    //
    // Case 3: 19700101[+02:00]
    // { [[Z]]: false, [[OffsetString]]: undefined, [[Name]]: "+02:00" }
    //
    // Case 4: 19700101Z[Europe/Berlin]
    // { [[Z]]: true, [[OffsetString]]: undefined, [[Name]]: "Europe/Berlin" }
    //
    // Case 5: 19700101+00:00[Europe/Berlin]
    // { [[Z]]: false, [[OffsetString]]: "+00:00", [[Name]]: "Europe/Berlin" }
    //
    // Case 6: 19700101[Europe/Berlin]
    // { [[Z]]: false, [[OffsetString]]: undefined, [[Name]]: "Europe/Berlin" }

    const auto& annotation = parsed.timeZone.annotation;
    if (!ParseTimeZoneAnnotation(cx, annotation, linear, &timeZoneAnnotation)) {
      return false;
    }

    if (parsed.timeZone.isUTC()) {
      timeZone.construct<UTCTimeZone>();
    } else if (parsed.timeZone.hasOffset()) {
      timeZone.construct<OffsetTimeZone>(
          ParseDateTimeUTCOffset(parsed.timeZone.offset));
    }
  } else {
    // GetTemporalRelativeToOption ignores any other time zone information when
    // no bracketed time zone annotation is present.
    timeZoneAnnotation.set(ParsedTimeZone{});
  }

  // Step 4. (ParseISODateTime, steps 23-24.)
  JSLinearString* calendar = nullptr;
  if (parsed.calendar.present()) {
    calendar = ToString(cx, linear, parsed.calendar);
    if (!calendar) {
      return false;
    }
  }

  // Step 4. (Return)
  result.set(ParsedZonedDateTime{
      dateTime,
      calendar,
      timeZoneAnnotation.get(),
      std::move(timeZone),
      isStartOfDay,
  });
  return true;
}

void js::temporal::ParsedTimeZone::trace(JSTracer* trc) {
  TraceRoot(trc, &name, "ParsedTimeZone::name");
}

void js::temporal::ParsedZonedDateTime::trace(JSTracer* trc) {
  TraceRoot(trc, &calendar, "ParsedZonedDateTime::calendar");
  timeZoneAnnotation.trace(trc);
}