spec/duration.html

<!doctype html>
<meta charset="utf8">

<emu-clause id="sec-temporal-duration-objects">
  <h1>Temporal.Duration Objects</h1>

  <p>
    A Temporal.Duration object describes the difference in elapsed time between
    two other Temporal objects of the same type: Instant, PlainDate,
    PlainDateTime, PlainTime, PlainYearMonth, or ZonedDateTime. Objects of this
    type are only created via the <i>.since()</i> and <i>.until()</i> methods of
    these objects.
  </p>

  <emu-clause id="sec-temporal-duration-constructor">
    <h1>The Temporal.Duration Constructor</h1>
    <p>The Temporal.Duration constructor:</p>
    <ul>
      <li>
        creates and initializes a new Temporal.Duration object when called as a constructor.
      </li>
      <li>
        is not intended to be called as a function and will throw an exception when called in that manner.
      </li>
      <li>
        may be used as the value of an `extends` clause of a class definition.
        Subclass constructors that intend to inherit the specified Temporal.Duration behaviour must
        include a super call to the %Temporal.Duration% constructor to create and initialize subclass
        instances with the necessary internal slots.
      </li>
    </ul>

    <emu-clause id="sec-temporal.duration">
      <h1>Temporal.Duration ( [ _years_ [ , _months_ [ , _weeks_ [ , _days_ [ , _hours_ [ , _minutes_ [ , _seconds_ [ , _milliseconds_ [ , _microseconds_ [ , _nanoseconds_ ] ] ] ] ] ] ] ] ] ] )</h1>
      <p>
        The `Temporal.Duration` function performs the following steps when called:
      </p>
      <emu-alg>
        1. If NewTarget is *undefined*, then
          1. Throw a *TypeError* exception.
        1. If _years_ is *undefined*, let _y_ be 0; else let _y_ be ? ToIntegerIfIntegral(_years_).
        1. If _months_ is *undefined*, let _mo_ be 0; else let _mo_ be ? ToIntegerIfIntegral(_months_).
        1. If _weeks_ is *undefined*, let _w_ be 0; else let _w_ be ? ToIntegerIfIntegral(_weeks_).
        1. If _days_ is *undefined*, let _d_ be 0; else let _d_ be ? ToIntegerIfIntegral(_days_).
        1. If _hours_ is *undefined*, let _h_ be 0; else let _h_ be ? ToIntegerIfIntegral(_hours_).
        1. If _minutes_ is *undefined*, let _m_ be 0; else let _m_ be ? ToIntegerIfIntegral(_minutes_).
        1. If _seconds_ is *undefined*, let _s_ be 0; else let _s_ be ? ToIntegerIfIntegral(_seconds_).
        1. If _milliseconds_ is *undefined*, let _ms_ be 0; else let _ms_ be ? ToIntegerIfIntegral(_milliseconds_).
        1. If _microseconds_ is *undefined*, let _mis_ be 0; else let _mis_ be ? ToIntegerIfIntegral(_microseconds_).
        1. If _nanoseconds_ is *undefined*, let _ns_ be 0; else let _ns_ be ? ToIntegerIfIntegral(_nanoseconds_).
        1. Return ? CreateTemporalDuration(_y_, _mo_, _w_, _d_, _h_, _m_, _s_, _ms_, _mis_, _ns_, NewTarget).
      </emu-alg>
    </emu-clause>
  </emu-clause>

  <emu-clause id="sec-properties-of-the-temporal-duration-constructor">
    <h1>Properties of the Temporal.Duration Constructor</h1>
    <p>
      The value of the [[Prototype]] internal slot of the Temporal.Duration
      constructor is the intrinsic object %Function.prototype%.
    </p>
    <p>The Temporal.Duration constructor has the following properties:</p>

    <emu-clause id="sec-temporal.duration.prototype">
      <h1>Temporal.Duration.prototype</h1>
      <p>
        The initial value of `Temporal.Duration.prototype` is
        %Temporal.Duration.prototype%.
      </p>
      <p>
        This property has the attributes { [[Writable]]: *false*, [[Enumerable]]:
        *false*, [[Configurable]]: *false* }.
      </p>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.from">
      <h1>Temporal.Duration.from ( _item_ )</h1>
      <p>
        The `Temporal.Duration.from` function performs the following steps when called:
      </p>
      <emu-alg>
        1. If Type(_item_) is Object and _item_ has an [[InitializedTemporalDuration]] internal slot, then
          1. Return ! CreateTemporalDuration(_item_.[[Years]], _item_.[[Months]], _item_.[[Weeks]], _item_.[[Days]], _item_.[[Hours]], _item_.[[Minutes]], _item_.[[Seconds]], _item_.[[Milliseconds]], _item_.[[Microseconds]], _item_.[[Nanoseconds]]).
        1. Return ? ToTemporalDuration(_item_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.compare">
      <h1>Temporal.Duration.compare ( _one_, _two_ [ , _options_ ] )</h1>
      <p>
        The `Temporal.Duration.compare` function performs the following steps when called:
      </p>
      <emu-alg>
        1. Set _one_ to ? ToTemporalDuration(_one_).
        1. Set _two_ to ? ToTemporalDuration(_two_).
        1. Set _options_ to ? GetOptionsObject(_options_).
        1. If _one_.[[Years]] = _two_.[[Years]], and _one_.[[Months]] = _two_.[[Months]], and _one_.[[Weeks]] = _two_.[[Weeks]], and _one_.[[Days]] = _two_.[[Days]], and _one_.[[Hours]] = _two_.[[Hours]], and _one_.[[Minutes]] = _two_.[[Minutes]], and _one_.[[Seconds]] = _two_.[[Seconds]], and _one_.[[Millieconds]] = _two_.[[Millieconds]], and _one_.[[Microseconds]] = _two_.[[Microseconds]], and _one_.[[Nanoseconds]] = _two_.[[Nanoseconds]], then
          1. Return *+0*<sub>𝔽</sub>.
        1. Let _relativeToRecord_ be ? ToRelativeTemporalObject(_options_).
        1. Let _zonedRelativeTo_ be _relativeToRecord_.[[ZonedRelativeTo]].
        1. Let _plainRelativeTo_ be _relativeToRecord_.[[PlainRelativeTo]].
        1. Let _calendarUnitsPresent_ be *false*.
        1. If _one_.[[Years]] &ne; 0, or _two_.[[Years]] &ne; 0, or _one_.[[Months]] &ne; 0, or _two_.[[Months]] &ne; 0, or _one_.[[Weeks]] &ne; 0, or _two_.[[Weeks]] &ne; 0, set _calendarUnitsPresent_ to *true*.
        1. If _zonedRelativeTo_ is not *undefined*, and either _calendarUnitsPresent_ is *true*, or _one_.[[Days]] &ne; 0, or _two_.[[Days]] &ne; 0, then
          1. Let _timeZone_ be _zonedRelativeTo_.[[TimeZone]].
          1. Let _calendar_ be _zonedRelativeTo_.[[Calendar]].
          1. Let _instant_ be ! CreateTemporalInstant(_zonedRelativeTo_.[[Nanoseconds]]).
          1. Let _precalculatedPlainDateTime_ be ? GetPlainDateTimeFor(_timeZone_, _instant_, _calendar_).
          1. Let _after1_ be ? AddZonedDateTime(_zonedRelativeTo_.[[Nanoseconds]], _timeZone_, _calendar_, _one_.[[Years]], _one_.[[Months]], _one_.[[Weeks]], _one_.[[Days]], _one_.[[Hours]], _one_.[[Minutes]], _one_.[[Seconds]], _one_.[[Milliseconds]], _one_.[[Microseconds]], _one_.[[Nanoseconds]], _precalculatedPlainDateTime_).
          1. Let _after2_ be ? AddZonedDateTime(_zonedRelativeTo_.[[Nanoseconds]], _timeZone_, _calendar_, _two_.[[Years]], _two_.[[Months]], _two_.[[Weeks]], _two_.[[Days]], _two_.[[Hours]], _two_.[[Minutes]], _two_.[[Seconds]], _two_.[[Milliseconds]], _two_.[[Microseconds]], _two_.[[Nanoseconds]], _precalculatedPlainDateTime_).
          1. If _after1_ &gt; _after2_, return *1*<sub>𝔽</sub>.
          1. If _after1_ &lt; _after2_, return *-1*<sub>𝔽</sub>.
          1. Return *+0*<sub>𝔽</sub>.
        1. If _calendarUnitsPresent_ is *true*, then
          1. Let _unbalanceResult1_ be ? UnbalanceDateDurationRelative(_one_.[[Years]], _one_.[[Months]], _one_.[[Weeks]], _one_.[[Days]], *"day"*, _plainRelativeTo_).
          1. Let _unbalanceResult2_ be ? UnbalanceDateDurationRelative(_two_.[[Years]], _two_.[[Months]], _two_.[[Weeks]], _two_.[[Days]], *"day"*, _plainRelativeTo_).
          1. Let _days1_ be _unbalanceResult1_.[[Days]].
          1. Let _days2_ be _unbalanceResult2_.[[Days]].
        1. Else,
          1. Let _days1_ be _one_.[[Days]].
          1. Let _days2_ be _two_.[[Days]].
        1. Let _hours1_ be _one_.[[Hours]] + _days1_ &times; 24.
        1. Let _hours2_ be _two_.[[Hours]] + _days2_ &times; 24.
        1. Let _ns1_ be TotalDurationNanoseconds(_hours1_, _one_.[[Minutes]], _one_.[[Seconds]], _one_.[[Milliseconds]], _one_.[[Microseconds]], _one_.[[Nanoseconds]]).
        1. Let _ns2_ be TotalDurationNanoseconds(_hours2_, _two_.[[Minutes]], _two_.[[Seconds]], _two_.[[Milliseconds]], _two_.[[Microseconds]], _two_.[[Nanoseconds]]).
        1. If _ns1_ &gt; _ns2_, return *1*<sub>𝔽</sub>.
        1. If _ns1_ &lt; _ns2_, return *-1*<sub>𝔽</sub>.
        1. Return *+0*<sub>𝔽</sub>.
      </emu-alg>
    </emu-clause>
  </emu-clause>

  <emu-clause id="sec-properties-of-the-temporal-duration-prototype-object">
    <h1>Properties of the Temporal.Duration Prototype Object</h1>

    <p>The Temporal.Duration prototype object</p>
    <ul>
      <li>is itself an ordinary object.</li>
      <li>is not a Temporal.Duration instance and doesn't have an [[InitializedTemporalDuration]] internal slot.</li>
      <li>has a [[Prototype]] internal slot whose value is %Object.prototype%.</li>
    </ul>

    <emu-clause id="sec-temporal.duration.prototype.constructor">
      <h1>Temporal.Duration.prototype.constructor</h1>
      <p>The initial value of `Temporal.Duration.prototype.constructor` is %Temporal.Duration%.</p>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype-@@tostringtag">
      <h1>Temporal.Duration.prototype[ @@toStringTag ]</h1>
      <p>The initial value of the @@toStringTag property is the string value *"Temporal.Duration"*.</p>
      <p>This property has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*, [[Configurable]]: *true* }.</p>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.years">
      <h1>get Temporal.Duration.prototype.years</h1>
      <p>
        `Temporal.Duration.prototype.years` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Years]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.months">
      <h1>get Temporal.Duration.prototype.months</h1>
      <p>
        `Temporal.Duration.prototype.months` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Months]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.weeks">
      <h1>get Temporal.Duration.prototype.weeks</h1>
      <p>
        `Temporal.Duration.prototype.weeks` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Weeks]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.days">
      <h1>get Temporal.Duration.prototype.days</h1>
      <p>
        `Temporal.Duration.prototype.days` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Days]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.hours">
      <h1>get Temporal.Duration.prototype.hours</h1>
      <p>
        `Temporal.Duration.prototype.hours` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Hours]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.minutes">
      <h1>get Temporal.Duration.prototype.minutes</h1>
      <p>
        `Temporal.Duration.prototype.minutes` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Minutes]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.seconds">
      <h1>get Temporal.Duration.prototype.seconds</h1>
      <p>
        `Temporal.Duration.prototype.seconds` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Seconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.milliseconds">
      <h1>get Temporal.Duration.prototype.milliseconds</h1>
      <p>
        `Temporal.Duration.prototype.milliseconds` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Milliseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.microseconds">
      <h1>get Temporal.Duration.prototype.microseconds</h1>
      <p>
        `Temporal.Duration.prototype.microseconds` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Microseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.nanoseconds">
      <h1>get Temporal.Duration.prototype.nanoseconds</h1>
      <p>
        `Temporal.Duration.prototype.nanoseconds` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(_duration_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.sign">
      <h1>get Temporal.Duration.prototype.sign</h1>
      <p>
        `Temporal.Duration.prototype.sign` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return 𝔽(! DurationSign(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]])).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-get-temporal.duration.prototype.blank">
      <h1>get Temporal.Duration.prototype.blank</h1>
      <p>
        `Temporal.Duration.prototype.blank` is an accessor property whose set accessor function is *undefined*.
        Its get accessor function performs the following steps:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Let _sign_ be ! DurationSign(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]]).
        1. If _sign_ = 0, return *true*.
        1. Return *false*.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.with">
      <h1>Temporal.Duration.prototype.with ( _temporalDurationLike_ )</h1>
      <p>
        The `Temporal.Duration.prototype.with` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Let _temporalDurationLike_ be ? ToTemporalPartialDurationRecord(_temporalDurationLike_).
        1. If _temporalDurationLike_.[[Years]] is not *undefined*, then
          1. Let _years_ be _temporalDurationLike_.[[Years]].
        1. Else,
          1. Let _years_ be _duration_.[[Years]].
        1. If _temporalDurationLike_.[[Months]] is not *undefined*, then
          1. Let _months_ be _temporalDurationLike_.[[Months]].
        1. Else,
          1. Let _months_ be _duration_.[[Months]].
        1. If _temporalDurationLike_.[[Weeks]] is not *undefined*, then
          1. Let _weeks_ be _temporalDurationLike_.[[Weeks]].
        1. Else,
          1. Let _weeks_ be _duration_.[[Weeks]].
        1. If _temporalDurationLike_.[[Days]] is not *undefined*, then
          1. Let _days_ be _temporalDurationLike_.[[Days]].
        1. Else,
          1. Let _days_ be _duration_.[[Days]].
        1. If _temporalDurationLike_.[[Hours]] is not *undefined*, then
          1. Let _hours_ be _temporalDurationLike_.[[Hours]].
        1. Else,
          1. Let _hours_ be _duration_.[[Hours]].
        1. If _temporalDurationLike_.[[Minutes]] is not *undefined*, then
          1. Let _minutes_ be _temporalDurationLike_.[[Minutes]].
        1. Else,
          1. Let _minutes_ be _duration_.[[Minutes]].
        1. If _temporalDurationLike_.[[Seconds]] is not *undefined*, then
          1. Let _seconds_ be _temporalDurationLike_.[[Seconds]].
        1. Else,
          1. Let _seconds_ be _duration_.[[Seconds]].
        1. If _temporalDurationLike_.[[Milliseconds]] is not *undefined*, then
          1. Let _milliseconds_ be _temporalDurationLike_.[[Milliseconds]].
        1. Else,
          1. Let _milliseconds_ be _duration_.[[Milliseconds]].
        1. If _temporalDurationLike_.[[Microseconds]] is not *undefined*, then
          1. Let _microseconds_ be _temporalDurationLike_.[[Microseconds]].
        1. Else,
          1. Let _microseconds_ be _duration_.[[Microseconds]].
        1. If _temporalDurationLike_.[[Nanoseconds]] is not *undefined*, then
          1. Let _nanoseconds_ be _temporalDurationLike_.[[Nanoseconds]].
        1. Else,
          1. Let _nanoseconds_ be _duration_.[[Nanoseconds]].
        1. Return ? CreateTemporalDuration(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.negated">
      <h1>Temporal.Duration.prototype.negated ( )</h1>
      <p>
        The `Temporal.Duration.prototype.negated` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ! CreateNegatedTemporalDuration(_duration_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.abs">
      <h1>Temporal.Duration.prototype.abs ( )</h1>
      <p>
        The `Temporal.Duration.prototype.abs` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ! CreateTemporalDuration(abs(_duration_.[[Years]]), abs(_duration_.[[Months]]), abs(_duration_.[[Weeks]]), abs(_duration_.[[Days]]), abs(_duration_.[[Hours]]), abs(_duration_.[[Minutes]]), abs(_duration_.[[Seconds]]), abs(_duration_.[[Milliseconds]]), abs(_duration_.[[Microseconds]]), abs(_duration_.[[Nanoseconds]])).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.add">
      <h1>Temporal.Duration.prototype.add ( _other_ [ , _options_ ] )</h1>
      <p>
        The `Temporal.Duration.prototype.add` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ? AddDurationToOrSubtractDurationFromDuration(~add~, _duration_, _other_, _options_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.subtract">
      <h1>Temporal.Duration.prototype.subtract ( _other_ [ , _options_ ] )</h1>
      <p>
        The `Temporal.Duration.prototype.subtract` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ? AddDurationToOrSubtractDurationFromDuration(~subtract~, _duration_, _other_, _options_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.round">
      <h1>Temporal.Duration.prototype.round ( _roundTo_ )</h1>
      <p>
        The `Temporal.Duration.prototype.round` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. If _roundTo_ is *undefined*, then
          1. Throw a *TypeError* exception.
        1. If Type(_roundTo_) is String, then
          1. Let _paramString_ be _roundTo_.
          1. Set _roundTo_ to OrdinaryObjectCreate(*null*).
          1. Perform ! CreateDataPropertyOrThrow(_roundTo_, *"smallestUnit"*, _paramString_).
        1. Else,
          1. Set _roundTo_ to ? GetOptionsObject(_roundTo_).
        1. Let _smallestUnitPresent_ be *true*.
        1. Let _largestUnitPresent_ be *true*.
        1. NOTE: The following steps read options and perform independent validation in alphabetical order (ToRelativeTemporalObject reads *"relativeTo"*, ToTemporalRoundingIncrement reads *"roundingIncrement"* and ToTemporalRoundingMode reads *"roundingMode"*).
        1. Let _largestUnit_ be ? GetTemporalUnit(_roundTo_, *"largestUnit"*, ~datetime~, *undefined*, « *"auto"* »).
        1. Let _relativeToRecord_ be ? ToRelativeTemporalObject(_roundTo_).
        1. Let _zonedRelativeTo_ be _relativeToRecord_.[[ZonedRelativeTo]].
        1. Let _plainRelativeTo_ be _relativeToRecord_.[[PlainRelativeTo]].
        1. Let _roundingIncrement_ be ? ToTemporalRoundingIncrement(_roundTo_).
        1. Let _roundingMode_ be ? ToTemporalRoundingMode(_roundTo_, *"halfExpand"*).
        1. Let _smallestUnit_ be ? GetTemporalUnit(_roundTo_, *"smallestUnit"*, ~datetime~, *undefined*).
        1. If _smallestUnit_ is *undefined*, then
          1. Set _smallestUnitPresent_ to *false*.
          1. Set _smallestUnit_ to *"nanosecond"*.
        1. Let _existingLargestUnit_ be ! DefaultTemporalLargestUnit(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]]).
        1. Let _defaultLargestUnit_ be ! LargerOfTwoTemporalUnits(_existingLargestUnit_, _smallestUnit_).
        1. If _largestUnit_ is *undefined*, then
          1. Set _largestUnitPresent_ to *false*.
          1. Set _largestUnit_ to _defaultLargestUnit_.
        1. Else if _largestUnit_ is *"auto"*, then
          1. Set _largestUnit_ to _defaultLargestUnit_.
        1. If _smallestUnitPresent_ is *false* and _largestUnitPresent_ is *false*, then
          1. Throw a *RangeError* exception.
        1. If LargerOfTwoTemporalUnits(_largestUnit_, _smallestUnit_) is not _largestUnit_, throw a *RangeError* exception.
        1. Let _maximum_ be ! MaximumTemporalDurationRoundingIncrement(_smallestUnit_).
        1. If _maximum_ is not *undefined*, perform ? ValidateTemporalRoundingIncrement(_roundingIncrement_, _maximum_, *false*).
        1. Let _hoursToDaysConversionMayOccur_ be *false*.
        1. If _duration_.[[Days]] &ne; 0 and _zonedRelativeTo_ is not *undefined*, set _hoursToDaysConversionMayOccur_ to *true*.
        1. Else if abs(_duration_.[[Hours]]) &ge; 24, set _hoursToDaysConversionMayOccur_ to *true*.
        1. If _smallestUnit_ is *"nanosecond"* and _roundingIncrement_ = 1, let _roundingGranularityIsNoop_ be *true*; else let _roundingGranularityIsNoop_ be *false*.
        1. If _duration_.[[Years]] = 0 and _duration_.[[Months]] = 0 and _duration_.[[Weeks]] = 0, let _calendarUnitsPresent_ be *false*; else let _calendarUnitsPresent_ be *true*.
        1. If _roundingGranularityIsNoop_ is *true*, and _largestUnit_ is _existingLargestUnit_, and _calendarUnitsPresent_ is *false*, and _hoursToDaysConversionMayOccur_ is *false*, and abs(_duration_.[[Minutes]]) &lt; 60, and abs(_duration_.[[Seconds]]) &lt; 60, and abs(_duration_.[[Milliseconds]]) &lt; 1000, and abs(_duration_.[[Microseconds]]) &lt; 1000, and abs(_duration_.[[Nanoseconds]]) &lt; 1000, then
          1. NOTE: The above conditions mean that the operation will have no effect: the smallest unit and rounding increment will leave the total duration unchanged, and it can be determined without calling a calendar or time zone method that no balancing will take place.
          1. Return ! CreateTemporalDuration(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]]).
        1. Let _precalculatedPlainDateTime_ be *undefined*.
        1. If _roundingGranularityIsNoop_ is *false*, or _largestUnit_ is *"year"*, or _largestUnit_ is *"month"*, or _largestUnit_ is *"week"*, or _largestUnit_ is *"day"*, or _calendarUnitsPresent_ is *true*, or _duration_.[[Days]] &ne; 0, let _plainDateTimeOrRelativeToWillBeUsed_ be *true*; else let _plainDateTimeOrRelativeToWillBeUsed_ be *false*.
        1. If _zonedRelativeTo_ is not *undefined* and _plainDateTimeOrRelativeToWillBeUsed_ is *true*, then
          1. NOTE: The above conditions mean that the corresponding `Temporal.PlainDateTime` or `Temporal.PlainDate` for _zonedRelativeTo_ will be used in one of the operations below.
          1. Let _instant_ be ! CreateTemporalInstant(_zonedRelativeTo_.[[Nanoseconds]]).
          1. Set _precalculatedPlainDateTime_ to ? GetPlainDateTimeFor(_zonedRelativeTo_.[[TimeZone]], _instant_, _zonedRelativeTo_.[[Calendar]]).
          1. Set _plainRelativeTo_ to ! CreateTemporalDate(_precalculatedPlainDateTime_.[[ISOYear]], _precalculatedPlainDateTime_.[[ISOMonth]], _precalculatedPlainDateTime_.[[ISODay]], _zonedRelativeTo_.[[Calendar]]).
        1. Let _unbalanceResult_ be ? UnbalanceDateDurationRelative(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _largestUnit_, _plainRelativeTo_).
        1. Let _roundRecord_ be ? RoundDuration(_unbalanceResult_.[[Years]], _unbalanceResult_.[[Months]], _unbalanceResult_.[[Weeks]], _unbalanceResult_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], _roundingIncrement_, _smallestUnit_, _roundingMode_, _plainRelativeTo_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
        1. Let _roundResult_ be _roundRecord_.[[DurationRecord]].
        1. If _zonedRelativeTo_ is not *undefined*, then
          1. Set _roundResult_ to ? AdjustRoundedDurationDays(_roundResult_.[[Years]], _roundResult_.[[Months]], _roundResult_.[[Weeks]], _roundResult_.[[Days]], _roundResult_.[[Hours]], _roundResult_.[[Minutes]], _roundResult_.[[Seconds]], _roundResult_.[[Milliseconds]], _roundResult_.[[Microseconds]], _roundResult_.[[Nanoseconds]], _roundingIncrement_, _smallestUnit_, _roundingMode_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
          1. Let _balanceResult_ be ? BalanceTimeDurationRelative(_roundResult_.[[Days]], _roundResult_.[[Hours]], _roundResult_.[[Minutes]], _roundResult_.[[Seconds]], _roundResult_.[[Milliseconds]], _roundResult_.[[Microseconds]], _roundResult_.[[Nanoseconds]], _largestUnit_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
        1. Else,
          1. Let _balanceResult_ be ? BalanceTimeDuration(_roundResult_.[[Days]], _roundResult_.[[Hours]], _roundResult_.[[Minutes]], _roundResult_.[[Seconds]], _roundResult_.[[Milliseconds]], _roundResult_.[[Microseconds]], _roundResult_.[[Nanoseconds]], _largestUnit_).
        1. Let _result_ be ? BalanceDateDurationRelative(_roundResult_.[[Years]], _roundResult_.[[Months]], _roundResult_.[[Weeks]], _balanceResult_.[[Days]], _largestUnit_, _plainRelativeTo_).
        1. Return ! CreateTemporalDuration(_result_.[[Years]], _result_.[[Months]], _result_.[[Weeks]], _result_.[[Days]], _balanceResult_.[[Hours]], _balanceResult_.[[Minutes]], _balanceResult_.[[Seconds]], _balanceResult_.[[Milliseconds]], _balanceResult_.[[Microseconds]], _balanceResult_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.total">
      <h1>Temporal.Duration.prototype.total ( _totalOf_ )</h1>
      <p>
        The `Temporal.Duration.prototype.total` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. If _totalOf_ is *undefined*, throw a *TypeError* exception.
        1. If Type(_totalOf_) is String, then
          1. Let _paramString_ be _totalOf_.
          1. Set _totalOf_ to OrdinaryObjectCreate(*null*).
          1. Perform ! CreateDataPropertyOrThrow(_totalOf_, *"unit"*, _paramString_).
        1. Else,
          1. Set _totalOf_ to ? GetOptionsObject(_totalOf_).
        1. NOTE: The following steps read options and perform independent validation in alphabetical order (ToRelativeTemporalObject reads *"relativeTo"*).
        1. Let _relativeToRecord_ be ? ToRelativeTemporalObject(_totalOf_).
        1. Let _zonedRelativeTo_ be _relativeToRecord_.[[ZonedRelativeTo]].
        1. Let _plainRelativeTo_ be _relativeToRecord_.[[PlainRelativeTo]].
        1. Let _unit_ be ? GetTemporalUnit(_totalOf_, *"unit"*, ~datetime~, ~required~).
        1. Let _precalculatedPlainDateTime_ be *undefined*.
        1. If _unit_ is *"year"*, or _unit_ is *"month"*, or _unit_ is *"week"*, or _unit_ is *"day"*, or _duration_.[[Years]] &ne; 0, or _duration_.[[Months]] &ne; 0, or _duration_.[[Weeks]] &ne; 0, or _duration_.[[Days]] &ne; 0, let _plainDateTimeOrRelativeToWillBeUsed_ be *true*; else let _plainDateTimeOrRelativeToWillBeUsed_ be *false*.
        1. If _zonedRelativeTo_ is not *undefined* and _plainDateTimeOrRelativeToWillBeUsed_ is *true*, then
          1. NOTE: The above conditions mean that the corresponding `Temporal.PlainDateTime` or `Temporal.PlainDate` for _zonedRelativeTo_ will be used in one of the operations below.
          1. Let _instant_ be ! CreateTemporalInstant(_zonedRelativeTo_.[[Nanoseconds]]).
          1. Set _precalculatedPlainDateTime_ to ? GetPlainDateTimeFor(_zonedRelativeTo_.[[TimeZone]], _instant_, _zonedRelativeTo_.[[Calendar]]).
          1. Set _plainRelativeTo_ to ! CreateTemporalDate(_precalculatedPlainDateTime_.[[ISOYear]], _precalculatedPlainDateTime_.[[ISOMonth]], _precalculatedPlainDateTime_.[[ISODay]], _zonedRelativeTo_.[[Calendar]]).
        1. Let _unbalanceResult_ be ? UnbalanceDateDurationRelative(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _unit_, _plainRelativeTo_).
        1. If _zonedRelativeTo_ is not *undefined*, then
          1. Let _intermediate_ be ? MoveRelativeZonedDateTime(_zonedRelativeTo_, _unbalanceResult_.[[Years]], _unbalanceResult_.[[Months]], _unbalanceResult_.[[Weeks]], 0, _precalculatedPlainDateTime_).
          1. Let _balanceResult_ be ? BalancePossiblyInfiniteTimeDurationRelative(_unbalanceResult_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], _unit_, _intermediate_).
        1. Else,
          1. Let _balanceResult_ be BalancePossiblyInfiniteTimeDuration(_unbalanceResult_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], _unit_).
        1. If _balanceResult_ is ~positive overflow~, return *+∞*<sub>𝔽</sub>.
        1. If _balanceResult_ is ~negative overflow~, return *-∞*<sub>𝔽</sub>.
        1. Assert: _balanceResult_ is a Time Duration Record.
        1. Let _roundRecord_ be ? RoundDuration(_unbalanceResult_.[[Years]], _unbalanceResult_.[[Months]], _unbalanceResult_.[[Weeks]], _balanceResult_.[[Days]], _balanceResult_.[[Hours]], _balanceResult_.[[Minutes]], _balanceResult_.[[Seconds]], _balanceResult_.[[Milliseconds]], _balanceResult_.[[Microseconds]], _balanceResult_.[[Nanoseconds]], 1, _unit_, *"trunc"*, _plainRelativeTo_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
        1. Return 𝔽(_roundRecord_.[[Total]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.tostring">
      <h1>Temporal.Duration.prototype.toString ( [ _options_ ] )</h1>
      <p>
        The `Temporal.Duration.prototype.toString` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Set _options_ to ? GetOptionsObject(_options_).
        1. NOTE: The following steps read options and perform independent validation in alphabetical order (ToFractionalSecondDigits reads *"fractionalSecondDigits"* and ToTemporalRoundingMode reads *"roundingMode"*).
        1. Let _digits_ be ? ToFractionalSecondDigits(_options_).
        1. Let _roundingMode_ be ? ToTemporalRoundingMode(_options_, *"trunc"*).
        1. Let _smallestUnit_ be ? GetTemporalUnit(_options_, *"smallestUnit"*, ~time~, *undefined*).
        1. If _smallestUnit_ is *"hour"* or *"minute"*, throw a *RangeError* exception.
        1. Let _precision_ be ToSecondsStringPrecisionRecord(_smallestUnit_, _digits_).
        1. Let _roundRecord_ be ? RoundDuration(0, 0, 0, 0, 0, 0, _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], _precision_.[[Increment]], _precision_.[[Unit]], _roundingMode_).
        1. Let _result_ be _roundRecord_.[[DurationRecord]].
        1. Return ! TemporalDurationToString(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]], _precision_.[[Precision]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.tojson">
      <h1>Temporal.Duration.prototype.toJSON ( )</h1>
      <p>
        The `Temporal.Duration.prototype.toJSON` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ! TemporalDurationToString(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], *"auto"*).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.tolocalestring">
      <h1>Temporal.Duration.prototype.toLocaleString ( [ _locales_ [ , _options_ ] ] )</h1>
      <p>
        An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the `Temporal.Duration.prototype.toLocaleString` method as specified in the ECMA-402 specification.
        If an ECMAScript implementation does not include the ECMA-402 API the following specification of the `Temporal.Duration.prototype.toLocaleString` method is used.
      </p>
      <p>
        The `Temporal.Duration.prototype.toLocaleString` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Let _duration_ be the *this* value.
        1. Perform ? RequireInternalSlot(_duration_, [[InitializedTemporalDuration]]).
        1. Return ! TemporalDurationToString(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], *"auto"*).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal.duration.prototype.valueof">
      <h1>Temporal.Duration.prototype.valueOf ( )</h1>
      <p>
        The `Temporal.Duration.prototype.valueOf` method performs the following steps when called:
      </p>
      <emu-alg>
        1. Throw a *TypeError* exception.
      </emu-alg>
    </emu-clause>
  </emu-clause>

  <emu-clause id="sec-properties-of-temporal-duration-instances">
    <h1>Properties of Temporal.Duration Instances</h1>
    <p>
      Temporal.Duration instances are ordinary objects that inherit properties from the %Temporal.Duration.prototype% intrinsic object.
      Temporal.Duration instances are initially created with the internal slots described in <emu-xref href="#table-internal-slots-of-temporalduration-instances"></emu-xref>.
    </p>
    <p>
      A <dfn variants="float64-representable integers">float64-representable integer</dfn> is an integer that is exactly representable as a Number value.
      That is, for a float64-representable integer _x_, it must hold that ℝ(𝔽(_x_)) = _x_.
    </p>
    <emu-note>
      The use of float64-representable integers here is intended so that implementations can store and do arithmetic on Duration fields using 64-bit floating-point values.
    </emu-note>
    <emu-table id="table-internal-slots-of-temporalduration-instances" caption="Internal Slots of Temporal.Duration Instances">
      <table>
        <tbody>
          <tr>
            <th>
              Internal Slot
            </th>
            <th>
              Description
            </th>
          </tr>
          <tr>
            <td>
              [[InitializedTemporalDuration]]
            </td>
            <td>
              The only specified use of this slot is for distinguishing Temporal.Duration instances from other objects.
            </td>
          </tr>
          <tr>
            <td>
              [[Years]]
            </td>
            <td>
              A float64-representable integer representing the number of years in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Months]]
            </td>
            <td>
              A float64-representable integer representing the number of months in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Weeks]]
            </td>
            <td>
              A float64-representable integer representing the number of weeks in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Days]]
            </td>
            <td>
              A float64-representable integer representing the number of days in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Hours]]
            </td>
            <td>
              A float64-representable integer representing the number of hours in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Minutes]]
            </td>
            <td>
              A float64-representable integer representing the number of minutes in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Seconds]]
            </td>
            <td>
              A float64-representable integer representing the number of seconds in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Milliseconds]]
            </td>
            <td>
              A float64-representable integer representing the number of milliseconds in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Microseconds]]
            </td>
            <td>
              A float64-representable integer representing the number of microseconds in the duration.
            </td>
          </tr>
          <tr>
            <td>
              [[Nanoseconds]]
            </td>
            <td>
              A float64-representable integer representing the number of nanoseconds in the duration.
            </td>
          </tr>
        </tbody>
      </table>
    </emu-table>
  </emu-clause>

  <emu-clause id="sec-temporal-duration-abstract-ops">
    <h1>Abstract Operations</h1>

    <emu-clause id="sec-temporal-duration-records">
      <h1>Duration Records</h1>
      <p>
        A <dfn variants="Duration Records">Duration Record</dfn> is a Record value used to represent a Temporal.Duration object.
        Duration Records are produced by the abstract operation CreateDurationRecord, among others.
      </p>
      <p>
        Duration Records have the fields listed in <emu-xref href="#table-temporal-duration-record-fields"></emu-xref>.
      </p>
      <emu-table id="table-temporal-duration-record-fields" caption="Duration Record Fields">
        <table class="real-table">
          <tr>
            <th>Field Name</th>
            <th>Property Name</th>
            <th>Value</th>
            <th>Meaning</th>
          </tr>
          <tr>
            <td>[[Years]]</td>
            <td>*"years"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of years in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Months]]</td>
            <td>*"months"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of months in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Weeks]]</td>
            <td>*"weeks"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of weeks in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Days]]</td>
            <td>*"days"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of days in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Hours]]</td>
            <td>*"hours"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of hours in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Minutes]]</td>
            <td>*"minutes"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of minutes in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Seconds]]</td>
            <td>*"seconds"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of seconds in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Milliseconds]]</td>
            <td>*"milliseconds"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of milliseconds in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Microseconds]]</td>
            <td>*"microseconds"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of microseconds in the duration.
            </td>
          </tr>
          <tr>
            <td>[[Nanoseconds]]</td>
            <td>*"nanoseconds"*</td>
            <td>a float64-representable integer</td>
            <td>
              The number of nanoseconds in the duration.
            </td>
          </tr>
        </table>
      </emu-table>
    </emu-clause>

    <emu-clause id="sec-temporal-date-duration-records">
      <h1>Date Duration Records</h1>
      <p>
        A <dfn variants="Date Duration Records">Date Duration Record</dfn> is a Record value used to represent the portion of a Temporal.Duration object that deals with calendar date units.
        Date Duration Records are produced by the abstract operation CreateDateDurationRecord, among others.
      </p>
      <p>
        Of the fields listed in <emu-xref href="#table-temporal-duration-record-fields"></emu-xref>, Date Duration Records have [[Years]], [[Months]], [[Weeks]], and [[Days]].
      </p>
    </emu-clause>

    <emu-clause id="sec-temporal-time-duration-records">
      <h1>Time Duration Records</h1>
      <p>
        A <dfn variants="Time Duration Records">Time Duration Record</dfn> is a Record value used to represent the portion of a Temporal.Duration object that deals with exact time units.
        Time Duration Records are produced by the abstract operation CreateTimeDurationRecord, among others.
      </p>
      <p>
        Of the fields listed in <emu-xref href="#table-temporal-duration-record-fields"></emu-xref>, Time Duration Records have [[Days]], [[Hours]], [[Minutes]], [[Seconds]], [[Milliseconds]], [[Microseconds]], and [[Nanoseconds]].
      </p>
    </emu-clause>

    <emu-clause id="sec-temporal-partial-duration-records">
      <h1>Partial Duration Records</h1>
      <p>
        A <dfn variants="partial Duration Records">partial Duration Record</dfn> is a Record value used to represent a portion of a Temporal.Duration object, in which it is not required that all the fields be specified.
      </p>
      <p>
        Partial Duration Records have the same fields listed in <emu-xref href="#table-temporal-duration-record-fields"></emu-xref>.
        Unlike Duration Records, each field of a partial Duration Record may also have the value *undefined* as long as there is at least one field that is not *undefined*.
      </p>
    </emu-clause>

    <emu-clause id="sec-temporal-createdurationrecord" type="abstract operation">
      <h1>
        CreateDurationRecord (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
        ): either a normal completion containing a Duration Record, or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd></dd>
      </dl>
      <emu-alg>
        1. If ! IsValidDuration(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_) is *false*, throw a *RangeError* exception.
        1. Return the Record {
            [[Years]]: ℝ(𝔽(_years_)),
            [[Months]]: ℝ(𝔽(_months_)),
            [[Weeks]]: ℝ(𝔽(_weeks_)),
            [[Days]]: ℝ(𝔽(_days_)),
            [[Hours]]: ℝ(𝔽(_hours_)),
            [[Minutes]]: ℝ(𝔽(_minutes_)),
            [[Seconds]]: ℝ(𝔽(_seconds_)),
            [[Milliseconds]]: ℝ(𝔽(_milliseconds_)),
            [[Microseconds]]: ℝ(𝔽(_microseconds_)),
            [[Nanoseconds]]: ℝ(𝔽(_nanoseconds_))
          }.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-createdatedurationrecord" type="abstract operation">
      <h1>
        CreateDateDurationRecord (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns a Date Duration Record.</dd>
      </dl>
      <emu-alg>
        1. If ! IsValidDuration(_years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0) is *false*, throw a *RangeError* exception.
        1. Return the Record {
            [[Years]]: ℝ(𝔽(_years_)),
            [[Months]]: ℝ(𝔽(_months_)),
            [[Weeks]]: ℝ(𝔽(_weeks_)),
            [[Days]]: ℝ(𝔽(_days_))
          }.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-createtimedurationrecord" type="abstract operation">
      <h1>
        CreateTimeDurationRecord (
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns a Time Duration Record.</dd>
      </dl>
      <emu-alg>
        1. Assert: ! IsValidDuration(0, 0, 0, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_) is *true*.
        1. Return the Record {
            [[Days]]: ℝ(𝔽(_days_)),
            [[Hours]]: ℝ(𝔽(_hours_)),
            [[Minutes]]: ℝ(𝔽(_minutes_)),
            [[Seconds]]: ℝ(𝔽(_seconds_)),
            [[Milliseconds]]: ℝ(𝔽(_milliseconds_)),
            [[Microseconds]]: ℝ(𝔽(_microseconds_)),
            [[Nanoseconds]]: ℝ(𝔽(_nanoseconds_))
          }.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-totemporalduration" type="abstract operation">
      <h1>
        ToTemporalDuration (
          _item_: an ECMAScript language value,
        ): either a normal completion containing a Temporal.Duration, or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns its argument _item_ if it is already a Temporal.Duration instance, converts _item_ to a new Temporal.Duration instance if possible and returns that, and throws otherwise.</dd>
      </dl>
      <emu-alg>
        1. If Type(_item_) is Object and _item_ has an [[InitializedTemporalDuration]] internal slot, then
          1. Return _item_.
        1. Let _result_ be ? ToTemporalDurationRecord(_item_).
        1. Return ! CreateTemporalDuration(_result_.[[Years]], _result_.[[Months]], _result_.[[Weeks]], _result_.[[Days]], _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-totemporaldurationrecord" type="abstract operation">
      <h1>
        ToTemporalDurationRecord (
          _temporalDurationLike_: an ECMAScript language value,
        ): either a normal completion containing a Duration Record, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>The returned Record has its fields set according to the properties of _temporalDurationLike_, with absent or undefined properties corresponding to fields containing 0.</dd>
      </dl>
      <emu-alg>
        1. If Type(_temporalDurationLike_) is not Object, then
          1. If _temporalDurationLike_ is not a String, throw a *TypeError* exception.
          1. Return ? ParseTemporalDurationString(_temporalDurationLike_).
        1. If _temporalDurationLike_ has an [[InitializedTemporalDuration]] internal slot, then
          1. Return ! CreateDurationRecord(_temporalDurationLike_.[[Years]], _temporalDurationLike_.[[Months]], _temporalDurationLike_.[[Weeks]], _temporalDurationLike_.[[Days]], _temporalDurationLike_.[[Hours]], _temporalDurationLike_.[[Minutes]], _temporalDurationLike_.[[Seconds]], _temporalDurationLike_.[[Milliseconds]], _temporalDurationLike_.[[Microseconds]], _temporalDurationLike_.[[Nanoseconds]]).
        1. Let _result_ be a new Duration Record with each field set to 0.
        1. Let _partial_ be ? ToTemporalPartialDurationRecord(_temporalDurationLike_).
        1. If _partial_.[[Years]] is not *undefined*, set _result_.[[Years]] to _partial_.[[Years]].
        1. If _partial_.[[Months]] is not *undefined*, set _result_.[[Months]] to _partial_.[[Months]].
        1. If _partial_.[[Weeks]] is not *undefined*, set _result_.[[Weeks]] to _partial_.[[Weeks]].
        1. If _partial_.[[Days]] is not *undefined*, set _result_.[[Days]] to _partial_.[[Days]].
        1. If _partial_.[[Hours]] is not *undefined*, set _result_.[[Hours]] to _partial_.[[Hours]].
        1. If _partial_.[[Minutes]] is not *undefined*, set _result_.[[Minutes]] to _partial_.[[Minutes]].
        1. If _partial_.[[Seconds]] is not *undefined*, set _result_.[[Seconds]] to _partial_.[[Seconds]].
        1. If _partial_.[[Milliseconds]] is not *undefined*, set _result_.[[Milliseconds]] to _partial_.[[Milliseconds]].
        1. If _partial_.[[Microseconds]] is not *undefined*, set _result_.[[Microseconds]] to _partial_.[[Microseconds]].
        1. If _partial_.[[Nanoseconds]] is not *undefined*, set _result_.[[Nanoseconds]] to _partial_.[[Nanoseconds]].
        1. If ! IsValidDuration(_result_.[[Years]], _result_.[[Months]], _result_.[[Weeks]], _result_.[[Days]], _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]) is *false*, then
          1. Throw a *RangeError* exception.
        1. Return _result_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-durationsign" type="abstract operation">
      <h1>
        DurationSign (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns 1 if the most significant non-zero element in its arguments is positive, and -1 if the most significant non-zero element is negative. If all of its arguments are zero, it returns 0.</dd>
      </dl>
      <emu-alg>
        1. For each value _v_ of « _years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_ », do
          1. If _v_ &lt; 0, return -1.
          1. If _v_ &gt; 0, return 1.
        1. Return 0.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-isvalidduration" type="abstract operation">
      <h1>
        IsValidDuration (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns *true* if its arguments form valid input from which to construct a `Temporal.Duration`, and *false* otherwise.</dd>
      </dl>
      <emu-alg>
        1. Let _sign_ be ! DurationSign(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. For each value _v_ of « _years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_ », do
          1. If 𝔽(_v_) is not finite, return *false*.
          1. If _v_ &lt; 0 and _sign_ &gt; 0, return *false*.
          1. If _v_ &gt; 0 and _sign_ &lt; 0, return *false*.
        1. Return *true*.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-defaulttemporallargestunit" type="abstract operation">
      <h1>
        DefaultTemporalLargestUnit (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It implements the logic used in the `Temporal.Duration.prototype.round()` method and elsewhere, where the `largestUnit` option, if not given explicitly, is set to the largest non-zero unit in the input Temporal.Duration.</dd>
      </dl>
      <emu-alg>
        1. If _years_ &ne; 0, return *"year"*.
        1. If _months_ &ne; 0, return *"month"*.
        1. If _weeks_ &ne; 0, return *"week"*.
        1. If _days_ &ne; 0, return *"day"*.
        1. If _hours_ &ne; 0, return *"hour"*.
        1. If _minutes_ &ne; 0, return *"minute"*.
        1. If _seconds_ &ne; 0, return *"second"*.
        1. If _milliseconds_ &ne; 0, return *"millisecond"*.
        1. If _microseconds_ &ne; 0, return *"microsecond"*.
        1. Return *"nanosecond"*.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-totemporalpartialdurationrecord" type="abstract operation">
      <h1>
        ToTemporalPartialDurationRecord (
          _temporalDurationLike_: an ECMAScript language value,
        ): either a normal completion containing a partial Duration Record, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>The returned Record has its fields set according to the properties of _temporalDurationLike_.</dd>
      </dl>
      <emu-alg>
        1. If Type(_temporalDurationLike_) is not Object, then
          1. Throw a *TypeError* exception.
        1. Let _result_ be a new partial Duration Record with each field set to *undefined*.
        1. NOTE: The following steps read properties and perform independent validation in alphabetical order.
        1. Let _days_ be ? Get(_temporalDurationLike_, *"days"*).
        1. If _days_ is not *undefined*, set _result_.[[Days]] to ? ToIntegerIfIntegral(_days_).
        1. Let _hours_ be ? Get(_temporalDurationLike_, *"hours"*).
        1. If _hours_ is not *undefined*, set _result_.[[Hours]] to ? ToIntegerIfIntegral(_hours_).
        1. Let _microseconds_ be ? Get(_temporalDurationLike_, *"microseconds"*).
        1. If _microseconds_ is not *undefined*, set _result_.[[Microseconds]] to ? ToIntegerIfIntegral(_microseconds_).
        1. Let _milliseconds_ be ? Get(_temporalDurationLike_, *"milliseconds"*).
        1. If _milliseconds_ is not *undefined*, set _result_.[[Milliseconds]] to ? ToIntegerIfIntegral(_milliseconds_).
        1. Let _minutes_ be ? Get(_temporalDurationLike_, *"minutes"*).
        1. If _minutes_ is not *undefined*, set _result_.[[Minutes]] to ? ToIntegerIfIntegral(_minutes_).
        1. Let _months_ be ? Get(_temporalDurationLike_, *"months"*).
        1. If _months_ is not *undefined*, set _result_.[[Months]] to ? ToIntegerIfIntegral(_months_).
        1. Let _nanoseconds_ be ? Get(_temporalDurationLike_, *"nanoseconds"*).
        1. If _nanoseconds_ is not *undefined*, set _result_.[[Nanoseconds]] to ? ToIntegerIfIntegral(_nanoseconds_).
        1. Let _seconds_ be ? Get(_temporalDurationLike_, *"seconds"*).
        1. If _seconds_ is not *undefined*, set _result_.[[Seconds]] to ? ToIntegerIfIntegral(_seconds_).
        1. Let _weeks_ be ? Get(_temporalDurationLike_, *"weeks"*).
        1. If _weeks_ is not *undefined*, set _result_.[[Weeks]] to ? ToIntegerIfIntegral(_weeks_).
        1. Let _years_ be ? Get(_temporalDurationLike_, *"years"*).
        1. If _years_ is not *undefined*, set _result_.[[Years]] to ? ToIntegerIfIntegral(_years_).
        1. If _years_ is *undefined*, and _months_ is *undefined*, and _weeks_ is *undefined*, and _days_ is *undefined*, and _hours_ is *undefined*, and _minutes_ is *undefined*, and _seconds_ is *undefined*, and _milliseconds_ is *undefined*, and _microseconds_ is *undefined*, and _nanoseconds_ is *undefined*, throw a *TypeError* exception.
        1. Return _result_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-createtemporalduration" type="abstract operation">
      <h1>
        CreateTemporalDuration (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          optional _newTarget_: a constructor,
        ): either a normal completion containing a Temporal.Duration, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It creates a Temporal.Duration instance and fills the internal slots with valid values.</dd>
      </dl>
      <emu-alg>
        1. If ! IsValidDuration(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_) is *false*, throw a *RangeError* exception.
        1. If _newTarget_ is not present, set _newTarget_ to %Temporal.Duration%.
        1. Let _object_ be ? OrdinaryCreateFromConstructor(_newTarget_, *"%Temporal.Duration.prototype%"*, « [[InitializedTemporalDuration]], [[Years]], [[Months]], [[Weeks]], [[Days]], [[Hours]], [[Minutes]], [[Seconds]], [[Milliseconds]], [[Microseconds]], [[Nanoseconds]] »).
        1. Set _object_.[[Years]] to ℝ(𝔽(_years_)).
        1. Set _object_.[[Months]] to ℝ(𝔽(_months_)).
        1. Set _object_.[[Weeks]] to ℝ(𝔽(_weeks_)).
        1. Set _object_.[[Days]] to ℝ(𝔽(_days_)).
        1. Set _object_.[[Hours]] to ℝ(𝔽(_hours_)).
        1. Set _object_.[[Minutes]] to ℝ(𝔽(_minutes_)).
        1. Set _object_.[[Seconds]] to ℝ(𝔽(_seconds_)).
        1. Set _object_.[[Milliseconds]] to ℝ(𝔽(_milliseconds_)).
        1. Set _object_.[[Microseconds]] to ℝ(𝔽(_microseconds_)).
        1. Set _object_.[[Nanoseconds]] to ℝ(𝔽(_nanoseconds_)).
        1. Return _object_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-createnegatedtemporalduration" type="abstract operation">
      <h1>
        CreateNegatedTemporalDuration (
          _duration_: a Temporal.Duration,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns a new Temporal.Duration instance that is the negation of _duration_.</dd>
      </dl>
      <emu-alg>
        1. Return ! CreateTemporalDuration(-_duration_.[[Years]], -_duration_.[[Months]], -_duration_.[[Weeks]], -_duration_.[[Days]], -_duration_.[[Hours]], -_duration_.[[Minutes]], -_duration_.[[Seconds]], -_duration_.[[Milliseconds]], -_duration_.[[Microseconds]], -_duration_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-totaldurationnanoseconds" type="abstract operation">
      <h1>
        TotalDurationNanoseconds (
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
        ): an integer
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>
          It computes an integer number of nanoseconds from the given units.
        </dd>
      </dl>
      <emu-alg>
        1. Set _minutes_ to _minutes_ + _hours_ &times; 60.
        1. Set _seconds_ to _seconds_ + _minutes_ &times; 60.
        1. Set _milliseconds_ to _milliseconds_ + _seconds_ &times; 1000.
        1. Set _microseconds_ to _microseconds_ + _milliseconds_ &times; 1000.
        1. Return _nanoseconds_ + _microseconds_ &times; 1000.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-balancetimeduration" type="abstract operation">
      <h1>
        BalanceTimeDuration (
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _largestUnit_: a String,
        ): either a normal completion containing a Time Duration Record, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the time units of a duration into a form where lower units are converted into higher units as much as possible, up to _largestUnit_. If the Number value for any unit is infinite, it returns abruptly with a *RangeError*.</dd>
      </dl>
      <emu-alg>
        1. Let _balanceResult_ be BalancePossiblyInfiniteTimeDuration(_days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_, _largestUnit_).
        1. If _balanceResult_ is ~positive overflow~ or ~negative overflow~, then
          1. Throw a *RangeError* exception.
        1. Else,
          1. Return _balanceResult_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-balancepossiblyinfinitetimeduration" type="abstract operation">
      <h1>
        BalancePossiblyInfiniteTimeDuration (
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _largestUnit_: a String,
          ): a Time Duration Record if there are no infinite values, or either ~positive overflow~ or ~negative overflow~ in case of infinite values
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the time units of a duration into a form where lower units are converted into higher units as much as possible, up to _largestUnit_. If the Number value for any unit is infinite, it returns a special value indicating the direction of overflow.</dd>
      </dl>
      <emu-alg>
        1. Set _hours_ to _hours_ + _days_ &times; 24.
        1. Set _nanoseconds_ to TotalDurationNanoseconds(_hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Set _days_, _hours_, _minutes_, _seconds_, _milliseconds_, and _microseconds_ to 0.
        1. If _nanoseconds_ &lt; 0, let _sign_ be -1; else, let _sign_ be 1.
        1. Set _nanoseconds_ to abs(_nanoseconds_).
        1. If _largestUnit_ is *"year"*, *"month"*, *"week"*, or *"day"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
          1. Set _milliseconds_ to floor(_microseconds_ / 1000).
          1. Set _microseconds_ to _microseconds_ modulo 1000.
          1. Set _seconds_ to floor(_milliseconds_ / 1000).
          1. Set _milliseconds_ to _milliseconds_ modulo 1000.
          1. Set _minutes_ to floor(_seconds_ / 60).
          1. Set _seconds_ to _seconds_ modulo 60.
          1. Set _hours_ to floor(_minutes_ / 60).
          1. Set _minutes_ to _minutes_ modulo 60.
          1. Set _days_ to floor(_hours_ / 24).
          1. Set _hours_ to _hours_ modulo 24.
        1. Else if _largestUnit_ is *"hour"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
          1. Set _milliseconds_ to floor(_microseconds_ / 1000).
          1. Set _microseconds_ to _microseconds_ modulo 1000.
          1. Set _seconds_ to floor(_milliseconds_ / 1000).
          1. Set _milliseconds_ to _milliseconds_ modulo 1000.
          1. Set _minutes_ to floor(_seconds_ / 60).
          1. Set _seconds_ to _seconds_ modulo 60.
          1. Set _hours_ to floor(_minutes_ / 60).
          1. Set _minutes_ to _minutes_ modulo 60.
        1. Else if _largestUnit_ is *"minute"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
          1. Set _milliseconds_ to floor(_microseconds_ / 1000).
          1. Set _microseconds_ to _microseconds_ modulo 1000.
          1. Set _seconds_ to floor(_milliseconds_ / 1000).
          1. Set _milliseconds_ to _milliseconds_ modulo 1000.
          1. Set _minutes_ to floor(_seconds_ / 60).
          1. Set _seconds_ to _seconds_ modulo 60.
        1. Else if _largestUnit_ is *"second"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
          1. Set _milliseconds_ to floor(_microseconds_ / 1000).
          1. Set _microseconds_ to _microseconds_ modulo 1000.
          1. Set _seconds_ to floor(_milliseconds_ / 1000).
          1. Set _milliseconds_ to _milliseconds_ modulo 1000.
        1. Else if _largestUnit_ is *"millisecond"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
          1. Set _milliseconds_ to floor(_microseconds_ / 1000).
          1. Set _microseconds_ to _microseconds_ modulo 1000.
        1. Else if _largestUnit_ is *"microsecond"*, then
          1. Set _microseconds_ to floor(_nanoseconds_ / 1000).
          1. Set _nanoseconds_ to _nanoseconds_ modulo 1000.
        1. Else,
          1. Assert: _largestUnit_ is *"nanosecond"*.
        1. For each value _v_ of « _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_ », do
          1. If 𝔽(_v_) is not finite, then
            1. If _sign_ = 1, then
              1. Return ~positive overflow~.
            1. Else if _sign_ = -1, then
              1. Return ~negative overflow~.
        1. Return ! CreateTimeDurationRecord(_days_ &times; _sign_, _hours_ &times; _sign_, _minutes_ &times; _sign_, _seconds_ &times; _sign_, _milliseconds_ &times; _sign_, _microseconds_ &times; _sign_, _nanoseconds_ &times; _sign_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-balancetimedurationrelative" type="abstract operation">
      <h1>
        BalanceTimeDurationRelative (
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _largestUnit_: a String,
          _zonedRelativeTo_: a Temporal.ZonedDateTime,
          _precalculatedPlainDateTime_: a Temporal.PlainDateTime or *undefined*,
        ): either a normal completion containing a Time Duration Record, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the time units of a duration into a form where lower units are converted into higher units as much as possible, up to _largestUnit_, taking day length of _zonedRelativeTo_ into account. If the Number value for any unit is infinite, it returns abruptly with a *RangeError*.</dd>
      </dl>
      <emu-alg>
        1. Let _balanceResult_ be ? BalancePossiblyInfiniteTimeDurationRelative(_days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_, _largestUnit_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
        1. If _balanceResult_ is ~positive overflow~ or ~negative overflow~, then
          1. Throw a *RangeError* exception.
        1. Return _balanceResult_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-balancepossiblyinfinitetimedurationrelative" type="abstract operation">
      <h1>
        BalancePossiblyInfiniteTimeDurationRelative (
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _largestUnit_: a String,
          _zonedRelativeTo_: a Temporal.ZonedDateTime,
          optional _precalculatedPlainDateTime_: a Temporal.PlainDateTime or *undefined*,
        ): either a normal completion containing either Time Duration Record if there are no infinite values, ~positive overflow~, or ~negative overflow~ in case of infinite values, or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the time units of a duration into a form where lower units are converted into higher units as much as possible, up to _largestUnit_, taking day length of _zonedRelativeTo_ into account. If the Number value for any unit is infinite, it returns a special value indicating the direction of overflow.</dd>
      </dl>
      <p>
        This operation observably calls time zone and calendar methods.
      </p>
      <emu-alg>
        1. If _precalculatedPlainDateTime_ is not present, let _precalculatedPlainDateTime_ be *undefined*.
        1. Let _intermediateNs_ be _zonedRelativeTo_.[[Nanoseconds]].
        1. Let _startInstant_ be ! CreateTemporalInstant(_zonedRelativeTo_.[[Nanoseconds]]).
        1. If _days_ &ne; 0, then
          1. If _precalculatedPlainDateTime_ is *undefined*, set _precalculatedPlainDateTime_ to ? GetPlainDateTimeFor(_zonedRelativeTo_.[[TimeZone]], _startInstant_, *"iso8601"*).
          1. Let _intermediateResult_ be ? AddDaysToZonedDateTime(_startInstant_, _precalculatedPlainDateTime_, _zonedRelativeTo_.[[TimeZone]], *"iso8601"*, _days_).
          1. Set _intermediateNs_ to _intermediateResult_.[[EpochNanoseconds]].
        1. Let _endNs_ be AddInstant(_intermediateNs_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Set _nanoseconds_ to ℝ(_endNs_ - _zonedRelativeTo_.[[Nanoseconds]]).
        1. If _nanoseconds_ = 0, return ! CreateTimeDurationRecord(0, 0, 0, 0, 0, 0, 0).
        1. If _largestUnit_ is one of *"year"*, *"month"*, *"week"*, or *"day"*, then
          1. If _precalculatedPlainDateTime_ is *undefined*, set _precalculatedPlainDateTime_ to ? GetPlainDateTimeFor(_zonedRelativeTo_.[[TimeZone]], _startInstant_, *"iso8601"*).
          1. Let _result_ be ? NanosecondsToDays(_nanoseconds_, _zonedRelativeTo_, _precalculatedPlainDateTime_).
          1. Set _days_ to _result_.[[Days]].
          1. Set _largestUnit_ to *"hour"*.
        1. Else,
          1. Set _days_ to 0.
        1. If 𝔽(_days_) is not finite, then
          1. If _days_ &gt; 0, return ~positive overflow~.
          1. Else, return ~negative overflow~.
        1. Let _balanceResult_ be BalancePossiblyInfiniteTimeDuration(0, 0, 0, 0, 0, 0, _result_.[[Nanoseconds]], _largestUnit_).
        1. If _balanceResult_ is ~positive overflow~ or ~negative overflow~, return _balanceResult_.
        1. Return ! CreateTimeDurationRecord(_days_, _balanceResult_.[[Hours]], _balanceResult_.[[Minutes]], _balanceResult_.[[Seconds]], _balanceResult_.[[Milliseconds]], _balanceResult_.[[Microseconds]], _balanceResult_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-unbalancedatedurationrelative" type="abstract operation">
      <h1>
        UnbalanceDateDurationRelative (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _largestUnit_: a String,
          _plainRelativeTo_: *undefined* or a Temporal.PlainDate,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the calendar units of a duration into a form where no unit is larger than _largestUnit_, and returns the result as a Date Duration Record.</dd>
      </dl>
      <emu-alg>
        1. Let _allZero_ be *false*.
        1. If _years_ = 0, and _months_ = 0, and _weeks_ = 0, and _days_ = 0, set _allZero_ to *true*.
        1. If _largestUnit_ is *"year"* or _allZero_ is *true*, then
          1. Return ! CreateDateDurationRecord(_years_, _months_, _weeks_, _days_).
        1. Let _sign_ be ! DurationSign(_years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0).
        1. Assert: _sign_ &ne; 0.
        1. Let _oneYear_ be ! CreateTemporalDuration(_sign_, 0, 0, 0, 0, 0, 0, 0, 0, 0).
        1. Let _oneMonth_ be ! CreateTemporalDuration(0, _sign_, 0, 0, 0, 0, 0, 0, 0, 0).
        1. Let _oneWeek_ be ! CreateTemporalDuration(0, 0, _sign_, 0, 0, 0, 0, 0, 0, 0).
        1. If _plainRelativeTo_ is not *undefined*, then
          1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
        1. Else,
          1. Let _calendar_ be *undefined*.
        1. If _largestUnit_ is *"month"*, then
          1. If _years_ = 0, return ! CreateDateDurationRecord(0, _months_, _weeks_, _days_).
          1. If _calendar_ is *undefined*, then
            1. Throw a *RangeError* exception.
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
            1. Let _dateUntil_ be ? GetMethod(_calendar_, *"dateUntil"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
            1. Let _dateUntil_ be ~unused~.
          1. Repeat, while _years_ &ne; 0,
            1. Let _newRelativeTo_ be ? CalendarDateAdd(_calendar_, _plainRelativeTo_, _oneYear_, *undefined*, _dateAdd_).
            1. Let _untilOptions_ be OrdinaryObjectCreate(*null*).
            1. Perform ! CreateDataPropertyOrThrow(_untilOptions_, *"largestUnit"*, *"month"*).
            1. Let _untilResult_ be ? CalendarDateUntil(_calendar_, _plainRelativeTo_, _newRelativeTo_, _untilOptions_, _dateUntil_).
            1. Let _oneYearMonths_ be _untilResult_.[[Months]].
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _years_ to _years_ - _sign_.
            1. Set _months_ to _months_ + _oneYearMonths_.
          1. Return ? CreateDateDurationRecord(0, _months_, _weeks_, _days_).
        1. If _largestUnit_ is *"week"*, then
          1. If _years_ = 0 and _months_ = 0, return ! CreateDateDurationRecord(0, 0, _weeks_, _days_).
          1. If _calendar_ is *undefined*, then
            1. Throw a *RangeError* exception.
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Repeat, while _years_ &ne; 0,
            1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneYear_, _dateAdd_).
            1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _days_ to _days_ + _moveResult_.[[Days]].
            1. Set _years_ to _years_ - _sign_.
          1. Repeat, while _months_ &ne; 0,
            1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
            1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _days_ to _days_ + _moveResult_.[[Days]].
            1. Set _months_ to _months_ - _sign_.
          1. Return ? CreateDateDurationRecord(0, 0, _weeks_, _days_).
        1. If _years_ = 0, and _months_ = 0, and _weeks_ = 0, return ! CreateDateDurationRecord(0, 0, 0, _days_).
        1. If _calendar_ is *undefined*, then
          1. Throw a *RangeError* exception.
        1. If _calendar_ is an Object, then
          1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
        1. Else,
          1. Let _dateAdd_ be ~unused~.
        1. Repeat, while _years_ &ne; 0,
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneYear_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Set _days_ to _days_ + _moveResult_.[[Days]].
          1. Set _years_ to _years_ - _sign_.
        1. Repeat, while _months_ &ne; 0,
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Set _days_ to _days_ +_moveResult_.[[Days]].
          1. Set _months_ to _months_ - _sign_.
        1. Repeat, while _weeks_ &ne; 0,
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneWeek_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Set _days_ to _days_ + _moveResult_.[[Days]].
          1. Set _weeks_ to _weeks_ - _sign_.
        1. Return ? CreateDateDurationRecord(0, 0, 0, _days_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-balancedatedurationrelative" type="abstract operation">
      <h1>
        BalanceDateDurationRelative (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _largestUnit_: a String,
          _plainRelativeTo_: *undefined* or a Temporal.PlainDate,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It converts the calendar units of a duration into a form where lower units are converted into higher units as much as possible, up to _largestUnit_, and returns the result as a Date Duration Record.</dd>
      </dl>
      <emu-alg>
        1. Let _allZero_ be *false*.
        1. If _years_ = 0, and _months_ = 0, and _weeks_ = 0, and _days_ = 0, set _allZero_ to *true*.
        1. If _largestUnit_ is not one of *"year"*, *"month"*, or *"week"*, or _allZero_ is *true*, then
          1. Return ! CreateDateDurationRecord(_years_, _months_, _weeks_, _days_).
        1. If _plainRelativeTo_ is *undefined*, then
          1. Throw a *RangeError* exception.
        1. Let _sign_ be ! DurationSign(_years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0).
        1. Assert: _sign_ &ne; 0.
        1. Let _oneYear_ be ! CreateTemporalDuration(_sign_, 0, 0, 0, 0, 0, 0, 0, 0, 0).
        1. Let _oneMonth_ be ! CreateTemporalDuration(0, _sign_, 0, 0, 0, 0, 0, 0, 0, 0).
        1. Let _oneWeek_ be ! CreateTemporalDuration(0, 0, _sign_, 0, 0, 0, 0, 0, 0, 0).
        1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
        1. If _largestUnit_ is *"year"*, then
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneYear_, _dateAdd_).
          1. Let _newRelativeTo_ be _moveResult_.[[RelativeTo]].
          1. Let _oneYearDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_days_) &ge; abs(_oneYearDays_),
            1. Set _days_ to _days_ - _oneYearDays_.
            1. Set _years_ to _years_ + _sign_.
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneYear_, _dateAdd_).
            1. Set _newRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneYearDays_ to _moveResult_.[[Days]].
          1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
          1. Set _newRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Let _oneMonthDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_days_) &ge; abs(_oneMonthDays_),
            1. Set _days_ to _days_ - _oneMonthDays_.
            1. Set _months_ to _months_ + _sign_.
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
            1. Set _newRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneMonthDays_ to _moveResult_.[[Days]].
          1. Set _newRelativeTo_ to ? CalendarDateAdd(_calendar_, _plainRelativeTo_, _oneYear_, *undefined*, _dateAdd_).
          1. If _calendar_ is an Object, then
            1. Let _dateUntil_ be ? GetMethod(_calendar_, *"dateUntil"*).
          1. Else,
            1. Let _dateUntil_ be ~unused~.
          1. Let _untilOptions_ be OrdinaryObjectCreate(*null*).
          1. Perform ! CreateDataPropertyOrThrow(_untilOptions_, *"largestUnit"*, *"month"*).
          1. Let _untilResult_ be ? CalendarDateUntil(_calendar_, _plainRelativeTo_, _newRelativeTo_, _untilOptions_, _dateUntil_).
          1. Let _oneYearMonths_ be _untilResult_.[[Months]].
          1. Repeat, while abs(_months_) &ge; abs(_oneYearMonths_),
            1. Set _months_ to _months_ - _oneYearMonths_.
            1. Set _years_ to _years_ + _sign_.
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _newRelativeTo_ to ? CalendarDateAdd(_calendar_, _plainRelativeTo_, _oneYear_, *undefined*, _dateAdd_).
            1. Set _untilOptions_ to OrdinaryObjectCreate(*null*).
            1. Perform ! CreateDataPropertyOrThrow(_untilOptions_, *"largestUnit"*, *"month"*).
            1. Set _untilResult_ to ? CalendarDateUntil(_calendar_, _plainRelativeTo_, _newRelativeTo_, _untilOptions_, _dateUntil_).
            1. Set _oneYearMonths_ to _untilResult_.[[Months]].
        1. Else if _largestUnit_ is *"month"*, then
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
          1. Let _newRelativeTo_ be _moveResult_.[[RelativeTo]].
          1. Let _oneMonthDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_days_) &ge; abs(_oneMonthDays_),
            1. Set _days_ to _days_ - _oneMonthDays_.
            1. Set _months_ to _months_ + _sign_.
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
            1. Set _newRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneMonthDays_ to _moveResult_.[[Days]].
        1. Else,
          1. Assert: _largestUnit_ is *"week"*.
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneWeek_, _dateAdd_).
          1. Let _newRelativeTo_ be _moveResult_.[[RelativeTo]].
          1. Let _oneWeekDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_days_) &ge; abs(_oneWeekDays_),
            1. Set _days_ to _days_ - _oneWeekDays_.
            1. Set _weeks_ to _weeks_ + _sign_.
            1. Set _plainRelativeTo_ to _newRelativeTo_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneWeek_, _dateAdd_).
            1. Set _newRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneWeekDays_ to _moveResult_.[[Days]].
        1. Return ! CreateDateDurationRecord(_years_, _months_, _weeks_, _days_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-addduration" type="abstract operation">
      <h1>
        AddDuration (
          _y1_: an integer,
          _mon1_: an integer,
          _w1_: an integer,
          _d1_: an integer,
          _h1_: an integer,
          _min1_: an integer,
          _s1_: an integer,
          _ms1_: an integer,
          _mus1_: an integer,
          _ns1_: an integer,
          _y2_: an integer,
          _mon2_: an integer,
          _w2_: an integer,
          _d2_: an integer,
          _h2_: an integer,
          _min2_: an integer,
          _s2_: an integer,
          _ms2_: an integer,
          _mus2_: an integer,
          _ns2_: an integer,
          _plainRelativeTo_: a Temporal.PlainDate or *undefined*,
          _zonedRelativeTo_: a Temporal.ZonedDateTime or *undefined*,
          optional _precalculatedPlainDateTime_: a Temporal.PlainDateTime or *undefined*,
        ): either a normal completion containing a Duration Record, or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It adds the components of a second duration represented by _y2_ through _ns2_ to those of a first duration represented by _y1_ through _ns1_, and balances the duration relative to the given date _zonedRelativeTo_ or _plainRelativeTo_, to ensure that no mixed signs remain in the result.</dd>
      </dl>
      <emu-alg>
        1. Let _largestUnit1_ be ! DefaultTemporalLargestUnit(_y1_, _mon1_, _w1_, _d1_, _h1_, _min1_, _s1_, _ms1_, _mus1_).
        1. Let _largestUnit2_ be ! DefaultTemporalLargestUnit(_y2_, _mon2_, _w2_, _d2_, _h2_, _min2_, _s2_, _ms2_, _mus2_).
        1. Let _largestUnit_ be ! LargerOfTwoTemporalUnits(_largestUnit1_, _largestUnit2_).
        1. If _zonedRelativeTo_ is *undefined* and _plainRelativeTo_ is *undefined*, then
          1. If _largestUnit_ is one of *"year"*, *"month"*, or *"week"*, then
            1. Throw a *RangeError* exception.
          1. Let _result_ be ? BalanceTimeDuration(_d1_ + _d2_, _h1_ + _h2_, _min1_ + _min2_, _s1_ + _s2_, _ms1_ + _ms2_, _mus1_ + _mus2_, _ns1_ + _ns2_, _largestUnit_).
          1. Return ! CreateDurationRecord(0, 0, 0, _result_.[[Days]], _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]).
        1. If _plainRelativeTo_ is not *undefined*, then
          1. Assert: _zonedRelativeTo_ is *undefined*.
          1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
          1. Let _dateDuration1_ be ! CreateTemporalDuration(_y1_, _mon1_, _w1_, _d1_, 0, 0, 0, 0, 0, 0).
          1. Let _dateDuration2_ be ! CreateTemporalDuration(_y2_, _mon2_, _w2_, _d2_, 0, 0, 0, 0, 0, 0).
          1. Let _calendarUnitsPresent_ be *true*.
          1. If _y1_ = 0 and _mon1_ = 0 and _w1_ = 0 and _y2_ = 0 and _mon2_ = 0 and _w2_ = 0, set _calendarUnitsPresent_ to *false*.
          1. If _calendar_ is an Object and _calendarUnitsPresent_ is *true*, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _intermediate_ be ? AddDate(_calendar_, _plainRelativeTo_, _dateDuration1_, *undefined*, _dateAdd_).
          1. Let _end_ be ? AddDate(_calendar_, _intermediate_, _dateDuration2_, *undefined*, _dateAdd_).
          1. Let _dateLargestUnit_ be ! LargerOfTwoTemporalUnits(*"day"*, _largestUnit_).
          1. Let _differenceOptions_ be OrdinaryObjectCreate(*null*).
          1. Perform ! CreateDataPropertyOrThrow(_differenceOptions_, *"largestUnit"*, _dateLargestUnit_).
          1. Let _dateDifference_ be ? DifferenceDate(_calendar_, _plainRelativeTo_, _end_, _differenceOptions_).
          1. Let _result_ be ? BalanceTimeDuration(_dateDifference_.[[Days]], _h1_ + _h2_, _min1_ + _min2_, _s1_ + _s2_, _ms1_ + _ms2_, _mus1_ + _mus2_, _ns1_ + _ns2_, _largestUnit_).
          1. Return ! CreateDurationRecord(_dateDifference_.[[Years]], _dateDifference_.[[Months]], _dateDifference_.[[Weeks]], _result_.[[Days]], _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]).
        1. Assert: _zonedRelativeTo_ is not *undefined*.
        1. If _precalculatedPlainDateTime_ is not present, let _precalculatedPlainDateTime_ be *undefined*.
        1. Let _timeZone_ be _zonedRelativeTo_.[[TimeZone]].
        1. Let _calendar_ be _zonedRelativeTo_.[[Calendar]].
        1. If _precalculatedPlainDateTime_ is *undefined*, then
          1. Let _startDateTime_ be ? GetPlainDateTimeFor(_timeZone_, _zonedRelativeTo_.[[Nanoseconds]], _calendar_).
        1. Else,
          1. Let _startDateTime_ be _precalculatedPlainDateTime_.
        1. Let _intermediateNs_ be ? AddZonedDateTime(_zonedRelativeTo_.[[Nanoseconds]], _timeZone_, _calendar_, _y1_, _mon1_, _w1_, _d1_, _h1_, _min1_, _s1_, _ms1_, _mus1_, _ns1_, _startDateTime_).
        1. Let _endNs_ be ? AddZonedDateTime(_intermediateNs_, _timeZone_, _calendar_, _y2_, _mon2_, _w2_, _d2_, _h2_, _min2_, _s2_, _ms2_, _mus2_, _ns2_).
        1. If _largestUnit_ is not one of *"year"*, *"month"*, *"week"*, or *"day"*, then
          1. Let _result_ be DifferenceInstant(_zonedRelativeTo_.[[Nanoseconds]], _endNs_, 1, *"nanosecond"*, _largestUnit_, *"halfExpand"*).
          1. Return ! CreateDurationRecord(0, 0, 0, 0, _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]).
        1. Return ? DifferenceZonedDateTime(_zonedRelativeTo_.[[Nanoseconds]], _endNs_, _timeZone_, _calendar_, _largestUnit_, OrdinaryObjectCreate(*null*), _startDateTime_).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-daysuntil" type="abstract operation">
      <h1>
        DaysUntil (
          _earlier_: a Temporal.PlainDate,
          _later_: a Temporal.PlainDate,
        ): an integer
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>The returned value is the number of days elapsed between the calendar dates of two Temporal.PlainDate instances _earlier_ and _later_.
        If _earlier_ is later than _later_, then the result is negative.</dd>
      </dl>
      <emu-alg>
        1. Let _epochDays1_ be ISODateToEpochDays(_earlier_.[[ISOYear]], _earlier_.[[ISOMonth]] - 1, _earlier_.[[ISODay]]).
        1. Let _epochDays2_ be ISODateToEpochDays(_later_.[[ISOYear]], _later_.[[ISOMonth]] - 1, _later_.[[ISODay]]).
        1. Return _epochDays2_ - _epochDays1_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-moverelativedate" type="abstract operation">
      <h1>
        MoveRelativeDate (
          _calendar_: an Object,
          _relativeTo_: a Temporal.PlainDate,
          _duration_: a Temporal.Duration,
          _dateAdd_: a function object or *undefined*,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>
          It adds _duration_ to _relativeTo_, returning a Record with a field [[RelativeTo]] (a Temporal.PlainDate) containing the result, as well as a [[Days]] field (an integer) containing the number of days added according to the calendar reckoning of _calendar_.
          This is used when balancing or rounding durations relative to a particular date.
        </dd>
      </dl>
      <emu-alg>
        1. Let _newDate_ be ? AddDate(_calendar_, _relativeTo_, _duration_, *undefined*, _dateAdd_).
        1. Let _days_ be DaysUntil(_relativeTo_, _newDate_).
        1. Return the Record {
            [[RelativeTo]]: _newDate_,
            [[Days]]: _days_
          }.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-moverelativezoneddatetime" type="abstract operation">
      <h1>
        MoveRelativeZonedDateTime (
          _zonedDateTime_: a Temporal.ZonedDateTime,
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _precalculatedPlainDateTime_: a Temporal.PlainDateTime or *undefined*,
        ): either a normal completion containing a Temporal.ZonedDateTime, or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It adjusts the calendar part of _zonedDateTime_ for use as the "relative-to" parameter of another operation and returns a new `Temporal.ZonedDateTime` instance.</dd>
      </dl>
      <emu-alg>
        1. Let _intermediateNs_ be ? AddZonedDateTime(_zonedDateTime_.[[Nanoseconds]], _zonedDateTime_.[[TimeZone]], _zonedDateTime_.[[Calendar]], _years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0, _precalculatedPlainDateTime_).
        1. Return ! CreateTemporalZonedDateTime(_intermediateNs_, _zonedDateTime_.[[TimeZone]], _zonedDateTime_.[[Calendar]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-roundduration" type="abstract operation">
      <h1>
        RoundDuration (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _increment_: an integer,
          _unit_: a String,
          _roundingMode_: a String,
          optional _plainRelativeTo_: *undefined* or a Temporal.PlainDate,
          optional _zonedRelativeTo_: *undefined* or a Temporal.ZonedDateTime,
          optional _precalculatedPlainDateTime_: *undefined* or a Temporal.PlainDateTime,
        ): either a normal completion containing a Record with fields [[DurationRecord]] (a Duration Record) and [[Total]] (a mathematical value), or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>
          It rounds a duration (denoted by _years_ through _nanoseconds_) according to the rounding parameters _unit_, _increment_, and _roundingMode_, and returns a Record with the Duration Record result in its [[DurationRecord]] field.
          It also returns the total of the smallest unit before the rounding operation in its [[Total]] field, for use in `Temporal.Duration.prototype.total`.
          For rounding involving calendar units, the _relativeTo_ parameter is required.
        </dd>
      </dl>
      <emu-alg>
        1. If _plainRelativeTo_ is not present, set _plainRelativeTo_ to *undefined*.
        1. If _zonedRelativeTo_ is not present, set _zonedRelativeTo_ to *undefined*.
        1. If _precalculatedPlainDateTime_ is not present, set _precalculatedPlainDateTime_ to *undefined*.
        1. If _unit_ is *"year"*, *"month"*, or *"week"*, and _plainRelativeTo_ is *undefined*, then
          1. Throw a *RangeError* exception.
        1. If _unit_ is one of *"year"*, *"month"*, *"week"*, or *"day"*, then
          1. Let _nanoseconds_ be TotalDurationNanoseconds(_hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
          1. If _zonedRelativeTo_ is not *undefined*, then
            1. Let _intermediate_ be ? MoveRelativeZonedDateTime(_zonedRelativeTo_, _years_, _months_, _weeks_, _days_, _precalculatedPlainDateTime_).
            1. Let _result_ be ? NanosecondsToDays(_nanoseconds_, _intermediate_).
            1. Let _fractionalDays_ be _days_ + _result_.[[Days]] + _result_.[[Nanoseconds]] / _result_.[[DayLength]].
          1. Else,
            1. Let _fractionalDays_ be _days_ + _nanoseconds_ / nsPerDay.
          1. Set _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, and _nanoseconds_ to 0.
          1. [declared="fractionalSeconds"] Assert: _fractionalSeconds_ is not used below.
        1. Else,
          1. Let _fractionalSeconds_ be _nanoseconds_ &times; 10<sup>-9</sup> + _microseconds_ &times; 10<sup>-6</sup> + _milliseconds_ &times; 10<sup>-3</sup> + _seconds_.
          1. Assert: _fractionalDays_ is not used below.
        1. Let _total_ be ~unset~.
        1. If _unit_ is *"year"*, then
          1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
          1. Let _yearsDuration_ be ! CreateTemporalDuration(_years_, 0, 0, 0, 0, 0, 0, 0, 0, 0).
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _yearsLater_ be ? AddDate(_calendar_, _plainRelativeTo_, _yearsDuration_, *undefined*, _dateAdd_).
          1. Let _yearsMonthsWeeks_ be ! CreateTemporalDuration(_years_, _months_, _weeks_, 0, 0, 0, 0, 0, 0, 0).
          1. Let _yearsMonthsWeeksLater_ be ? AddDate(_calendar_, _plainRelativeTo_, _yearsMonthsWeeks_, *undefined*, _dateAdd_).
          1. Let _monthsWeeksInDays_ be DaysUntil(_yearsLater_, _yearsMonthsWeeksLater_).
          1. Set _plainRelativeTo_ to _yearsLater_.
          1. Set _fractionalDays_ to _fractionalDays_ + _monthsWeeksInDays_.
          1. Let _isoResult_ be ! AddISODate(_plainRelativeTo_.[[ISOYear]]. _plainRelativeTo_.[[ISOMonth]], _plainRelativeTo_.[[ISODay]], 0, 0, 0, truncate(_fractionalDays_), *"constrain"*).
          1. Let _wholeDaysLater_ be ? CreateTemporalDate(_isoResult_.[[Year]], _isoResult_.[[Month]], _isoResult_.[[Day]], _calendar_).
          1. Let _untilOptions_ be OrdinaryObjectCreate(*null*).
          1. Perform ! CreateDataPropertyOrThrow(_untilOptions_, *"largestUnit"*, *"year"*).
          1. Let _timePassed_ be ? DifferenceDate(_calendar_, _plainRelativeTo_, _wholeDaysLater_, _untilOptions_).
          1. Let _yearsPassed_ be _timePassed_.[[Years]].
          1. Set _years_ to _years_ + _yearsPassed_.
          1. Let _yearsDuration_ be ! CreateTemporalDuration(_yearsPassed_, 0, 0, 0, 0, 0, 0, 0, 0, 0).
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _yearsDuration_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Let _daysPassed_ be _moveResult_.[[Days]].
          1. Set _fractionalDays_ to _fractionalDays_ - _daysPassed_.
          1. If _fractionalDays_ &lt; 0, let _sign_ be -1; else, let _sign_ be 1.
          1. Let _oneYear_ be ! CreateTemporalDuration(_sign_, 0, 0, 0, 0, 0, 0, 0, 0, 0).
          1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneYear_, _dateAdd_).
          1. Let _oneYearDays_ be _moveResult_.[[Days]].
          1. Let _fractionalYears_ be _years_ + _fractionalDays_ / abs(_oneYearDays_).
          1. Set _years_ to RoundNumberToIncrement(_fractionalYears_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalYears_.
          1. Set _months_ and _weeks_ to 0.
        1. Else if _unit_ is *"month"*, then
          1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
          1. Let _yearsMonths_ be ! CreateTemporalDuration(_years_, _months_, 0, 0, 0, 0, 0, 0, 0, 0).
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _yearsMonthsLater_ be ? AddDate(_calendar_, _plainRelativeTo_, _yearsMonths_, *undefined*, _dateAdd_).
          1. Let _yearsMonthsWeeks_ be ! CreateTemporalDuration(_years_, _months_, _weeks_, 0, 0, 0, 0, 0, 0, 0).
          1. Let _yearsMonthsWeeksLater_ be ? AddDate(_calendar_, _plainRelativeTo_, _yearsMonthsWeeks_, *undefined*, _dateAdd_).
          1. Let _weeksInDays_ be DaysUntil(_yearsMonthsLater_, _yearsMonthsWeeksLater_).
          1. Set _plainRelativeTo_ to _yearsMonthsLater_.
          1. Set _fractionalDays_ to _fractionalDays_ + _weeksInDays_.
          1. If _fractionalDays_ &lt; 0, let _sign_ be -1; else, let _sign_ be 1.
          1. Let _oneMonth_ be ! CreateTemporalDuration(0, _sign_, 0, 0, 0, 0, 0, 0, 0, 0).
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Let _oneMonthDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_fractionalDays_) &ge; abs(_oneMonthDays_),
            1. Set _months_ to _months_ + _sign_.
            1. Set _fractionalDays_ to _fractionalDays_ - _oneMonthDays_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneMonth_, _dateAdd_).
            1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneMonthDays_ to _moveResult_.[[Days]].
          1. Let _fractionalMonths_ be _months_ + _fractionalDays_ / abs(_oneMonthDays_).
          1. Set _months_ to RoundNumberToIncrement(_fractionalMonths_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalMonths_.
          1. Set _weeks_ to 0.
        1. Else if _unit_ is *"week"*, then
          1. Let _calendar_ be _plainRelativeTo_.[[Calendar]].
          1. If _fractionalDays_ &lt; 0, let _sign_ be -1; else, let _sign_ be 1.
          1. Let _oneWeek_ be ! CreateTemporalDuration(0, 0, _sign_, 0, 0, 0, 0, 0, 0, 0).
          1. If _calendar_ is an Object, then
            1. Let _dateAdd_ be ? GetMethod(_calendar_, *"dateAdd"*).
          1. Else,
            1. Let _dateAdd_ be ~unused~.
          1. Let _moveResult_ be ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneWeek_, _dateAdd_).
          1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
          1. Let _oneWeekDays_ be _moveResult_.[[Days]].
          1. Repeat, while abs(_fractionalDays_) &ge; abs(_oneWeekDays_),
            1. Set _weeks_ to _weeks_ + _sign_.
            1. Set _fractionalDays_ to _fractionalDays_ - _oneWeekDays_.
            1. Set _moveResult_ to ? MoveRelativeDate(_calendar_, _plainRelativeTo_, _oneWeek_, _dateAdd_).
            1. Set _plainRelativeTo_ to _moveResult_.[[RelativeTo]].
            1. Set _oneWeekDays_ to _moveResult_.[[Days]].
          1. Let _fractionalWeeks_ be _weeks_ + _fractionalDays_ / abs(_oneWeekDays_).
          1. Set _weeks_ to RoundNumberToIncrement(_fractionalWeeks_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalWeeks_.
        1. Else if _unit_ is *"day"*, then
          1. Set _days_ to RoundNumberToIncrement(_fractionalDays_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalDays_.
        1. Else if _unit_ is *"hour"*, then
          1. Let _fractionalHours_ be (_fractionalSeconds_ / 60 + _minutes_) / 60 + _hours_.
          1. Set _hours_ to RoundNumberToIncrement(_fractionalHours_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalHours_.
          1. Set _minutes_, _seconds_, _milliseconds_, _microseconds_, and _nanoseconds_ to 0.
        1. Else if _unit_ is *"minute"*, then
          1. Let _fractionalMinutes_ be _fractionalSeconds_ / 60 + _minutes_.
          1. Set _minutes_ to RoundNumberToIncrement(_fractionalMinutes_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalMinutes_.
          1. Set _seconds_, _milliseconds_, _microseconds_, and _nanoseconds_ to 0.
        1. Else if _unit_ is *"second"*, then
          1. Set _seconds_ to RoundNumberToIncrement(_fractionalSeconds_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalSeconds_.
          1. Set _milliseconds_, _microseconds_, and _nanoseconds_ to 0.
        1. Else if _unit_ is *"millisecond"*, then
          1. Let _fractionalMilliseconds_ be _nanoseconds_ &times; 10<sup>-6</sup> + _microseconds_ &times; 10<sup>-3</sup> + _milliseconds_.
          1. Set _milliseconds_ to RoundNumberToIncrement(_fractionalMilliseconds_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalMilliseconds_.
          1. Set _microseconds_ and _nanoseconds_ to 0.
        1. Else if _unit_ is *"microsecond"*, then
          1. Let _fractionalMicroseconds_ be _nanoseconds_ &times; 10<sup>-3</sup> + _microseconds_.
          1. Set _microseconds_ to RoundNumberToIncrement(_fractionalMicroseconds_, _increment_, _roundingMode_).
          1. Set _total_ to _fractionalMicroseconds_.
          1. Set _nanoseconds_ to 0.
        1. Else,
          1. Assert: _unit_ is *"nanosecond"*.
          1. Set _total_ to _nanoseconds_.
          1. Set _nanoseconds_ to RoundNumberToIncrement(_nanoseconds_, _increment_, _roundingMode_).
        1. Let _duration_ be ? CreateDurationRecord(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Return the Record {
          [[DurationRecord]]: _duration_,
          [[Total]]: _total_
          }.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-adjustroundeddurationdays" type="abstract operation">
      <h1>
        AdjustRoundedDurationDays (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _increment_: an integer,
          _unit_: a String,
          _roundingMode_: a String,
          _zonedRelativeTo_: a Temporal.ZonedDateTime,
          _precalculatedPlainDateTime_: a Temporal.PlainDateTime or *undefined*,
        ): either a normal completion containing a Duration Record, or a throw completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>
          It adjusts, if necessary, a duration that was rounded to a unit of hours or lower relative to a Temporal.ZonedDateTime, and returns the result.
          On a calendar day that is not 24 hours in length due to time zone offset changes, it is possible for a duration's time units to round up to exceed the day's length.
          In this case, the days part of the duration is adjusted by one, and the time part is re-rounded.
        </dd>
      </dl>
      <emu-alg>
        1. If _unit_ is one of *"year"*, *"month"*, *"week"*, or *"day"*; or _unit_ is *"nanosecond"* and _increment_ is 1, then
          1. Return ! CreateDurationRecord(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Assert: _precalculatedPlainDateTime_ is not *undefined*.
        1. Let _timeRemainderNs_ be TotalDurationNanoseconds(_hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. If _timeRemainderNs_ = 0, let _direction_ be 0.
        1. Else if _timeRemainderNs_ &lt; 0, let _direction_ be -1.
        1. Else, let _direction_ be 1.
        1. Let _dayStart_ be ? AddZonedDateTime(_zonedRelativeTo_.[[Nanoseconds]], _zonedRelativeTo_.[[TimeZone]], _zonedRelativeTo_.[[Calendar]], _years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0, _precalculatedPlainDateTime_).
        1. Let _dayStartInstant_ be ! CreateTemporalInstant(_dayStart_).
        1. Let _dayStartDateTime_ be ? GetPlainDateTimeFor(_zonedRelativeTo_.[[TimeZone]], _dayStartInstant_, _zonedRelativeTo_.[[Calendar]]).
        1. Let _dayEnd_ be ? AddDaysToZonedDateTime(_dayStartInstant_, _dayStartDateTime_, _zonedRelativeTo_.[[TimeZone]], _zonedRelativeTo_.[[Calendar]], _direction_).[[EpochNanoseconds]].
        1. Let _dayLengthNs_ be ℝ(_dayEnd_ - _dayStart_).
        1. Let _oneDayLess_ be _timeRemainderNs_ - _dayLengthNs_.
        1. If _oneDayLess_ &times; _direction_ &lt; 0, then
          1. Return ! CreateDurationRecord(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Let _adjustedDateDuration_ be ? AddDuration(_years_, _months_, _weeks_, _days_, 0, 0, 0, 0, 0, 0, 0, 0, 0, _direction_, 0, 0, 0, 0, 0, 0, *undefined*, _zonedRelativeTo_, _precalculatedPlainDateTime_).
        1. Let _adjustedTimeDuration_ be ! RoundDuration(0, 0, 0, 0, 0, 0, 0, 0, 0, _oneDayLess_, _increment_, _unit_, _roundingMode_).
        1. Set _adjustedTimeDuration_ to ? BalanceTimeDuration(0, _adjustedTimeDuration_.[[Hours]], _adjustedTimeDuration_.[[Minutes]], _adjustedTimeDuration_.[[Seconds]], _adjustedTimeDuration_.[[Milliseconds]], _adjustedTimeDuration_.[[Microseconds]], _adjustedTimeDuration_.[[Nanoseconds]], *"hour"*).
        1. Return ! CreateDurationRecord(_adjustedDateDuration_.[[Years]], _adjustedDateDuration_.[[Months]], _adjustedDateDuration_.[[Weeks]], _adjustedDateDuration_.[[Days]], _adjustedTimeDuration_.[[Hours]], _adjustedTimeDuration_.[[Minutes]], _adjustedTimeDuration_.[[Seconds]], _adjustedTimeDuration_.[[Milliseconds]], _adjustedTimeDuration_.[[Microseconds]], _adjustedTimeDuration_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-temporaldurationtostring" type="abstract operation">
      <h1>
        TemporalDurationToString (
          _years_: an integer,
          _months_: an integer,
          _weeks_: an integer,
          _days_: an integer,
          _hours_: an integer,
          _minutes_: an integer,
          _seconds_: an integer,
          _milliseconds_: an integer,
          _microseconds_: an integer,
          _nanoseconds_: an integer,
          _precision_: an integer between 0 and 9 inclusive, or *"auto"*,
        )
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It returns a String which is the ISO 8601 representation of the duration denoted by _years_ through _nanoseconds_, with the number of decimal places in the seconds value controlled by _precision_.</dd>
      </dl>
      <emu-alg>
        1. Let _sign_ be ! DurationSign(_years_, _months_, _weeks_, _days_, _hours_, _minutes_, _seconds_, _milliseconds_, _microseconds_, _nanoseconds_).
        1. Set _microseconds_ to _microseconds_ + truncate(_nanoseconds_ / 1000).
        1. Set _nanoseconds_ to remainder(_nanoseconds_, 1000).
        1. Set _milliseconds_ to _milliseconds_ + truncate(_microseconds_ / 1000).
        1. Set _microseconds_ to remainder(_microseconds_, 1000).
        1. Set _seconds_ to _seconds_ + truncate(_milliseconds_ / 1000).
        1. Set _milliseconds_ to remainder(_milliseconds_, 1000).
        1. Let _datePart_ be *""*.
        1. If _years_ is not 0, then
          1. Set _datePart_ to the string concatenation of abs(_years_) formatted as a decimal number and the code unit 0x0059 (LATIN CAPITAL LETTER Y).
        1. If _months_ is not 0, then
          1. Set _datePart_ to the string concatenation of _datePart_, abs(_months_) formatted as a decimal number, and the code unit 0x004D (LATIN CAPITAL LETTER M).
        1. If _weeks_ is not 0, then
          1. Set _datePart_ to the string concatenation of _datePart_, abs(_weeks_) formatted as a decimal number, and the code unit 0x0057 (LATIN CAPITAL LETTER W).
        1. If _days_ is not 0, then
          1. Set _datePart_ to the string concatenation of _datePart_, abs(_days_) formatted as a decimal number, and the code unit 0x0044 (LATIN CAPITAL LETTER D).
        1. Let _timePart_ be *""*.
        1. If _hours_ is not 0, then
          1. Set _timePart_ to the string concatenation of abs(_hours_) formatted as a decimal number and the code unit 0x0048 (LATIN CAPITAL LETTER H).
        1. If _minutes_ is not 0, then
          1. Set _timePart_ to the string concatenation of _timePart_, abs(_minutes_) formatted as a decimal number, and the code unit 0x004D (LATIN CAPITAL LETTER M).
        1. Let _nonzeroSecondsAndLower_ be *false*.
        1. If _seconds_ &ne; 0, or _milliseconds_ &ne; 0, or _microseconds_ &ne; 0, or _nanoseconds_ &ne; 0, set _nonzeroSecondsAndLower_ to *true*.
        1. Let _zeroMinutesAndHigher_ be *false*.
        1. If _years_ = 0, and _months_ = 0, and _weeks_ = 0, and _days_ = 0, and _hours_ = 0, and _minutes_ = 0, set _zeroMinutesAndHigher_ to *true*.
        1. If _nonzeroSecondsAndLower_ is *true*, or _zeroMinutesAndHigher_ is *true*, or _precision_ is not *"auto"*, then
          1. Let _secondsPart_ be abs(_seconds_) formatted as a decimal number.
          1. Let _subSecondNanoseconds_ be abs(_milliseconds_) &times; 10<sup>6</sup> + abs(_microseconds_) &times; 10<sup>3</sup> + abs(_nanoseconds_).
          1. Let _subSecondsPart_ be FormatFractionalSeconds(_subSecondNanoseconds_, _precision_).
          1. Set _timePart_ to the string concatenation of _timePart_, _secondsPart_, _subSecondsPart_, and the code unit 0x0053 (LATIN CAPITAL LETTER S).
        1. Let _signPart_ be the code unit 0x002D (HYPHEN-MINUS) if _sign_ &lt; 0, and otherwise the empty String.
        1. Let _result_ be the string concatenation of _signPart_, the code unit 0x0050 (LATIN CAPITAL LETTER P) and _datePart_.
        1. If _timePart_ is not *""*, then
          1. Set _result_ to the string concatenation of _result_, the code unit 0x0054 (LATIN CAPITAL LETTER T), and _timePart_.
        1. Return _result_.
      </emu-alg>
    </emu-clause>

    <emu-clause id="sec-temporal-adddurationtoorsubtractdurationfromduration" type="abstract operation">
      <h1>
        AddDurationToOrSubtractDurationFromDuration (
          _operation_: ~add~ or ~subtract~,
          _duration_: a Temporal.Duration,
          _other_: an ECMAScript language value,
          _options_: an ECMAScript language value,
        ): either a normal completion containing a Temporal.Duration or an abrupt completion
      </h1>
      <dl class="header">
        <dt>description</dt>
        <dd>It adds/subtracts _other_ to/from _duration_, resulting in a longer/shorter duration.</dd>
      </dl>
      <emu-alg>
        1. If _operation_ is ~subtract~, let _sign_ be -1. Otherwise, let _sign_ be 1.
        1. Set _other_ to ? ToTemporalDurationRecord(_other_).
        1. Set _options_ to ? GetOptionsObject(_options_).
        1. Let _relativeToRecord_ be ? ToRelativeTemporalObject(_options_).
        1. Let _result_ be ? AddDuration(_duration_.[[Years]], _duration_.[[Months]], _duration_.[[Weeks]], _duration_.[[Days]], _duration_.[[Hours]], _duration_.[[Minutes]], _duration_.[[Seconds]], _duration_.[[Milliseconds]], _duration_.[[Microseconds]], _duration_.[[Nanoseconds]], _sign_ &times; _other_.[[Years]], _sign_ &times; _other_.[[Months]], _sign_ &times; _other_.[[Weeks]], _sign_ &times; _other_.[[Days]], _sign_ &times; _other_.[[Hours]], _sign_ &times; _other_.[[Minutes]], _sign_ &times; _other_.[[Seconds]], _sign_ &times; _other_.[[Milliseconds]], _sign_ &times; _other_.[[Microseconds]], _sign_ &times; _other_.[[Nanoseconds]], _relativeToRecord_.[[PlainRelativeTo]], _relativeToRecord_.[[ZonedRelativeTo]]).
        1. Return ! CreateTemporalDuration(_result_.[[Years]], _result_.[[Months]], _result_.[[Weeks]], _result_.[[Days]], _result_.[[Hours]], _result_.[[Minutes]], _result_.[[Seconds]], _result_.[[Milliseconds]], _result_.[[Microseconds]], _result_.[[Nanoseconds]]).
      </emu-alg>
    </emu-clause>
  </emu-clause>
</emu-clause>