@js-joda/extra 0.10.2 → 0.11.0

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

@@ -1,23 +1,20 @@
-//! @version @js-joda/extra - 0.10.2
+//! @version @js-joda/extra - 0.11.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, ArithmeticException, Period, TemporalField, TemporalUnit, ChronoUnit, ZoneOffset, OffsetDateTime, Temporal, DateTimeFormatter, IsoFields, IllegalStateException, ValueRange, DateTimeFormatterBuilder, SignStyle, DayOfWeek, use } from '@js-joda/core';
+import { NullPointerException, IllegalArgumentException, _, ZoneId, Clock, LocalDate, DateTimeException, ChronoField, UnsupportedTemporalTypeException, TemporalQueries, IsoChronology, Month, MonthDay, TemporalAccessor, TemporalQuery, Year, Duration, Instant, ZonedDateTime, DateTimeParseException, Period, ArithmeticException, ZoneOffset, DateTimeFormatter, TemporalField, TemporalUnit, ChronoUnit, OffsetDateTime, Temporal, IsoFields, IllegalStateException, ParsePosition, TemporalAdjuster, ValueRange, DateTimeFormatterBuilder, SignStyle, DayOfWeek, use } from '@js-joda/core';
 
 function _inheritsLoose(subClass, superClass) {
   subClass.prototype = Object.create(superClass.prototype);
   subClass.prototype.constructor = subClass;
-
   _setPrototypeOf(subClass, superClass);
 }
-
 function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
     o.__proto__ = p;
     return o;
   };
-
   return _setPrototypeOf(o, p);
 }
 
@@ -38,57 +35,45 @@ function requireNonNull(value, parameterName) {
   if (value == null) {
     throw new NullPointerException(parameterName + " must not be null");
   }
-
   return value;
 }
 function requireInstance(value, _class, parameterName) {
   if (!(value instanceof _class)) {
     throw new IllegalArgumentException(parameterName + " must be an instance of " + (_class.name ? _class.name : _class) + (value && value.constructor && value.constructor.name ? ", but is " + value.constructor.name : ''));
   }
-
   return value;
 }
 
