@js-joda/extra 0.10.2 → 0.11.0

package/dist/js-joda-extra.js

@@ -1,4 +1,4 @@
-//! @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)
@@ -12,16 +12,13 @@
   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);
   }
 
@@ -42,57 +39,45 @@
     if (value == null) {
       throw new core.NullPointerException(parameterName + " must not be null");
     }
-
     return value;
   }
   function requireInstance(value, _class, parameterName) {
     if (!(value instanceof _class)) {
       throw new core.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 = core._.MathUtil;
+  var MathUtil$6 = core._.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 core.ZoneId) {
             return DayOfMonth._nowZoneId(zoneIdOrClock);
           }
-
           if (zoneIdOrClock instanceof core.Clock) {
             return DayOfMonth._nowClock(zoneIdOrClock);
           }
-
           throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
-
         default:
           throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
       }
     };
-
     DayOfMonth._now0 = function _now0() {
       return this.now(core.Clock.systemDefaultZone());
     };
-
     DayOfMonth._nowZoneId = function _nowZoneId(zone) {
       return this.now(core.Clock.system(zone));
     };
-
     DayOfMonth._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return DayOfMonth.of(now.dayOfMonth());
     };
-
     DayOfMonth.of = function of(dayOfMonth) {
       if (1 <= dayOfMonth && dayOfMonth <= 31) {
         return DayOfMonth.VALUES[dayOfMonth - 1];
@@ -100,180 +85,138 @@
         throw new core.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(core.ChronoField.DAY_OF_MONTH));
       } catch (ex) {
         throw new core.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 core.ChronoField) {
         return field === core.ChronoField.DAY_OF_MONTH;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
-
       if (field === core.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 === core.ChronoField.DAY_OF_MONTH) {
         return this._day;
       } else if (field instanceof core.ChronoField) {
         throw new core.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, core.TemporalQuery, 'query');
-
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       }
-
       return _TemporalAccessor.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       requireNonNull(temporal, 'temporal');
       return temporal.with(core.ChronoField.DAY_OF_MONTH, this._day);
     };
-
     _proto.atMonth = function atMonth(month) {
       requireNonNull(month, 'month');
-
       if (month instanceof core.Month) {
         return core.MonthDay.of(month, Math.min(this._day, month.maxLength()));
       } else {
         return core.MonthDay.of(month, Math.min(this._day, core.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;
   }(core.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 = core._.MathUtil;
+  var MathUtil$5 = core._.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 core.ZoneId) {
             return DayOfYear._nowZoneId(zoneIdOrClock);
           }
-
           if (zoneIdOrClock instanceof core.Clock) {
             return DayOfYear._nowClock(zoneIdOrClock);
           }
-
           throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
-
         default:
           throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
       }
     };
-
     DayOfYear._now0 = function _now0() {
       return DayOfYear.now(core.Clock.systemDefaultZone());
     };
-
     DayOfYear._nowZoneId = function _nowZoneId(zone) {
       return DayOfYear.now(core.Clock.system(zone));
     };
-
     DayOfYear._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return DayOfYear.of(now.dayOfYear());
     };
-
     DayOfYear.of = function of(dayOfYear) {
       if (1 <= dayOfYear && dayOfYear <= 366) {
         return DayOfYear.VALUES[dayOfYear - 1];
@@ -281,131 +224,100 @@
         throw new core.DateTimeException("Invalid value for DayOfYear: " + dayOfYear);
       }
     };
-
     DayOfYear.from = function from(temporal) {
       requireNonNull(temporal, 'temporal');
       requireInstance(temporal, core.TemporalAccessor, 'temporal');
-
       if (temporal instanceof DayOfYear) {
         return temporal;
       }
-
       try {
         return DayOfYear.of(temporal.get(core.ChronoField.DAY_OF_YEAR));
       } catch (ex) {
         throw new core.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 core.ChronoField) {
         return field === core.ChronoField.DAY_OF_YEAR;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
-
       if (field === core.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 === core.ChronoField.DAY_OF_YEAR) {
         return this._day;
       } else if (field instanceof core.ChronoField) {
         throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
       }
-
       return field.getFrom(this);
     };
-
     _proto.isValidYear = function isValidYear(year) {
       return this._day < 366 || core.Year.isLeap(year);
     };
-
     _proto.query = function query(_query) {
       requireNonNull(_query, 'query');
       requireInstance(_query, core.TemporalQuery, 'query');
-
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       }
-
       return _TemporalAccessor.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       requireNonNull(temporal, 'temporal');
       return temporal.with(core.ChronoField.DAY_OF_YEAR, this._day);
     };
-
     _proto.atYear = function atYear(year) {
       requireNonNull(year, 'year');
-
       if (year instanceof core.Year) {
         return year.atDay(this._day);
       } else {
         return core.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;
   }(core.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);
     }
@@ -424,148 +336,113 @@
         return Interval.ofInstantInstant(startInstant, endInstantOrDuration);
       }
     };
-
     Interval.ofInstantInstant = function ofInstantInstant(startInclusive, endExclusive) {
       requireNonNull(startInclusive, 'startInclusive');
       requireNonNull(endExclusive, 'endExclusive');
       requireInstance(startInclusive, core.Instant, 'startInclusive');
       requireInstance(endExclusive, core.Instant, 'endExclusive');
-
       if (endExclusive.isBefore(startInclusive)) {
         throw new core.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, core.Instant, 'startInclusive');
       requireInstance(duration, core.Duration, 'duration');
-
       if (duration.isNegative()) {
         throw new core.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 core.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 = core.Duration.parse(text.substring(0, i));
             var end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
             return Interval.of(end.minus(duration), end);
           } else {
             var start = core.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 = core.Duration.parse(text.substring(i + 1, text.length));
-
                 return Interval.of(start, start.plus(_duration));
               }
             }
-
             var _end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
-
             return Interval.of(start, _end);
           }
         }
       }
-
       throw new core.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(core.Instant.MIN);
     };
-
     _proto.isUnboundedEnd = function isUnboundedEnd() {
       return this._end.equals(core.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, core.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 core.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) {
@@ -576,19 +453,14 @@
         return Interval.of(newStart, newEnd);
       }
     };
-
     _proto.union = function union(other) {
       requireNonNull(other, 'other');
       requireInstance(other, Interval, 'other');
-
       if (this.isConnected(other) === false) {
         throw new core.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) {
@@ -599,20 +471,15 @@
         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 core.Instant) {
         return this.isAfterInstant(instantOrInterval);
@@ -620,7 +487,6 @@
         return this.isAfterInterval(instantOrInterval);
       }
     };
-
     _proto.isBefore = function isBefore(instantOrInterval) {
       if (instantOrInterval instanceof core.Instant) {
         return this.isBeforeInstant(instantOrInterval);
@@ -628,50 +494,39 @@
         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 core.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(core.Instant.MIN, core.Instant.MAX);
   }
 
@@ -687,24 +542,18 @@
       if (startInclusive instanceof core.LocalDate && endExclusiveOrPeriod instanceof core.LocalDate) {
         return LocalDateRange._ofLocalDateLocalDate(startInclusive, endExclusiveOrPeriod);
       }
-
       if (startInclusive instanceof core.LocalDate && endExclusiveOrPeriod instanceof core.Period) {
         return LocalDateRange._ofLocalDatePeriod(startInclusive, endExclusiveOrPeriod);
       }
-
       var messageParts = [];
-
       if (!(startInclusive instanceof core.LocalDate)) {
         messageParts.push("startInclusive must be an instance of LocalDate but is " + startInclusive.constructor.name);
       }
-
       if (!(endExclusiveOrPeriod instanceof core.LocalDate || endExclusiveOrPeriod instanceof core.Period)) {
         messageParts.push("endExclusiveOrPeriod must be an instance of LocalDate or Period but is " + endExclusiveOrPeriod.constructor.name);
       }
-
       throw new core.IllegalArgumentException(messageParts.join(' and '));
     };
-
     LocalDateRange._ofLocalDateLocalDate = function _ofLocalDateLocalDate(startInclusive, endExclusive) {
       requireNonNull(startInclusive, 'startInclusive');
       requireNonNull(endExclusive, 'endExclusive');
@@ -712,188 +561,143 @@
       requireInstance(endExclusive, core.LocalDate, 'endExclusive');
       return new LocalDateRange(startInclusive, endExclusive);
     };
-
     LocalDateRange._ofLocalDatePeriod = function _ofLocalDatePeriod(startInclusive, period) {
       requireNonNull(startInclusive, 'startInclusive');
       requireNonNull(period, 'period');
       requireInstance(startInclusive, core.LocalDate, 'startInclusive');
       requireInstance(period, core.Period, 'period');
-
       if (period.isNegative()) {
         throw new core.DateTimeException('Period must not be zero or negative');
       }
-
       return new LocalDateRange(startInclusive, startInclusive.plus(period));
     };
