@js-joda/extra 0.9.1 → 0.10.0

package/dist/js-joda-extra.esm.js

@@ -1,9 +1,9 @@
-//! @version @js-joda/extra - 0.9.1
+//! @version @js-joda/extra - 0.10.0
 //! @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)
 
-import { NullPointerException, IllegalArgumentException, _, ChronoField, UnsupportedTemporalTypeException, TemporalQueries, IsoChronology, Month, MonthDay, TemporalAccessor, ZoneId, Clock, LocalDate, DateTimeException, TemporalQuery, Year, Instant, Duration, ZonedDateTime, DateTimeParseException, use } from '@js-joda/core';
+import { NullPointerException, IllegalArgumentException, _, ChronoField, UnsupportedTemporalTypeException, TemporalQueries, IsoChronology, Month, MonthDay, TemporalAccessor, ZoneId, Clock, LocalDate, DateTimeException, TemporalQuery, Year, Instant, Duration, ZonedDateTime, DateTimeParseException, ArithmeticException, Period, TemporalField, TemporalUnit, ChronoUnit, ZoneOffset, OffsetDateTime, Temporal, DateTimeFormatter, IsoFields, IllegalStateException, ValueRange, DateTimeFormatterBuilder, SignStyle, DayOfWeek, use } from '@js-joda/core';
 
 function _inheritsLoose(subClass, superClass) {
   subClass.prototype = Object.create(superClass.prototype);
@@ -25,6 +25,15 @@ function _setPrototypeOf(o, p) {
  * @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 NullPointerException(parameterName + " must not be null");
@@ -40,24 +49,24 @@ function requireInstance(value, _class, parameterName) {
   return value;
 }
 
-var MathUtil$1 = _.MathUtil;
+var MathUtil$5 = _.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 ZoneId) {
-          return DayOfMonth.nowZoneId(zoneIdOrClock);
+          return DayOfMonth._nowZoneId(zoneIdOrClock);
         }
 
         if (zoneIdOrClock instanceof Clock) {
-          return DayOfMonth.nowClock(zoneIdOrClock);
+          return DayOfMonth._nowClock(zoneIdOrClock);
         }
 
         throw new IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
@@ -67,15 +76,15 @@ var DayOfMonth = function (_TemporalAccessor) {
     }
   };
 
