@js-joda/extra 0.9.1 → 0.10.1

package/dist/js-joda-extra.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/extra - 0.9.1
+//! @version @js-joda/extra - 0.10.1
 //! @copyright (c) 2015-present, Philipp Thürwächter, Pattrick Hüper & js-joda contributors
 //! @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
 //! @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
@@ -29,6 +29,15 @@
    * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
    * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
    */
+  function assert(assertion, msg, error) {
+    if (!assertion) {
+      if (error) {
+        throw new error(msg);
+      } else {
+        throw new Error(msg);
+      }
+    }
+  }
   function requireNonNull(value, parameterName) {
     if (value == null) {
       throw new core.NullPointerException(parameterName + " must not be null");
@@ -44,24 +53,24 @@
     return value;
   }
 
-  var MathUtil$1 = core._.MathUtil;
+  var MathUtil$5 = core._.MathUtil;
   var DayOfMonth = function (_TemporalAccessor) {
     _inheritsLoose(DayOfMonth, _TemporalAccessor);
 
     DayOfMonth.now = function now(zoneIdOrClock) {
       switch (arguments.length) {
         case 0:
-          return DayOfMonth.now0();
+          return DayOfMonth._now0();
 
         case 1:
           requireNonNull(zoneIdOrClock, 'clockOrZone');
 
           if (zoneIdOrClock instanceof core.ZoneId) {
-            return DayOfMonth.nowZoneId(zoneIdOrClock);
+            return DayOfMonth._nowZoneId(zoneIdOrClock);
           }
 
           if (zoneIdOrClock instanceof core.Clock) {
-            return DayOfMonth.nowClock(zoneIdOrClock);
+            return DayOfMonth._nowClock(zoneIdOrClock);
           }
 
           throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
@@ -71,15 +80,15 @@
       }
     };
 
-    DayOfMonth.now0 = function now0() {
+    DayOfMonth._now0 = function _now0() {
       return this.now(core.Clock.systemDefaultZone());
     };
 
-    DayOfMonth.nowZoneId = function nowZoneId(zone) {
+    DayOfMonth._nowZoneId = function _nowZoneId(zone) {
       return this.now(core.Clock.system(zone));
     };
 
-    DayOfMonth.nowClock = function nowClock(clock) {
+    DayOfMonth._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return DayOfMonth.of(now.dayOfMonth());
     };
@@ -110,7 +119,7 @@
       var _this;
 
       _this = _TemporalAccessor.call(this) || this;
-      _this._day = MathUtil$1.safeToInt(dayOfMonth);
+      _this._day = MathUtil$5.safeToInt(dayOfMonth);
       return _this;
     }
 
@@ -217,7 +226,7 @@
 
     return DayOfMonth;
   }(core.TemporalAccessor);
-  function _init$2() {
+  function _init$7() {
     DayOfMonth.VALUES = new Array(31);
 
     for (var i = 0; i < 31; i++) {
@@ -225,24 +234,24 @@
     }
   }
 
-  var MathUtil = core._.MathUtil;
+  var MathUtil$4 = core._.MathUtil;
   var DayOfYear = function (_TemporalAccessor) {
     _inheritsLoose(DayOfYear, _TemporalAccessor);
 
     DayOfYear.now = function now(zoneIdOrClock) {
       switch (arguments.length) {
         case 0:
-          return DayOfYear.now0();
+          return DayOfYear._now0();
 
         case 1:
           requireNonNull(zoneIdOrClock, 'clockOrZone');
 
           if (zoneIdOrClock instanceof core.ZoneId) {
-            return DayOfYear.nowZoneId(zoneIdOrClock);
+            return DayOfYear._nowZoneId(zoneIdOrClock);
           }
 
           if (zoneIdOrClock instanceof core.Clock) {
-            return DayOfYear.nowClock(zoneIdOrClock);
+            return DayOfYear._nowClock(zoneIdOrClock);
           }
 
           throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
@@ -252,15 +261,15 @@
       }
     };
 
-    DayOfYear.now0 = function now0() {
+    DayOfYear._now0 = function _now0() {
       return DayOfYear.now(core.Clock.systemDefaultZone());
     };
 
-    DayOfYear.nowZoneId = function nowZoneId(zone) {
+    DayOfYear._nowZoneId = function _nowZoneId(zone) {
       return DayOfYear.now(core.Clock.system(zone));
     };
 
-    DayOfYear.nowClock = function nowClock(clock) {
+    DayOfYear._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return DayOfYear.of(now.dayOfYear());
     };
@@ -292,7 +301,7 @@
       var _this;
 
       _this = _TemporalAccessor.call(this) || this;
-      _this._day = MathUtil.safeToInt(dayOfYear);
+      _this._day = MathUtil$4.safeToInt(dayOfYear);
       return _this;
     }
 
@@ -394,7 +403,7 @@
 
     return DayOfYear;
   }(core.TemporalAccessor);
-  function _init$1() {
+  function _init$6() {
     DayOfYear.VALUES = new Array(366);
 
     for (var i = 0; i < 366; i++) {
@@ -662,10 +671,1965 @@
 
     return Interval;
   }();
-  function _init() {
+  function _init$5() {
     Interval.ALL = Interval.of(core.Instant.MIN, core.Instant.MAX);
   }
 
+  /**
+   * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper & Michał Sobkiewicz
+   * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+   * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+   */
+  var MINP1 = core.LocalDate.MIN.plusDays(1);
+  var MAXM1 = core.LocalDate.MAX.minusDays(1);
+  var LocalDateRange = function () {
+    LocalDateRange.of = function of(startInclusive, endExclusiveOrPeriod) {
+      if (startInclusive instanceof core.LocalDate && endExclusiveOrPeriod instanceof core.LocalDate) {
+        return LocalDateRange._ofLocalDateLocalDate(startInclusive, endExclusiveOrPeriod);
+      }
+
+      if (startInclusive instanceof core.LocalDate && endExclusiveOrPeriod instanceof core.Period) {
+        return LocalDateRange._ofLocalDatePeriod(startInclusive, endExclusiveOrPeriod);
+      }
+
+      var messageParts = [];
+
+      if (!(startInclusive instanceof core.LocalDate)) {
+        messageParts.push("startInclusive must be an instance of LocalDate but is " + startInclusive.constructor.name);
+      }
+
+      if (!(endExclusiveOrPeriod instanceof core.LocalDate || endExclusiveOrPeriod instanceof core.Period)) {
+        messageParts.push("endExclusiveOrPeriod must be an instance of LocalDate or Period but is " + endExclusiveOrPeriod.constructor.name);
+      }
+
+      throw new core.IllegalArgumentException(messageParts.join(' and '));
+    };
+
+    LocalDateRange._ofLocalDateLocalDate = function _ofLocalDateLocalDate(startInclusive, endExclusive) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(endExclusive, 'endExclusive');
+      requireInstance(startInclusive, core.LocalDate, 'startInclusive');
+      requireInstance(endExclusive, core.LocalDate, 'endExclusive');
+      return new LocalDateRange(startInclusive, endExclusive);
+    };
+
+    LocalDateRange._ofLocalDatePeriod = function _ofLocalDatePeriod(startInclusive, period) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(period, 'period');
+      requireInstance(startInclusive, core.LocalDate, 'startInclusive');
+      requireInstance(period, core.Period, 'period');
+
+      if (period.isNegative()) {
+        throw new core.DateTimeException('Period must not be zero or negative');
+      }
+
+      return new LocalDateRange(startInclusive, startInclusive.plus(period));
+    };
+
+    LocalDateRange.ofClosed = function ofClosed(startInclusive, endInclusive) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(endInclusive, 'endInclusive');
+      requireInstance(startInclusive, core.LocalDate, 'startInclusive');
+      requireInstance(endInclusive, core.LocalDate, 'endInclusive');
+
+      if (endInclusive.isBefore(startInclusive)) {
+        throw new core.DateTimeException('Start date must be on or before end date');
+      }
+
+      var end = endInclusive.equals(core.LocalDate.MAX) ? core.LocalDate.MAX : endInclusive.plusDays(1);
+      return new LocalDateRange(startInclusive, end);
+    };
+
+    LocalDateRange.ofEmpty = function ofEmpty(date) {
+      requireNonNull(date, 'date');
+      requireInstance(date, core.LocalDate, 'date');
+      return new LocalDateRange(date, date);
+    };
+
+    LocalDateRange.ofUnbounded = function ofUnbounded() {
+      return LocalDateRange.ALL;
+    };
+
+    LocalDateRange.ofUnboundedStart = function ofUnboundedStart(endExclusive) {
+      requireNonNull(endExclusive, 'endExclusive');
+      requireInstance(endExclusive, core.LocalDate, 'endExclusive');
+      return LocalDateRange.of(core.LocalDate.MIN, endExclusive);
+    };
+
+    LocalDateRange.ofUnboundedEnd = function ofUnboundedEnd(startInclusive) {
+      return LocalDateRange.of(startInclusive, core.LocalDate.MAX);
+    };
+
+    LocalDateRange.parse = function parse(text) {
+      requireNonNull(text, 'text');
+
+      for (var i = 0; i < text.length; i++) {
+        if (text[i] === '/') {
+          var firstChar = text.charAt(0);
+
+          if (firstChar === 'P' || firstChar === 'p') {
+            var duration = core.Period.parse(text.slice(0, i));
+            var end = core.LocalDate.parse(text.slice(i + 1, text.length));
+            return LocalDateRange.of(end.minus(duration), end);
+          } else {
+            var start = core.LocalDate.parse(text.slice(0, i));
+
+            if (i + 1 < text.length) {
+              var c = text[i + 1];
+
+              if (c === 'P' || c === 'p') {
+                var _duration = core.Period.parse(text.slice(i + 1, text.length));
+
+                return LocalDateRange.of(start, start.plus(_duration));
+              }
+            }
+
+            var _end = core.LocalDate.parse(text.slice(i + 1, text.length));
+
+            return LocalDateRange.of(start, _end);
+          }
+        }
+      }
+
+      throw new core.DateTimeParseException('LocalDateRange cannot be parsed, no forward slash found', text, 0);
+    };
+
+    function LocalDateRange(startInclusive, endExclusive) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(endExclusive, 'endExclusive');
+      requireInstance(startInclusive, core.LocalDate, 'startInclusive');
+      requireInstance(endExclusive, core.LocalDate, 'endExclusive');
+
+      if (endExclusive.isBefore(startInclusive)) {
+        throw new core.DateTimeException('End date must be on or after start date');
+      }
+
+      if (startInclusive.equals(MAXM1)) {
+        throw new core.DateTimeException('Range must not start at LocalDate.MAX.minusDays(1)');
+      }
+
+      if (endExclusive.equals(MINP1)) {
+        throw new core.DateTimeException('Range must not end at LocalDate.MIN.plusDays(1)');
+      }
+
+      if (endExclusive.equals(core.LocalDate.MIN) || startInclusive.equals(core.LocalDate.MAX)) {
+        throw new core.DateTimeException('Empty range must not be at LocalDate.MIN or LocalDate.MAX');
+      }
+
+      this._start = startInclusive;
+      this._end = endExclusive;
+    }
+
+    var _proto = LocalDateRange.prototype;
+
+    _proto.start = function start() {
+      return this._start;
+    };
+
+    _proto.end = function end() {
+      return this._end;
+    };
+
+    _proto.endInclusive = function endInclusive() {
+      if (this.isUnboundedEnd()) {
+        return core.LocalDate.MAX;
+      }
+
+      return this._end.minusDays(1);
+    };
+
+    _proto.isEmpty = function isEmpty() {
+      return this._start.equals(this._end);
+    };
+
+    _proto.isUnboundedStart = function isUnboundedStart() {
+      return this._start.equals(core.LocalDate.MIN);
+    };
+
+    _proto.isUnboundedEnd = function isUnboundedEnd() {
+      return this._end.equals(core.LocalDate.MAX);
+    };
+
+    _proto.withStart = function withStart(adjuster) {
+      return LocalDateRange.of(this._start.with(adjuster), this._end);
+    };
+
+    _proto.withEnd = function withEnd(adjuster) {
+      return LocalDateRange.of(this._start, this._end.with(adjuster));
+    };
+
+    _proto.contains = function contains(date) {
+      requireNonNull(date, 'date');
+      return this._start.compareTo(date) <= 0 && (date.compareTo(this._end) < 0 || this.isUnboundedEnd());
+    };
+
+    _proto.encloses = function encloses(other) {
+      requireNonNull(other, 'other');
+      return this._start.compareTo(other._start) <= 0 && other._end.compareTo(this._end) <= 0;
+    };
+
+    _proto.abuts = function abuts(other) {
+      requireNonNull(other, 'other');
+      return this._end.equals(other._start) !== this._start.equals(other._end);
+    };
+
+    _proto.isConnected = function isConnected(other) {
+      requireNonNull(other, 'other');
+      return this.equals(other) || this._start.compareTo(other._end) <= 0 && other._start.compareTo(this._end) <= 0;
+    };
+
+    _proto.overlaps = function overlaps(other) {
+      requireNonNull(other, 'other');
+      return other.equals(this) || this._start.compareTo(other._end) < 0 && other._start.compareTo(this._end) < 0;
+    };
+
+    _proto.intersection = function intersection(other) {
+      requireNonNull(other, 'other');
+
+      if (this.isConnected(other) === false) {
+        throw new core.DateTimeException("Ranges do not connect: " + this + " and " + other);
+      }
+
+      var cmpStart = this._start.compareTo(other._start);
+
+      var cmpEnd = this._end.compareTo(other._end);
+
+      if (cmpStart >= 0 && cmpEnd <= 0) {
+        return this;
+      } else if (cmpStart <= 0 && cmpEnd >= 0) {
+        return other;
+      } else {
+        var newStart = cmpStart >= 0 ? this._start : other._start;
+        var newEnd = cmpEnd <= 0 ? this._end : other._end;
+        return LocalDateRange.of(newStart, newEnd);
+      }
+    };
+
+    _proto.union = function union(other) {
+      requireNonNull(other, 'other');
+
+      if (this.isConnected(other) === false) {
+        throw new core.DateTimeException("Ranges do not connect: " + this + " and " + other);
+      }
+
+      var cmpStart = this._start.compareTo(other._start);
+
+      var cmpEnd = this._end.compareTo(other._end);
+
+      if (cmpStart >= 0 && cmpEnd <= 0) {
+        return other;
+      } else if (cmpStart <= 0 && cmpEnd >= 0) {
+        return this;
+      } else {
+        var newStart = cmpStart >= 0 ? other._start : this._start;
+        var newEnd = cmpEnd <= 0 ? other._end : this._end;
+        return LocalDateRange.of(newStart, newEnd);
+      }
+    };
+
+    _proto.span = function span(other) {
+      requireNonNull(other, 'other');
+
+      var cmpStart = this._start.compareTo(other._start);
+
+      var cmpEnd = this._end.compareTo(other._end);
+
+      var newStart = cmpStart >= 0 ? other._start : this._start;
+      var newEnd = cmpEnd <= 0 ? other._end : this._end;
+      return LocalDateRange.of(newStart, newEnd);
+    };
+
+    _proto.isAfter = function isAfter(localDateOrLocalDateRange) {
+      if (localDateOrLocalDateRange instanceof core.LocalDate) {
+        return this._isAfterLocalDate(localDateOrLocalDateRange);
+      }
+
+      if (localDateOrLocalDateRange instanceof LocalDateRange) {
+        return this._isAfterLocalDateRange(localDateOrLocalDateRange);
+      }
+
+      throw new core.IllegalArgumentException("localDateOrLocalDateRange must be an instance of LocalDate or LocalDateRange but is " + localDateOrLocalDateRange.constructor.name);
+    };
+
+    _proto.isBefore = function isBefore(localDateOrLocalDateRange) {
+      if (localDateOrLocalDateRange instanceof core.LocalDate) {
+        return this._isBeforeLocalDate(localDateOrLocalDateRange);
+      }
+
+      if (localDateOrLocalDateRange instanceof LocalDateRange) {
+        return this._isBeforeLocalDateRange(localDateOrLocalDateRange);
+      }
+
+      throw new core.IllegalArgumentException("localDateOrLocalDateRange must be an instance of LocalDate or LocalDateRange but is " + localDateOrLocalDateRange.constructor.name);
+    };
+
+    _proto._isAfterLocalDate = function _isAfterLocalDate(date) {
+      return this._start.compareTo(date) > 0;
+    };
+
+    _proto._isBeforeLocalDate = function _isBeforeLocalDate(date) {
+      return this._end.compareTo(date) <= 0 && this._start.compareTo(date) < 0;
+    };
+
+    _proto._isAfterLocalDateRange = function _isAfterLocalDateRange(other) {
+      return this._start.compareTo(other._end) >= 0 && !other.equals(this);
+    };
+
+    _proto._isBeforeLocalDateRange = function _isBeforeLocalDateRange(range) {
+      return this._end.compareTo(range._start) <= 0 && !range.equals(this);
+    };
+
+    _proto.lengthInDays = function lengthInDays() {
+      if (this.isUnboundedStart() || this.isUnboundedEnd()) {
+        return Number.POSITIVE_INFINITY;
+      }
+
+      return this._end.toEpochDay() - this._start.toEpochDay();
+    };
+
+    _proto.toPeriod = function toPeriod() {
+      if (this.isUnboundedStart() || this.isUnboundedEnd()) {
+        throw new core.ArithmeticException('Unbounded range cannot be converted to a Period');
+      }
+
+      return core.Period.between(this._start, this._end);
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof LocalDateRange) {
+        var other = obj;
+        return this._start.equals(other._start) && this._end.equals(other._end);
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._start.hashCode() ^ this._end.hashCode();
+    };
+
+    _proto.toString = function toString() {
+      return this._start.toString() + "/" + this._end.toString();
+    };
+
+    return LocalDateRange;
+  }();
+  function _init$4() {
+    LocalDateRange.ALL = new LocalDateRange(core.LocalDate.MIN, core.LocalDate.MAX);
+  }
+
+  var MathUtil$3 = core._.MathUtil;
+  var SECONDS_PER_DAY = 86400;
+  var OffsetDate = function (_Temporal) {
+    _inheritsLoose(OffsetDate, _Temporal);
+
+    OffsetDate.now = function now(zoneIdOrClock) {
+      if (arguments.length === 0) {
+        return OffsetDate._now0();
+      } else if (arguments.length === 1 && zoneIdOrClock instanceof core.ZoneId) {
+        return OffsetDate._nowZoneId(zoneIdOrClock);
+      } else {
+        return OffsetDate._nowClock(zoneIdOrClock);
+      }
+    };
+
+    OffsetDate._now0 = function _now0() {
+      return OffsetDate.now(core.Clock.systemDefaultZone());
+    };
+
+    OffsetDate._nowZoneId = function _nowZoneId(zone) {
+      return OffsetDate.now(core.Clock.system(zone));
+    };
+
+    OffsetDate._nowClock = function _nowClock(clock) {
+      requireNonNull(clock, 'clock');
+      var now = clock.instant();
+      return OffsetDate.ofInstant(now, clock.zone().rules().offset(now));
+    };
+
+    OffsetDate.of = function of() {
+      switch (arguments.length) {
+        case 2:
+          return OffsetDate._ofLocalDateZoneOffset.apply(OffsetDate, arguments);
+
+        case 4:
+          return OffsetDate._ofIntIntIntZoneOffset.apply(OffsetDate, arguments);
+
+        default:
+          throw new core.IllegalArgumentException('Illegal number of arguments');
+      }
+    };
+
+    OffsetDate._ofLocalDateZoneOffset = function _ofLocalDateZoneOffset(date, offset) {
+      return new OffsetDate(date, offset);
+    };
+
+    OffsetDate._ofIntIntIntZoneOffset = function _ofIntIntIntZoneOffset(year, month, dayOfMonth, offset) {
+      var d = core.LocalDate.of(year, month, dayOfMonth);
+      return new OffsetDate(d, offset);
+    };
+
+    OffsetDate.ofInstant = function ofInstant(instant, zone) {
+      requireNonNull(instant, 'instant');
+      requireNonNull(zone, 'zone');
+      var rules = zone.rules();
+      var offset = rules.offset(instant);
+      var epochSec = instant.epochSecond() + offset.totalSeconds();
+      var epochDay = MathUtil$3.floorDiv(epochSec, SECONDS_PER_DAY);
+      var date = core.LocalDate.ofEpochDay(epochDay);
+      return new OffsetDate(date, offset);
+    };
+
+    OffsetDate.from = function from(temporal) {
+      if (temporal instanceof OffsetDate) {
+        return temporal;
+      }
+
+      requireNonNull(temporal, 'temporal');
+
+      try {
+        var date = core.LocalDate.from(temporal);
+        var offset = core.ZoneOffset.from(temporal);
+        return new OffsetDate(date, offset);
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain OffsetDate from TemporalAccessor: " + temporal.constructor.name, ex);
+      }
+    };
+
+    OffsetDate.parse = function parse(text, formatter) {
+      if (formatter === void 0) {
+        formatter = core.DateTimeFormatter.ISO_OFFSET_DATE;
+      }
+
+      requireNonNull(formatter, 'formatter');
+      return formatter.parse(text, OffsetDate.FROM);
+    };
+
+    function OffsetDate(date, offset) {
+      var _this;
+
+      _this = _Temporal.call(this) || this;
+      _this._date = requireNonNull(date, 'date');
+      _this._offset = requireNonNull(offset, 'offset');
+      return _this;
+    }
+
+    var _proto = OffsetDate.prototype;
+
+    _proto._with = function _with(date, offset) {
+      if (this._date === date && this._offset.equals(offset)) {
+        return this;
+      }
+
+      return new OffsetDate(date, offset);
+    };
+
+    _proto.isSupported = function isSupported(fieldOrUnit) {
+      if (fieldOrUnit instanceof core.TemporalField) {
+        return this._isSupportedField(fieldOrUnit);
+      }
+
+      if (fieldOrUnit instanceof core.TemporalUnit) {
+        return this._isSupportedUnit(fieldOrUnit);
+      }
+
+      if (fieldOrUnit == null) {
+        return false;
+      }
+
+      throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+    };
+
+    _proto._isSupportedField = function _isSupportedField(field) {
+      if (field instanceof core.ChronoField) {
+        return field.isDateBased() || field === core.ChronoField.OFFSET_SECONDS;
+      }
+
+      return field != null && field.isSupportedBy(this);
+    };
+
+    _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+      if (unit instanceof core.ChronoUnit) {
+        return unit.isDateBased();
+      }
+
+      return unit != null && unit.isSupportedBy(this);
+    };
+
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field instanceof core.ChronoField) {
+        if (field === core.ChronoField.OFFSET_SECONDS) {
+          return field.range();
+        }
+
+        return this._date.range(field);
+      }
+
+      return field.rangeRefinedBy(this);
+    };
+
+    _proto.get = function get(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
+
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field instanceof core.ChronoField) {
+        if (field === core.ChronoField.OFFSET_SECONDS) {
+          return this.offset().totalSeconds();
+        }
+
+        return this._date.getLong(field);
+      }
+
+      return field.getFrom(this);
+    };
+
+    _proto.offset = function offset() {
+      return this._offset;
+    };
+
+    _proto.withOffsetSameLocal = function withOffsetSameLocal(offset) {
+      requireNonNull(offset, 'offset');
+      return this._with(this._date, offset);
+    };
+
+    _proto.toLocalDate = function toLocalDate() {
+      return this._date;
+    };
+
+    _proto.year = function year() {
+      return this._date.year();
+    };
+
+    _proto.monthValue = function monthValue() {
+      return this._date.monthValue();
+    };
+
+    _proto.month = function month() {
+      return this._date.month();
+    };
+
+    _proto.dayOfMonth = function dayOfMonth() {
+      return this._date.dayOfMonth();
+    };
+
+    _proto.dayOfYear = function dayOfYear() {
+      return this._date.dayOfYear();
+    };
+
+    _proto.dayOfWeek = function dayOfWeek() {
+      return this._date.dayOfWeek();
+    };
+
+    _proto._withAdjuster = function _withAdjuster(adjuster) {
+      if (adjuster instanceof core.LocalDate) {
+        return this._with(adjuster, this._offset);
+      } else if (adjuster instanceof core.ZoneOffset) {
+        return this._with(this._date, adjuster);
+      } else if (adjuster instanceof OffsetDate) {
+        return adjuster;
+      }
+
+      return _Temporal.prototype._withAdjuster.call(this, adjuster);
+    };
+
+    _proto._withField = function _withField(field, newValue) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field instanceof core.ChronoField) {
+        if (field === core.ChronoField.OFFSET_SECONDS) {
+          var f = field;
+          return this._with(this._date, core.ZoneOffset.ofTotalSeconds(f.checkValidIntValue(newValue)));
+        }
+
+        return this._with(this._date.with(field, newValue), this._offset);
+      }
+
+      return field.adjustInto(this, newValue);
+    };
+
+    _proto.withYear = function withYear(year) {
+      return this._with(this._date.withYear(year), this._offset);
+    };
+
+    _proto.withMonth = function withMonth(month) {
+      return this._with(this._date.withMonth(month), this._offset);
+    };
+
+    _proto.withDayOfMonth = function withDayOfMonth(dayOfMonth) {
+      return this._with(this._date.withDayOfMonth(dayOfMonth), this._offset);
+    };
+
+    _proto.withDayOfYear = function withDayOfYear(dayOfYear) {
+      return this._with(this._date.withDayOfYear(dayOfYear), this._offset);
+    };
+
+    _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
+      if (unit instanceof core.ChronoUnit) {
+        return this._with(this._date.plus(amountToAdd, unit), this._offset);
+      }
+
+      return unit.addTo(this, amountToAdd);
+    };
+
+    _proto.plusYears = function plusYears(years) {
+      return this._with(this._date.plusYears(years), this._offset);
+    };
+
+    _proto.plusMonths = function plusMonths(months) {
+      return this._with(this._date.plusMonths(months), this._offset);
+    };
+
+    _proto.plusWeeks = function plusWeeks(weeks) {
+      return this._with(this._date.plusWeeks(weeks), this._offset);
+    };
+
+    _proto.plusDays = function plusDays(days) {
+      return this._with(this._date.plusDays(days), this._offset);
+    };
+
+    _proto.minusYears = function minusYears(years) {
+      return this._with(this._date.minusYears(years), this._offset);
+    };
+
+    _proto.minusMonths = function minusMonths(months) {
+      return this._with(this._date.minusMonths(months), this._offset);
+    };
+
+    _proto.minusWeeks = function minusWeeks(weeks) {
+      return this._with(this._date.minusWeeks(weeks), this._offset);
+    };
+
+    _proto.minusDays = function minusDays(days) {
+      return this._with(this._date.minusDays(days), this._offset);
+    };
+
+    _proto.query = function query(_query) {
+      requireNonNull(_query, 'query');
+      requireInstance(_query, core.TemporalQuery, 'query');
+
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      } else if (_query === core.TemporalQueries.precision()) {
+        return core.ChronoUnit.DAYS;
+      } else if (_query === core.TemporalQueries.offset() || _query === core.TemporalQueries.zone()) {
+        return this.offset();
+      }
+
+      return _Temporal.prototype.query.call(this, _query);
+    };
+
+    _proto.adjustInto = function adjustInto(temporal) {
+      return temporal.with(core.ChronoField.OFFSET_SECONDS, this.offset().totalSeconds()).with(core.ChronoField.EPOCH_DAY, this.toLocalDate().toEpochDay());
+    };
+
+    _proto.until = function until(endExclusive, unit) {
+      var end = OffsetDate.from(endExclusive);
+
+      if (unit instanceof core.ChronoUnit) {
+        var offsetDiff = end._offset.totalSeconds() - this._offset.totalSeconds();
+
+        var endLocal = end._date.plusDays(MathUtil$3.intDiv(-offsetDiff, SECONDS_PER_DAY));
+
+        return this._date.until(endLocal, unit);
+      }
+
+      return unit.between(this, end);
+    };
+
+    _proto.format = function format(formatter) {
+      requireNonNull(formatter, 'formatter');
+      return formatter.format(this);
+    };
+
+    _proto.atTime = function atTime(time) {
+      return core.OffsetDateTime.of(this._date, time, this._offset);
+    };
+
+    _proto._toEpochSecond = function _toEpochSecond() {
+      var epochDay = this._date.toEpochDay();
+
+      var secs = epochDay * SECONDS_PER_DAY;
+      return secs - this._offset.totalSeconds();
+    };
+
+    _proto.toEpochSecond = function toEpochSecond(time) {
+      requireNonNull(time, 'time');
+      return this._toEpochSecond() + time.toSecondOfDay();
+    };
+
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, OffsetDate, 'other');
+
+      if (this._offset.equals(other._offset)) {
+        return this._date.compareTo(other._date);
+      }
+
+      var compare = this._toEpochSecond() - other._toEpochSecond();
+
+      if (compare === 0) {
+        compare = this._date.compareTo(other._date);
+      }
+
+      return compare;
+    };
+
+    _proto.isAfter = function isAfter(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, OffsetDate, 'other');
+      return this._toEpochSecond() > other._toEpochSecond();
+    };
+
+    _proto.isBefore = function isBefore(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, OffsetDate, 'other');
+      return this._toEpochSecond() < other._toEpochSecond();
+    };
+
+    _proto.isEqual = function isEqual(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, OffsetDate, 'other');
+      return this._toEpochSecond() === other._toEpochSecond();
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof OffsetDate) {
+        var other = obj;
+        return this._date.equals(other._date) && this._offset.equals(other._offset);
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._date.hashCode() ^ this._offset.hashCode();
+    };
+
+    _proto.toString = function toString() {
+      return this._date.toString() + this._offset.toString();
+    };
+
+    return OffsetDate;
+  }(core.Temporal);
+  function _init$3() {
+    OffsetDate.MIN = OffsetDate.of(core.LocalDate.MIN, core.ZoneOffset.MAX);
+    OffsetDate.MAX = OffsetDate.of(core.LocalDate.MAX, core.ZoneOffset.MIN);
+    OffsetDate.FROM = createTemporalQuery$3('OffsetDate.FROM', function (temporal) {
+      return OffsetDate.from(temporal);
+    });
+  }
+
+  function createTemporalQuery$3(name, queryFromFunction) {
+    var ExtendedTemporalQuery = function (_TemporalQuery) {
+      _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
+
+      function ExtendedTemporalQuery() {
+        return _TemporalQuery.apply(this, arguments) || this;
+      }
+
+      return ExtendedTemporalQuery;
+    }(core.TemporalQuery);
+
+    ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+    return new ExtendedTemporalQuery(name);
+  }
+
+  var MathUtil$2 = core._.MathUtil;
+  var Quarter = function (_TemporalAccessor) {
+    _inheritsLoose(Quarter, _TemporalAccessor);
+
+    Quarter.valueOf = function valueOf(name) {
+      requireNonNull(name, 'name');
+
+      switch (name) {
+        case 'Q1':
+          return Quarter.Q1;
+
+        case 'Q2':
+          return Quarter.Q2;
+
+        case 'Q3':
+          return Quarter.Q3;
+
+        case 'Q4':
+          return Quarter.Q4;
+      }
+
+      throw new core.IllegalArgumentException("No enum constant Quarter." + name);
+    };
+
+    Quarter.values = function values() {
+      return QUARTERS.slice();
+    };
+
+    Quarter.of = function of(quarterOfYear) {
+      requireNonNull(quarterOfYear, 'quarterOfYear');
+
+      switch (quarterOfYear) {
+        case 1:
+          return Quarter.Q1;
+
+        case 2:
+          return Quarter.Q2;
+
+        case 3:
+          return Quarter.Q3;
+
+        case 4:
+          return Quarter.Q4;
+
+        default:
+          throw new core.DateTimeException("Invalid value for Quarter: " + quarterOfYear);
+      }
+    };
+
+    Quarter.ofMonth = function ofMonth(monthOfYear) {
+      requireNonNull(monthOfYear, 'monthOfYear');
+      core.ChronoField.MONTH_OF_YEAR.range().checkValidValue(monthOfYear, core.ChronoField.MONTH_OF_YEAR);
+      return Quarter.of(MathUtil$2.intDiv(monthOfYear - 1, 3) + 1);
+    };
+
+    Quarter.from = function from(temporal) {
+      if (temporal instanceof Quarter) {
+        return temporal;
+      } else if (temporal instanceof core.Month) {
+        var month = temporal;
+        return Quarter.of(MathUtil$2.intDiv(month.ordinal(), 3) + 1);
+      }
+
+      try {
+        var qoy = MathUtil$2.safeToInt(temporal.getLong(core.IsoFields.QUARTER_OF_YEAR));
+        return Quarter.of(qoy);
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain Quarter from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+      }
+    };
+
+    function Quarter(value, name) {
+      var _this;
+
+      _this = _TemporalAccessor.call(this) || this;
+      _this._value = MathUtil$2.safeToInt(value);
+      _this._name = name;
+      return _this;
+    }
+
+    var _proto = Quarter.prototype;
+
+    _proto.value = function value() {
+      return this._value;
+    };
+
+    _proto.displayName = function displayName(style, locale) {
+      throw new core.IllegalArgumentException('Pattern using (localized) text not implemented yet!');
+    };
+
+    _proto.isSupported = function isSupported(field) {
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return true;
+      } else if (field instanceof core.ChronoField) {
+        return false;
+      }
+
+      return field != null && field.isSupportedBy(this);
+    };
+
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
+
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return field.range();
+      } else if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
+
+      return _TemporalAccessor.prototype.range.call(this, field);
+    };
+
+    _proto.get = function get(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
+
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
+
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return this.value();
+      } else if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
+
+      return field.getFrom(this);
+    };
+
+    _proto.plus = function plus(quarters) {
+      var amount = MathUtil$2.intMod(quarters, 4);
+      return QUARTERS[(this.ordinal() + amount + 4) % 4];
+    };
+
+    _proto.minus = function minus(quarters) {
+      return this.plus(-MathUtil$2.intMod(quarters, 4));
+    };
+
+    _proto.length = function length(leapYear) {
+      switch (this) {
+        case Quarter.Q1:
+          return leapYear ? 91 : 90;
+
+        case Quarter.Q2:
+          return 91;
+
+        default:
+          return 92;
+      }
+    };
+
+    _proto.firstMonth = function firstMonth() {
+      switch (this) {
+        case Quarter.Q1:
+          return core.Month.JANUARY;
+
+        case Quarter.Q2:
+          return core.Month.APRIL;
+
+        case Quarter.Q3:
+          return core.Month.JULY;
+
+        case Quarter.Q4:
+          return core.Month.OCTOBER;
+
+        default:
+          throw new core.IllegalStateException('Unreachable');
+      }
+    };
+
+    _proto.query = function query(_query) {
+      requireNonNull(_query, 'query');
+      requireInstance(_query, core.TemporalQuery, 'query');
+
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      } else if (_query === core.TemporalQueries.precision()) {
+        return core.IsoFields.QUARTER_YEARS;
+      }
+
+      return _TemporalAccessor.prototype.query.call(this, _query);
+    };
+
+    _proto.adjustInto = function adjustInto(temporal) {
+      requireNonNull(temporal, 'temporal');
+      return temporal.with(core.IsoFields.QUARTER_OF_YEAR, this.value());
+    };
+
+    _proto.ordinal = function ordinal() {
+      return this._value - 1;
+    };
+
+    _proto.name = function name() {
+      return this._name;
+    };
+
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Quarter, 'other');
+      return this._value - other._value;
+    };
+
+    _proto.toString = function toString() {
+      return this.name();
+    };
+
+    _proto.equals = function equals(other) {
+      return this === other;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._value;
+    };
+
+    return Quarter;
+  }(core.TemporalAccessor);
+  var QUARTERS;
+  function _init$2() {
+    Quarter.Q1 = new Quarter(1, 'Q1');
+    Quarter.Q2 = new Quarter(2, 'Q2');
+    Quarter.Q3 = new Quarter(3, 'Q3');
+    Quarter.Q4 = new Quarter(4, 'Q4');
+    Quarter.FROM = createTemporalQuery$2('Quarter.FROM', function (temporal) {
+      return Quarter.from(temporal);
+    });
+    QUARTERS = [Quarter.Q1, Quarter.Q2, Quarter.Q3, Quarter.Q4];
+  }
+
+  function createTemporalQuery$2(name, queryFromFunction) {
+    var ExtendedTemporalQuery = function (_TemporalQuery) {
+      _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
+
+      function ExtendedTemporalQuery() {
+        return _TemporalQuery.apply(this, arguments) || this;
+      }
+
+      return ExtendedTemporalQuery;
+    }(core.TemporalQuery);
+
+    ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+    return new ExtendedTemporalQuery(name);
+  }
+
+  var MathUtil$1 = core._.MathUtil;
+  var YearQuarter = function (_Temporal) {
+    _inheritsLoose(YearQuarter, _Temporal);
+
+    YearQuarter.now = function now(zoneIdOrClock) {
+      if (arguments.length === 0) {
+        return YearQuarter._now0();
+      } else if (arguments.length === 1 && zoneIdOrClock instanceof core.ZoneId) {
+        return YearQuarter._nowZoneId(zoneIdOrClock);
+      } else {
+        return YearQuarter._nowClock(zoneIdOrClock);
+      }
+    };
+
+    YearQuarter._now0 = function _now0() {
+      return YearQuarter.now(core.Clock.systemDefaultZone());
+    };
+
+    YearQuarter._nowZoneId = function _nowZoneId(zone) {
+      return YearQuarter.now(core.Clock.system(zone));
+    };
+
+    YearQuarter._nowClock = function _nowClock(clock) {
+      var now = core.LocalDate.now(clock);
+      return YearQuarter.of(now.getYear(), Quarter.from(now.getMonth()));
+    };
+
+    YearQuarter.of = function of(year, quarter) {
+      if (year instanceof core.Year && quarter instanceof Quarter) {
+        return YearQuarter._ofYearQuarter(year, quarter);
+      }
+
+      if (year instanceof core.Year && typeof quarter === 'number') {
+        return YearQuarter._ofYearInt(year, quarter);
+      }
+
+      if (typeof year === 'number' && quarter instanceof Quarter) {
+        return YearQuarter._ofIntQuarter(year, quarter);
+      }
+
+      if (typeof year === 'number' && typeof quarter === 'number') {
+        return YearQuarter._ofIntInt(year, quarter);
+      }
+
+      var yearMessage = "year must be an instance of Year or number but is " + year.constructor.name;
+      var quarterMessage = "quarter must be an instance of Quarter or number but is " + quarter.constructor.name;
+      throw new core.IllegalArgumentException(yearMessage + " and " + quarterMessage);
+    };
+
+    YearQuarter._ofYearQuarter = function _ofYearQuarter(year, quarter) {
+      return YearQuarter.of(year.value(), quarter);
+    };
+
+    YearQuarter._ofYearInt = function _ofYearInt(year, quarter) {
+      return YearQuarter.of(year.value(), Quarter.of(quarter));
+    };
+
+    YearQuarter._ofIntQuarter = function _ofIntQuarter(year, quarter) {
+      core.ChronoField.YEAR.checkValidValue(year);
+      requireNonNull(quarter, 'quarter');
+      return new YearQuarter(year, quarter);
+    };
+
+    YearQuarter._ofIntInt = function _ofIntInt(year, quarter) {
+      core.ChronoField.YEAR.checkValidValue(year);
+      return new YearQuarter(year, Quarter.of(quarter));
+    };
+
+    YearQuarter.from = function from(temporal) {
+      if (temporal instanceof YearQuarter) {
+        return temporal;
+      }
+
+      requireNonNull(temporal, 'temporal');
+
+      try {
+        var year = MathUtil$1.safeToInt(temporal.getLong(core.ChronoField.YEAR));
+        var qoy = MathUtil$1.safeToInt(temporal.getLong(core.IsoFields.QUARTER_OF_YEAR));
+        return YearQuarter.of(year, qoy);
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain YearQuarter from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+      }
+    };
+
+    YearQuarter.parse = function parse(text, formatter) {
+      if (formatter === void 0) {
+        formatter = YearQuarter.PARSER;
+      }
+
+      requireNonNull(formatter, 'formatter');
+      requireInstance(formatter, core.DateTimeFormatter, 'formatter');
+      return formatter.parse(text, YearQuarter.FROM);
+    };
+
+    function YearQuarter(year, quarter) {
+      var _this;
+
+      _this = _Temporal.call(this) || this;
+      _this._year = MathUtil$1.safeToInt(year);
+      _this._quarter = requireInstance(quarter, Quarter, 'Quarter');
+      return _this;
+    }
+
+    var _proto = YearQuarter.prototype;
+
+    _proto._with = function _with(newYear, newQuarter) {
+      if (this._year === newYear && this._quarter === newQuarter) {
+        return this;
+      }
+
+      return new YearQuarter(newYear, newQuarter);
+    };
+
+    _proto.isSupported = function isSupported(fieldOrUnit) {
+      if (fieldOrUnit instanceof core.TemporalField) {
+        return this._isSupportedField(fieldOrUnit);
+      }
+
+      if (fieldOrUnit instanceof core.TemporalUnit) {
+        return this._isSupportedUnit(fieldOrUnit);
+      }
+
+      if (fieldOrUnit == null) {
+        return false;
+      }
+
+      throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+    };
+
+    _proto._isSupportedField = function _isSupportedField(field) {
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return true;
+      } else if (field instanceof core.ChronoField) {
+        return field === core.ChronoField.YEAR || field === core.ChronoField.YEAR_OF_ERA || field === core.ChronoField.ERA;
+      }
+
+      return field != null && field.isSupportedBy(this);
+    };
+
+    _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+      if (unit === core.IsoFields.QUARTER_YEARS) {
+        return true;
+      } else if (unit instanceof core.ChronoUnit) {
+        return unit === core.ChronoUnit.YEARS || unit === core.ChronoUnit.DECADES || unit === core.ChronoUnit.CENTURIES || unit === core.ChronoUnit.MILLENNIA || unit === core.ChronoUnit.ERAS;
+      }
+
+      return unit != null && unit.isSupportedBy(this);
+    };
+
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return core.IsoFields.QUARTER_OF_YEAR.range();
+      }
+
+      if (field === core.ChronoField.YEAR_OF_ERA) {
+        return this.year() <= 0 ? core.ValueRange.of(1, core.Year.MAX_VALUE + 1) : core.ValueRange.of(1, core.Year.MAX_VALUE);
+      }
+
+      return _Temporal.prototype.range.call(this, field);
+    };
+
+    _proto.get = function get(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
+
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return this._quarter.value();
+      } else if (field instanceof core.ChronoField) {
+        switch (field) {
+          case core.ChronoField.YEAR_OF_ERA:
+            return this._year < 1 ? 1 - this._year : this._year;
+
+          case core.ChronoField.YEAR:
+            return this._year;
+
+          case core.ChronoField.ERA:
+            return this._year < 1 ? 0 : 1;
+
+          default:
+            throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+        }
+      }
+
+      return _Temporal.prototype.get.call(this, field);
+    };
+
+    _proto._prolepticQuarter = function _prolepticQuarter() {
+      return this._year * 4 + (this._quarter.value() - 1);
+    };
+
+    _proto.year = function year() {
+      return this._year;
+    };
+
+    _proto.quarterValue = function quarterValue() {
+      return this._quarter.value();
+    };
+
+    _proto.quarter = function quarter() {
+      return this._quarter;
+    };
+
+    _proto.isLeapYear = function isLeapYear() {
+      return core.IsoChronology.isLeapYear(this._year);
+    };
+
+    _proto.isValidDay = function isValidDay(dayOfQuarter) {
+      return dayOfQuarter >= 1 && dayOfQuarter <= this.lengthOfQuarter();
+    };
+
+    _proto.lengthOfQuarter = function lengthOfQuarter() {
+      return this._quarter.length(this.isLeapYear());
+    };
+
+    _proto.lengthOfYear = function lengthOfYear() {
+      return this.isLeapYear() ? 366 : 365;
+    };
+
+    _proto._withAdjuster = function _withAdjuster(adjuster) {
+      if (adjuster instanceof YearQuarter) {
+        return adjuster;
+      }
+
+      return _Temporal.prototype._withAdjuster.call(this, adjuster);
+    };
+
+    _proto._withField = function _withField(field, newValue) {
+      requireNonNull(field, 'field');
+      requireInstance(field, core.TemporalField, 'field');
+
+      if (field === core.IsoFields.QUARTER_OF_YEAR) {
+        return this.withQuarter(core.IsoFields.QUARTER_OF_YEAR.range().checkValidIntValue(newValue, core.IsoFields.QUARTER_OF_YEAR));
+      } else if (field instanceof core.ChronoField) {
+        field.checkValidValue(newValue);
+
+        switch (field) {
+          case core.ChronoField.YEAR_OF_ERA:
+            return this.withYear(this._year < 1 ? 1 - newValue : newValue);
+
+          case core.ChronoField.YEAR:
+            return this.withYear(newValue);
+
+          case core.ChronoField.ERA:
+            return this.getLong(core.ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year);
+
+          default:
+            throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+        }
+      }
+
+      return field.adjustInto(this, newValue);
+    };
+
+    _proto.withYear = function withYear(year) {
+      core.ChronoField.YEAR.checkValidValue(year);
+      return this._with(year, this._quarter);
+    };
+
+    _proto.withQuarter = function withQuarter(quarter) {
+      core.IsoFields.QUARTER_OF_YEAR.range().checkValidValue(quarter, core.IsoFields.QUARTER_OF_YEAR);
+      return this._with(this._year, Quarter.of(quarter));
+    };
+
+    _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
+      if (unit === core.IsoFields.QUARTER_YEARS) {
+        return this.plusQuarters(amountToAdd);
+      } else if (unit instanceof core.ChronoUnit) {
+        switch (unit) {
+          case core.ChronoUnit.YEARS:
+            return this.plusYears(amountToAdd);
+
+          case core.ChronoUnit.DECADES:
+            return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 10));
+
+          case core.ChronoUnit.CENTURIES:
+            return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 100));
+
+          case core.ChronoUnit.MILLENNIA:
+            return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 1000));
+
+          case core.ChronoUnit.ERAS:
+            return this.with(core.ChronoField.ERA, MathUtil$1.safeAdd(this.getLong(core.ChronoField.ERA), amountToAdd));
+
+          default:
+            throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+        }
+      }
+
+      return unit.addTo(this, amountToAdd);
+    };
+
+    _proto.plusYears = function plusYears(yearsToAdd) {
+      if (yearsToAdd === 0) {
+        return this;
+      }
+
+      var newYear = core.ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd);
+      return this._with(newYear, this._quarter);
+    };
+
+    _proto.plusQuarters = function plusQuarters(quartersToAdd) {
+      if (quartersToAdd === 0) {
+        return this;
+      }
+
+      var quarterCount = this._year * 4 + (this._quarter.value() - 1);
+      var calcQuarters = quarterCount + quartersToAdd;
+      var newYear = core.ChronoField.YEAR.checkValidIntValue(MathUtil$1.intDiv(calcQuarters, 4));
+      var newQuarter = MathUtil$1.floorMod(calcQuarters, 4) + 1;
+      return this._with(newYear, Quarter.of(newQuarter));
+    };
+
+    _proto.minusYears = function minusYears(yearsToSubtract) {
+      return yearsToSubtract === MathUtil$1.MIN_SAFE_INTEGER ? this.plusYears(MathUtil$1.MIN_SAFE_INTEGER).plusYears(1) : this.plusYears(-yearsToSubtract);
+    };
+
+    _proto.minusQuarters = function minusQuarters(quartersToSubtract) {
+      return quartersToSubtract === MathUtil$1.MIN_SAFE_INTEGER ? this.plusQuarters(MathUtil$1.MIN_SAFE_INTEGER).plusQuarters(1) : this.plusQuarters(-quartersToSubtract);
+    };
+
+    _proto.query = function query(_query) {
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      } else if (_query === core.TemporalQueries.precision()) {
+        return core.IsoFields.QUARTER_YEARS;
+      }
+
+      return _Temporal.prototype.query.call(this, _query);
+    };
+
+    _proto.adjustInto = function adjustInto(temporal) {
+      var newProlepticQuarter = this._prolepticQuarter();
+
+      var oldProlepticQuarter = temporal.get(core.ChronoField.YEAR) * 4 + (temporal.get(core.IsoFields.QUARTER_OF_YEAR) - 1);
+      return temporal.plus(newProlepticQuarter - oldProlepticQuarter, core.IsoFields.QUARTER_YEARS);
+    };
+
+    _proto.until = function until(endExclusive, unit) {
+      requireNonNull(endExclusive, 'endExclusive');
+      requireNonNull(unit, 'unit');
+      requireInstance(endExclusive, core.Temporal, 'endExclusive');
+      requireInstance(unit, core.TemporalUnit, 'unit');
+      var end = YearQuarter.from(endExclusive);
+
+      var quartersUntil = end._prolepticQuarter() - this._prolepticQuarter();
+
+      if (unit === core.IsoFields.QUARTER_YEARS) {
+        return quartersUntil;
+      } else if (unit instanceof core.ChronoUnit) {
+        switch (unit) {
+          case core.ChronoUnit.YEARS:
+            return MathUtil$1.intDiv(quartersUntil, 4);
+
+          case core.ChronoUnit.DECADES:
+            return MathUtil$1.intDiv(quartersUntil, 40);
+
+          case core.ChronoUnit.CENTURIES:
+            return MathUtil$1.intDiv(quartersUntil, 400);
+
+          case core.ChronoUnit.MILLENNIA:
+            return MathUtil$1.intDiv(quartersUntil, 4000);
+
+          case core.ChronoUnit.ERAS:
+            return end.getLong(core.ChronoField.ERA) - this.getLong(core.ChronoField.ERA);
+
+          default:
+            throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+        }
+      }
+
+      return unit.between(this, end);
+    };
+
+    _proto.format = function format(formatter) {
+      requireNonNull(formatter, 'formatter');
+      return formatter.format(this);
+    };
+
+    _proto.atDay = function atDay(dayOfQuarter) {
+      core.ValueRange.of(1, this.lengthOfQuarter()).checkValidValue(dayOfQuarter, core.IsoFields.DAY_OF_QUARTER);
+      var leap = core.Year.isLeap(this._year);
+
+      var month = this._quarter.firstMonth();
+
+      while (dayOfQuarter > month.length(leap)) {
+        dayOfQuarter -= month.length(leap);
+        month = month.plus(1);
+      }
+
+      return core.LocalDate.of(this._year, month, dayOfQuarter);
+    };
+
+    _proto.atEndOfQuarter = function atEndOfQuarter() {
+      var month = this._quarter.firstMonth().plus(2);
+
+      return core.LocalDate.of(this._year, month, month.maxLength());
+    };
+
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, YearQuarter, 'other');
+      var cmp = this._year - other._year;
+
+      if (cmp === 0) {
+        cmp = this._quarter.compareTo(other._quarter);
+      }
+
+      return cmp;
+    };
+
+    _proto.isAfter = function isAfter(other) {
+      return this.compareTo(other) > 0;
+    };
+
+    _proto.isBefore = function isBefore(other) {
+      return this.compareTo(other) < 0;
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof YearQuarter) {
+        var other = obj;
+        return this._year === other._year && this._quarter === other._quarter;
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._year ^ this._quarter.value() << 27;
+    };
+
+    _proto.toString = function toString() {
+      var yearString;
+      var yearValue = this._year;
+      var absYear = Math.abs(yearValue);
+
+      if (absYear < 1000) {
+        if (yearValue < 0) {
+          yearString = "-" + ("" + (yearValue - 10000)).slice(-4);
+        } else {
+          yearString = ("" + (yearValue + 10000)).slice(-4);
+        }
+      } else {
+        if (yearValue > 9999) {
+          yearString = "+" + yearValue;
+        } else {
+          yearString = "" + yearValue;
+        }
+      }
+
+      return yearString.concat('-').concat(this._quarter);
+    };
+
+    return YearQuarter;
+  }(core.Temporal);
+  function _init$1() {
+    YearQuarter.PARSER = new core.DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(core.ChronoField.YEAR, 4, 10, core.SignStyle.EXCEEDS_PAD).appendLiteral('-').appendLiteral('Q').appendValue(core.IsoFields.QUARTER_OF_YEAR, 1).toFormatter();
+    YearQuarter.FROM = createTemporalQuery$1('YearQuarter.FROM', function (temporal) {
+      return YearQuarter.from(temporal);
+    });
+  }
+
+  function createTemporalQuery$1(name, queryFromFunction) {
+    var ExtendedTemporalQuery = function (_TemporalQuery) {
+      _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
+
+      function ExtendedTemporalQuery() {
+        return _TemporalQuery.apply(this, arguments) || this;
+      }
+
+      return ExtendedTemporalQuery;
+    }(core.TemporalQuery);
+
+    ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+    return new ExtendedTemporalQuery(name);
+  }
+
+  var MathUtil = core._.MathUtil;
+  var YearWeek = function (_Temporal) {
+    _inheritsLoose(YearWeek, _Temporal);
+
+    YearWeek.now = function now(zoneIdOrClock) {
+      switch (arguments.length) {
+        case 0:
+          return YearWeek._now0();
+
+        case 1:
+          requireNonNull(zoneIdOrClock, 'clockOrZone');
+
+          if (zoneIdOrClock instanceof core.ZoneId) {
+            return YearWeek._nowZoneId(zoneIdOrClock);
+          }
+
+          if (zoneIdOrClock instanceof core.Clock) {
+            return YearWeek._nowClock(zoneIdOrClock);
+          }
+
+          throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
+
+        default:
+          throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
+      }
+    };
+
+    YearWeek._now0 = function _now0() {
+      return YearWeek.now(core.Clock.systemDefaultZone());
+    };
+
+    YearWeek._nowZoneId = function _nowZoneId(zone) {
+      return YearWeek.now(core.Clock.system(zone));
+    };
+
+    YearWeek._nowClock = function _nowClock(clock) {
+      var now = core.LocalDate.now(clock);
+      return YearWeek.of(now.get(core.IsoFields.WEEK_BASED_YEAR), now.get(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+    };
+
+    YearWeek.of = function of(year, week) {
+      MathUtil.verifyInt(week);
+
+      if (year instanceof core.Year) {
+        return this._ofYearWeek(year, week);
+      } else {
+        MathUtil.verifyInt(year);
+        return this._ofWeekBasedYear(year, week);
+      }
+    };
+
+    YearWeek._ofYearWeek = function _ofYearWeek(year, week) {
+      var weekBasedYear = year.value();
+      return this._ofWeekBasedYear(weekBasedYear, week);
+    };
+
+    YearWeek._ofWeekBasedYear = function _ofWeekBasedYear(weekBasedYear, week) {
+      core.IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, core.IsoFields.WEEK_BASED_YEAR);
+      core.IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidValue(week, core.IsoFields.WEEK_OF_WEEK_BASED_YEAR);
+
+      if (week === 53 && YearWeek._weekRange(weekBasedYear) < 53) {
+        week = 1;
+        weekBasedYear++;
+        core.IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, core.IsoFields.WEEK_BASED_YEAR);
+      }
+
+      return new YearWeek(weekBasedYear, week);
+    };
+
+    YearWeek._weekRange = function _weekRange(weekBasedYear) {
+      var date = core.LocalDate.of(weekBasedYear, 1, 1);
+
+      if (date.dayOfWeek() === core.DayOfWeek.THURSDAY || date.dayOfWeek() === core.DayOfWeek.WEDNESDAY && date.isLeapYear()) {
+        return 53;
+      }
+
+      return 52;
+    };
+
+    YearWeek.from = function from(temporal) {
+      if (temporal instanceof YearWeek) {
+        return temporal;
+      }
+
+      requireNonNull(temporal, 'temporal');
+
+      try {
+        var year = MathUtil.safeToInt(temporal.getLong(core.IsoFields.WEEK_BASED_YEAR));
+        var week = MathUtil.safeToInt(temporal.getLong(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+        return YearWeek.of(year, week);
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain YearWeek from TemporalAccessor: " + temporal.constructor.name, ex);
+      }
+    };
+
+    YearWeek.parse = function parse(text, formatter) {
+      if (formatter === void 0) {
+        formatter = YearWeek.PARSER;
+      }
+
+      assert(formatter != null, 'formatter', core.NullPointerException);
+      return formatter.parse(text, YearWeek.FROM);
+    };
+
+    function YearWeek(weekBasedYear, week) {
+      var _this;
+
+      _this = _Temporal.call(this) || this;
+      _this._year = weekBasedYear;
+      _this._week = week;
+      return _this;
+    }
+
+    var _proto = YearWeek.prototype;
+
+    _proto.isSupported = function isSupported(fieldOrUnit) {
+      if (fieldOrUnit instanceof core.TemporalField) {
+        return this._isSupportedField(fieldOrUnit);
+      }
+
+      if (fieldOrUnit instanceof core.TemporalUnit) {
+        return this._isSupportedUnit(fieldOrUnit);
+      }
+
+      if (fieldOrUnit == null) {
+        return false;
+      }
+
+      throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+    };
+
+    _proto._isSupportedField = function _isSupportedField(field) {
+      if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR || field === core.IsoFields.WEEK_BASED_YEAR) {
+        return true;
+      } else if (field instanceof core.ChronoField) {
+        return false;
+      }
+
+      return field != null && field.isSupportedBy(this);
+    };
+
+    _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+      if (unit === core.ChronoUnit.WEEKS || unit === core.IsoFields.WEEK_BASED_YEARS) {
+        return true;
+      } else if (unit instanceof core.ChronoUnit) {
+        return false;
+      }
+
+      return unit != null && unit.isSupportedBy(this);
+    };
+
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
+
+      if (field === core.IsoFields.WEEK_BASED_YEAR) {
+        return core.IsoFields.WEEK_BASED_YEAR.range();
+      }
+
+      if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+        return core.ValueRange.of(1, YearWeek._weekRange(this._year));
+      }
+
+      return _Temporal.prototype.range.call(this, field);
+    };
+
+    _proto.get = function get(field) {
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
+
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
+
+      if (field === core.IsoFields.WEEK_BASED_YEAR) {
+        return this._year;
+      }
+
+      if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+        return this._week;
+      }
+
+      if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
+
+      return field.getFrom(this);
+    };
+
+    _proto.year = function year() {
+      return this._year;
+    };
+
+    _proto.week = function week() {
+      return this._week;
+    };
+
+    _proto.is53WeekYear = function is53WeekYear() {
+      return YearWeek._weekRange(this._year) === 53;
+    };
+
+    _proto.lengthOfYear = function lengthOfYear() {
+      return this.is53WeekYear() ? 371 : 364;
+    };
+
+    _proto._withAdjuster = function _withAdjuster(adjuster) {
+      if (adjuster instanceof YearWeek) {
+        return adjuster;
+      }
+
+      return _Temporal.prototype._withAdjuster.call(this, adjuster);
+    };
+
+    _proto._withField = function _withField(field, newValue) {
+      if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+        return this.withWeek(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidIntValue(newValue, core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+      } else if (field === core.IsoFields.WEEK_BASED_YEAR) {
+        return this.withYear(core.IsoFields.WEEK_BASED_YEAR.range().checkValidIntValue(newValue, core.IsoFields.WEEK_BASED_YEAR));
+      } else if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
+
+      return field.adjustInto(this, newValue);
+    };
+
+    _proto.withYear = function withYear(weekBasedYear) {
+      if (this._week === 53 && YearWeek._weekRange(weekBasedYear) < 53) {
+        return YearWeek.of(weekBasedYear, 52);
+      }
+
+      return YearWeek.of(weekBasedYear, this._week);
+    };
+
+    _proto.withWeek = function withWeek(week) {
+      return YearWeek.of(this._year, week);
+    };
+
+    _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
+      if (unit === core.ChronoUnit.WEEKS) {
+        return this.plusWeeks(amountToAdd);
+      } else if (unit === core.IsoFields.WEEK_BASED_YEARS) {
+        return this.plusYears(amountToAdd);
+      } else if (unit instanceof core.ChronoUnit) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+      }
+
+      return unit.addTo(this, amountToAdd);
+    };
+
+    _proto.plusYears = function plusYears(yearsToAdd) {
+      if (yearsToAdd === 0) {
+        return this;
+      }
+
+      var newYear = MathUtil.safeToInt(MathUtil.safeAdd(this._year, yearsToAdd));
+      return this.withYear(newYear);
+    };
+
+    _proto.plusWeeks = function plusWeeks(weeksToAdd) {
+      if (weeksToAdd === 0) {
+        return this;
+      }
+
+      var mondayOfWeek = this.atDay(core.DayOfWeek.MONDAY).plusWeeks(weeksToAdd);
+      return YearWeek.from(mondayOfWeek);
+    };
+
+    _proto._minusUnit = function _minusUnit(amountToSubtract, unit) {
+      requireNonNull(amountToSubtract, 'amountToSubtract');
+      requireNonNull(unit, 'unit');
+      return this._plusUnit(-amountToSubtract, unit);
+    };
+
+    _proto.minusYears = function minusYears(yearsToSubtract) {
+      if (yearsToSubtract === 0) {
+        return this;
+      }
+
+      var newYear = MathUtil.safeToInt(MathUtil.safeSubtract(this._year, yearsToSubtract));
+      return this.withYear(newYear);
+    };
+
+    _proto.minusWeeks = function minusWeeks(weeksToSubtract) {
+      if (weeksToSubtract === 0) {
+        return this;
+      }
+
+      var mondayOfWeek = this.atDay(core.DayOfWeek.MONDAY).minusWeeks(weeksToSubtract);
+      return YearWeek.from(mondayOfWeek);
+    };
+
+    _proto.query = function query(_query) {
+      requireNonNull(_query, 'query');
+      requireInstance(_query, core.TemporalQuery, 'query');
+
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      }
+
+      return _Temporal.prototype.query.call(this, _query);
+    };
+
+    _proto.adjustInto = function adjustInto(temporal) {
+      return temporal.with(core.IsoFields.WEEK_BASED_YEAR, this._year).with(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR, this._week);
+    };
+
+    _proto.until = function until(endExclusive, unit) {
+      var end = YearWeek.from(endExclusive);
+
+      if (unit === core.ChronoUnit.WEEKS) {
+        return this._daysUntil(end);
+      } else if (unit === core.IsoFields.WEEK_BASED_YEARS) {
+        return this._yearsUntil(end);
+      } else if (unit instanceof core.ChronoUnit) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+      }
+
+      return unit.between(this, end);
+    };
+
+    _proto._daysUntil = function _daysUntil(end) {
+      var startDate = this.atDay(core.DayOfWeek.MONDAY);
+      var endDate = end.atDay(core.DayOfWeek.MONDAY);
+      var days = endDate.toEpochDay() - startDate.toEpochDay();
+      return MathUtil.intDiv(days, 7);
+    };
+
+    _proto._yearsUntil = function _yearsUntil(end) {
+      var yearsDiff = end._year - this._year;
+
+      if (yearsDiff > 0 && end._week < this._week) {
+        return yearsDiff - 1;
+      }
+
+      if (yearsDiff < 0 && end._week > this._week) {
+        return yearsDiff + 1;
+      }
+
+      return yearsDiff;
+    };
+
+    _proto.format = function format(formatter) {
+      requireNonNull(formatter, 'formatter');
+      return formatter.format(this);
+    };
+
+    _proto.atDay = function atDay(dayOfWeek) {
+      requireNonNull(dayOfWeek, 'dayOfWeek');
+      var correction = core.LocalDate.of(this._year, 1, 4).dayOfWeek().value() + 3;
+      var dayOfYear = this._week * 7 + dayOfWeek.value() - correction;
+      var maxDaysOfYear = core.Year.isLeap(this._year) ? 366 : 365;
+
+      if (dayOfYear > maxDaysOfYear) {
+        return core.LocalDate.ofYearDay(this._year + 1, dayOfYear - maxDaysOfYear);
+      }
+
+      if (dayOfYear > 0) {
+        return core.LocalDate.ofYearDay(this._year, dayOfYear);
+      } else {
+        var daysOfPreviousYear = core.Year.isLeap(this._year - 1) ? 366 : 365;
+        return core.LocalDate.ofYearDay(this._year - 1, daysOfPreviousYear + dayOfYear);
+      }
+    };
+
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, YearWeek, 'other');
+      var cmp = this._year - other._year;
+
+      if (cmp === 0) {
+        cmp = this._week - other._week;
+      }
+
+      return cmp;
+    };
+
+    _proto.isAfter = function isAfter(other) {
+      return this.compareTo(other) > 0;
+    };
+
+    _proto.isBefore = function isBefore(other) {
+      return this.compareTo(other) < 0;
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof YearWeek) {
+        return this._year === obj._year && this._week === obj._week;
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._year ^ this._week << 25;
+    };
+
+    _proto.toString = function toString() {
+      var yearString;
+      var yearValue = this._year;
+      var absYear = Math.abs(yearValue);
+
+      if (absYear < 1000) {
+        if (yearValue < 0) {
+          yearString = "-" + ("" + (yearValue - 10000)).slice(-4);
+        } else {
+          yearString = ("" + (yearValue + 10000)).slice(-4);
+        }
+      } else {
+        if (yearValue > 9999) {
+          yearString = "+" + yearValue;
+        } else {
+          yearString = "" + yearValue;
+        }
+      }
+
+      return yearString.concat(this._week < 10 ? '-W0' : '-W').concat(this._week);
+    };
+
+    return YearWeek;
+  }(core.Temporal);
+  function _init() {
+    YearWeek.PARSER = new core.DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(core.IsoFields.WEEK_BASED_YEAR, 4, 10, core.SignStyle.EXCEEDS_PAD).appendLiteral('-W').appendValue(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR, 2).toFormatter();
+    YearWeek.FROM = createTemporalQuery('YearWeek.FROM', function (temporal) {
+      return YearWeek.from(temporal);
+    });
+  }
+
+  function createTemporalQuery(name, queryFromFunction) {
+    var ExtendedTemporalQuery = function (_TemporalQuery) {
+      _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
+
+      function ExtendedTemporalQuery() {
+        return _TemporalQuery.apply(this, arguments) || this;
+      }
+
+      return ExtendedTemporalQuery;
+    }(core.TemporalQuery);
+
+    ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+    return new ExtendedTemporalQuery(name);
+  }
+
   /*
    * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
    * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
@@ -678,6 +2642,11 @@
     }
 
     isInit = true;
+    _init$7();
+    _init$6();
+    _init$5();
+    _init$4();
+    _init$3();
     _init$2();
     _init$1();
     _init();
@@ -700,6 +2669,11 @@
   exports.DayOfMonth = DayOfMonth;
   exports.DayOfYear = DayOfYear;
   exports.Interval = Interval;
+  exports.LocalDateRange = LocalDateRange;
+  exports.OffsetDate = OffsetDate;
+  exports.Quarter = Quarter;
+  exports.YearQuarter = YearQuarter;
+  exports.YearWeek = YearWeek;
 
   Object.defineProperty(exports, '__esModule', { value: true });