-
     LocalDateRange.ofClosed = function ofClosed(startInclusive, endInclusive) {
       requireNonNull(startInclusive, 'startInclusive');
       requireNonNull(endInclusive, 'endInclusive');
       requireInstance(startInclusive, core.LocalDate, 'startInclusive');
       requireInstance(endInclusive, core.LocalDate, 'endInclusive');
-
       if (endInclusive.isBefore(startInclusive)) {
         throw new core.DateTimeException('Start date must be on or before end date');
       }
-
       var end = endInclusive.equals(core.LocalDate.MAX) ? core.LocalDate.MAX : endInclusive.plusDays(1);
       return new LocalDateRange(startInclusive, end);
     };
-
     LocalDateRange.ofEmpty = function ofEmpty(date) {
       requireNonNull(date, 'date');
       requireInstance(date, core.LocalDate, 'date');
       return new LocalDateRange(date, date);
     };
-
     LocalDateRange.ofUnbounded = function ofUnbounded() {
       return LocalDateRange.ALL;
     };
-
     LocalDateRange.ofUnboundedStart = function ofUnboundedStart(endExclusive) {
       requireNonNull(endExclusive, 'endExclusive');
       requireInstance(endExclusive, core.LocalDate, 'endExclusive');
       return LocalDateRange.of(core.LocalDate.MIN, endExclusive);
     };
-
     LocalDateRange.ofUnboundedEnd = function ofUnboundedEnd(startInclusive) {
       return LocalDateRange.of(startInclusive, core.LocalDate.MAX);
     };
-
     LocalDateRange.parse = function parse(text) {
       requireNonNull(text, 'text');
-
       for (var i = 0; i < text.length; i++) {
         if (text[i] === '/') {
           var firstChar = text.charAt(0);
-
           if (firstChar === 'P' || firstChar === 'p') {
             var duration = core.Period.parse(text.slice(0, i));
             var end = core.LocalDate.parse(text.slice(i + 1, text.length));
             return LocalDateRange.of(end.minus(duration), end);
           } else {
             var start = core.LocalDate.parse(text.slice(0, i));
-
             if (i + 1 < text.length) {
               var c = text[i + 1];
-
               if (c === 'P' || c === 'p') {
                 var _duration = core.Period.parse(text.slice(i + 1, text.length));
-
                 return LocalDateRange.of(start, start.plus(_duration));
               }
             }
-
             var _end = core.LocalDate.parse(text.slice(i + 1, text.length));
-
             return LocalDateRange.of(start, _end);
           }
         }
       }
-
       throw new core.DateTimeParseException('LocalDateRange cannot be parsed, no forward slash found', text, 0);
     };
-
     function LocalDateRange(startInclusive, endExclusive) {
       requireNonNull(startInclusive, 'startInclusive');
       requireNonNull(endExclusive, 'endExclusive');
       requireInstance(startInclusive, core.LocalDate, 'startInclusive');
       requireInstance(endExclusive, core.LocalDate, 'endExclusive');
-
       if (endExclusive.isBefore(startInclusive)) {
         throw new core.DateTimeException('End date must be on or after start date');
       }
-
       if (startInclusive.equals(MAXM1)) {
         throw new core.DateTimeException('Range must not start at LocalDate.MAX.minusDays(1)');
       }
-
       if (endExclusive.equals(MINP1)) {
         throw new core.DateTimeException('Range must not end at LocalDate.MIN.plusDays(1)');
       }
-
       if (endExclusive.equals(core.LocalDate.MIN) || startInclusive.equals(core.LocalDate.MAX)) {
         throw new core.DateTimeException('Empty range must not be at LocalDate.MIN or LocalDate.MAX');
       }
-
       this._start = startInclusive;
       this._end = endExclusive;
     }
-
     var _proto = LocalDateRange.prototype;
-
     _proto.start = function start() {
       return this._start;
     };
-
     _proto.end = function end() {
       return this._end;
     };
-
     _proto.endInclusive = function endInclusive() {
       if (this.isUnboundedEnd()) {
         return core.LocalDate.MAX;
       }
-
       return this._end.minusDays(1);
     };
-
     _proto.isEmpty = function isEmpty() {
       return this._start.equals(this._end);
     };
-
     _proto.isUnboundedStart = function isUnboundedStart() {
       return this._start.equals(core.LocalDate.MIN);
     };
-
     _proto.isUnboundedEnd = function isUnboundedEnd() {
       return this._end.equals(core.LocalDate.MAX);
     };
-
     _proto.withStart = function withStart(adjuster) {
       return LocalDateRange.of(this._start.with(adjuster), this._end);
     };
-
     _proto.withEnd = function withEnd(adjuster) {
       return LocalDateRange.of(this._start, this._end.with(adjuster));
     };
-
     _proto.contains = function contains(date) {
       requireNonNull(date, 'date');
       return this._start.compareTo(date) <= 0 && (date.compareTo(this._end) < 0 || this.isUnboundedEnd());
     };
-
     _proto.encloses = function encloses(other) {
       requireNonNull(other, 'other');
       return this._start.compareTo(other._start) <= 0 && other._end.compareTo(this._end) <= 0;
     };
-
     _proto.abuts = function abuts(other) {
       requireNonNull(other, 'other');
       return this._end.equals(other._start) !== this._start.equals(other._end);
     };
-
     _proto.isConnected = function isConnected(other) {
       requireNonNull(other, 'other');
       return this.equals(other) || this._start.compareTo(other._end) <= 0 && other._start.compareTo(this._end) <= 0;
     };
-
     _proto.overlaps = function overlaps(other) {
       requireNonNull(other, 'other');
       return other.equals(this) || this._start.compareTo(other._end) < 0 && other._start.compareTo(this._end) < 0;
     };
-
     _proto.intersection = function intersection(other) {
       requireNonNull(other, 'other');
-
       if (this.isConnected(other) === false) {
         throw new core.DateTimeException("Ranges do not connect: " + this + " and " + other);
       }
-
       var cmpStart = this._start.compareTo(other._start);
-
       var cmpEnd = this._end.compareTo(other._end);
-
       if (cmpStart >= 0 && cmpEnd <= 0) {
         return this;
       } else if (cmpStart <= 0 && cmpEnd >= 0) {
@@ -904,18 +708,13 @@
         return LocalDateRange.of(newStart, newEnd);
       }
     };
-
     _proto.union = function union(other) {
       requireNonNull(other, 'other');
-
       if (this.isConnected(other) === false) {
         throw new core.DateTimeException("Ranges do not connect: " + this + " and " + other);
       }
-
       var cmpStart = this._start.compareTo(other._start);
-
       var cmpEnd = this._end.compareTo(other._end);
-
       if (cmpStart >= 0 && cmpEnd <= 0) {
         return other;
       } else if (cmpStart <= 0 && cmpEnd >= 0) {
@@ -926,107 +725,82 @@
         return LocalDateRange.of(newStart, newEnd);
       }
     };
-
     _proto.span = function span(other) {
       requireNonNull(other, 'other');
-
       var cmpStart = this._start.compareTo(other._start);
-
       var cmpEnd = this._end.compareTo(other._end);
-
       var newStart = cmpStart >= 0 ? other._start : this._start;
       var newEnd = cmpEnd <= 0 ? other._end : this._end;
       return LocalDateRange.of(newStart, newEnd);
     };
-
     _proto.isAfter = function isAfter(localDateOrLocalDateRange) {
       if (localDateOrLocalDateRange instanceof core.LocalDate) {
         return this._isAfterLocalDate(localDateOrLocalDateRange);
       }
-
       if (localDateOrLocalDateRange instanceof LocalDateRange) {
         return this._isAfterLocalDateRange(localDateOrLocalDateRange);
       }
-
       throw new core.IllegalArgumentException("localDateOrLocalDateRange must be an instance of LocalDate or LocalDateRange but is " + localDateOrLocalDateRange.constructor.name);
     };
-
     _proto.isBefore = function isBefore(localDateOrLocalDateRange) {
       if (localDateOrLocalDateRange instanceof core.LocalDate) {
         return this._isBeforeLocalDate(localDateOrLocalDateRange);
       }
-
       if (localDateOrLocalDateRange instanceof LocalDateRange) {
         return this._isBeforeLocalDateRange(localDateOrLocalDateRange);
       }
-
       throw new core.IllegalArgumentException("localDateOrLocalDateRange must be an instance of LocalDate or LocalDateRange but is " + localDateOrLocalDateRange.constructor.name);
     };