-  DayOfMonth.now0 = function now0() {
+  DayOfMonth._now0 = function _now0() {
     return this.now(Clock.systemDefaultZone());
   };
 
-  DayOfMonth.nowZoneId = function nowZoneId(zone) {
+  DayOfMonth._nowZoneId = function _nowZoneId(zone) {
     return this.now(Clock.system(zone));
   };
 
-  DayOfMonth.nowClock = function nowClock(clock) {
+  DayOfMonth._nowClock = function _nowClock(clock) {
     var now = LocalDate.now(clock);
     return DayOfMonth.of(now.dayOfMonth());
   };
@@ -106,7 +115,7 @@ var DayOfMonth = function (_TemporalAccessor) {
     var _this;
 
     _this = _TemporalAccessor.call(this) || this;
-    _this._day = MathUtil$1.safeToInt(dayOfMonth);
+    _this._day = MathUtil$5.safeToInt(dayOfMonth);
     return _this;
   }
 
@@ -213,7 +222,7 @@ var DayOfMonth = function (_TemporalAccessor) {
 
   return DayOfMonth;
 }(TemporalAccessor);
-function _init$2() {
+function _init$7() {
   DayOfMonth.VALUES = new Array(31);
 
   for (var i = 0; i < 31; i++) {
@@ -221,24 +230,24 @@ function _init$2() {
   }
 }
 
-var MathUtil = _.MathUtil;
+var MathUtil$4 = _.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 ZoneId) {
-          return DayOfYear.nowZoneId(zoneIdOrClock);
+          return DayOfYear._nowZoneId(zoneIdOrClock);
         }
 
         if (zoneIdOrClock instanceof Clock) {
-          return DayOfYear.nowClock(zoneIdOrClock);
+          return DayOfYear._nowClock(zoneIdOrClock);
         }
 
         throw new IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
@@ -248,15 +257,15 @@ var DayOfYear = function (_TemporalAccessor) {
     }
   };
 
-  DayOfYear.now0 = function now0() {
+  DayOfYear._now0 = function _now0() {
     return DayOfYear.now(Clock.systemDefaultZone());
   };
 
-  DayOfYear.nowZoneId = function nowZoneId(zone) {
+  DayOfYear._nowZoneId = function _nowZoneId(zone) {
     return DayOfYear.now(Clock.system(zone));
   };
 
-  DayOfYear.nowClock = function nowClock(clock) {
+  DayOfYear._nowClock = function _nowClock(clock) {
     var now = LocalDate.now(clock);
     return DayOfYear.of(now.dayOfYear());
   };
@@ -288,7 +297,7 @@ var DayOfYear = function (_TemporalAccessor) {
     var _this;
 
     _this = _TemporalAccessor.call(this) || this;
-    _this._day = MathUtil.safeToInt(dayOfYear);
+    _this._day = MathUtil$4.safeToInt(dayOfYear);
     return _this;
   }
 
@@ -390,7 +399,7 @@ var DayOfYear = function (_TemporalAccessor) {
 
   return DayOfYear;
 }(TemporalAccessor);
-function _init$1() {
+function _init$6() {
   DayOfYear.VALUES = new Array(366);
 
   for (var i = 0; i < 366; i++) {
@@ -658,10 +667,1965 @@ var Interval = function () {
 
   return Interval;
 }();
-function _init() {
+function _init$5() {
   Interval.ALL = Interval.of(Instant.MIN, 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 = LocalDate.MIN.plusDays(1);
+var MAXM1 = LocalDate.MAX.minusDays(1);
+var LocalDateRange = function () {
+  LocalDateRange.of = function of(startInclusive, endExclusiveOrPeriod) {
+    if (startInclusive instanceof LocalDate && endExclusiveOrPeriod instanceof LocalDate) {
+      return LocalDateRange._ofLocalDateLocalDate(startInclusive, endExclusiveOrPeriod);
+    }
+
+    if (startInclusive instanceof LocalDate && endExclusiveOrPeriod instanceof Period) {
+      return LocalDateRange._ofLocalDatePeriod(startInclusive, endExclusiveOrPeriod);
+    }
+
+    var messageParts = [];
+
+    if (!(startInclusive instanceof LocalDate)) {
+      messageParts.push("startInclusive must be an instance of LocalDate but is " + startInclusive.constructor.name);
+    }
+
+    if (!(endExclusiveOrPeriod instanceof LocalDate || endExclusiveOrPeriod instanceof Period)) {
+      messageParts.push("endExclusiveOrPeriod must be an instance of LocalDate or Period but is " + endExclusiveOrPeriod.constructor.name);
+    }
+
+    throw new IllegalArgumentException(messageParts.join(' and '));
+  };
+
+  LocalDateRange._ofLocalDateLocalDate = function _ofLocalDateLocalDate(startInclusive, endExclusive) {
+    requireNonNull(startInclusive, 'startInclusive');
+    requireNonNull(endExclusive, 'endExclusive');
+    requireInstance(startInclusive, LocalDate, 'startInclusive');
+    requireInstance(endExclusive, LocalDate, 'endExclusive');
+    return new LocalDateRange(startInclusive, endExclusive);
+  };
+
+  LocalDateRange._ofLocalDatePeriod = function _ofLocalDatePeriod(startInclusive, period) {
+    requireNonNull(startInclusive, 'startInclusive');
+    requireNonNull(period, 'period');
+    requireInstance(startInclusive, LocalDate, 'startInclusive');
+    requireInstance(period, Period, 'period');
+
+    if (period.isNegative()) {
+      throw new 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, LocalDate, 'startInclusive');
+    requireInstance(endInclusive, LocalDate, 'endInclusive');
+
+    if (endInclusive.isBefore(startInclusive)) {
+      throw new DateTimeException('Start date must be on or before end date');
+    }
+
+    var end = endInclusive.equals(LocalDate.MAX) ? LocalDate.MAX : endInclusive.plusDays(1);
+    return new LocalDateRange(startInclusive, end);
+  };
+
+  LocalDateRange.ofEmpty = function ofEmpty(date) {
+    requireNonNull(date, 'date');
+    requireInstance(date, LocalDate, 'date');
+    return new LocalDateRange(date, date);
+  };
+
+  LocalDateRange.ofUnbounded = function ofUnbounded() {
+    return LocalDateRange.ALL;
+  };
+
+  LocalDateRange.ofUnboundedStart = function ofUnboundedStart(endExclusive) {
+    requireNonNull(endExclusive, 'endExclusive');
+    requireInstance(endExclusive, LocalDate, 'endExclusive');
+    return LocalDateRange.of(LocalDate.MIN, endExclusive);
+  };
+
+  LocalDateRange.ofUnboundedEnd = function ofUnboundedEnd(startInclusive) {
+    return LocalDateRange.of(startInclusive, 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 = Period.parse(text.slice(0, i));
+          var end = LocalDate.parse(text.slice(i + 1, text.length));
+          return LocalDateRange.of(end.minus(duration), end);
+        } else {
+          var start = LocalDate.parse(text.slice(0, i));
+
+          if (i + 1 < text.length) {
+            var c = text[i + 1];
+
+            if (c === 'P' || c === 'p') {
+              var _duration = Period.parse(text.slice(i + 1, text.length));
+
+              return LocalDateRange.of(start, start.plus(_duration));
+            }
+          }
+
+          var _end = LocalDate.parse(text.slice(i + 1, text.length));
+
+          return LocalDateRange.of(start, _end);
+        }
+      }
+    }
+
+    throw new DateTimeParseException('LocalDateRange cannot be parsed, no forward slash found', text, 0);
+  };
+
+  function LocalDateRange(startInclusive, endExclusive) {
+    requireNonNull(startInclusive, 'startInclusive');
+    requireNonNull(endExclusive, 'endExclusive');
+    requireInstance(startInclusive, LocalDate, 'startInclusive');
+    requireInstance(endExclusive, LocalDate, 'endExclusive');
+
+    if (endExclusive.isBefore(startInclusive)) {
+      throw new DateTimeException('End date must be on or after start date');
+    }
+
+    if (startInclusive.equals(MAXM1)) {
+      throw new DateTimeException('Range must not start at LocalDate.MAX.minusDays(1)');
+    }
+
+    if (endExclusive.equals(MINP1)) {
+      throw new DateTimeException('Range must not end at LocalDate.MIN.plusDays(1)');
+    }
+
+    if (endExclusive.equals(LocalDate.MIN) || startInclusive.equals(LocalDate.MAX)) {
+      throw new 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 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(LocalDate.MIN);
+  };
+
+  _proto.isUnboundedEnd = function isUnboundedEnd() {
+    return this._end.equals(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 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 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 LocalDate) {
+      return this._isAfterLocalDate(localDateOrLocalDateRange);
+    }
+
+    if (localDateOrLocalDateRange instanceof LocalDateRange) {
+      return this._isAfterLocalDateRange(localDateOrLocalDateRange);
+    }
+
+    throw new IllegalArgumentException("localDateOrLocalDateRange must be an instance of LocalDate or LocalDateRange but is " + localDateOrLocalDateRange.constructor.name);
+  };
+
+  _proto.isBefore = function isBefore(localDateOrLocalDateRange) {
+    if (localDateOrLocalDateRange instanceof LocalDate) {
+      return this._isBeforeLocalDate(localDateOrLocalDateRange);
+    }
+
+    if (localDateOrLocalDateRange instanceof LocalDateRange) {
+      return this._isBeforeLocalDateRange(localDateOrLocalDateRange);
+    }
+
+    throw new 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.NaN;
+    }
+
+    return this._end.toEpochDay() - this._start.toEpochDay();
+  };
+
+  _proto.toPeriod = function toPeriod() {
+    if (this.isUnboundedStart() || this.isUnboundedEnd()) {
+      throw new ArithmeticException('Unbounded range cannot be converted to a Period');
+    }
+
+    return 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(LocalDate.MIN, LocalDate.MAX);
+}
+
+var MathUtil$3 = _.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 ZoneId) {
+      return OffsetDate._nowZoneId(zoneIdOrClock);
+    } else {
+      return OffsetDate._nowClock(zoneIdOrClock);
+    }
+  };
+
+  OffsetDate._now0 = function _now0() {
+    return OffsetDate.now(Clock.systemDefaultZone());
+  };
+
+  OffsetDate._nowZoneId = function _nowZoneId(zone) {
+    return OffsetDate.now(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 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 = 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 = 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 = LocalDate.from(temporal);
+      var offset = ZoneOffset.from(temporal);
+      return new OffsetDate(date, offset);
+    } catch (ex) {
+      throw new DateTimeException("Unable to obtain OffsetDate from TemporalAccessor: " + temporal.constructor.name, ex);
+    }
+  };
+
+  OffsetDate.parse = function parse(text, formatter) {
+    if (formatter === void 0) {
+      formatter = 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 TemporalField) {
+      return this._isSupportedField(fieldOrUnit);
+    }
+
+    if (fieldOrUnit instanceof TemporalUnit) {
+      return this._isSupportedUnit(fieldOrUnit);
+    }
+
+    if (fieldOrUnit == null) {
+      return false;
+    }
+
+    throw new IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+  };
+
+  _proto._isSupportedField = function _isSupportedField(field) {
+    if (field instanceof ChronoField) {
+      return field.isDateBased() || field === ChronoField.OFFSET_SECONDS;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+    if (unit instanceof ChronoUnit) {
+      return unit.isDateBased();
+    }
+
+    return unit != null && unit.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+
+    if (field instanceof ChronoField) {
+      if (field === 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, TemporalField, 'field');
+    return this.range(field).checkValidIntValue(this.getLong(field), field);
+  };
+
+  _proto.getLong = function getLong(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+
+    if (field instanceof ChronoField) {
+      if (field === 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 LocalDate) {
+      return this._with(adjuster, this._offset);
+    } else if (adjuster instanceof 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, TemporalField, 'field');
+
+    if (field instanceof ChronoField) {
+      if (field === ChronoField.OFFSET_SECONDS) {
+        var f = field;
+        return this._with(this._date, 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 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, TemporalQuery, 'query');
+
+    if (_query === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    } else if (_query === TemporalQueries.precision()) {
+      return ChronoUnit.DAYS;
+    } else if (_query === TemporalQueries.offset() || _query === TemporalQueries.zone()) {
+      return this.offset();
+    }
+
+    return _Temporal.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    return temporal.with(ChronoField.OFFSET_SECONDS, this.offset().totalSeconds()).with(ChronoField.EPOCH_DAY, this.toLocalDate().toEpochDay());
+  };
+
+  _proto.until = function until(endExclusive, unit) {
+    var end = OffsetDate.from(endExclusive);
+
+    if (unit instanceof 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 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;
+}(Temporal);
+function _init$3() {
+  OffsetDate.MIN = OffsetDate.of(LocalDate.MIN, ZoneOffset.MAX);
+  OffsetDate.MAX = OffsetDate.of(LocalDate.MAX, 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;
+  }(TemporalQuery);
+
+  ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+  return new ExtendedTemporalQuery(name);
+}
+
+var MathUtil$2 = _.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 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 DateTimeException("Invalid value for Quarter: " + quarterOfYear);
+    }
+  };
+
+  Quarter.ofMonth = function ofMonth(monthOfYear) {
+    requireNonNull(monthOfYear, 'monthOfYear');
+    ChronoField.MONTH_OF_YEAR.range().checkValidValue(monthOfYear, 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 Month) {
+      var month = temporal;
+      return Quarter.of(MathUtil$2.intDiv(month.ordinal(), 3) + 1);
+    }
+
+    try {
+      var qoy = MathUtil$2.safeToInt(temporal.getLong(IsoFields.QUARTER_OF_YEAR));
+      return Quarter.of(qoy);
+    } catch (ex) {
+      throw new 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 IllegalArgumentException('Pattern using (localized) text not implemented yet!');
+  };
+
+  _proto.isSupported = function isSupported(field) {
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return true;
+    } else if (field instanceof ChronoField) {
+      return false;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return field.range();
+    } else if (field instanceof ChronoField) {
+      throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+    }
+
+    return _TemporalAccessor.prototype.range.call(this, field);
+  };
+
+  _proto.get = function get(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+    return this.range(field).checkValidIntValue(this.getLong(field), field);
+  };
+
+  _proto.getLong = function getLong(field) {
+    requireNonNull(field, 'field');
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return this.value();
+    } else if (field instanceof ChronoField) {
+      throw new 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 Month.JANUARY;
+
+      case Quarter.Q2:
+        return Month.APRIL;
+
+      case Quarter.Q3:
+        return Month.JULY;
+
+      case Quarter.Q4:
+        return Month.OCTOBER;
+
+      default:
+        throw new IllegalStateException('Unreachable');
+    }
+  };
+
+  _proto.query = function query(_query) {
+    requireNonNull(_query, 'query');
+    requireInstance(_query, TemporalQuery, 'query');
+
+    if (_query === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    } else if (_query === TemporalQueries.precision()) {
+      return IsoFields.QUARTER_YEARS;
+    }
+
+    return _TemporalAccessor.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    requireNonNull(temporal, 'temporal');
+    return temporal.with(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;
+}(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;
+  }(TemporalQuery);
+
+  ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+  return new ExtendedTemporalQuery(name);
+}
+
+var MathUtil$1 = _.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 ZoneId) {
+      return YearQuarter._nowZoneId(zoneIdOrClock);
+    } else {
+      return YearQuarter._nowClock(zoneIdOrClock);
+    }
+  };
+
+  YearQuarter._now0 = function _now0() {
+    return YearQuarter.now(Clock.systemDefaultZone());
+  };
+
+  YearQuarter._nowZoneId = function _nowZoneId(zone) {
+    return YearQuarter.now(Clock.system(zone));
+  };
+
+  YearQuarter._nowClock = function _nowClock(clock) {
+    var now = LocalDate.now(clock);
+    return YearQuarter.of(now.getYear(), Quarter.from(now.getMonth()));
+  };
+
+  YearQuarter.of = function of(year, quarter) {
+    if (year instanceof Year && quarter instanceof Quarter) {
+      return YearQuarter._ofYearQuarter(year, quarter);
+    }
+
+    if (year instanceof 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 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) {
+    ChronoField.YEAR.checkValidValue(year);
+    requireNonNull(quarter, 'quarter');
+    return new YearQuarter(year, quarter);
+  };
+
+  YearQuarter._ofIntInt = function _ofIntInt(year, quarter) {
+    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(ChronoField.YEAR));
+      var qoy = MathUtil$1.safeToInt(temporal.getLong(IsoFields.QUARTER_OF_YEAR));
+      return YearQuarter.of(year, qoy);
+    } catch (ex) {
+      throw new 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, 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 TemporalField) {
+      return this._isSupportedField(fieldOrUnit);
+    }
+
+    if (fieldOrUnit instanceof TemporalUnit) {
+      return this._isSupportedUnit(fieldOrUnit);
+    }
+
+    if (fieldOrUnit == null) {
+      return false;
+    }
+
+    throw new IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+  };
+
+  _proto._isSupportedField = function _isSupportedField(field) {
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return true;
+    } else if (field instanceof ChronoField) {
+      return field === ChronoField.YEAR || field === ChronoField.YEAR_OF_ERA || field === ChronoField.ERA;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+    if (unit === IsoFields.QUARTER_YEARS) {
+      return true;
+    } else if (unit instanceof ChronoUnit) {
+      return unit === ChronoUnit.YEARS || unit === ChronoUnit.DECADES || unit === ChronoUnit.CENTURIES || unit === ChronoUnit.MILLENNIA || unit === ChronoUnit.ERAS;
+    }
+
+    return unit != null && unit.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return IsoFields.QUARTER_OF_YEAR.range();
+    }
+
+    if (field === ChronoField.YEAR_OF_ERA) {
+      return this.year() <= 0 ? ValueRange.of(1, Year.MAX_VALUE + 1) : ValueRange.of(1, Year.MAX_VALUE);
+    }
+
+    return _Temporal.prototype.range.call(this, field);
+  };
+
+  _proto.get = function get(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+    return this.range(field).checkValidIntValue(this.getLong(field), field);
+  };
+
+  _proto.getLong = function getLong(field) {
+    requireNonNull(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return this._quarter.value();
+    } else if (field instanceof ChronoField) {
+      switch (field) {
+        case ChronoField.YEAR_OF_ERA:
+          return this._year < 1 ? 1 - this._year : this._year;
+
+        case ChronoField.YEAR:
+          return this._year;
+
+        case ChronoField.ERA:
+          return this._year < 1 ? 0 : 1;
+
+        default:
+          throw new 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 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, TemporalField, 'field');
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      return this.withQuarter(IsoFields.QUARTER_OF_YEAR.range().checkValidIntValue(newValue, IsoFields.QUARTER_OF_YEAR));
+    } else if (field instanceof ChronoField) {
+      field.checkValidValue(newValue);
+
+      switch (field) {
+        case ChronoField.YEAR_OF_ERA:
+          return this.withYear(this._year < 1 ? 1 - newValue : newValue);
+
+        case ChronoField.YEAR:
+          return this.withYear(newValue);
+
+        case ChronoField.ERA:
+          return this.getLong(ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year);
+
+        default:
+          throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
+    }
+
+    return field.adjustInto(this, newValue);
+  };
+
+  _proto.withYear = function withYear(year) {
+    ChronoField.YEAR.checkValidValue(year);
+    return this._with(year, this._quarter);
+  };
+
+  _proto.withQuarter = function withQuarter(quarter) {
+    IsoFields.QUARTER_OF_YEAR.range().checkValidValue(quarter, IsoFields.QUARTER_OF_YEAR);
+    return this._with(this._year, Quarter.of(quarter));
+  };
+
+  _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
+    if (unit === IsoFields.QUARTER_YEARS) {
+      return this.plusQuarters(amountToAdd);
+    } else if (unit instanceof ChronoUnit) {
+      switch (unit) {
+        case ChronoUnit.YEARS:
+          return this.plusYears(amountToAdd);
+
+        case ChronoUnit.DECADES:
+          return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 10));
+
+        case ChronoUnit.CENTURIES:
+          return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 100));
+
+        case ChronoUnit.MILLENNIA:
+          return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 1000));
+
+        case ChronoUnit.ERAS:
+          return this.with(ChronoField.ERA, MathUtil$1.safeAdd(this.getLong(ChronoField.ERA), amountToAdd));
+
+        default:
+          throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+      }
+    }
+
+    return unit.addTo(this, amountToAdd);
+  };
+
+  _proto.plusYears = function plusYears(yearsToAdd) {
+    if (yearsToAdd === 0) {
+      return this;
+    }
+
+    var newYear = 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 = 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 === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    } else if (_query === TemporalQueries.precision()) {
+      return IsoFields.QUARTER_YEARS;
+    }
+
+    return _Temporal.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    var newProlepticQuarter = this._prolepticQuarter();
+
+    var oldProlepticQuarter = temporal.get(ChronoField.YEAR) * 4 + (temporal.get(IsoFields.QUARTER_OF_YEAR) - 1);
+    return temporal.plus(newProlepticQuarter - oldProlepticQuarter, IsoFields.QUARTER_YEARS);
+  };
+
+  _proto.until = function until(endExclusive, unit) {
+    requireNonNull(endExclusive, 'endExclusive');
+    requireNonNull(unit, 'unit');
+    requireInstance(endExclusive, Temporal, 'endExclusive');
+    requireInstance(unit, TemporalUnit, 'unit');
+    var end = YearQuarter.from(endExclusive);
+
+    var quartersUntil = end._prolepticQuarter() - this._prolepticQuarter();
+
+    if (unit === IsoFields.QUARTER_YEARS) {
+      return quartersUntil;
+    } else if (unit instanceof ChronoUnit) {
+      switch (unit) {
+        case ChronoUnit.YEARS:
+          return MathUtil$1.intDiv(quartersUntil, 4);
+
+        case ChronoUnit.DECADES:
+          return MathUtil$1.intDiv(quartersUntil, 40);
+
+        case ChronoUnit.CENTURIES:
+          return MathUtil$1.intDiv(quartersUntil, 400);
+
+        case ChronoUnit.MILLENNIA:
+          return MathUtil$1.intDiv(quartersUntil, 4000);
+
+        case ChronoUnit.ERAS:
+          return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
+
+        default:
+          throw new 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) {
+    ValueRange.of(1, this.lengthOfQuarter()).checkValidValue(dayOfQuarter, IsoFields.DAY_OF_QUARTER);
+    var leap = Year.isLeap(this._year);
+
+    var month = this._quarter.firstMonth();
+
+    while (dayOfQuarter > month.length(leap)) {
+      dayOfQuarter -= month.length(leap);
+      month = month.plus(1);
+    }
+
+    return LocalDate.of(this._year, month, dayOfQuarter);
+  };
+
+  _proto.atEndOfQuarter = function atEndOfQuarter() {
+    var month = this._quarter.firstMonth().plus(2);
+
+    return 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;
+}(Temporal);
+function _init$1() {
+  YearQuarter.PARSER = new DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral('-').appendLiteral('Q').appendValue(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;
+  }(TemporalQuery);
+
+  ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
+  return new ExtendedTemporalQuery(name);
+}
+
+var MathUtil = _.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 ZoneId) {
+          return YearWeek._nowZoneId(zoneIdOrClock);
+        }
+
+        if (zoneIdOrClock instanceof Clock) {
+          return YearWeek._nowClock(zoneIdOrClock);
+        }
+
+        throw new IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
+
+      default:
+        throw new IllegalArgumentException("Invalid number of arguments: " + arguments.length);
+    }
+  };
+
+  YearWeek._now0 = function _now0() {
+    return YearWeek.now(Clock.systemDefaultZone());
+  };
+
+  YearWeek._nowZoneId = function _nowZoneId(zone) {
+    return YearWeek.now(Clock.system(zone));
+  };
+
+  YearWeek._nowClock = function _nowClock(clock) {
+    var now = LocalDate.now(clock);
+    return YearWeek.of(now.get(IsoFields.WEEK_BASED_YEAR), now.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+  };
+
+  YearWeek.of = function of(year, week) {
+    MathUtil.verifyInt(week);
+
+    if (year instanceof 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) {
+    IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, IsoFields.WEEK_BASED_YEAR);
+    IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidValue(week, IsoFields.WEEK_OF_WEEK_BASED_YEAR);
+
+    if (week === 53 && YearWeek._weekRange(weekBasedYear) < 53) {
+      week = 1;
+      weekBasedYear++;
+      IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, IsoFields.WEEK_BASED_YEAR);
+    }
+
+    return new YearWeek(weekBasedYear, week);
+  };
+
+  YearWeek._weekRange = function _weekRange(weekBasedYear) {
+    var date = LocalDate.of(weekBasedYear, 1, 1);
+
+    if (date.dayOfWeek() === DayOfWeek.THURSDAY || date.dayOfWeek() === 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(IsoFields.WEEK_BASED_YEAR));
+      var week = MathUtil.safeToInt(temporal.getLong(IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+      return YearWeek.of(year, week);
+    } catch (ex) {
+      throw new 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', 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 TemporalField) {
+      return this._isSupportedField(fieldOrUnit);
+    }
+
+    if (fieldOrUnit instanceof TemporalUnit) {
+      return this._isSupportedUnit(fieldOrUnit);
+    }
+
+    if (fieldOrUnit == null) {
+      return false;
+    }
+
+    throw new IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
+  };
+
+  _proto._isSupportedField = function _isSupportedField(field) {
+    if (field === IsoFields.WEEK_OF_WEEK_BASED_YEAR || field === IsoFields.WEEK_BASED_YEAR) {
+      return true;
+    } else if (field instanceof ChronoField) {
+      return false;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto._isSupportedUnit = function _isSupportedUnit(unit) {
+    if (unit === ChronoUnit.WEEKS || unit === IsoFields.WEEK_BASED_YEARS) {
+      return true;
+    } else if (unit instanceof ChronoUnit) {
+      return false;
+    }
+
+    return unit != null && unit.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+
+    if (field === IsoFields.WEEK_BASED_YEAR) {
+      return IsoFields.WEEK_BASED_YEAR.range();
+    }
+
+    if (field === IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+      return 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 === IsoFields.WEEK_BASED_YEAR) {
+      return this._year;
+    }
+
+    if (field === IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+      return this._week;
+    }
+
+    if (field instanceof ChronoField) {
+      throw new 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 === IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
+      return this.withWeek(IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidIntValue(newValue, IsoFields.WEEK_OF_WEEK_BASED_YEAR));
+    } else if (field === IsoFields.WEEK_BASED_YEAR) {
+      return this.withYear(IsoFields.WEEK_BASED_YEAR.range().checkValidIntValue(newValue, IsoFields.WEEK_BASED_YEAR));
+    } else if (field instanceof ChronoField) {
+      throw new 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 === ChronoUnit.WEEKS) {
+      return this.plusWeeks(amountToAdd);
+    } else if (unit === IsoFields.WEEK_BASED_YEARS) {
+      return this.plusYears(amountToAdd);
+    } else if (unit instanceof ChronoUnit) {
+      throw new 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(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(DayOfWeek.MONDAY).minusWeeks(weeksToSubtract);
+    return YearWeek.from(mondayOfWeek);
+  };
+
+  _proto.query = function query(_query) {
+    requireNonNull(_query, 'query');
+    requireInstance(_query, TemporalQuery, 'query');
+
+    if (_query === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    }
+
+    return _Temporal.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    return temporal.with(IsoFields.WEEK_BASED_YEAR, this._year).with(IsoFields.WEEK_OF_WEEK_BASED_YEAR, this._week);
+  };
+
+  _proto.until = function until(endExclusive, unit) {
+    var end = YearWeek.from(endExclusive);
+
+    if (unit === ChronoUnit.WEEKS) {
+      return this._daysUntil(end);
+    } else if (unit === IsoFields.WEEK_BASED_YEARS) {
+      return this._yearsUntil(end);
+    } else if (unit instanceof ChronoUnit) {
+      throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+    }
+
+    return unit.between(this, end);
+  };
+
+  _proto._daysUntil = function _daysUntil(end) {
+    var startDate = this.atDay(DayOfWeek.MONDAY);
+    var endDate = end.atDay(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 = LocalDate.of(this._year, 1, 4).dayOfWeek().value() + 3;
+    var dayOfYear = this._week * 7 + dayOfWeek.value() - correction;
+    var maxDaysOfYear = Year.isLeap(this._year) ? 366 : 365;
+
+    if (dayOfYear > maxDaysOfYear) {
+      return LocalDate.ofYearDay(this._year + 1, dayOfYear - maxDaysOfYear);
+    }
+
+    if (dayOfYear > 0) {
+      return LocalDate.ofYearDay(this._year, dayOfYear);
+    } else {
+      var daysOfPreviousYear = Year.isLeap(this._year - 1) ? 366 : 365;
+      return 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;
+}(Temporal);
+function _init() {
+  YearWeek.PARSER = new DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral('-W').appendValue(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;
+  }(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)
@@ -674,6 +2638,11 @@ function init() {
   }
 
   isInit = true;
+  _init$7();
+  _init$6();
+  _init$5();
+  _init$4();
+  _init$3();
   _init$2();
   _init$1();
   _init();
@@ -693,5 +2662,5 @@ function plug () {}
  */
 use(plug);
 
-export { DayOfMonth, DayOfYear, Interval };
+export { DayOfMonth, DayOfYear, Interval, LocalDateRange, OffsetDate, Quarter, YearQuarter, YearWeek };
 //# sourceMappingURL=js-joda-extra.esm.js.map