-var MathUtil$5 = _.MathUtil;
+var MathUtil$6 = _.MathUtil;
 var DayOfMonth = function (_TemporalAccessor) {
   _inheritsLoose(DayOfMonth, _TemporalAccessor);
-
   DayOfMonth.now = function now(zoneIdOrClock) {
     switch (arguments.length) {
       case 0:
         return DayOfMonth._now0();
-
       case 1:
         requireNonNull(zoneIdOrClock, 'clockOrZone');
-
         if (zoneIdOrClock instanceof ZoneId) {
           return DayOfMonth._nowZoneId(zoneIdOrClock);
         }
-
         if (zoneIdOrClock instanceof Clock) {
           return DayOfMonth._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);
     }
   };
-
   DayOfMonth._now0 = function _now0() {
     return this.now(Clock.systemDefaultZone());
   };
-
   DayOfMonth._nowZoneId = function _nowZoneId(zone) {
     return this.now(Clock.system(zone));
   };
-
   DayOfMonth._nowClock = function _nowClock(clock) {
     var now = LocalDate.now(clock);
     return DayOfMonth.of(now.dayOfMonth());
   };
-
   DayOfMonth.of = function of(dayOfMonth) {
     if (1 <= dayOfMonth && dayOfMonth <= 31) {
       return DayOfMonth.VALUES[dayOfMonth - 1];
@@ -96,180 +81,138 @@ var DayOfMonth = function (_TemporalAccessor) {
       throw new DateTimeException("Invalid value for DayOfMonth: " + dayOfMonth);
     }
   };
-
   DayOfMonth.from = function from(temporal) {
     if (temporal instanceof DayOfMonth) {
       return temporal;
     }
-
     requireNonNull(temporal, 'temporal');
-
     try {
       return DayOfMonth.of(temporal.get(ChronoField.DAY_OF_MONTH));
     } catch (ex) {
       throw new DateTimeException("Unable to obtain DayOfMonth from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
     }
   };
-
   function DayOfMonth(dayOfMonth) {
     var _this;
-
     _this = _TemporalAccessor.call(this) || this;
-    _this._day = MathUtil$5.safeToInt(dayOfMonth);
+    _this._day = MathUtil$6.safeToInt(dayOfMonth);
     return _this;
   }
-
   var _proto = DayOfMonth.prototype;
-
   _proto.value = function value() {
     return this._day;
   };
-
   _proto.isSupported = function isSupported(field) {
     if (field instanceof ChronoField) {
       return field === ChronoField.DAY_OF_MONTH;
     }
-
     return field != null && field.isSupportedBy(this);
   };
-
   _proto.range = function range(field) {
     requireNonNull(field, 'field');
-
     if (field === ChronoField.DAY_OF_MONTH) {
       return field.range();
     }
-
     return _TemporalAccessor.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 === ChronoField.DAY_OF_MONTH) {
       return this._day;
     } else if (field instanceof ChronoField) {
       throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
     }
-
     return field.getFrom(this);
   };
-
   _proto.isValidYearMonth = function isValidYearMonth(yearMonth) {
     return yearMonth != null && yearMonth.isValidDay(this._day);
   };
-
   _proto.query = function query(_query) {
     requireNonNull(_query, 'query');
     requireInstance(_query, TemporalQuery, 'query');
-
     if (_query === TemporalQueries.chronology()) {
       return IsoChronology.INSTANCE;
     }
-
     return _TemporalAccessor.prototype.query.call(this, _query);
   };
-
   _proto.adjustInto = function adjustInto(temporal) {
     requireNonNull(temporal, 'temporal');
     return temporal.with(ChronoField.DAY_OF_MONTH, this._day);
   };
-
   _proto.atMonth = function atMonth(month) {
     requireNonNull(month, 'month');
-
     if (month instanceof Month) {
       return MonthDay.of(month, Math.min(this._day, month.maxLength()));
     } else {
       return MonthDay.of(month, Math.min(this._day, Month.of(month).maxLength()));
     }
   };
-
   _proto.atYearMonth = function atYearMonth(yearMonth) {
     requireNonNull(yearMonth, 'yearMonth');
     return yearMonth.atDay(Math.min(this._day, yearMonth.lengthOfMonth()));
   };
-
   _proto.compareTo = function compareTo(other) {
     requireNonNull(other, 'other');
     requireInstance(other, DayOfMonth, 'other');
     return this._day - other._day;
   };
-
   _proto.equals = function equals(obj) {
     if (this === obj) {
       return true;
     }
-
     if (obj instanceof DayOfMonth) {
       return this._day === obj._day;
     }
-
     return false;
   };
-
   _proto.hashCode = function hashCode() {
     return this._day;
   };
-
   _proto.toString = function toString() {
     return "DayOfMonth:" + this._day;
   };
-
   return DayOfMonth;
 }(TemporalAccessor);
-function _init$7() {
+function _init$8() {
   DayOfMonth.VALUES = new Array(31);
-
   for (var i = 0; i < 31; i++) {
     DayOfMonth.VALUES[i] = new DayOfMonth(i + 1);
   }
 }
 
-var MathUtil$4 = _.MathUtil;
+var MathUtil$5 = _.MathUtil;
 var DayOfYear = function (_TemporalAccessor) {
   _inheritsLoose(DayOfYear, _TemporalAccessor);
-
   DayOfYear.now = function now(zoneIdOrClock) {
     switch (arguments.length) {
       case 0:
         return DayOfYear._now0();
-
       case 1:
         requireNonNull(zoneIdOrClock, 'clockOrZone');
-
         if (zoneIdOrClock instanceof ZoneId) {
           return DayOfYear._nowZoneId(zoneIdOrClock);
         }
-
         if (zoneIdOrClock instanceof Clock) {
           return DayOfYear._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);
     }
   };
-
   DayOfYear._now0 = function _now0() {
     return DayOfYear.now(Clock.systemDefaultZone());
   };
-
   DayOfYear._nowZoneId = function _nowZoneId(zone) {
     return DayOfYear.now(Clock.system(zone));
   };
-
   DayOfYear._nowClock = function _nowClock(clock) {
     var now = LocalDate.now(clock);
     return DayOfYear.of(now.dayOfYear());
   };
-
   DayOfYear.of = function of(dayOfYear) {
     if (1 <= dayOfYear && dayOfYear <= 366) {
       return DayOfYear.VALUES[dayOfYear - 1];
@@ -277,131 +220,100 @@ var DayOfYear = function (_TemporalAccessor) {
       throw new DateTimeException("Invalid value for DayOfYear: " + dayOfYear);
     }
   };
-
   DayOfYear.from = function from(temporal) {
     requireNonNull(temporal, 'temporal');
     requireInstance(temporal, TemporalAccessor, 'temporal');
-
     if (temporal instanceof DayOfYear) {
       return temporal;
     }
-
     try {
       return DayOfYear.of(temporal.get(ChronoField.DAY_OF_YEAR));
     } catch (ex) {
       throw new DateTimeException("Unable to obtain DayOfYear from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
     }
   };
-
   function DayOfYear(dayOfYear) {
     var _this;
-
     _this = _TemporalAccessor.call(this) || this;
-    _this._day = MathUtil$4.safeToInt(dayOfYear);
+    _this._day = MathUtil$5.safeToInt(dayOfYear);
     return _this;
   }
-
   var _proto = DayOfYear.prototype;
-
   _proto.value = function value() {
     return this._day;
   };
-
   _proto.isSupported = function isSupported(field) {
     if (field instanceof ChronoField) {
       return field === ChronoField.DAY_OF_YEAR;
     }
-
     return field != null && field.isSupportedBy(this);
   };
-
   _proto.range = function range(field) {
     requireNonNull(field, 'field');
-
     if (field === ChronoField.DAY_OF_YEAR) {
       return field.range();
     }
-
     return _TemporalAccessor.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 === ChronoField.DAY_OF_YEAR) {
       return this._day;
     } else if (field instanceof ChronoField) {
       throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
     }
-
     return field.getFrom(this);
   };
-
   _proto.isValidYear = function isValidYear(year) {
     return this._day < 366 || Year.isLeap(year);
   };
-
   _proto.query = function query(_query) {
     requireNonNull(_query, 'query');
     requireInstance(_query, TemporalQuery, 'query');
-
     if (_query === TemporalQueries.chronology()) {
       return IsoChronology.INSTANCE;
     }
-
     return _TemporalAccessor.prototype.query.call(this, _query);
   };
-
   _proto.adjustInto = function adjustInto(temporal) {
     requireNonNull(temporal, 'temporal');
     return temporal.with(ChronoField.DAY_OF_YEAR, this._day);
   };
-
   _proto.atYear = function atYear(year) {
     requireNonNull(year, 'year');
-
     if (year instanceof Year) {
       return year.atDay(this._day);
     } else {
       return LocalDate.ofYearDay(year, this._day);
     }
   };
-
   _proto.compareTo = function compareTo(other) {
     requireNonNull(other, 'other');
     requireInstance(other, DayOfYear, 'other');
     return this._day - other._day;
   };
-
   _proto.equals = function equals(obj) {
     if (this === obj) {
       return true;
     }
-
     if (obj instanceof DayOfYear) {
       return this._day === obj._day;
     }
-
     return false;
   };
-
   _proto.hashCode = function hashCode() {
     return this._day;
   };
-
   _proto.toString = function toString() {
     return "DayOfYear:" + this._day;
   };
-
   return DayOfYear;
 }(TemporalAccessor);
-function _init$6() {
+function _init$7() {
   DayOfYear.VALUES = new Array(366);
-
   for (var i = 0; i < 366; i++) {
     DayOfYear.VALUES[i] = new DayOfYear(i + 1);
   }
@@ -420,148 +332,113 @@ var Interval = function () {
       return Interval.ofInstantInstant(startInstant, endInstantOrDuration);
     }
   };
-
   Interval.ofInstantInstant = function ofInstantInstant(startInclusive, endExclusive) {
     requireNonNull(startInclusive, 'startInclusive');
     requireNonNull(endExclusive, 'endExclusive');
     requireInstance(startInclusive, Instant, 'startInclusive');
     requireInstance(endExclusive, Instant, 'endExclusive');
-
     if (endExclusive.isBefore(startInclusive)) {
       throw new DateTimeException('End instant must on or after start instant');
     }
-
     return new Interval(startInclusive, endExclusive);
   };
-
   Interval.ofInstantDuration = function ofInstantDuration(startInclusive, duration) {
     requireNonNull(startInclusive, 'startInclusive');
     requireNonNull(duration, 'duration');
     requireInstance(startInclusive, Instant, 'startInclusive');
     requireInstance(duration, Duration, 'duration');
-
     if (duration.isNegative()) {
       throw new DateTimeException('Duration must not be zero or negative');
     }
-
     return new Interval(startInclusive, startInclusive.plus(duration));
   };
-
   Interval.parse = function parse(text) {
     requireNonNull(text, 'text');
-
     if (!(typeof text === 'string')) {
       throw new IllegalArgumentException("text must be a string, but is " + text.constructor.name);
     }
-
     for (var i = 0; i < text.length; i += 1) {
       if (text.charAt(i) === '/') {
         var firstChar = text.charAt(0);
-
         if (firstChar === 'P' || firstChar === 'p') {
           var duration = Duration.parse(text.substring(0, i));
           var end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
           return Interval.of(end.minus(duration), end);
         } else {
           var start = ZonedDateTime.parse(text.substring(0, i)).toInstant();
-
           if (i + 1 < text.length) {
             var c = text.charAt(i + 1);
-
             if (c === 'P' || c === 'p') {
               var _duration = Duration.parse(text.substring(i + 1, text.length));
-
               return Interval.of(start, start.plus(_duration));
             }
           }
-
           var _end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
-
           return Interval.of(start, _end);
         }
       }
     }
-
     throw new DateTimeParseException('Interval cannot be parsed, no forward slash found', text, 0);
   };
-
   function Interval(startInclusive, endExclusive) {
     this._start = startInclusive;
     this._end = endExclusive;
   }
-
   var _proto = Interval.prototype;
-
   _proto.start = function start() {
     return this._start;
   };
-
   _proto.end = function end() {
     return this._end;
   };
-
   _proto.isEmpty = function isEmpty() {
     return this._start.equals(this._end);
   };
-
   _proto.isUnboundedStart = function isUnboundedStart() {
     return this._start.equals(Instant.MIN);
   };
-
   _proto.isUnboundedEnd = function isUnboundedEnd() {
     return this._end.equals(Instant.MAX);
   };
-
   _proto.withStart = function withStart(start) {
     return Interval.of(start, this._end);
   };
-
   _proto.withEnd = function withEnd(end) {
     return Interval.of(this._start, end);
   };
-
   _proto.contains = function contains(instant) {
     requireNonNull(instant, 'instant');
     requireInstance(instant, Instant, 'instant');
     return this._start.compareTo(instant) <= 0 && (instant.compareTo(this._end) < 0 || this.isUnboundedEnd());
   };
-
   _proto.encloses = function encloses(other) {
     requireNonNull(other, 'other');
     requireInstance(other, Interval, 'other');
     return this._start.compareTo(other.start()) <= 0 && other.end().compareTo(this._end) <= 0;
   };
-
   _proto.abuts = function abuts(other) {
     requireNonNull(other, 'other');
     requireInstance(other, Interval, 'other');
     return !this._end.equals(other.start()) !== !this._start.equals(other.end());
   };
-
   _proto.isConnected = function isConnected(other) {
     requireNonNull(other, 'other');
     requireInstance(other, Interval, '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');
     requireInstance(other, Interval, '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');
     requireInstance(other, Interval, 'other');
-
     if (this.isConnected(other) === false) {
       throw new DateTimeException("Intervals 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) {
@@ -572,19 +449,14 @@ var Interval = function () {
       return Interval.of(newStart, newEnd);
     }
   };
-
   _proto.union = function union(other) {
     requireNonNull(other, 'other');
     requireInstance(other, Interval, 'other');
-
     if (this.isConnected(other) === false) {
       throw new DateTimeException("Intervals 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) {
@@ -595,20 +467,15 @@ var Interval = function () {
       return Interval.of(newStart, newEnd);
     }
   };
-
   _proto.span = function span(other) {
     requireNonNull(other, 'other');
     requireInstance(other, Interval, '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 Interval.of(newStart, newEnd);
   };
-
   _proto.isAfter = function isAfter(instantOrInterval) {
     if (instantOrInterval instanceof Instant) {
       return this.isAfterInstant(instantOrInterval);
@@ -616,7 +483,6 @@ var Interval = function () {
       return this.isAfterInterval(instantOrInterval);
     }
   };
-
   _proto.isBefore = function isBefore(instantOrInterval) {
     if (instantOrInterval instanceof Instant) {
       return this.isBeforeInstant(instantOrInterval);
@@ -624,50 +490,39 @@ var Interval = function () {
       return this.isBeforeInterval(instantOrInterval);
     }
   };
-
   _proto.isAfterInstant = function isAfterInstant(instant) {
     return this._start.compareTo(instant) > 0;
   };
-
   _proto.isBeforeInstant = function isBeforeInstant(instant) {
     return this._end.compareTo(instant) <= 0 && this._start.compareTo(instant) < 0;
   };
-
   _proto.isAfterInterval = function isAfterInterval(interval) {
     return this._start.compareTo(interval.end()) >= 0 && !interval.equals(this);
   };
-
   _proto.isBeforeInterval = function isBeforeInterval(interval) {
     return this._end.compareTo(interval.start()) <= 0 && !interval.equals(this);
   };
-
   _proto.toDuration = function toDuration() {
     return Duration.between(this._start, this._end);
   };
-
   _proto.equals = function equals(obj) {
     if (this === obj) {
       return true;
     }
-
     if (obj instanceof Interval) {
       return this._start.equals(obj.start()) && this._end.equals(obj.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 Interval;
 }();
-function _init$5() {
+function _init$6() {
   Interval.ALL = Interval.of(Instant.MIN, Instant.MAX);
 }
 
@@ -683,24 +538,18 @@ var LocalDateRange = function () {
     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');
@@ -708,188 +557,143 @@ var LocalDateRange = function () {
     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) {
@@ -900,18 +704,13 @@ var LocalDateRange = function () {
       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) {
@@ -922,107 +721,82 @@ var LocalDateRange = function () {
       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.POSITIVE_INFINITY;
     }
-
     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() {
+function _init$5() {
   LocalDateRange.ALL = new LocalDateRange(LocalDate.MIN, LocalDate.MAX);
 }
 
-var MathUtil$3 = _.MathUtil;
+var MathUtil$4 = _.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();
@@ -1032,61 +806,49 @@ var OffsetDate = function (_Temporal) {
       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 epochDay = MathUtil$4.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);
@@ -1095,140 +857,106 @@ var OffsetDate = function (_Temporal) {
       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);
@@ -1237,86 +965,65 @@ var OffsetDate = function (_Temporal) {
     } 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()) {
@@ -1324,349 +1031,268 @@ var OffsetDate = function (_Temporal) {
     } 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));
-
+      var endLocal = end._date.plusDays(MathUtil$4.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() {
+function _init$4() {
   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 MathUtil$3 = _.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);
+    return Quarter.of(MathUtil$3.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);
+      return Quarter.of(MathUtil$3.intDiv(month.ordinal(), 3) + 1);
     }
-
     try {
-      var qoy = MathUtil$2.safeToInt(temporal.getLong(IsoFields.QUARTER_OF_YEAR));
+      var qoy = MathUtil$3.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._value = MathUtil$3.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);
+    var amount = MathUtil$3.intMod(quarters, 4);
     return QUARTERS[(this.ordinal() + amount + 4) % 4];
   };
-
   _proto.minus = function minus(quarters) {
-    return this.plus(-MathUtil$2.intMod(quarters, 4));
+    return this.plus(-MathUtil$3.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() {
+function _init$3() {
   Quarter.Q1 = new Quarter(1, 'Q1');
   Quarter.Q2 = new Quarter(2, 'Q2');
   Quarter.Q3 = new Quarter(3, 'Q3');
@@ -1676,26 +1302,204 @@ function _init$2() {
   });
   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$2 = _.MathUtil;
+var Temporals = function () {
+  Temporals.nextWorkingDay = function nextWorkingDay() {
+    return Adjuster.NEXT_WORKING;
+  };
+  Temporals.nextWorkingDayOrSame = function nextWorkingDayOrSame() {
+    return Adjuster.NEXT_WORKING_OR_SAME;
+  };
+  Temporals.previousWorkingDay = function previousWorkingDay() {
+    return Adjuster.PREVIOUS_WORKING;
+  };
+  Temporals.previousWorkingDayOrSame = function previousWorkingDayOrSame() {
+    return Adjuster.PREVIOUS_WORKING_OR_SAME;
+  };
+  Temporals.parseFirstMatching = function parseFirstMatching(text, query) {
+    requireNonNull(text, 'text');
+    requireNonNull(query, 'query');
+    for (var _len = arguments.length, formatters = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      formatters[_key - 2] = arguments[_key];
+    }
+    requireNonNull(formatters, 'formatters');
+    if (formatters.length === 0) {
+      throw new DateTimeParseException('No formatters specified', text, 0);
+    }
+    if (formatters.length === 1) {
+      return formatters[0].parse(text, query);
+    }
+    for (var _i = 0, _formatters = formatters; _i < _formatters.length; _i++) {
+      var formatter = _formatters[_i];
+      try {
+        var pp = new ParsePosition(0);
+        formatter.parseUnresolved(text, pp);
+        var len = text.length;
+        if (pp.getErrorIndex() === -1 && pp.getIndex() === len) {
+          return formatter.parse(text, query);
+        }
+      } catch (ignored) {}
+    }
+    throw new DateTimeParseException("Text '" + text + "' could not be parsed", text, 0);
+  };
+  Temporals.convertAmount = function convertAmount(amount, fromUnit, toUnit) {
+    requireNonNull(fromUnit, 'fromUnit');
+    requireNonNull(toUnit, 'toUnit');
+    Temporals._validateUnit(fromUnit);
+    Temporals._validateUnit(toUnit);
+    if (fromUnit === toUnit) {
+      return [amount, 0];
+    }
+    if (Temporals._isPrecise(fromUnit) && Temporals._isPrecise(toUnit)) {
+      var fromNanos = fromUnit.duration().toNanos();
+      var toNanos = toUnit.duration().toNanos();
+      if (fromNanos > toNanos) {
+        var multiple = MathUtil$2.intDiv(fromNanos, toNanos);
+        return [MathUtil$2.safeMultiply(amount, multiple), 0];
+      } else {
+        var _multiple = MathUtil$2.intDiv(toNanos, fromNanos);
+        return [MathUtil$2.intDiv(amount, _multiple), MathUtil$2.intMod(amount, _multiple)];
+      }
+    }
+    var fromMonthFactor = Temporals._monthMonthFactor(fromUnit, fromUnit, toUnit);
+    var toMonthFactor = Temporals._monthMonthFactor(toUnit, fromUnit, toUnit);
+    if (fromMonthFactor > toMonthFactor) {
+      var _multiple2 = MathUtil$2.intDiv(fromMonthFactor, toMonthFactor);
+      return [MathUtil$2.safeMultiply(amount, _multiple2), 0];
+    } else {
+      var _multiple3 = MathUtil$2.intDiv(toMonthFactor, fromMonthFactor);
+      return [MathUtil$2.intDiv(amount, _multiple3), MathUtil$2.intMod(amount, _multiple3)];
+    }
+  };
+  Temporals._validateUnit = function _validateUnit(unit) {
+    if (unit instanceof ChronoUnit) {
+      if (unit === ChronoUnit.ERAS || unit === ChronoUnit.FOREVER) {
+        throw new UnsupportedTemporalTypeException("Unsupported TemporalUnit: " + unit);
+      }
+    } else if (unit !== IsoFields.QUARTER_YEARS) {
+      throw new UnsupportedTemporalTypeException("Unsupported TemporalUnit: " + unit);
+    }
+  };
+  Temporals._isPrecise = function _isPrecise(unit) {
+    return unit instanceof ChronoUnit && unit.compareTo(ChronoUnit.WEEKS) <= 0;
+  };
+  Temporals._monthMonthFactor = function _monthMonthFactor(unit, fromUnit, toUnit) {
+    if (unit instanceof ChronoUnit) {
+      switch (unit) {
+        case ChronoUnit.MONTHS:
+          return 1;
+        case ChronoUnit.YEARS:
+          return 12;
+        case ChronoUnit.DECADES:
+          return 120;
+        case ChronoUnit.CENTURIES:
+          return 1200;
+        case ChronoUnit.MILLENNIA:
+          return 12000;
+        default:
+          throw new DateTimeException("Unable to convert between units: " + fromUnit + " to " + toUnit);
+      }
+    }
+    return 3;
+  };
+  function Temporals() {}
+  return Temporals;
+}();
+var Adjuster = {};
+function _init$2() {
+  Adjuster.NEXT_WORKING = new (function (_TemporalAdjuster) {
+    _inheritsLoose(_class, _TemporalAdjuster);
+    function _class() {
+      return _TemporalAdjuster.apply(this, arguments) || this;
+    }
+    var _proto = _class.prototype;
+    _proto.adjustInto = function adjustInto(temporal) {
+      var dow = temporal.get(ChronoField.DAY_OF_WEEK);
+      switch (dow) {
+        case 6:
+          return temporal.plus(2, ChronoUnit.DAYS);
+        case 5:
+          return temporal.plus(3, ChronoUnit.DAYS);
+        default:
+          return temporal.plus(1, ChronoUnit.DAYS);
+      }
+    };
+    return _class;
+  }(TemporalAdjuster))();
+  Adjuster.PREVIOUS_WORKING = new (function (_TemporalAdjuster2) {
+    _inheritsLoose(_class2, _TemporalAdjuster2);
+    function _class2() {
+      return _TemporalAdjuster2.apply(this, arguments) || this;
+    }
+    var _proto2 = _class2.prototype;
+    _proto2.adjustInto = function adjustInto(temporal) {
+      var dow = temporal.get(ChronoField.DAY_OF_WEEK);
+      switch (dow) {
+        case 1:
+          return temporal.minus(3, ChronoUnit.DAYS);
+        case 7:
+          return temporal.minus(2, ChronoUnit.DAYS);
+        default:
+          return temporal.minus(1, ChronoUnit.DAYS);
+      }
+    };
+    return _class2;
+  }(TemporalAdjuster))();
+  Adjuster.NEXT_WORKING_OR_SAME = new (function (_TemporalAdjuster3) {
+    _inheritsLoose(_class3, _TemporalAdjuster3);
+    function _class3() {
+      return _TemporalAdjuster3.apply(this, arguments) || this;
+    }
+    var _proto3 = _class3.prototype;
+    _proto3.adjustInto = function adjustInto(temporal) {
+      var dow = temporal.get(ChronoField.DAY_OF_WEEK);
+      switch (dow) {
+        case 6:
+          return temporal.plus(2, ChronoUnit.DAYS);
+        case 7:
+          return temporal.plus(1, ChronoUnit.DAYS);
+        default:
+          return temporal;
+      }
+    };
+    return _class3;
+  }(TemporalAdjuster))();
+  Adjuster.PREVIOUS_WORKING_OR_SAME = new (function (_TemporalAdjuster4) {
+    _inheritsLoose(_class4, _TemporalAdjuster4);
+    function _class4() {
+      return _TemporalAdjuster4.apply(this, arguments) || this;
+    }
+    var _proto4 = _class4.prototype;
+    _proto4.adjustInto = function adjustInto(temporal) {
+      var dow = temporal.get(ChronoField.DAY_OF_WEEK);
+      switch (dow) {
+        case 6:
+          return temporal.minus(1, ChronoUnit.DAYS);
+        case 7:
+          return temporal.minus(2, ChronoUnit.DAYS);
+        default:
+          return temporal;
+      }
+    };
+    return _class4;
+  }(TemporalAdjuster))();
+}
+
 var MathUtil$1 = _.MathUtil;
 var YearQuarter = function (_Temporal) {
   _inheritsLoose(YearQuarter, _Temporal);
-
   YearQuarter.now = function now(zoneIdOrClock) {
     if (arguments.length === 0) {
       return YearQuarter._now0();
@@ -1705,68 +1509,53 @@ var YearQuarter = function (_Temporal) {
       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));
@@ -1775,195 +1564,149 @@ var YearQuarter = function (_Temporal) {
       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);
@@ -1971,176 +1714,133 @@ var YearQuarter = function (_Temporal) {
       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);
@@ -2154,10 +1854,8 @@ var YearQuarter = function (_Temporal) {
         yearString = "" + yearValue;
       }
     }
-
     return yearString.concat('-').concat(this._quarter);
   };
-
   return YearQuarter;
 }(Temporal);
 function _init$1() {
@@ -2166,18 +1864,14 @@ function _init$1() {
     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);
 }
@@ -2185,46 +1879,35 @@ function createTemporalQuery$1(name, queryFromFunction) {
 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 {
@@ -2232,42 +1915,32 @@ var YearWeek = function (_Temporal) {
       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));
@@ -2276,123 +1949,93 @@ var YearWeek = function (_Temporal) {
       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));
@@ -2401,22 +2044,17 @@ var YearWeek = function (_Temporal) {
     } 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);
@@ -2425,70 +2063,54 @@ var YearWeek = function (_Temporal) {
     } 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) {
@@ -2496,46 +2118,36 @@ var YearWeek = function (_Temporal) {
     } 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 {
@@ -2543,48 +2155,37 @@ var YearWeek = function (_Temporal) {
       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);
@@ -2598,10 +2199,8 @@ var YearWeek = function (_Temporal) {
         yearString = "" + yearValue;
       }
     }
-
     return yearString.concat(this._week < 10 ? '-W0' : '-W').concat(this._week);
   };
-
   return YearWeek;
 }(Temporal);
 function _init() {
@@ -2610,18 +2209,14 @@ function _init() {
     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);
 }
@@ -2631,13 +2226,12 @@ function createTemporalQuery(name, queryFromFunction) {
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 var isInit = false;
-
 function init() {
   if (isInit) {
     return;
   }
-
   isInit = true;
+  _init$8();
   _init$7();
   _init$6();
   _init$5();
@@ -2647,13 +2241,8 @@ function init() {
   _init$1();
   _init();
 }
-
 init();
 
-/*
- * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper
- * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
- */
 function plug () {}
 
 /*
@@ -2662,5 +2251,5 @@ function plug () {}
  */
 use(plug);
 
-export { DayOfMonth, DayOfYear, Interval, LocalDateRange, OffsetDate, Quarter, YearQuarter, YearWeek };
+export { DayOfMonth, DayOfYear, Interval, LocalDateRange, OffsetDate, Quarter, Temporals, YearQuarter, YearWeek };
 //# sourceMappingURL=js-joda-extra.esm.js.map