-
     _proto._isAfterLocalDate = function _isAfterLocalDate(date) {
       return this._start.compareTo(date) > 0;
     };
-
     _proto._isBeforeLocalDate = function _isBeforeLocalDate(date) {
       return this._end.compareTo(date) <= 0 && this._start.compareTo(date) < 0;
     };
-
     _proto._isAfterLocalDateRange = function _isAfterLocalDateRange(other) {
       return this._start.compareTo(other._end) >= 0 && !other.equals(this);
     };
-
     _proto._isBeforeLocalDateRange = function _isBeforeLocalDateRange(range) {
       return this._end.compareTo(range._start) <= 0 && !range.equals(this);
     };
-
     _proto.lengthInDays = function lengthInDays() {
       if (this.isUnboundedStart() || this.isUnboundedEnd()) {
         return Number.POSITIVE_INFINITY;
       }
-
       return this._end.toEpochDay() - this._start.toEpochDay();
     };
-
     _proto.toPeriod = function toPeriod() {
       if (this.isUnboundedStart() || this.isUnboundedEnd()) {
         throw new core.ArithmeticException('Unbounded range cannot be converted to a Period');
       }
-
       return core.Period.between(this._start, this._end);
     };
-
     _proto.equals = function equals(obj) {
       if (this === obj) {
         return true;
       }
-
       if (obj instanceof LocalDateRange) {
         var other = obj;
         return this._start.equals(other._start) && this._end.equals(other._end);
       }
-
       return false;
     };
-
     _proto.hashCode = function hashCode() {
       return this._start.hashCode() ^ this._end.hashCode();
     };
-
     _proto.toString = function toString() {
       return this._start.toString() + "/" + this._end.toString();
     };
-
     return LocalDateRange;
   }();
-  function _init$4() {
+  function _init$5() {
     LocalDateRange.ALL = new LocalDateRange(core.LocalDate.MIN, core.LocalDate.MAX);
   }
 
-  var MathUtil$3 = core._.MathUtil;
+  var MathUtil$4 = core._.MathUtil;
   var SECONDS_PER_DAY = 86400;
   var OffsetDate = function (_Temporal) {
     _inheritsLoose(OffsetDate, _Temporal);
-
     OffsetDate.now = function now(zoneIdOrClock) {
       if (arguments.length === 0) {
         return OffsetDate._now0();
@@ -1036,61 +810,49 @@
         return OffsetDate._nowClock(zoneIdOrClock);
       }
     };
-
     OffsetDate._now0 = function _now0() {
       return OffsetDate.now(core.Clock.systemDefaultZone());
     };
-
     OffsetDate._nowZoneId = function _nowZoneId(zone) {
       return OffsetDate.now(core.Clock.system(zone));
     };
-
     OffsetDate._nowClock = function _nowClock(clock) {
       requireNonNull(clock, 'clock');
       var now = clock.instant();
       return OffsetDate.ofInstant(now, clock.zone().rules().offset(now));
     };
-
     OffsetDate.of = function of() {
       switch (arguments.length) {
         case 2:
           return OffsetDate._ofLocalDateZoneOffset.apply(OffsetDate, arguments);
-
         case 4:
           return OffsetDate._ofIntIntIntZoneOffset.apply(OffsetDate, arguments);
-
         default:
           throw new core.IllegalArgumentException('Illegal number of arguments');
       }
     };
-
     OffsetDate._ofLocalDateZoneOffset = function _ofLocalDateZoneOffset(date, offset) {
       return new OffsetDate(date, offset);
     };
-
     OffsetDate._ofIntIntIntZoneOffset = function _ofIntIntIntZoneOffset(year, month, dayOfMonth, offset) {
       var d = core.LocalDate.of(year, month, dayOfMonth);
       return new OffsetDate(d, offset);
     };
-
     OffsetDate.ofInstant = function ofInstant(instant, zone) {
       requireNonNull(instant, 'instant');
       requireNonNull(zone, 'zone');
       var rules = zone.rules();
       var offset = rules.offset(instant);
       var epochSec = instant.epochSecond() + offset.totalSeconds();
-      var epochDay = MathUtil$3.floorDiv(epochSec, SECONDS_PER_DAY);
+      var epochDay = MathUtil$4.floorDiv(epochSec, SECONDS_PER_DAY);
       var date = core.LocalDate.ofEpochDay(epochDay);
       return new OffsetDate(date, offset);
     };
-
     OffsetDate.from = function from(temporal) {
       if (temporal instanceof OffsetDate) {
         return temporal;
       }
-
       requireNonNull(temporal, 'temporal');
-
       try {
         var date = core.LocalDate.from(temporal);
         var offset = core.ZoneOffset.from(temporal);
@@ -1099,140 +861,106 @@
         throw new core.DateTimeException("Unable to obtain OffsetDate from TemporalAccessor: " + temporal.constructor.name, ex);
       }
     };
-
     OffsetDate.parse = function parse(text, formatter) {
       if (formatter === void 0) {
         formatter = core.DateTimeFormatter.ISO_OFFSET_DATE;
       }
-
       requireNonNull(formatter, 'formatter');
       return formatter.parse(text, OffsetDate.FROM);
     };
-
     function OffsetDate(date, offset) {
       var _this;
-
       _this = _Temporal.call(this) || this;
       _this._date = requireNonNull(date, 'date');
       _this._offset = requireNonNull(offset, 'offset');
       return _this;
     }
-
     var _proto = OffsetDate.prototype;
-
     _proto._with = function _with(date, offset) {
       if (this._date === date && this._offset.equals(offset)) {
         return this;
       }
-
       return new OffsetDate(date, offset);
     };
-
     _proto.isSupported = function isSupported(fieldOrUnit) {
       if (fieldOrUnit instanceof core.TemporalField) {
         return this._isSupportedField(fieldOrUnit);
       }
-
       if (fieldOrUnit instanceof core.TemporalUnit) {
         return this._isSupportedUnit(fieldOrUnit);
       }
-
       if (fieldOrUnit == null) {
         return false;
       }
-
       throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
     };
-
     _proto._isSupportedField = function _isSupportedField(field) {
       if (field instanceof core.ChronoField) {
         return field.isDateBased() || field === core.ChronoField.OFFSET_SECONDS;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto._isSupportedUnit = function _isSupportedUnit(unit) {
       if (unit instanceof core.ChronoUnit) {
         return unit.isDateBased();
       }
-
       return unit != null && unit.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field instanceof core.ChronoField) {
         if (field === core.ChronoField.OFFSET_SECONDS) {
           return field.range();
         }
-
         return this._date.range(field);
       }
-
       return field.rangeRefinedBy(this);
     };
-
     _proto.get = function get(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
       return this.range(field).checkValidIntValue(this.getLong(field), field);
     };
-
     _proto.getLong = function getLong(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field instanceof core.ChronoField) {
         if (field === core.ChronoField.OFFSET_SECONDS) {
           return this.offset().totalSeconds();
         }
-
         return this._date.getLong(field);
       }
-
       return field.getFrom(this);
     };
-
     _proto.offset = function offset() {
       return this._offset;
     };
-
     _proto.withOffsetSameLocal = function withOffsetSameLocal(offset) {
       requireNonNull(offset, 'offset');
       return this._with(this._date, offset);
     };
-
     _proto.toLocalDate = function toLocalDate() {
       return this._date;
     };
-
     _proto.year = function year() {
       return this._date.year();
     };
-
     _proto.monthValue = function monthValue() {
       return this._date.monthValue();
     };
-
     _proto.month = function month() {
       return this._date.month();
     };
-
     _proto.dayOfMonth = function dayOfMonth() {
       return this._date.dayOfMonth();
     };
-
     _proto.dayOfYear = function dayOfYear() {
       return this._date.dayOfYear();
     };
-
     _proto.dayOfWeek = function dayOfWeek() {
       return this._date.dayOfWeek();
     };
-
     _proto._withAdjuster = function _withAdjuster(adjuster) {
       if (adjuster instanceof core.LocalDate) {
         return this._with(adjuster, this._offset);
@@ -1241,86 +969,65 @@
       } else if (adjuster instanceof OffsetDate) {
         return adjuster;
       }
-
       return _Temporal.prototype._withAdjuster.call(this, adjuster);
     };
-
     _proto._withField = function _withField(field, newValue) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field instanceof core.ChronoField) {
         if (field === core.ChronoField.OFFSET_SECONDS) {
           var f = field;
           return this._with(this._date, core.ZoneOffset.ofTotalSeconds(f.checkValidIntValue(newValue)));
         }
-
         return this._with(this._date.with(field, newValue), this._offset);
       }
-
       return field.adjustInto(this, newValue);
     };
-
     _proto.withYear = function withYear(year) {
       return this._with(this._date.withYear(year), this._offset);
     };
-
     _proto.withMonth = function withMonth(month) {
       return this._with(this._date.withMonth(month), this._offset);
     };
-
     _proto.withDayOfMonth = function withDayOfMonth(dayOfMonth) {
       return this._with(this._date.withDayOfMonth(dayOfMonth), this._offset);
     };
-
     _proto.withDayOfYear = function withDayOfYear(dayOfYear) {
       return this._with(this._date.withDayOfYear(dayOfYear), this._offset);
     };
-
     _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
       if (unit instanceof core.ChronoUnit) {
         return this._with(this._date.plus(amountToAdd, unit), this._offset);
       }
-
       return unit.addTo(this, amountToAdd);
     };
-
     _proto.plusYears = function plusYears(years) {
       return this._with(this._date.plusYears(years), this._offset);
     };
-
     _proto.plusMonths = function plusMonths(months) {
       return this._with(this._date.plusMonths(months), this._offset);
     };
-
     _proto.plusWeeks = function plusWeeks(weeks) {
       return this._with(this._date.plusWeeks(weeks), this._offset);
     };
-
     _proto.plusDays = function plusDays(days) {
       return this._with(this._date.plusDays(days), this._offset);
     };
-
     _proto.minusYears = function minusYears(years) {
       return this._with(this._date.minusYears(years), this._offset);
     };
-
     _proto.minusMonths = function minusMonths(months) {
       return this._with(this._date.minusMonths(months), this._offset);
     };
-
     _proto.minusWeeks = function minusWeeks(weeks) {
       return this._with(this._date.minusWeeks(weeks), this._offset);
     };
-
     _proto.minusDays = function minusDays(days) {
       return this._with(this._date.minusDays(days), this._offset);
     };
-
     _proto.query = function query(_query) {
       requireNonNull(_query, 'query');
       requireInstance(_query, core.TemporalQuery, 'query');
-
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       } else if (_query === core.TemporalQueries.precision()) {
@@ -1328,349 +1035,268 @@
       } else if (_query === core.TemporalQueries.offset() || _query === core.TemporalQueries.zone()) {
         return this.offset();
       }
-
       return _Temporal.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       return temporal.with(core.ChronoField.OFFSET_SECONDS, this.offset().totalSeconds()).with(core.ChronoField.EPOCH_DAY, this.toLocalDate().toEpochDay());
     };
-
     _proto.until = function until(endExclusive, unit) {
       var end = OffsetDate.from(endExclusive);
-
       if (unit instanceof core.ChronoUnit) {
         var offsetDiff = end._offset.totalSeconds() - this._offset.totalSeconds();
-
-        var endLocal = end._date.plusDays(MathUtil$3.intDiv(-offsetDiff, SECONDS_PER_DAY));
-
+        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 core.OffsetDateTime.of(this._date, time, this._offset);
     };
-
     _proto._toEpochSecond = function _toEpochSecond() {
       var epochDay = this._date.toEpochDay();
-
       var secs = epochDay * SECONDS_PER_DAY;
       return secs - this._offset.totalSeconds();
     };
-
     _proto.toEpochSecond = function toEpochSecond(time) {
       requireNonNull(time, 'time');
       return this._toEpochSecond() + time.toSecondOfDay();
     };
-
     _proto.compareTo = function compareTo(other) {
       requireNonNull(other, 'other');
       requireInstance(other, OffsetDate, 'other');
-
       if (this._offset.equals(other._offset)) {
         return this._date.compareTo(other._date);
       }
-
       var compare = this._toEpochSecond() - other._toEpochSecond();
-
       if (compare === 0) {
         compare = this._date.compareTo(other._date);
       }
-
       return compare;
     };
-
     _proto.isAfter = function isAfter(other) {
       requireNonNull(other, 'other');
       requireInstance(other, OffsetDate, 'other');
       return this._toEpochSecond() > other._toEpochSecond();
     };
-
     _proto.isBefore = function isBefore(other) {
       requireNonNull(other, 'other');
       requireInstance(other, OffsetDate, 'other');
       return this._toEpochSecond() < other._toEpochSecond();
     };
-
     _proto.isEqual = function isEqual(other) {
       requireNonNull(other, 'other');
       requireInstance(other, OffsetDate, 'other');
       return this._toEpochSecond() === other._toEpochSecond();
     };
-
     _proto.equals = function equals(obj) {
       if (this === obj) {
         return true;
       }
-
       if (obj instanceof OffsetDate) {
         var other = obj;
         return this._date.equals(other._date) && this._offset.equals(other._offset);
       }
-
       return false;
     };
-
     _proto.hashCode = function hashCode() {
       return this._date.hashCode() ^ this._offset.hashCode();
     };
-
     _proto.toString = function toString() {
       return this._date.toString() + this._offset.toString();
     };
-
     return OffsetDate;
   }(core.Temporal);
-  function _init$3() {
+  function _init$4() {
     OffsetDate.MIN = OffsetDate.of(core.LocalDate.MIN, core.ZoneOffset.MAX);
     OffsetDate.MAX = OffsetDate.of(core.LocalDate.MAX, core.ZoneOffset.MIN);
     OffsetDate.FROM = createTemporalQuery$3('OffsetDate.FROM', function (temporal) {
       return OffsetDate.from(temporal);
     });
   }
-
   function createTemporalQuery$3(name, queryFromFunction) {
     var ExtendedTemporalQuery = function (_TemporalQuery) {
       _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
-
       function ExtendedTemporalQuery() {
         return _TemporalQuery.apply(this, arguments) || this;
       }
-
       return ExtendedTemporalQuery;
     }(core.TemporalQuery);
-
     ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
     return new ExtendedTemporalQuery(name);
   }
 
-  var MathUtil$2 = core._.MathUtil;
+  var MathUtil$3 = core._.MathUtil;
   var Quarter = function (_TemporalAccessor) {
     _inheritsLoose(Quarter, _TemporalAccessor);
-
     Quarter.valueOf = function valueOf(name) {
       requireNonNull(name, 'name');
-
       switch (name) {
         case 'Q1':
           return Quarter.Q1;
-
         case 'Q2':
           return Quarter.Q2;
-
         case 'Q3':
           return Quarter.Q3;
-
         case 'Q4':
           return Quarter.Q4;
       }
-
       throw new core.IllegalArgumentException("No enum constant Quarter." + name);
     };
-
     Quarter.values = function values() {
       return QUARTERS.slice();
     };
-
     Quarter.of = function of(quarterOfYear) {
       requireNonNull(quarterOfYear, 'quarterOfYear');
-
       switch (quarterOfYear) {
         case 1:
           return Quarter.Q1;
-
         case 2:
           return Quarter.Q2;
-
         case 3:
           return Quarter.Q3;
-
         case 4:
           return Quarter.Q4;
-
         default:
           throw new core.DateTimeException("Invalid value for Quarter: " + quarterOfYear);
       }
     };
-
     Quarter.ofMonth = function ofMonth(monthOfYear) {
       requireNonNull(monthOfYear, 'monthOfYear');
       core.ChronoField.MONTH_OF_YEAR.range().checkValidValue(monthOfYear, core.ChronoField.MONTH_OF_YEAR);
-      return Quarter.of(MathUtil$2.intDiv(monthOfYear - 1, 3) + 1);
+      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 core.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(core.IsoFields.QUARTER_OF_YEAR));
+        var qoy = MathUtil$3.safeToInt(temporal.getLong(core.IsoFields.QUARTER_OF_YEAR));
         return Quarter.of(qoy);
       } catch (ex) {
         throw new core.DateTimeException("Unable to obtain Quarter from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
       }
     };
-
     function Quarter(value, name) {
       var _this;
-
       _this = _TemporalAccessor.call(this) || this;
-      _this._value = MathUtil$2.safeToInt(value);
+      _this._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 core.IllegalArgumentException('Pattern using (localized) text not implemented yet!');
     };
-
     _proto.isSupported = function isSupported(field) {
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return true;
       } else if (field instanceof core.ChronoField) {
         return false;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
-
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return field.range();
       } else if (field instanceof core.ChronoField) {
         throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
       }
-
       return _TemporalAccessor.prototype.range.call(this, field);
     };
-
     _proto.get = function get(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
       return this.range(field).checkValidIntValue(this.getLong(field), field);
     };
-
     _proto.getLong = function getLong(field) {
       requireNonNull(field, 'field');
-
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return this.value();
       } else if (field instanceof core.ChronoField) {
         throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
       }
-
       return field.getFrom(this);
     };
-
     _proto.plus = function plus(quarters) {
-      var amount = MathUtil$2.intMod(quarters, 4);
+      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 core.Month.JANUARY;
-
         case Quarter.Q2:
           return core.Month.APRIL;
-
         case Quarter.Q3:
           return core.Month.JULY;
-
         case Quarter.Q4:
           return core.Month.OCTOBER;
-
         default:
           throw new core.IllegalStateException('Unreachable');
       }
     };
-
     _proto.query = function query(_query) {
       requireNonNull(_query, 'query');
       requireInstance(_query, core.TemporalQuery, 'query');
-
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       } else if (_query === core.TemporalQueries.precision()) {
         return core.IsoFields.QUARTER_YEARS;
       }
-
       return _TemporalAccessor.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       requireNonNull(temporal, 'temporal');
       return temporal.with(core.IsoFields.QUARTER_OF_YEAR, this.value());
     };
-
     _proto.ordinal = function ordinal() {
       return this._value - 1;
     };
-
     _proto.name = function name() {
       return this._name;
     };
-
     _proto.compareTo = function compareTo(other) {
       requireNonNull(other, 'other');
       requireInstance(other, Quarter, 'other');
       return this._value - other._value;
     };
-
     _proto.toString = function toString() {
       return this.name();
     };
-
     _proto.equals = function equals(other) {
       return this === other;
     };
-
     _proto.hashCode = function hashCode() {
       return this._value;
     };
-
     return Quarter;
   }(core.TemporalAccessor);
   var QUARTERS;
-  function _init$2() {
+  function _init$3() {
     Quarter.Q1 = new Quarter(1, 'Q1');
     Quarter.Q2 = new Quarter(2, 'Q2');
     Quarter.Q3 = new Quarter(3, 'Q3');
@@ -1680,26 +1306,204 @@
     });
     QUARTERS = [Quarter.Q1, Quarter.Q2, Quarter.Q3, Quarter.Q4];
   }
-
   function createTemporalQuery$2(name, queryFromFunction) {
     var ExtendedTemporalQuery = function (_TemporalQuery) {
       _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
-
       function ExtendedTemporalQuery() {
         return _TemporalQuery.apply(this, arguments) || this;
       }
-
       return ExtendedTemporalQuery;
     }(core.TemporalQuery);
-
     ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
     return new ExtendedTemporalQuery(name);
   }
 
+  var MathUtil$2 = core._.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 core.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 core.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 core.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 core.ChronoUnit) {
+        if (unit === core.ChronoUnit.ERAS || unit === core.ChronoUnit.FOREVER) {
+          throw new core.UnsupportedTemporalTypeException("Unsupported TemporalUnit: " + unit);
+        }
+      } else if (unit !== core.IsoFields.QUARTER_YEARS) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported TemporalUnit: " + unit);
+      }
+    };
+    Temporals._isPrecise = function _isPrecise(unit) {
+      return unit instanceof core.ChronoUnit && unit.compareTo(core.ChronoUnit.WEEKS) <= 0;
+    };
+    Temporals._monthMonthFactor = function _monthMonthFactor(unit, fromUnit, toUnit) {
+      if (unit instanceof core.ChronoUnit) {
+        switch (unit) {
+          case core.ChronoUnit.MONTHS:
+            return 1;
+          case core.ChronoUnit.YEARS:
+            return 12;
+          case core.ChronoUnit.DECADES:
+            return 120;
+          case core.ChronoUnit.CENTURIES:
+            return 1200;
+          case core.ChronoUnit.MILLENNIA:
+            return 12000;
+          default:
+            throw new core.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(core.ChronoField.DAY_OF_WEEK);
+        switch (dow) {
+          case 6:
+            return temporal.plus(2, core.ChronoUnit.DAYS);
+          case 5:
+            return temporal.plus(3, core.ChronoUnit.DAYS);
+          default:
+            return temporal.plus(1, core.ChronoUnit.DAYS);
+        }
+      };
+      return _class;
+    }(core.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(core.ChronoField.DAY_OF_WEEK);
+        switch (dow) {
+          case 1:
+            return temporal.minus(3, core.ChronoUnit.DAYS);
+          case 7:
+            return temporal.minus(2, core.ChronoUnit.DAYS);
+          default:
+            return temporal.minus(1, core.ChronoUnit.DAYS);
+        }
+      };
+      return _class2;
+    }(core.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(core.ChronoField.DAY_OF_WEEK);
+        switch (dow) {
+          case 6:
+            return temporal.plus(2, core.ChronoUnit.DAYS);
+          case 7:
+            return temporal.plus(1, core.ChronoUnit.DAYS);
+          default:
+            return temporal;
+        }
+      };
+      return _class3;
+    }(core.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(core.ChronoField.DAY_OF_WEEK);
+        switch (dow) {
+          case 6:
+            return temporal.minus(1, core.ChronoUnit.DAYS);
+          case 7:
+            return temporal.minus(2, core.ChronoUnit.DAYS);
+          default:
+            return temporal;
+        }
+      };
+      return _class4;
+    }(core.TemporalAdjuster))();
+  }
+
   var MathUtil$1 = core._.MathUtil;
   var YearQuarter = function (_Temporal) {
     _inheritsLoose(YearQuarter, _Temporal);
-
     YearQuarter.now = function now(zoneIdOrClock) {
       if (arguments.length === 0) {
         return YearQuarter._now0();
@@ -1709,68 +1513,53 @@
         return YearQuarter._nowClock(zoneIdOrClock);
       }
     };
-
     YearQuarter._now0 = function _now0() {
       return YearQuarter.now(core.Clock.systemDefaultZone());
     };
-
     YearQuarter._nowZoneId = function _nowZoneId(zone) {
       return YearQuarter.now(core.Clock.system(zone));
     };
-
     YearQuarter._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return YearQuarter.of(now.getYear(), Quarter.from(now.getMonth()));
     };
-
     YearQuarter.of = function of(year, quarter) {
       if (year instanceof core.Year && quarter instanceof Quarter) {
         return YearQuarter._ofYearQuarter(year, quarter);
       }
-
       if (year instanceof core.Year && typeof quarter === 'number') {
         return YearQuarter._ofYearInt(year, quarter);
       }
-
       if (typeof year === 'number' && quarter instanceof Quarter) {
         return YearQuarter._ofIntQuarter(year, quarter);
       }
-
       if (typeof year === 'number' && typeof quarter === 'number') {
         return YearQuarter._ofIntInt(year, quarter);
       }
-
       var yearMessage = "year must be an instance of Year or number but is " + year.constructor.name;
       var quarterMessage = "quarter must be an instance of Quarter or number but is " + quarter.constructor.name;
       throw new core.IllegalArgumentException(yearMessage + " and " + quarterMessage);
     };
-
     YearQuarter._ofYearQuarter = function _ofYearQuarter(year, quarter) {
       return YearQuarter.of(year.value(), quarter);
     };
-
     YearQuarter._ofYearInt = function _ofYearInt(year, quarter) {
       return YearQuarter.of(year.value(), Quarter.of(quarter));
     };
-
     YearQuarter._ofIntQuarter = function _ofIntQuarter(year, quarter) {
       core.ChronoField.YEAR.checkValidValue(year);
       requireNonNull(quarter, 'quarter');
       return new YearQuarter(year, quarter);
     };
-
     YearQuarter._ofIntInt = function _ofIntInt(year, quarter) {
       core.ChronoField.YEAR.checkValidValue(year);
       return new YearQuarter(year, Quarter.of(quarter));
     };
-
     YearQuarter.from = function from(temporal) {
       if (temporal instanceof YearQuarter) {
         return temporal;
       }
-
       requireNonNull(temporal, 'temporal');
-
       try {
         var year = MathUtil$1.safeToInt(temporal.getLong(core.ChronoField.YEAR));
         var qoy = MathUtil$1.safeToInt(temporal.getLong(core.IsoFields.QUARTER_OF_YEAR));
@@ -1779,195 +1568,149 @@
         throw new core.DateTimeException("Unable to obtain YearQuarter from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
       }
     };
-
     YearQuarter.parse = function parse(text, formatter) {
       if (formatter === void 0) {
         formatter = YearQuarter.PARSER;
       }
-
       requireNonNull(formatter, 'formatter');
       requireInstance(formatter, core.DateTimeFormatter, 'formatter');
       return formatter.parse(text, YearQuarter.FROM);
     };
-
     function YearQuarter(year, quarter) {
       var _this;
-
       _this = _Temporal.call(this) || this;
       _this._year = MathUtil$1.safeToInt(year);
       _this._quarter = requireInstance(quarter, Quarter, 'Quarter');
       return _this;
     }
-
     var _proto = YearQuarter.prototype;
-
     _proto._with = function _with(newYear, newQuarter) {
       if (this._year === newYear && this._quarter === newQuarter) {
         return this;
       }
-
       return new YearQuarter(newYear, newQuarter);
     };
-
     _proto.isSupported = function isSupported(fieldOrUnit) {
       if (fieldOrUnit instanceof core.TemporalField) {
         return this._isSupportedField(fieldOrUnit);
       }
-
       if (fieldOrUnit instanceof core.TemporalUnit) {
         return this._isSupportedUnit(fieldOrUnit);
       }
-
       if (fieldOrUnit == null) {
         return false;
       }
-
       throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
     };
-
     _proto._isSupportedField = function _isSupportedField(field) {
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return true;
       } else if (field instanceof core.ChronoField) {
         return field === core.ChronoField.YEAR || field === core.ChronoField.YEAR_OF_ERA || field === core.ChronoField.ERA;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto._isSupportedUnit = function _isSupportedUnit(unit) {
       if (unit === core.IsoFields.QUARTER_YEARS) {
         return true;
       } else if (unit instanceof core.ChronoUnit) {
         return unit === core.ChronoUnit.YEARS || unit === core.ChronoUnit.DECADES || unit === core.ChronoUnit.CENTURIES || unit === core.ChronoUnit.MILLENNIA || unit === core.ChronoUnit.ERAS;
       }
-
       return unit != null && unit.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return core.IsoFields.QUARTER_OF_YEAR.range();
       }
-
       if (field === core.ChronoField.YEAR_OF_ERA) {
         return this.year() <= 0 ? core.ValueRange.of(1, core.Year.MAX_VALUE + 1) : core.ValueRange.of(1, core.Year.MAX_VALUE);
       }
-
       return _Temporal.prototype.range.call(this, field);
     };
-
     _proto.get = function get(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
       return this.range(field).checkValidIntValue(this.getLong(field), field);
     };
-
     _proto.getLong = function getLong(field) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return this._quarter.value();
       } else if (field instanceof core.ChronoField) {
         switch (field) {
           case core.ChronoField.YEAR_OF_ERA:
             return this._year < 1 ? 1 - this._year : this._year;
-
           case core.ChronoField.YEAR:
             return this._year;
-
           case core.ChronoField.ERA:
             return this._year < 1 ? 0 : 1;
-
           default:
             throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
         }
       }
-
       return _Temporal.prototype.get.call(this, field);
     };
-
     _proto._prolepticQuarter = function _prolepticQuarter() {
       return this._year * 4 + (this._quarter.value() - 1);
     };
-
     _proto.year = function year() {
       return this._year;
     };
-
     _proto.quarterValue = function quarterValue() {
       return this._quarter.value();
     };
-
     _proto.quarter = function quarter() {
       return this._quarter;
     };
-
     _proto.isLeapYear = function isLeapYear() {
       return core.IsoChronology.isLeapYear(this._year);
     };
-
     _proto.isValidDay = function isValidDay(dayOfQuarter) {
       return dayOfQuarter >= 1 && dayOfQuarter <= this.lengthOfQuarter();
     };
-
     _proto.lengthOfQuarter = function lengthOfQuarter() {
       return this._quarter.length(this.isLeapYear());
     };
-
     _proto.lengthOfYear = function lengthOfYear() {
       return this.isLeapYear() ? 366 : 365;
     };
-
     _proto._withAdjuster = function _withAdjuster(adjuster) {
       if (adjuster instanceof YearQuarter) {
         return adjuster;
       }
-
       return _Temporal.prototype._withAdjuster.call(this, adjuster);
     };
-
     _proto._withField = function _withField(field, newValue) {
       requireNonNull(field, 'field');
       requireInstance(field, core.TemporalField, 'field');
-
       if (field === core.IsoFields.QUARTER_OF_YEAR) {
         return this.withQuarter(core.IsoFields.QUARTER_OF_YEAR.range().checkValidIntValue(newValue, core.IsoFields.QUARTER_OF_YEAR));
       } else if (field instanceof core.ChronoField) {
         field.checkValidValue(newValue);
-
         switch (field) {
           case core.ChronoField.YEAR_OF_ERA:
             return this.withYear(this._year < 1 ? 1 - newValue : newValue);
-
           case core.ChronoField.YEAR:
             return this.withYear(newValue);
-
           case core.ChronoField.ERA:
             return this.getLong(core.ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year);
-
           default:
             throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
         }
       }
-
       return field.adjustInto(this, newValue);
     };
-
     _proto.withYear = function withYear(year) {
       core.ChronoField.YEAR.checkValidValue(year);
       return this._with(year, this._quarter);
     };
-
     _proto.withQuarter = function withQuarter(quarter) {
       core.IsoFields.QUARTER_OF_YEAR.range().checkValidValue(quarter, core.IsoFields.QUARTER_OF_YEAR);
       return this._with(this._year, Quarter.of(quarter));
     };
-
     _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
       if (unit === core.IsoFields.QUARTER_YEARS) {
         return this.plusQuarters(amountToAdd);
@@ -1975,176 +1718,133 @@
         switch (unit) {
           case core.ChronoUnit.YEARS:
             return this.plusYears(amountToAdd);
-
           case core.ChronoUnit.DECADES:
             return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 10));
-
           case core.ChronoUnit.CENTURIES:
             return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 100));
-
           case core.ChronoUnit.MILLENNIA:
             return this.plusYears(MathUtil$1.safeMultiply(amountToAdd, 1000));
-
           case core.ChronoUnit.ERAS:
             return this.with(core.ChronoField.ERA, MathUtil$1.safeAdd(this.getLong(core.ChronoField.ERA), amountToAdd));
-
           default:
             throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
         }
       }
-
       return unit.addTo(this, amountToAdd);
     };
-
     _proto.plusYears = function plusYears(yearsToAdd) {
       if (yearsToAdd === 0) {
         return this;
       }
-
       var newYear = core.ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd);
       return this._with(newYear, this._quarter);
     };
-
     _proto.plusQuarters = function plusQuarters(quartersToAdd) {
       if (quartersToAdd === 0) {
         return this;
       }
-
       var quarterCount = this._year * 4 + (this._quarter.value() - 1);
       var calcQuarters = quarterCount + quartersToAdd;
       var newYear = core.ChronoField.YEAR.checkValidIntValue(MathUtil$1.intDiv(calcQuarters, 4));
       var newQuarter = MathUtil$1.floorMod(calcQuarters, 4) + 1;
       return this._with(newYear, Quarter.of(newQuarter));
     };
-
     _proto.minusYears = function minusYears(yearsToSubtract) {
       return yearsToSubtract === MathUtil$1.MIN_SAFE_INTEGER ? this.plusYears(MathUtil$1.MIN_SAFE_INTEGER).plusYears(1) : this.plusYears(-yearsToSubtract);
     };
-
     _proto.minusQuarters = function minusQuarters(quartersToSubtract) {
       return quartersToSubtract === MathUtil$1.MIN_SAFE_INTEGER ? this.plusQuarters(MathUtil$1.MIN_SAFE_INTEGER).plusQuarters(1) : this.plusQuarters(-quartersToSubtract);
     };
-
     _proto.query = function query(_query) {
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       } else if (_query === core.TemporalQueries.precision()) {
         return core.IsoFields.QUARTER_YEARS;
       }
-
       return _Temporal.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       var newProlepticQuarter = this._prolepticQuarter();
-
       var oldProlepticQuarter = temporal.get(core.ChronoField.YEAR) * 4 + (temporal.get(core.IsoFields.QUARTER_OF_YEAR) - 1);
       return temporal.plus(newProlepticQuarter - oldProlepticQuarter, core.IsoFields.QUARTER_YEARS);
     };
-
     _proto.until = function until(endExclusive, unit) {
       requireNonNull(endExclusive, 'endExclusive');
       requireNonNull(unit, 'unit');
       requireInstance(endExclusive, core.Temporal, 'endExclusive');
       requireInstance(unit, core.TemporalUnit, 'unit');
       var end = YearQuarter.from(endExclusive);
-
       var quartersUntil = end._prolepticQuarter() - this._prolepticQuarter();
-
       if (unit === core.IsoFields.QUARTER_YEARS) {
         return quartersUntil;
       } else if (unit instanceof core.ChronoUnit) {
         switch (unit) {
           case core.ChronoUnit.YEARS:
             return MathUtil$1.intDiv(quartersUntil, 4);
-
           case core.ChronoUnit.DECADES:
             return MathUtil$1.intDiv(quartersUntil, 40);
-
           case core.ChronoUnit.CENTURIES:
             return MathUtil$1.intDiv(quartersUntil, 400);
-
           case core.ChronoUnit.MILLENNIA:
             return MathUtil$1.intDiv(quartersUntil, 4000);
-
           case core.ChronoUnit.ERAS:
             return end.getLong(core.ChronoField.ERA) - this.getLong(core.ChronoField.ERA);
-
           default:
             throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
         }
       }
-
       return unit.between(this, end);
     };
-
     _proto.format = function format(formatter) {
       requireNonNull(formatter, 'formatter');
       return formatter.format(this);
     };
-
     _proto.atDay = function atDay(dayOfQuarter) {
       core.ValueRange.of(1, this.lengthOfQuarter()).checkValidValue(dayOfQuarter, core.IsoFields.DAY_OF_QUARTER);
       var leap = core.Year.isLeap(this._year);
-
       var month = this._quarter.firstMonth();
-
       while (dayOfQuarter > month.length(leap)) {
         dayOfQuarter -= month.length(leap);
         month = month.plus(1);
       }
-
       return core.LocalDate.of(this._year, month, dayOfQuarter);
     };
-
     _proto.atEndOfQuarter = function atEndOfQuarter() {
       var month = this._quarter.firstMonth().plus(2);
-
       return core.LocalDate.of(this._year, month, month.maxLength());
     };
-
     _proto.compareTo = function compareTo(other) {
       requireNonNull(other, 'other');
       requireInstance(other, YearQuarter, 'other');
       var cmp = this._year - other._year;
-
       if (cmp === 0) {
         cmp = this._quarter.compareTo(other._quarter);
       }
-
       return cmp;
     };
-
     _proto.isAfter = function isAfter(other) {
       return this.compareTo(other) > 0;
     };
-
     _proto.isBefore = function isBefore(other) {
       return this.compareTo(other) < 0;
     };
-
     _proto.equals = function equals(obj) {
       if (this === obj) {
         return true;
       }
-
       if (obj instanceof YearQuarter) {
         var other = obj;
         return this._year === other._year && this._quarter === other._quarter;
       }
-
       return false;
     };
-
     _proto.hashCode = function hashCode() {
       return this._year ^ this._quarter.value() << 27;
     };
-
     _proto.toString = function toString() {
       var yearString;
       var yearValue = this._year;
       var absYear = Math.abs(yearValue);
-
       if (absYear < 1000) {
         if (yearValue < 0) {
           yearString = "-" + ("" + (yearValue - 10000)).slice(-4);
@@ -2158,10 +1858,8 @@
           yearString = "" + yearValue;
         }
       }
-
       return yearString.concat('-').concat(this._quarter);
     };
-
     return YearQuarter;
   }(core.Temporal);
   function _init$1() {
@@ -2170,18 +1868,14 @@
       return YearQuarter.from(temporal);
     });
   }
-
   function createTemporalQuery$1(name, queryFromFunction) {
     var ExtendedTemporalQuery = function (_TemporalQuery) {
       _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
-
       function ExtendedTemporalQuery() {
         return _TemporalQuery.apply(this, arguments) || this;
       }
-
       return ExtendedTemporalQuery;
     }(core.TemporalQuery);
-
     ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
     return new ExtendedTemporalQuery(name);
   }
@@ -2189,46 +1883,35 @@
   var MathUtil = core._.MathUtil;
   var YearWeek = function (_Temporal) {
     _inheritsLoose(YearWeek, _Temporal);
-
     YearWeek.now = function now(zoneIdOrClock) {
       switch (arguments.length) {
         case 0:
           return YearWeek._now0();
-
         case 1:
           requireNonNull(zoneIdOrClock, 'clockOrZone');
-
           if (zoneIdOrClock instanceof core.ZoneId) {
             return YearWeek._nowZoneId(zoneIdOrClock);
           }
-
           if (zoneIdOrClock instanceof core.Clock) {
             return YearWeek._nowClock(zoneIdOrClock);
           }
-
           throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
-
         default:
           throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
       }
     };
-
     YearWeek._now0 = function _now0() {
       return YearWeek.now(core.Clock.systemDefaultZone());
     };
-
     YearWeek._nowZoneId = function _nowZoneId(zone) {
       return YearWeek.now(core.Clock.system(zone));
     };
-
     YearWeek._nowClock = function _nowClock(clock) {
       var now = core.LocalDate.now(clock);
       return YearWeek.of(now.get(core.IsoFields.WEEK_BASED_YEAR), now.get(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
     };
-
     YearWeek.of = function of(year, week) {
       MathUtil.verifyInt(week);
-
       if (year instanceof core.Year) {
         return this._ofYearWeek(year, week);
       } else {
@@ -2236,42 +1919,32 @@
         return this._ofWeekBasedYear(year, week);
       }
     };
-
     YearWeek._ofYearWeek = function _ofYearWeek(year, week) {
       var weekBasedYear = year.value();
       return this._ofWeekBasedYear(weekBasedYear, week);
     };
-
     YearWeek._ofWeekBasedYear = function _ofWeekBasedYear(weekBasedYear, week) {
       core.IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, core.IsoFields.WEEK_BASED_YEAR);
       core.IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidValue(week, core.IsoFields.WEEK_OF_WEEK_BASED_YEAR);
-
       if (week === 53 && YearWeek._weekRange(weekBasedYear) < 53) {
         week = 1;
         weekBasedYear++;
         core.IsoFields.WEEK_BASED_YEAR.range().checkValidValue(weekBasedYear, core.IsoFields.WEEK_BASED_YEAR);
       }
-
       return new YearWeek(weekBasedYear, week);
     };
-
     YearWeek._weekRange = function _weekRange(weekBasedYear) {
       var date = core.LocalDate.of(weekBasedYear, 1, 1);
-
       if (date.dayOfWeek() === core.DayOfWeek.THURSDAY || date.dayOfWeek() === core.DayOfWeek.WEDNESDAY && date.isLeapYear()) {
         return 53;
       }
-
       return 52;
     };
-
     YearWeek.from = function from(temporal) {
       if (temporal instanceof YearWeek) {
         return temporal;
       }
-
       requireNonNull(temporal, 'temporal');
-
       try {
         var year = MathUtil.safeToInt(temporal.getLong(core.IsoFields.WEEK_BASED_YEAR));
         var week = MathUtil.safeToInt(temporal.getLong(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
@@ -2280,123 +1953,93 @@
         throw new core.DateTimeException("Unable to obtain YearWeek from TemporalAccessor: " + temporal.constructor.name, ex);
       }
     };
-
     YearWeek.parse = function parse(text, formatter) {
       if (formatter === void 0) {
         formatter = YearWeek.PARSER;
       }
-
       assert(formatter != null, 'formatter', core.NullPointerException);
       return formatter.parse(text, YearWeek.FROM);
     };
-
     function YearWeek(weekBasedYear, week) {
       var _this;
-
       _this = _Temporal.call(this) || this;
       _this._year = weekBasedYear;
       _this._week = week;
       return _this;
     }
-
     var _proto = YearWeek.prototype;
-
     _proto.isSupported = function isSupported(fieldOrUnit) {
       if (fieldOrUnit instanceof core.TemporalField) {
         return this._isSupportedField(fieldOrUnit);
       }
-
       if (fieldOrUnit instanceof core.TemporalUnit) {
         return this._isSupportedUnit(fieldOrUnit);
       }
-
       if (fieldOrUnit == null) {
         return false;
       }
-
       throw new core.IllegalArgumentException("fieldOrUnit must be an instance of TemporalField or TemporalUnit, but is " + fieldOrUnit.constructor.name);
     };
-
     _proto._isSupportedField = function _isSupportedField(field) {
       if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR || field === core.IsoFields.WEEK_BASED_YEAR) {
         return true;
       } else if (field instanceof core.ChronoField) {
         return false;
       }
-
       return field != null && field.isSupportedBy(this);
     };
-
     _proto._isSupportedUnit = function _isSupportedUnit(unit) {
       if (unit === core.ChronoUnit.WEEKS || unit === core.IsoFields.WEEK_BASED_YEARS) {
         return true;
       } else if (unit instanceof core.ChronoUnit) {
         return false;
       }
-
       return unit != null && unit.isSupportedBy(this);
     };
-
     _proto.range = function range(field) {
       requireNonNull(field, 'field');
-
       if (field === core.IsoFields.WEEK_BASED_YEAR) {
         return core.IsoFields.WEEK_BASED_YEAR.range();
       }
-
       if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
         return core.ValueRange.of(1, YearWeek._weekRange(this._year));
       }
-
       return _Temporal.prototype.range.call(this, field);
     };
-
     _proto.get = function get(field) {
       return this.range(field).checkValidIntValue(this.getLong(field), field);
     };
-
     _proto.getLong = function getLong(field) {
       requireNonNull(field, 'field');
-
       if (field === core.IsoFields.WEEK_BASED_YEAR) {
         return this._year;
       }
-
       if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
         return this._week;
       }
-
       if (field instanceof core.ChronoField) {
         throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
       }
-
       return field.getFrom(this);
     };
-
     _proto.year = function year() {
       return this._year;
     };
-
     _proto.week = function week() {
       return this._week;
     };
-
     _proto.is53WeekYear = function is53WeekYear() {
       return YearWeek._weekRange(this._year) === 53;
     };
-
     _proto.lengthOfYear = function lengthOfYear() {
       return this.is53WeekYear() ? 371 : 364;
     };
-
     _proto._withAdjuster = function _withAdjuster(adjuster) {
       if (adjuster instanceof YearWeek) {
         return adjuster;
       }
-
       return _Temporal.prototype._withAdjuster.call(this, adjuster);
     };
-
     _proto._withField = function _withField(field, newValue) {
       if (field === core.IsoFields.WEEK_OF_WEEK_BASED_YEAR) {
         return this.withWeek(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR.range().checkValidIntValue(newValue, core.IsoFields.WEEK_OF_WEEK_BASED_YEAR));
@@ -2405,22 +2048,17 @@
       } else if (field instanceof core.ChronoField) {
         throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
       }
-
       return field.adjustInto(this, newValue);
     };
-
     _proto.withYear = function withYear(weekBasedYear) {
       if (this._week === 53 && YearWeek._weekRange(weekBasedYear) < 53) {
         return YearWeek.of(weekBasedYear, 52);
       }
-
       return YearWeek.of(weekBasedYear, this._week);
     };
-
     _proto.withWeek = function withWeek(week) {
       return YearWeek.of(this._year, week);
     };
-
     _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
       if (unit === core.ChronoUnit.WEEKS) {
         return this.plusWeeks(amountToAdd);
@@ -2429,70 +2067,54 @@
       } else if (unit instanceof core.ChronoUnit) {
         throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
       }
-
       return unit.addTo(this, amountToAdd);
     };
-
     _proto.plusYears = function plusYears(yearsToAdd) {
       if (yearsToAdd === 0) {
         return this;
       }
-
       var newYear = MathUtil.safeToInt(MathUtil.safeAdd(this._year, yearsToAdd));
       return this.withYear(newYear);
     };
-
     _proto.plusWeeks = function plusWeeks(weeksToAdd) {
       if (weeksToAdd === 0) {
         return this;
       }
-
       var mondayOfWeek = this.atDay(core.DayOfWeek.MONDAY).plusWeeks(weeksToAdd);
       return YearWeek.from(mondayOfWeek);
     };
-
     _proto._minusUnit = function _minusUnit(amountToSubtract, unit) {
       requireNonNull(amountToSubtract, 'amountToSubtract');
       requireNonNull(unit, 'unit');
       return this._plusUnit(-amountToSubtract, unit);
     };
-
     _proto.minusYears = function minusYears(yearsToSubtract) {
       if (yearsToSubtract === 0) {
         return this;
       }
-
       var newYear = MathUtil.safeToInt(MathUtil.safeSubtract(this._year, yearsToSubtract));
       return this.withYear(newYear);
     };
-
     _proto.minusWeeks = function minusWeeks(weeksToSubtract) {
       if (weeksToSubtract === 0) {
         return this;
       }
-
       var mondayOfWeek = this.atDay(core.DayOfWeek.MONDAY).minusWeeks(weeksToSubtract);
       return YearWeek.from(mondayOfWeek);
     };
-
     _proto.query = function query(_query) {
       requireNonNull(_query, 'query');
       requireInstance(_query, core.TemporalQuery, 'query');
-
       if (_query === core.TemporalQueries.chronology()) {
         return core.IsoChronology.INSTANCE;
       }
-
       return _Temporal.prototype.query.call(this, _query);
     };
-
     _proto.adjustInto = function adjustInto(temporal) {
       return temporal.with(core.IsoFields.WEEK_BASED_YEAR, this._year).with(core.IsoFields.WEEK_OF_WEEK_BASED_YEAR, this._week);
     };
-
     _proto.until = function until(endExclusive, unit) {
       var end = YearWeek.from(endExclusive);
-
       if (unit === core.ChronoUnit.WEEKS) {
         return this._daysUntil(end);
       } else if (unit === core.IsoFields.WEEK_BASED_YEARS) {
@@ -2500,46 +2122,36 @@
       } else if (unit instanceof core.ChronoUnit) {
         throw new core.UnsupportedTemporalTypeException("Unsupported unit: " + unit);
       }
-
       return unit.between(this, end);
     };
-
     _proto._daysUntil = function _daysUntil(end) {
       var startDate = this.atDay(core.DayOfWeek.MONDAY);
       var endDate = end.atDay(core.DayOfWeek.MONDAY);
       var days = endDate.toEpochDay() - startDate.toEpochDay();
       return MathUtil.intDiv(days, 7);
     };
-
     _proto._yearsUntil = function _yearsUntil(end) {
       var yearsDiff = end._year - this._year;
-
       if (yearsDiff > 0 && end._week < this._week) {
         return yearsDiff - 1;
       }
-
       if (yearsDiff < 0 && end._week > this._week) {
         return yearsDiff + 1;
       }
-
       return yearsDiff;
     };
-
     _proto.format = function format(formatter) {
       requireNonNull(formatter, 'formatter');
       return formatter.format(this);
     };
-
     _proto.atDay = function atDay(dayOfWeek) {
       requireNonNull(dayOfWeek, 'dayOfWeek');
       var correction = core.LocalDate.of(this._year, 1, 4).dayOfWeek().value() + 3;
       var dayOfYear = this._week * 7 + dayOfWeek.value() - correction;
       var maxDaysOfYear = core.Year.isLeap(this._year) ? 366 : 365;
-
       if (dayOfYear > maxDaysOfYear) {
         return core.LocalDate.ofYearDay(this._year + 1, dayOfYear - maxDaysOfYear);
       }
-
       if (dayOfYear > 0) {
         return core.LocalDate.ofYearDay(this._year, dayOfYear);
       } else {
@@ -2547,48 +2159,37 @@
         return core.LocalDate.ofYearDay(this._year - 1, daysOfPreviousYear + dayOfYear);
       }
     };
-
     _proto.compareTo = function compareTo(other) {
       requireNonNull(other, 'other');
       requireInstance(other, YearWeek, 'other');
       var cmp = this._year - other._year;
-
       if (cmp === 0) {
         cmp = this._week - other._week;
       }
-
       return cmp;
     };
-
     _proto.isAfter = function isAfter(other) {
       return this.compareTo(other) > 0;
     };
-
     _proto.isBefore = function isBefore(other) {
       return this.compareTo(other) < 0;
     };
-
     _proto.equals = function equals(obj) {
       if (this === obj) {
         return true;
       }
-
       if (obj instanceof YearWeek) {
         return this._year === obj._year && this._week === obj._week;
       }
-
       return false;
     };
-
     _proto.hashCode = function hashCode() {
       return this._year ^ this._week << 25;
     };
-
     _proto.toString = function toString() {
       var yearString;
       var yearValue = this._year;
       var absYear = Math.abs(yearValue);
-
       if (absYear < 1000) {
         if (yearValue < 0) {
           yearString = "-" + ("" + (yearValue - 10000)).slice(-4);
@@ -2602,10 +2203,8 @@
           yearString = "" + yearValue;
         }
       }
-
       return yearString.concat(this._week < 10 ? '-W0' : '-W').concat(this._week);
     };
-
     return YearWeek;
   }(core.Temporal);
   function _init() {
@@ -2614,18 +2213,14 @@
       return YearWeek.from(temporal);
     });
   }
-
   function createTemporalQuery(name, queryFromFunction) {
     var ExtendedTemporalQuery = function (_TemporalQuery) {
       _inheritsLoose(ExtendedTemporalQuery, _TemporalQuery);
-
       function ExtendedTemporalQuery() {
         return _TemporalQuery.apply(this, arguments) || this;
       }
-
       return ExtendedTemporalQuery;
     }(core.TemporalQuery);
-
     ExtendedTemporalQuery.prototype.queryFrom = queryFromFunction;
     return new ExtendedTemporalQuery(name);
   }
@@ -2635,13 +2230,12 @@
    * @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();
@@ -2651,13 +2245,8 @@
     _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 () {}
 
   /*
@@ -2672,10 +2261,9 @@
   exports.LocalDateRange = LocalDateRange;
   exports.OffsetDate = OffsetDate;
   exports.Quarter = Quarter;
+  exports.Temporals = Temporals;
   exports.YearQuarter = YearQuarter;
   exports.YearWeek = YearWeek;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=js-joda-extra.js.map