@js-joda/core 6.0.1 → 6.2.0

package/dist/js-joda.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/core - 6.0.1
+//! @version @js-joda/core - 6.2.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)
@@ -668,10 +668,15 @@
         if (divisor === 1) {
           return this;
         }
-        var secs = MathUtil.intDiv(this._seconds, divisor);
-        var secsMod = MathUtil.roundDown((this._seconds / divisor - secs) * LocalTime.NANOS_PER_SECOND);
-        var nos = MathUtil.intDiv(this._nanos, divisor);
-        nos = secsMod + nos;
+        var seconds = this._seconds;
+        var nanos = this._nanos;
+        if (seconds < 0 && nanos > 0) {
+          seconds += 1;
+          nanos -= LocalTime.NANOS_PER_SECOND;
+        }
+        var secs = MathUtil.intDiv(seconds, divisor);
+        var remainder = MathUtil.intMod(seconds, divisor);
+        var nos = MathUtil.intDiv(remainder * LocalTime.NANOS_PER_SECOND + nanos, divisor);
         return Duration.ofSeconds(secs, nos);
       };
       _proto.negated = function negated() {
@@ -753,9 +758,12 @@
         if (this === Duration.ZERO) {
           return 'PT0S';
         }
-        var hours = MathUtil.intDiv(this._seconds, LocalTime.SECONDS_PER_HOUR);
-        var minutes = MathUtil.intDiv(MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_HOUR), LocalTime.SECONDS_PER_MINUTE);
-        var secs = MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_MINUTE);
+        var negativeFraction = this._seconds < 0 && this._nanos > 0;
+        var wholeSeconds = negativeFraction ? this._seconds + 1 : this._seconds;
+        var fractionNanos = negativeFraction ? LocalTime.NANOS_PER_SECOND - this._nanos : this._nanos;
+        var hours = MathUtil.intDiv(wholeSeconds, LocalTime.SECONDS_PER_HOUR);
+        var minutes = MathUtil.intDiv(MathUtil.intMod(wholeSeconds, LocalTime.SECONDS_PER_HOUR), LocalTime.SECONDS_PER_MINUTE);
+        var secs = MathUtil.intMod(wholeSeconds, LocalTime.SECONDS_PER_MINUTE);
         var rval = 'PT';
         if (hours !== 0) {
           rval += hours + "H";
@@ -763,31 +771,23 @@
         if (minutes !== 0) {
           rval += minutes + "M";
         }
-        if (secs === 0 && this._nanos === 0 && rval.length > 2) {
+        if (secs === 0 && fractionNanos === 0 && rval.length > 2) {
           return rval;
         }
-        if (secs < 0 && this._nanos > 0) {
-          if (secs === -1) {
-            rval += '-0';
-          } else {
-            rval += secs + 1;
-          }
+        if (secs === 0 && negativeFraction) {
+          rval += '-0';
         } else {
-          rval += secs;
+          rval += "" + secs;
         }
-        if (this._nanos > 0) {
-          rval += '.';
-          var nanoString;
-          if (secs < 0) {
-            nanoString = "" + (2 * LocalTime.NANOS_PER_SECOND - this._nanos);
-          } else {
-            nanoString = "" + (LocalTime.NANOS_PER_SECOND + this._nanos);
+        if (fractionNanos > 0) {
+          var fraction = "" + fractionNanos;
+          while (fraction.length < 9) {
+            fraction = "0" + fraction;
           }
-          nanoString = nanoString.slice(1, nanoString.length);
-          rval += nanoString;
-          while (rval.charAt(rval.length - 1) === '0') {
-            rval = rval.slice(0, rval.length - 1);
+          while (fraction.charAt(fraction.length - 1) === '0') {
+            fraction = fraction.slice(0, fraction.length - 1);
           }
+          rval += "." + fraction;
         }
         rval += 'S';
         return rval;
@@ -2073,1410 +2073,1426 @@
       return ChronoLocalDate;
     }(Temporal);
 
-    /*
-     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
-     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
-     */
-
-    var StringUtil = function () {
-      function StringUtil() {}
-      StringUtil.startsWith = function startsWith(text, pattern) {
-        return text.indexOf(pattern) === 0;
+    var IsoFields = {};
+    var QUARTER_DAYS = [0, 90, 181, 273, 0, 91, 182, 274];
+    var Field = function (_TemporalField) {
+      function Field() {
+        return _TemporalField.apply(this, arguments) || this;
+      }
+      _inheritsLoose(Field, _TemporalField);
+      var _proto = Field.prototype;
+      _proto.isDateBased = function isDateBased() {
+        return true;
       };
-      StringUtil.hashCode = function hashCode(text) {
-        var len = text.length;
-        if (len === 0) {
-          return 0;
+      _proto.isTimeBased = function isTimeBased() {
+        return false;
+      };
+      _proto._isIso = function _isIso() {
+        return true;
+      };
+      Field._getWeekRangeByLocalDate = function _getWeekRangeByLocalDate(date) {
+        var wby = Field._getWeekBasedYear(date);
+        return ValueRange.of(1, Field._getWeekRangeByYear(wby));
+      };
+      Field._getWeekRangeByYear = function _getWeekRangeByYear(wby) {
+        var date = LocalDate.of(wby, 1, 1);
+        if (date.dayOfWeek() === DayOfWeek.THURSDAY || date.dayOfWeek() === DayOfWeek.WEDNESDAY && date.isLeapYear()) {
+          return 53;
         }
-        var hash = 0;
-        for (var i = 0; i < len; i++) {
-          var chr = text.charCodeAt(i);
-          hash = (hash << 5) - hash + chr;
-          hash |= 0;
+        return 52;
+      };
+      Field._getWeek = function _getWeek(date) {
+        var dow0 = date.dayOfWeek().ordinal();
+        var doy0 = date.dayOfYear() - 1;
+        var doyThu0 = doy0 + (3 - dow0);
+        var alignedWeek = MathUtil.intDiv(doyThu0, 7);
+        var firstThuDoy0 = doyThu0 - alignedWeek * 7;
+        var firstMonDoy0 = firstThuDoy0 - 3;
+        if (firstMonDoy0 < -3) {
+          firstMonDoy0 += 7;
         }
-        return MathUtil.smi(hash);
+        if (doy0 < firstMonDoy0) {
+          return Field._getWeekRangeByLocalDate(date.withDayOfYear(180).minusYears(1)).maximum();
+        }
+        var week = MathUtil.intDiv(doy0 - firstMonDoy0, 7) + 1;
+        if (week === 53) {
+          if ((firstMonDoy0 === -3 || firstMonDoy0 === -2 && date.isLeapYear()) === false) {
+            week = 1;
+          }
+        }
+        return week;
       };
-      return StringUtil;
-    }();
-
-    /*
-     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
-     * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
-     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
-     */
-
-    var ZoneId = function () {
-      function ZoneId() {}
-      ZoneId.systemDefault = function systemDefault() {
-        throw new DateTimeException('not supported operation');
+      Field._getWeekBasedYear = function _getWeekBasedYear(date) {
+        var year = date.year();
+        var doy = date.dayOfYear();
+        if (doy <= 3) {
+          var dow = date.dayOfWeek().ordinal();
+          if (doy - dow < -2) {
+            year--;
+          }
+        } else if (doy >= 363) {
+          var _dow = date.dayOfWeek().ordinal();
+          doy = doy - 363 - (date.isLeapYear() ? 1 : 0);
+          if (doy - _dow >= 0) {
+            year++;
+          }
+        }
+        return year;
       };
-      ZoneId.getAvailableZoneIds = function getAvailableZoneIds() {
-        throw new DateTimeException('not supported operation');
+      _proto.displayName = function displayName() {
+        return this.toString();
       };
-      ZoneId.of = function of(zoneId) {
-        throw new DateTimeException("not supported operation" + zoneId);
+      _proto.resolve = function resolve() {
+        return null;
       };
-      ZoneId.ofOffset = function ofOffset(prefix, offset) {
-        throw new DateTimeException("not supported operation" + prefix + offset);
+      _proto.name = function name() {
+        return this.toString();
       };
-      ZoneId.from = function from(temporal) {
-        throw new DateTimeException("not supported operation" + temporal);
+      return Field;
+    }(TemporalField);
+    var DAY_OF_QUARTER_FIELD = function (_Field) {
+      function DAY_OF_QUARTER_FIELD() {
+        return _Field.apply(this, arguments) || this;
+      }
+      _inheritsLoose(DAY_OF_QUARTER_FIELD, _Field);
+      var _proto2 = DAY_OF_QUARTER_FIELD.prototype;
+      _proto2.toString = function toString() {
+        return 'DayOfQuarter';
       };
-      var _proto = ZoneId.prototype;
-      _proto.id = function id() {
-        abstractMethodFail('ZoneId.id');
+      _proto2.baseUnit = function baseUnit() {
+        return ChronoUnit.DAYS;
       };
-      _proto.rules = function rules() {
-        abstractMethodFail('ZoneId.rules');
+      _proto2.rangeUnit = function rangeUnit() {
+        return QUARTER_YEARS;
       };
-      _proto.normalized = function normalized() {
-        var rules = this.rules();
-        if (rules.isFixedOffset()) {
-          return rules.offset(Instant.EPOCH);
-        }
-        return this;
+      _proto2.range = function range() {
+        return ValueRange.of(1, 90, 92);
       };
-      _proto.equals = function equals(other) {
-        if (this === other) {
-          return true;
+      _proto2.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(ChronoField.DAY_OF_YEAR) && temporal.isSupported(ChronoField.MONTH_OF_YEAR) && temporal.isSupported(ChronoField.YEAR) && this._isIso(temporal);
+      };
+      _proto2.rangeRefinedBy = function rangeRefinedBy(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: DayOfQuarter');
         }
-        if (other instanceof ZoneId) {
-          return this.id() === other.id();
+        var qoy = temporal.getLong(QUARTER_OF_YEAR);
+        if (qoy === 1) {
+          var year = temporal.getLong(ChronoField.YEAR);
+          return IsoChronology.isLeapYear(year) ? ValueRange.of(1, 91) : ValueRange.of(1, 90);
+        } else if (qoy === 2) {
+          return ValueRange.of(1, 91);
+        } else if (qoy === 3 || qoy === 4) {
+          return ValueRange.of(1, 92);
         }
-        return false;
-      };
-      _proto.hashCode = function hashCode() {
-        return StringUtil.hashCode(this.id());
-      };
-      _proto.toString = function toString() {
-        return this.id();
-      };
-      _proto.toJSON = function toJSON() {
-        return this.toString();
+        return this.range();
       };
-      return ZoneId;
-    }();
-
-    var ZoneRules = function () {
-      function ZoneRules() {}
-      ZoneRules.of = function of(offset) {
-        requireNonNull(offset, 'offset');
-        return new Fixed(offset);
+      _proto2.getFrom = function getFrom(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: DayOfQuarter');
+        }
+        var doy = temporal.get(ChronoField.DAY_OF_YEAR);
+        var moy = temporal.get(ChronoField.MONTH_OF_YEAR);
+        var year = temporal.getLong(ChronoField.YEAR);
+        return doy - QUARTER_DAYS[MathUtil.intDiv(moy - 1, 3) + (IsoChronology.isLeapYear(year) ? 4 : 0)];
       };
-      var _proto = ZoneRules.prototype;
-      _proto.isFixedOffset = function isFixedOffset() {
-        abstractMethodFail('ZoneRules.isFixedOffset');
+      _proto2.adjustInto = function adjustInto(temporal, newValue) {
+        var curValue = this.getFrom(temporal);
+        this.range().checkValidValue(newValue, this);
+        return temporal.with(ChronoField.DAY_OF_YEAR, temporal.getLong(ChronoField.DAY_OF_YEAR) + (newValue - curValue));
       };
-      _proto.offset = function offset(instantOrLocalDateTime) {
-        if (instantOrLocalDateTime instanceof Instant) {
-          return this.offsetOfInstant(instantOrLocalDateTime);
+      _proto2.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
+        var yearLong = fieldValues.get(ChronoField.YEAR);
+        var qoyLong = fieldValues.get(QUARTER_OF_YEAR);
+        if (yearLong == null || qoyLong == null) {
+          return null;
+        }
+        var y = ChronoField.YEAR.checkValidIntValue(yearLong);
+        var doq = fieldValues.get(DAY_OF_QUARTER);
+        var date;
+        if (resolverStyle === ResolverStyle.LENIENT) {
+          var qoy = qoyLong;
+          date = LocalDate.of(y, 1, 1);
+          date = date.plusMonths(MathUtil.safeMultiply(MathUtil.safeSubtract(qoy, 1), 3));
+          date = date.plusDays(MathUtil.safeSubtract(doq, 1));
         } else {
-          return this.offsetOfLocalDateTime(instantOrLocalDateTime);
+          var _qoy = QUARTER_OF_YEAR.range().checkValidIntValue(qoyLong, QUARTER_OF_YEAR);
+          if (resolverStyle === ResolverStyle.STRICT) {
+            var max = 92;
+            if (_qoy === 1) {
+              max = IsoChronology.isLeapYear(y) ? 91 : 90;
+            } else if (_qoy === 2) {
+              max = 91;
+            }
+            ValueRange.of(1, max).checkValidValue(doq, this);
+          } else {
+            this.range().checkValidValue(doq, this);
+          }
+          date = LocalDate.of(y, (_qoy - 1) * 3 + 1, 1).plusDays(doq - 1);
         }
+        fieldValues.remove(this);
+        fieldValues.remove(ChronoField.YEAR);
+        fieldValues.remove(QUARTER_OF_YEAR);
+        return date;
       };
-      _proto.offsetOfInstant = function offsetOfInstant(instant) {
-        abstractMethodFail('ZoneRules.offsetInstant');
+      return DAY_OF_QUARTER_FIELD;
+    }(Field);
+    var QUARTER_OF_YEAR_FIELD = function (_Field2) {
+      function QUARTER_OF_YEAR_FIELD() {
+        return _Field2.apply(this, arguments) || this;
+      }
+      _inheritsLoose(QUARTER_OF_YEAR_FIELD, _Field2);
+      var _proto3 = QUARTER_OF_YEAR_FIELD.prototype;
+      _proto3.toString = function toString() {
+        return 'QuarterOfYear';
       };
-      _proto.offsetOfEpochMilli = function offsetOfEpochMilli(epochMilli) {
-        abstractMethodFail('ZoneRules.offsetOfEpochMilli');
+      _proto3.baseUnit = function baseUnit() {
+        return QUARTER_YEARS;
       };
-      _proto.offsetOfLocalDateTime = function offsetOfLocalDateTime(localDateTime) {
-        abstractMethodFail('ZoneRules.offsetLocalDateTime');
+      _proto3.rangeUnit = function rangeUnit() {
+        return ChronoUnit.YEARS;
       };
-      _proto.validOffsets = function validOffsets(localDateTime) {
-        abstractMethodFail('ZoneRules.validOffsets');
+      _proto3.range = function range() {
+        return ValueRange.of(1, 4);
       };
-      _proto.transition = function transition(localDateTime) {
-        abstractMethodFail('ZoneRules.transition');
+      _proto3.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(ChronoField.MONTH_OF_YEAR) && this._isIso(temporal);
       };
-      _proto.standardOffset = function standardOffset(instant) {
-        abstractMethodFail('ZoneRules.standardOffset');
-      };
-      _proto.daylightSavings = function daylightSavings(instant) {
-        abstractMethodFail('ZoneRules.daylightSavings');
-      };
-      _proto.isDaylightSavings = function isDaylightSavings(instant) {
-        abstractMethodFail('ZoneRules.isDaylightSavings');
-      };
-      _proto.isValidOffset = function isValidOffset(localDateTime, offset) {
-        abstractMethodFail('ZoneRules.isValidOffset');
-      };
-      _proto.nextTransition = function nextTransition(instant) {
-        abstractMethodFail('ZoneRules.nextTransition');
+      _proto3.rangeRefinedBy = function rangeRefinedBy(temporal) {
+        return this.range();
       };
-      _proto.previousTransition = function previousTransition(instant) {
-        abstractMethodFail('ZoneRules.previousTransition');
+      _proto3.getFrom = function getFrom(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: QuarterOfYear');
+        }
+        var moy = temporal.getLong(ChronoField.MONTH_OF_YEAR);
+        return MathUtil.intDiv(moy + 2, 3);
       };
-      _proto.transitions = function transitions() {
-        abstractMethodFail('ZoneRules.transitions');
+      _proto3.adjustInto = function adjustInto(temporal, newValue) {
+        var curValue = this.getFrom(temporal);
+        this.range().checkValidValue(newValue, this);
+        return temporal.with(ChronoField.MONTH_OF_YEAR, temporal.getLong(ChronoField.MONTH_OF_YEAR) + (newValue - curValue) * 3);
       };
-      _proto.transitionRules = function transitionRules() {
-        abstractMethodFail('ZoneRules.transitionRules');
+      return QUARTER_OF_YEAR_FIELD;
+    }(Field);
+    var WEEK_OF_WEEK_BASED_YEAR_FIELD = function (_Field3) {
+      function WEEK_OF_WEEK_BASED_YEAR_FIELD() {
+        return _Field3.apply(this, arguments) || this;
+      }
+      _inheritsLoose(WEEK_OF_WEEK_BASED_YEAR_FIELD, _Field3);
+      var _proto4 = WEEK_OF_WEEK_BASED_YEAR_FIELD.prototype;
+      _proto4.toString = function toString() {
+        return 'WeekOfWeekBasedYear';
       };
-      _proto.toString = function toString() {
-        abstractMethodFail('ZoneRules.toString');
+      _proto4.baseUnit = function baseUnit() {
+        return ChronoUnit.WEEKS;
       };
-      _proto.toJSON = function toJSON() {
-        return this.toString();
+      _proto4.rangeUnit = function rangeUnit() {
+        return WEEK_BASED_YEARS;
       };
-      return ZoneRules;
-    }();
-    var Fixed = function (_ZoneRules) {
-      function Fixed(offset) {
-        var _this;
-        _this = _ZoneRules.call(this) || this;
-        _this._offset = offset;
-        return _this;
-      }
-      _inheritsLoose(Fixed, _ZoneRules);
-      var _proto2 = Fixed.prototype;
-      _proto2.isFixedOffset = function isFixedOffset() {
-        return true;
+      _proto4.range = function range() {
+        return ValueRange.of(1, 52, 53);
       };
-      _proto2.offsetOfInstant = function offsetOfInstant() {
-        return this._offset;
+      _proto4.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(ChronoField.EPOCH_DAY) && this._isIso(temporal);
       };
-      _proto2.offsetOfEpochMilli = function offsetOfEpochMilli() {
-        return this._offset;
+      _proto4.rangeRefinedBy = function rangeRefinedBy(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: WeekOfWeekBasedYear');
+        }
+        return Field._getWeekRangeByLocalDate(LocalDate.from(temporal));
       };
-      _proto2.offsetOfLocalDateTime = function offsetOfLocalDateTime() {
-        return this._offset;
+      _proto4.getFrom = function getFrom(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: WeekOfWeekBasedYear');
+        }
+        return Field._getWeek(LocalDate.from(temporal));
       };
-      _proto2.validOffsets = function validOffsets() {
-        return [this._offset];
+      _proto4.adjustInto = function adjustInto(temporal, newValue) {
+        this.range().checkValidValue(newValue, this);
+        return temporal.plus(MathUtil.safeSubtract(newValue, this.getFrom(temporal)), ChronoUnit.WEEKS);
       };
-      _proto2.transition = function transition() {
-        return null;
+      _proto4.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
+        var wbyLong = fieldValues.get(WEEK_BASED_YEAR);
+        var dowLong = fieldValues.get(ChronoField.DAY_OF_WEEK);
+        if (wbyLong == null || dowLong == null) {
+          return null;
+        }
+        var wby = WEEK_BASED_YEAR.range().checkValidIntValue(wbyLong, WEEK_BASED_YEAR);
+        var wowby = fieldValues.get(WEEK_OF_WEEK_BASED_YEAR);
+        var date;
+        if (resolverStyle === ResolverStyle.LENIENT) {
+          var dow = dowLong;
+          var weeks = 0;
+          if (dow > 7) {
+            weeks = MathUtil.intDiv(dow - 1, 7);
+            dow = MathUtil.intMod(dow - 1, 7) + 1;
+          } else if (dow < 1) {
+            weeks = MathUtil.intDiv(dow, 7) - 1;
+            dow = MathUtil.intMod(dow, 7) + 7;
+          }
+          date = LocalDate.of(wby, 1, 4).plusWeeks(wowby - 1).plusWeeks(weeks).with(ChronoField.DAY_OF_WEEK, dow);
+        } else {
+          var _dow2 = ChronoField.DAY_OF_WEEK.checkValidIntValue(dowLong);
+          if (resolverStyle === ResolverStyle.STRICT) {
+            var temp = LocalDate.of(wby, 1, 4);
+            var range = Field._getWeekRangeByLocalDate(temp);
+            range.checkValidValue(wowby, this);
+          } else {
+            this.range().checkValidValue(wowby, this);
+          }
+          date = LocalDate.of(wby, 1, 4).plusWeeks(wowby - 1).with(ChronoField.DAY_OF_WEEK, _dow2);
+        }
+        fieldValues.remove(this);
+        fieldValues.remove(WEEK_BASED_YEAR);
+        fieldValues.remove(ChronoField.DAY_OF_WEEK);
+        return date;
       };
-      _proto2.standardOffset = function standardOffset() {
-        return this._offset;
+      _proto4.displayName = function displayName() {
+        return 'Week';
       };
-      _proto2.daylightSavings = function daylightSavings() {
-        return Duration.ZERO;
+      return WEEK_OF_WEEK_BASED_YEAR_FIELD;
+    }(Field);
+    var WEEK_BASED_YEAR_FIELD = function (_Field4) {
+      function WEEK_BASED_YEAR_FIELD() {
+        return _Field4.apply(this, arguments) || this;
+      }
+      _inheritsLoose(WEEK_BASED_YEAR_FIELD, _Field4);
+      var _proto5 = WEEK_BASED_YEAR_FIELD.prototype;
+      _proto5.toString = function toString() {
+        return 'WeekBasedYear';
       };
-      _proto2.isDaylightSavings = function isDaylightSavings() {
-        return false;
+      _proto5.baseUnit = function baseUnit() {
+        return WEEK_BASED_YEARS;
       };
-      _proto2.isValidOffset = function isValidOffset(localDateTime, offset) {
-        return this._offset.equals(offset);
+      _proto5.rangeUnit = function rangeUnit() {
+        return ChronoUnit.FOREVER;
       };
-      _proto2.nextTransition = function nextTransition() {
-        return null;
+      _proto5.range = function range() {
+        return ChronoField.YEAR.range();
       };
-      _proto2.previousTransition = function previousTransition() {
-        return null;
+      _proto5.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(ChronoField.EPOCH_DAY) && this._isIso(temporal);
       };
-      _proto2.transitions = function transitions() {
-        return [];
+      _proto5.rangeRefinedBy = function rangeRefinedBy(temporal) {
+        return ChronoField.YEAR.range();
       };
-      _proto2.transitionRules = function transitionRules() {
-        return [];
+      _proto5.getFrom = function getFrom(temporal) {
+        if (temporal.isSupported(this) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: WeekBasedYear');
+        }
+        return Field._getWeekBasedYear(LocalDate.from(temporal));
       };
-      _proto2.equals = function equals(other) {
-        if (this === other) {
-          return true;
+      _proto5.adjustInto = function adjustInto(temporal, newValue) {
+        if (this.isSupportedBy(temporal) === false) {
+          throw new UnsupportedTemporalTypeException('Unsupported field: WeekBasedYear');
         }
-        if (other instanceof Fixed) {
-          return this._offset.equals(other._offset);
+        var newWby = this.range().checkValidIntValue(newValue, WEEK_BASED_YEAR);
+        var date = LocalDate.from(temporal);
+        var dow = date.get(ChronoField.DAY_OF_WEEK);
+        var week = Field._getWeek(date);
+        if (week === 53 && Field._getWeekRangeByYear(newWby) === 52) {
+          week = 52;
         }
-        return false;
-      };
-      _proto2.toString = function toString() {
-        return "FixedRules:" + this._offset.toString();
+        var resolved = LocalDate.of(newWby, 1, 4);
+        var days = dow - resolved.get(ChronoField.DAY_OF_WEEK) + (week - 1) * 7;
+        resolved = resolved.plusDays(days);
+        return temporal.with(resolved);
       };
-      return Fixed;
-    }(ZoneRules);
-
-    var SECONDS_CACHE = {};
-    var ID_CACHE = {};
-    var ZoneOffset = function (_ZoneId) {
-      function ZoneOffset(totalSeconds) {
+      return WEEK_BASED_YEAR_FIELD;
+    }(Field);
+    var Unit = function (_TemporalUnit) {
+      function Unit(name, estimatedDuration) {
         var _this;
-        _this = _ZoneId.call(this) || this;
-        ZoneOffset._validateTotalSeconds(totalSeconds);
-        _this._totalSeconds = MathUtil.safeToInt(totalSeconds);
-        _this._rules = ZoneRules.of(_this);
-        _this._id = ZoneOffset._buildId(totalSeconds);
+        _this = _TemporalUnit.call(this) || this;
+        _this._name = name;
+        _this._duration = estimatedDuration;
         return _this;
       }
-      _inheritsLoose(ZoneOffset, _ZoneId);
-      var _proto = ZoneOffset.prototype;
-      _proto.totalSeconds = function totalSeconds() {
-        return this._totalSeconds;
+      _inheritsLoose(Unit, _TemporalUnit);
+      var _proto6 = Unit.prototype;
+      _proto6.duration = function duration() {
+        return this._duration;
       };
-      _proto.id = function id() {
-        return this._id;
+      _proto6.isDurationEstimated = function isDurationEstimated() {
+        return true;
       };
-      ZoneOffset._buildId = function _buildId(totalSeconds) {
-        if (totalSeconds === 0) {
-          return 'Z';
-        } else {
-          var absTotalSeconds = Math.abs(totalSeconds);
-          var absHours = MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_HOUR);
-          var absMinutes = MathUtil.intMod(MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);
-          var buf = "" + (totalSeconds < 0 ? '-' : '+') + (absHours < 10 ? '0' : '') + absHours + (absMinutes < 10 ? ':0' : ':') + absMinutes;
-          var absSeconds = MathUtil.intMod(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE);
-          if (absSeconds !== 0) {
-            buf += (absSeconds < 10 ? ':0' : ':') + absSeconds;
-          }
-          return buf;
-        }
+      _proto6.isDateBased = function isDateBased() {
+        return true;
       };
-      ZoneOffset._validateTotalSeconds = function _validateTotalSeconds(totalSeconds) {
-        if (Math.abs(totalSeconds) > ZoneOffset.MAX_SECONDS) {
-          throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
+      _proto6.isTimeBased = function isTimeBased() {
+        return false;
+      };
+      _proto6.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(ChronoField.EPOCH_DAY);
+      };
+      _proto6.addTo = function addTo(temporal, periodToAdd) {
+        switch (this) {
+          case WEEK_BASED_YEARS:
+            {
+              var added = MathUtil.safeAdd(temporal.get(WEEK_BASED_YEAR), periodToAdd);
+              return temporal.with(WEEK_BASED_YEAR, added);
+            }
+          case QUARTER_YEARS:
+            return temporal.plus(MathUtil.intDiv(periodToAdd, 256), ChronoUnit.YEARS).plus(MathUtil.intMod(periodToAdd, 256) * 3, ChronoUnit.MONTHS);
+          default:
+            throw new IllegalStateException('Unreachable');
         }
       };
-      ZoneOffset._validate = function _validate(hours, minutes, seconds) {
-        if (hours < -18 || hours > 18) {
-          throw new DateTimeException("Zone offset hours not in valid range: value " + hours + " is not in the range -18 to 18");
-        }
-        if (hours > 0) {
-          if (minutes < 0 || seconds < 0) {
-            throw new DateTimeException('Zone offset minutes and seconds must be positive because hours is positive');
-          }
-        } else if (hours < 0) {
-          if (minutes > 0 || seconds > 0) {
-            throw new DateTimeException('Zone offset minutes and seconds must be negative because hours is negative');
-          }
-        } else if (minutes > 0 && seconds < 0 || minutes < 0 && seconds > 0) {
-          throw new DateTimeException('Zone offset minutes and seconds must have the same sign');
-        }
-        if (Math.abs(minutes) > 59) {
-          throw new DateTimeException("Zone offset minutes not in valid range: abs(value) " + Math.abs(minutes) + " is not in the range 0 to 59");
-        }
-        if (Math.abs(seconds) > 59) {
-          throw new DateTimeException("Zone offset seconds not in valid range: abs(value) " + Math.abs(seconds) + " is not in the range 0 to 59");
-        }
-        if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {
-          throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
-        }
-      };
-      ZoneOffset.of = function of(offsetId) {
-        requireNonNull(offsetId, 'offsetId');
-        var offset = ID_CACHE[offsetId];
-        if (offset != null) {
-          return offset;
-        }
-        var hours, minutes, seconds;
-        switch (offsetId.length) {
-          case 2:
-            offsetId = offsetId[0] + "0" + offsetId[1];
-          case 3:
-            hours = ZoneOffset._parseNumber(offsetId, 1, false);
-            minutes = 0;
-            seconds = 0;
-            break;
-          case 5:
-            hours = ZoneOffset._parseNumber(offsetId, 1, false);
-            minutes = ZoneOffset._parseNumber(offsetId, 3, false);
-            seconds = 0;
-            break;
-          case 6:
-            hours = ZoneOffset._parseNumber(offsetId, 1, false);
-            minutes = ZoneOffset._parseNumber(offsetId, 4, true);
-            seconds = 0;
-            break;
-          case 7:
-            hours = ZoneOffset._parseNumber(offsetId, 1, false);
-            minutes = ZoneOffset._parseNumber(offsetId, 3, false);
-            seconds = ZoneOffset._parseNumber(offsetId, 5, false);
-            break;
-          case 9:
-            hours = ZoneOffset._parseNumber(offsetId, 1, false);
-            minutes = ZoneOffset._parseNumber(offsetId, 4, true);
-            seconds = ZoneOffset._parseNumber(offsetId, 7, true);
-            break;
+      _proto6.between = function between(temporal1, temporal2) {
+        switch (this) {
+          case WEEK_BASED_YEARS:
+            return MathUtil.safeSubtract(temporal2.getLong(WEEK_BASED_YEAR), temporal1.getLong(WEEK_BASED_YEAR));
+          case QUARTER_YEARS:
+            return MathUtil.intDiv(temporal1.until(temporal2, ChronoUnit.MONTHS), 3);
           default:
-            throw new DateTimeException("Invalid ID for ZoneOffset, invalid format: " + offsetId);
-        }
-        var first = offsetId[0];
-        if (first !== '+' && first !== '-') {
-          throw new DateTimeException("Invalid ID for ZoneOffset, plus/minus not found when expected: " + offsetId);
-        }
-        if (first === '-') {
-          return ZoneOffset.ofHoursMinutesSeconds(-hours, -minutes, -seconds);
-        } else {
-          return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, seconds);
-        }
-      };
-      ZoneOffset._parseNumber = function _parseNumber(offsetId, pos, precededByColon) {
-        if (precededByColon && offsetId[pos - 1] !== ':') {
-          throw new DateTimeException("Invalid ID for ZoneOffset, colon not found when expected: " + offsetId);
-        }
-        var ch1 = offsetId[pos];
-        var ch2 = offsetId[pos + 1];
-        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
-          throw new DateTimeException("Invalid ID for ZoneOffset, non numeric characters found: " + offsetId);
+            throw new IllegalStateException('Unreachable');
         }
-        return (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
       };
-      ZoneOffset.ofHours = function ofHours(hours) {
-        return ZoneOffset.ofHoursMinutesSeconds(hours, 0, 0);
+      _proto6.toString = function toString() {
+        return this._name;
       };
-      ZoneOffset.ofHoursMinutes = function ofHoursMinutes(hours, minutes) {
-        return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, 0);
+      return Unit;
+    }(TemporalUnit);
+    var DAY_OF_QUARTER = null;
+    var QUARTER_OF_YEAR = null;
+    var WEEK_OF_WEEK_BASED_YEAR = null;
+    var WEEK_BASED_YEAR = null;
+    var WEEK_BASED_YEARS = null;
+    var QUARTER_YEARS = null;
+    function _init$g() {
+      DAY_OF_QUARTER = new DAY_OF_QUARTER_FIELD();
+      QUARTER_OF_YEAR = new QUARTER_OF_YEAR_FIELD();
+      WEEK_OF_WEEK_BASED_YEAR = new WEEK_OF_WEEK_BASED_YEAR_FIELD();
+      WEEK_BASED_YEAR = new WEEK_BASED_YEAR_FIELD();
+      WEEK_BASED_YEARS = new Unit('WeekBasedYears', Duration.ofSeconds(31556952));
+      QUARTER_YEARS = new Unit('QuarterYears', Duration.ofSeconds(31556952 / 4));
+      IsoFields.DAY_OF_QUARTER = DAY_OF_QUARTER;
+      IsoFields.QUARTER_OF_YEAR = QUARTER_OF_YEAR;
+      IsoFields.WEEK_OF_WEEK_BASED_YEAR = WEEK_OF_WEEK_BASED_YEAR;
+      IsoFields.WEEK_BASED_YEAR = WEEK_BASED_YEAR;
+      IsoFields.WEEK_BASED_YEARS = WEEK_BASED_YEARS;
+      IsoFields.QUARTER_YEARS = QUARTER_YEARS;
+      LocalDate.prototype.isoWeekOfWeekyear = function () {
+        return this.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);
       };
-      ZoneOffset.ofHoursMinutesSeconds = function ofHoursMinutesSeconds(hours, minutes, seconds) {
-        ZoneOffset._validate(hours, minutes, seconds);
-        var totalSeconds = hours * LocalTime.SECONDS_PER_HOUR + minutes * LocalTime.SECONDS_PER_MINUTE + seconds;
-        return ZoneOffset.ofTotalSeconds(totalSeconds);
+      LocalDate.prototype.isoWeekyear = function () {
+        return this.get(IsoFields.WEEK_BASED_YEAR);
       };
-      ZoneOffset.ofTotalMinutes = function ofTotalMinutes(totalMinutes) {
-        var totalSeconds = totalMinutes * LocalTime.SECONDS_PER_MINUTE;
-        return ZoneOffset.ofTotalSeconds(totalSeconds);
+    }
+
+    /*
+     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+     */
+
+    var StringUtil = function () {
+      function StringUtil() {}
+      StringUtil.startsWith = function startsWith(text, pattern) {
+        return text.indexOf(pattern) === 0;
       };
-      ZoneOffset.ofTotalSeconds = function ofTotalSeconds(totalSeconds) {
-        if (totalSeconds % (15 * LocalTime.SECONDS_PER_MINUTE) === 0) {
-          var totalSecs = totalSeconds;
-          var result = SECONDS_CACHE[totalSecs];
-          if (result == null) {
-            result = new ZoneOffset(totalSeconds);
-            SECONDS_CACHE[totalSecs] = result;
-            ID_CACHE[result.id()] = result;
-          }
-          return result;
-        } else {
-          return new ZoneOffset(totalSeconds);
+      StringUtil.hashCode = function hashCode(text) {
+        var len = text.length;
+        if (len === 0) {
+          return 0;
         }
+        var hash = 0;
+        for (var i = 0; i < len; i++) {
+          var chr = text.charCodeAt(i);
+          hash = (hash << 5) - hash + chr;
+          hash |= 0;
+        }
+        return MathUtil.smi(hash);
       };
-      _proto.rules = function rules() {
-        return this._rules;
+      return StringUtil;
+    }();
+
+    /*
+     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+     * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+     */
+
+    var ZoneId = function () {
+      function ZoneId() {}
+      ZoneId.systemDefault = function systemDefault() {
+        throw new DateTimeException('not supported operation');
       };
-      _proto.get = function get(field) {
-        return this.getLong(field);
+      ZoneId.getAvailableZoneIds = function getAvailableZoneIds() {
+        throw new DateTimeException('not supported operation');
       };
-      _proto.getLong = function getLong(field) {
-        if (field === ChronoField.OFFSET_SECONDS) {
-          return this._totalSeconds;
-        } else if (field instanceof ChronoField) {
-          throw new DateTimeException("Unsupported field: " + field);
-        }
-        return field.getFrom(this);
+      ZoneId.of = function of(zoneId) {
+        throw new DateTimeException("not supported operation" + zoneId);
       };
-      _proto.query = function query(_query) {
-        requireNonNull(_query, 'query');
-        if (_query === TemporalQueries.offset() || _query === TemporalQueries.zone()) {
-          return this;
-        } else if (_query === TemporalQueries.localDate() || _query === TemporalQueries.localTime() || _query === TemporalQueries.precision() || _query === TemporalQueries.chronology() || _query === TemporalQueries.zoneId()) {
-          return null;
-        }
-        return _query.queryFrom(this);
+      ZoneId.ofOffset = function ofOffset(prefix, offset) {
+        throw new DateTimeException("not supported operation" + prefix + offset);
       };
-      _proto.adjustInto = function adjustInto(temporal) {
-        return temporal.with(ChronoField.OFFSET_SECONDS, this._totalSeconds);
+      ZoneId.from = function from(temporal) {
+        throw new DateTimeException("not supported operation" + temporal);
       };
-      _proto.compareTo = function compareTo(other) {
-        requireNonNull(other, 'other');
-        return other._totalSeconds - this._totalSeconds;
+      var _proto = ZoneId.prototype;
+      _proto.id = function id() {
+        abstractMethodFail('ZoneId.id');
       };
-      _proto.equals = function equals(obj) {
-        if (this === obj) {
+      _proto.rules = function rules() {
+        abstractMethodFail('ZoneId.rules');
+      };
+      _proto.normalized = function normalized() {
+        var rules = this.rules();
+        if (rules.isFixedOffset()) {
+          return rules.offset(Instant.EPOCH);
+        }
+        return this;
+      };
+      _proto.equals = function equals(other) {
+        if (this === other) {
           return true;
         }
-        if (obj instanceof ZoneOffset) {
-          return this._totalSeconds === obj._totalSeconds;
+        if (other instanceof ZoneId) {
+          return this.id() === other.id();
         }
         return false;
       };
       _proto.hashCode = function hashCode() {
-        return this._totalSeconds;
+        return StringUtil.hashCode(this.id());
       };
       _proto.toString = function toString() {
-        return this._id;
+        return this.id();
       };
-      return ZoneOffset;
-    }(ZoneId);
-    function _init$g() {
-      ZoneOffset.MAX_SECONDS = 18 * LocalTime.SECONDS_PER_HOUR;
-      ZoneOffset.UTC = ZoneOffset.ofTotalSeconds(0);
-      ZoneOffset.MIN = ZoneOffset.ofTotalSeconds(-ZoneOffset.MAX_SECONDS);
-      ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);
-    }
+      _proto.toJSON = function toJSON() {
+        return this.toString();
+      };
+      return ZoneId;
+    }();
 
-    var DateTimeBuilder = function (_TemporalAccessor) {
-      function DateTimeBuilder() {
-        var _this;
-        _this = _TemporalAccessor.call(this) || this;
-        _this.fieldValues = new EnumMap();
-        _this.chrono = null;
-        _this.zone = null;
-        _this.date = null;
-        _this.time = null;
-        _this.leapSecond = false;
-        _this.excessDays = null;
-        return _this;
-      }
-      _inheritsLoose(DateTimeBuilder, _TemporalAccessor);
-      DateTimeBuilder.create = function create(field, value) {
-        var dtb = new DateTimeBuilder();
-        dtb._addFieldValue(field, value);
-        return dtb;
+    var ZoneRules = function () {
+      function ZoneRules() {}
+      ZoneRules.of = function of(offset) {
+        requireNonNull(offset, 'offset');
+        return new Fixed(offset);
       };
-      var _proto = DateTimeBuilder.prototype;
-      _proto.getFieldValue0 = function getFieldValue0(field) {
-        return this.fieldValues.get(field);
+      var _proto = ZoneRules.prototype;
+      _proto.isFixedOffset = function isFixedOffset() {
+        abstractMethodFail('ZoneRules.isFixedOffset');
       };
-      _proto._addFieldValue = function _addFieldValue(field, value) {
-        requireNonNull(field, 'field');
-        var old = this.getFieldValue0(field);
-        if (old != null && old !== value) {
-          throw new DateTimeException("Conflict found: " + field + " " + old + " differs from " + field + " " + value + ": " + this);
+      _proto.offset = function offset(instantOrLocalDateTime) {
+        if (instantOrLocalDateTime instanceof Instant) {
+          return this.offsetOfInstant(instantOrLocalDateTime);
+        } else {
+          return this.offsetOfLocalDateTime(instantOrLocalDateTime);
         }
-        return this._putFieldValue0(field, value);
       };
-      _proto._putFieldValue0 = function _putFieldValue0(field, value) {
-        this.fieldValues.put(field, value);
-        return this;
+      _proto.offsetOfInstant = function offsetOfInstant(instant) {
+        abstractMethodFail('ZoneRules.offsetInstant');
       };
-      _proto.resolve = function resolve(resolverStyle, resolverFields) {
-        if (resolverFields != null) {
-          this.fieldValues.retainAll(resolverFields);
+      _proto.offsetOfEpochMilli = function offsetOfEpochMilli(epochMilli) {
+        abstractMethodFail('ZoneRules.offsetOfEpochMilli');
+      };
+      _proto.offsetOfLocalDateTime = function offsetOfLocalDateTime(localDateTime) {
+        abstractMethodFail('ZoneRules.offsetLocalDateTime');
+      };
+      _proto.validOffsets = function validOffsets(localDateTime) {
+        abstractMethodFail('ZoneRules.validOffsets');
+      };
+      _proto.transition = function transition(localDateTime) {
+        abstractMethodFail('ZoneRules.transition');
+      };
+      _proto.standardOffset = function standardOffset(instant) {
+        abstractMethodFail('ZoneRules.standardOffset');
+      };
+      _proto.daylightSavings = function daylightSavings(instant) {
+        abstractMethodFail('ZoneRules.daylightSavings');
+      };
+      _proto.isDaylightSavings = function isDaylightSavings(instant) {
+        abstractMethodFail('ZoneRules.isDaylightSavings');
+      };
+      _proto.isValidOffset = function isValidOffset(localDateTime, offset) {
+        abstractMethodFail('ZoneRules.isValidOffset');
+      };
+      _proto.nextTransition = function nextTransition(instant) {
+        abstractMethodFail('ZoneRules.nextTransition');
+      };
+      _proto.previousTransition = function previousTransition(instant) {
+        abstractMethodFail('ZoneRules.previousTransition');
+      };
+      _proto.transitions = function transitions() {
+        abstractMethodFail('ZoneRules.transitions');
+      };
+      _proto.transitionRules = function transitionRules() {
+        abstractMethodFail('ZoneRules.transitionRules');
+      };
+      _proto.toString = function toString() {
+        abstractMethodFail('ZoneRules.toString');
+      };
+      _proto.toJSON = function toJSON() {
+        return this.toString();
+      };
+      return ZoneRules;
+    }();
+    var Fixed = function (_ZoneRules) {
+      function Fixed(offset) {
+        var _this;
+        _this = _ZoneRules.call(this) || this;
+        _this._offset = offset;
+        return _this;
+      }
+      _inheritsLoose(Fixed, _ZoneRules);
+      var _proto2 = Fixed.prototype;
+      _proto2.isFixedOffset = function isFixedOffset() {
+        return true;
+      };
+      _proto2.offsetOfInstant = function offsetOfInstant() {
+        return this._offset;
+      };
+      _proto2.offsetOfEpochMilli = function offsetOfEpochMilli() {
+        return this._offset;
+      };
+      _proto2.offsetOfLocalDateTime = function offsetOfLocalDateTime() {
+        return this._offset;
+      };
+      _proto2.validOffsets = function validOffsets() {
+        return [this._offset];
+      };
+      _proto2.transition = function transition() {
+        return null;
+      };
+      _proto2.standardOffset = function standardOffset() {
+        return this._offset;
+      };
+      _proto2.daylightSavings = function daylightSavings() {
+        return Duration.ZERO;
+      };
+      _proto2.isDaylightSavings = function isDaylightSavings() {
+        return false;
+      };
+      _proto2.isValidOffset = function isValidOffset(localDateTime, offset) {
+        return this._offset.equals(offset);
+      };
+      _proto2.nextTransition = function nextTransition() {
+        return null;
+      };
+      _proto2.previousTransition = function previousTransition() {
+        return null;
+      };
+      _proto2.transitions = function transitions() {
+        return [];
+      };
+      _proto2.transitionRules = function transitionRules() {
+        return [];
+      };
+      _proto2.equals = function equals(other) {
+        if (this === other) {
+          return true;
         }
-        this._mergeDate(resolverStyle);
-        this._mergeTime(resolverStyle);
-        this._resolveTimeInferZeroes(resolverStyle);
-        if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
-          this.date = this.date.plus(this.excessDays);
-          this.excessDays = Period.ZERO;
+        if (other instanceof Fixed) {
+          return this._offset.equals(other._offset);
         }
-        this._resolveInstant();
-        return this;
+        return false;
       };
-      _proto._mergeDate = function _mergeDate(resolverStyle) {
-        this._checkDate(IsoChronology.INSTANCE.resolveDate(this.fieldValues, resolverStyle));
+      _proto2.toString = function toString() {
+        return "FixedRules:" + this._offset.toString();
       };
-      _proto._checkDate = function _checkDate(date) {
-        if (date != null) {
-          this._addObject(date);
-          for (var fieldName in this.fieldValues.keySet()) {
-            var field = ChronoField.byName(fieldName);
-            if (field) {
-              if (this.fieldValues.get(field) !== undefined) {
-                if (field.isDateBased()) {
-                  var val1 = void 0;
-                  try {
-                    val1 = date.getLong(field);
-                  } catch (ex) {
-                    if (ex instanceof DateTimeException) {
-                      continue;
-                    } else {
-                      throw ex;
-                    }
-                  }
-                  var val2 = this.fieldValues.get(field);
-                  if (val1 !== val2) {
-                    throw new DateTimeException("Conflict found: Field " + field + " " + val1 + " differs from " + field + " " + val2 + " derived from " + date);
-                  }
-                }
-              }
-            }
+      return Fixed;
+    }(ZoneRules);
+
+    var SECONDS_CACHE = {};
+    var ID_CACHE = {};
+    var ZoneOffset = function (_ZoneId) {
+      function ZoneOffset(totalSeconds) {
+        var _this;
+        _this = _ZoneId.call(this) || this;
+        ZoneOffset._validateTotalSeconds(totalSeconds);
+        _this._totalSeconds = MathUtil.safeToInt(totalSeconds);
+        _this._rules = ZoneRules.of(_this);
+        _this._id = ZoneOffset._buildId(totalSeconds);
+        return _this;
+      }
+      _inheritsLoose(ZoneOffset, _ZoneId);
+      var _proto = ZoneOffset.prototype;
+      _proto.totalSeconds = function totalSeconds() {
+        return this._totalSeconds;
+      };
+      _proto.id = function id() {
+        return this._id;
+      };
+      ZoneOffset._buildId = function _buildId(totalSeconds) {
+        if (totalSeconds === 0) {
+          return 'Z';
+        } else {
+          var absTotalSeconds = Math.abs(totalSeconds);
+          var absHours = MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_HOUR);
+          var absMinutes = MathUtil.intMod(MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);
+          var buf = "" + (totalSeconds < 0 ? '-' : '+') + (absHours < 10 ? '0' : '') + absHours + (absMinutes < 10 ? ':0' : ':') + absMinutes;
+          var absSeconds = MathUtil.intMod(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE);
+          if (absSeconds !== 0) {
+            buf += (absSeconds < 10 ? ':0' : ':') + absSeconds;
           }
+          return buf;
         }
       };
-      _proto._mergeTime = function _mergeTime(resolverStyle) {
-        if (this.fieldValues.containsKey(ChronoField.CLOCK_HOUR_OF_DAY)) {
-          var ch = this.fieldValues.remove(ChronoField.CLOCK_HOUR_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            if (resolverStyle === ResolverStyle.SMART && ch === 0) ; else {
-              ChronoField.CLOCK_HOUR_OF_DAY.checkValidValue(ch);
-            }
-          }
-          this._addFieldValue(ChronoField.HOUR_OF_DAY, ch === 24 ? 0 : ch);
+      ZoneOffset._validateTotalSeconds = function _validateTotalSeconds(totalSeconds) {
+        if (Math.abs(totalSeconds) > ZoneOffset.MAX_SECONDS) {
+          throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
         }
-        if (this.fieldValues.containsKey(ChronoField.CLOCK_HOUR_OF_AMPM)) {
-          var _ch = this.fieldValues.remove(ChronoField.CLOCK_HOUR_OF_AMPM);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            if (resolverStyle === ResolverStyle.SMART && _ch === 0) ; else {
-              ChronoField.CLOCK_HOUR_OF_AMPM.checkValidValue(_ch);
-            }
-          }
-          this._addFieldValue(ChronoField.HOUR_OF_AMPM, _ch === 12 ? 0 : _ch);
+      };
+      ZoneOffset._validate = function _validate(hours, minutes, seconds) {
+        if (hours < -18 || hours > 18) {
+          throw new DateTimeException("Zone offset hours not in valid range: value " + hours + " is not in the range -18 to 18");
         }
-        if (resolverStyle !== ResolverStyle.LENIENT) {
-          if (this.fieldValues.containsKey(ChronoField.AMPM_OF_DAY)) {
-            ChronoField.AMPM_OF_DAY.checkValidValue(this.fieldValues.get(ChronoField.AMPM_OF_DAY));
+        if (hours > 0) {
+          if (minutes < 0 || seconds < 0) {
+            throw new DateTimeException('Zone offset minutes and seconds must be positive because hours is positive');
           }
-          if (this.fieldValues.containsKey(ChronoField.HOUR_OF_AMPM)) {
-            ChronoField.HOUR_OF_AMPM.checkValidValue(this.fieldValues.get(ChronoField.HOUR_OF_AMPM));
+        } else if (hours < 0) {
+          if (minutes > 0 || seconds > 0) {
+            throw new DateTimeException('Zone offset minutes and seconds must be negative because hours is negative');
           }
+        } else if (minutes > 0 && seconds < 0 || minutes < 0 && seconds > 0) {
+          throw new DateTimeException('Zone offset minutes and seconds must have the same sign');
         }
-        if (this.fieldValues.containsKey(ChronoField.AMPM_OF_DAY) && this.fieldValues.containsKey(ChronoField.HOUR_OF_AMPM)) {
-          var ap = this.fieldValues.remove(ChronoField.AMPM_OF_DAY);
-          var hap = this.fieldValues.remove(ChronoField.HOUR_OF_AMPM);
-          this._addFieldValue(ChronoField.HOUR_OF_DAY, ap * 12 + hap);
+        if (Math.abs(minutes) > 59) {
+          throw new DateTimeException("Zone offset minutes not in valid range: abs(value) " + Math.abs(minutes) + " is not in the range 0 to 59");
         }
-        if (this.fieldValues.containsKey(ChronoField.NANO_OF_DAY)) {
-          var nod = this.fieldValues.remove(ChronoField.NANO_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            ChronoField.NANO_OF_DAY.checkValidValue(nod);
-          }
-          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(nod, 1000000000));
-          this._addFieldValue(ChronoField.NANO_OF_SECOND, MathUtil.intMod(nod, 1000000000));
-        }
-        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_DAY)) {
-          var cod = this.fieldValues.remove(ChronoField.MICRO_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            ChronoField.MICRO_OF_DAY.checkValidValue(cod);
-          }
-          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(cod, 1000000));
-          this._addFieldValue(ChronoField.MICRO_OF_SECOND, MathUtil.intMod(cod, 1000000));
-        }
-        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_DAY)) {
-          var lod = this.fieldValues.remove(ChronoField.MILLI_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            ChronoField.MILLI_OF_DAY.checkValidValue(lod);
-          }
-          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(lod, 1000));
-          this._addFieldValue(ChronoField.MILLI_OF_SECOND, MathUtil.intMod(lod, 1000));
-        }
-        if (this.fieldValues.containsKey(ChronoField.SECOND_OF_DAY)) {
-          var sod = this.fieldValues.remove(ChronoField.SECOND_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            ChronoField.SECOND_OF_DAY.checkValidValue(sod);
-          }
-          this._addFieldValue(ChronoField.HOUR_OF_DAY, MathUtil.intDiv(sod, 3600));
-          this._addFieldValue(ChronoField.MINUTE_OF_HOUR, MathUtil.intMod(MathUtil.intDiv(sod, 60), 60));
-          this._addFieldValue(ChronoField.SECOND_OF_MINUTE, MathUtil.intMod(sod, 60));
-        }
-        if (this.fieldValues.containsKey(ChronoField.MINUTE_OF_DAY)) {
-          var mod = this.fieldValues.remove(ChronoField.MINUTE_OF_DAY);
-          if (resolverStyle !== ResolverStyle.LENIENT) {
-            ChronoField.MINUTE_OF_DAY.checkValidValue(mod);
-          }
-          this._addFieldValue(ChronoField.HOUR_OF_DAY, MathUtil.intDiv(mod, 60));
-          this._addFieldValue(ChronoField.MINUTE_OF_HOUR, MathUtil.intMod(mod, 60));
+        if (Math.abs(seconds) > 59) {
+          throw new DateTimeException("Zone offset seconds not in valid range: abs(value) " + Math.abs(seconds) + " is not in the range 0 to 59");
         }
-        if (resolverStyle !== ResolverStyle.LENIENT) {
-          if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND)) {
-            ChronoField.MILLI_OF_SECOND.checkValidValue(this.fieldValues.get(ChronoField.MILLI_OF_SECOND));
-          }
-          if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
-            ChronoField.MICRO_OF_SECOND.checkValidValue(this.fieldValues.get(ChronoField.MICRO_OF_SECOND));
-          }
+        if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {
+          throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
         }
-        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND) && this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
-          var los = this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
-          var cos = this.fieldValues.get(ChronoField.MICRO_OF_SECOND);
-          this._putFieldValue0(ChronoField.MICRO_OF_SECOND, los * 1000 + MathUtil.intMod(cos, 1000));
+      };
+      ZoneOffset.of = function of(offsetId) {
+        requireNonNull(offsetId, 'offsetId');
+        var offset = ID_CACHE[offsetId];
+        if (offset != null) {
+          return offset;
         }
-        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND) && this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
-          var nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
-          this._putFieldValue0(ChronoField.MICRO_OF_SECOND, MathUtil.intDiv(nos, 1000));
-          this.fieldValues.remove(ChronoField.MICRO_OF_SECOND);
+        var hours, minutes, seconds;
+        switch (offsetId.length) {
+          case 2:
+            offsetId = offsetId[0] + "0" + offsetId[1];
+          case 3:
+            hours = ZoneOffset._parseNumber(offsetId, 1, false);
+            minutes = 0;
+            seconds = 0;
+            break;
+          case 5:
+            hours = ZoneOffset._parseNumber(offsetId, 1, false);
+            minutes = ZoneOffset._parseNumber(offsetId, 3, false);
+            seconds = 0;
+            break;
+          case 6:
+            hours = ZoneOffset._parseNumber(offsetId, 1, false);
+            minutes = ZoneOffset._parseNumber(offsetId, 4, true);
+            seconds = 0;
+            break;
+          case 7:
+            hours = ZoneOffset._parseNumber(offsetId, 1, false);
+            minutes = ZoneOffset._parseNumber(offsetId, 3, false);
+            seconds = ZoneOffset._parseNumber(offsetId, 5, false);
+            break;
+          case 9:
+            hours = ZoneOffset._parseNumber(offsetId, 1, false);
+            minutes = ZoneOffset._parseNumber(offsetId, 4, true);
+            seconds = ZoneOffset._parseNumber(offsetId, 7, true);
+            break;
+          default:
+            throw new DateTimeException("Invalid ID for ZoneOffset, invalid format: " + offsetId);
         }
-        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND) && this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
-          var _nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
-          this._putFieldValue0(ChronoField.MILLI_OF_SECOND, MathUtil.intDiv(_nos, 1000000));
-          this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
+        var first = offsetId[0];
+        if (first !== '+' && first !== '-') {
+          throw new DateTimeException("Invalid ID for ZoneOffset, plus/minus not found when expected: " + offsetId);
         }
-        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
-          var _cos = this.fieldValues.remove(ChronoField.MICRO_OF_SECOND);
-          this._putFieldValue0(ChronoField.NANO_OF_SECOND, _cos * 1000);
-        } else if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND)) {
-          var _los = this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
-          this._putFieldValue0(ChronoField.NANO_OF_SECOND, _los * 1000000);
+        if (first === '-') {
+          return ZoneOffset.ofHoursMinutesSeconds(-hours, -minutes, -seconds);
+        } else {
+          return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, seconds);
         }
       };
-      _proto._resolveTimeInferZeroes = function _resolveTimeInferZeroes(resolverStyle) {
-        var hod = this.fieldValues.get(ChronoField.HOUR_OF_DAY);
-        var moh = this.fieldValues.get(ChronoField.MINUTE_OF_HOUR);
-        var som = this.fieldValues.get(ChronoField.SECOND_OF_MINUTE);
-        var nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
-        if (hod == null) {
-          return;
-        }
-        if (moh == null && (som != null || nos != null)) {
-          return;
+      ZoneOffset._parseNumber = function _parseNumber(offsetId, pos, precededByColon) {
+        if (precededByColon && offsetId[pos - 1] !== ':') {
+          throw new DateTimeException("Invalid ID for ZoneOffset, colon not found when expected: " + offsetId);
         }
-        if (moh != null && som == null && nos != null) {
-          return;
+        var ch1 = offsetId[pos];
+        var ch2 = offsetId[pos + 1];
+        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
+          throw new DateTimeException("Invalid ID for ZoneOffset, non numeric characters found: " + offsetId);
         }
-        if (resolverStyle !== ResolverStyle.LENIENT) {
-          if (hod != null) {
-            if (resolverStyle === ResolverStyle.SMART && hod === 24 && (moh == null || moh === 0) && (som == null || som === 0) && (nos == null || nos === 0)) {
-              hod = 0;
-              this.excessDays = Period.ofDays(1);
-            }
-            var hodVal = ChronoField.HOUR_OF_DAY.checkValidIntValue(hod);
-            if (moh != null) {
-              var mohVal = ChronoField.MINUTE_OF_HOUR.checkValidIntValue(moh);
-              if (som != null) {
-                var somVal = ChronoField.SECOND_OF_MINUTE.checkValidIntValue(som);
-                if (nos != null) {
-                  var nosVal = ChronoField.NANO_OF_SECOND.checkValidIntValue(nos);
-                  this._addObject(LocalTime.of(hodVal, mohVal, somVal, nosVal));
-                } else {
-                  this._addObject(LocalTime.of(hodVal, mohVal, somVal));
-                }
-              } else {
-                if (nos == null) {
-                  this._addObject(LocalTime.of(hodVal, mohVal));
-                }
-              }
-            } else {
-              if (som == null && nos == null) {
-                this._addObject(LocalTime.of(hodVal, 0));
-              }
-            }
+        return (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
+      };
+      ZoneOffset.ofHours = function ofHours(hours) {
+        return ZoneOffset.ofHoursMinutesSeconds(hours, 0, 0);
+      };
+      ZoneOffset.ofHoursMinutes = function ofHoursMinutes(hours, minutes) {
+        return ZoneOffset.ofHoursMinutesSeconds(hours, minutes, 0);
+      };
+      ZoneOffset.ofHoursMinutesSeconds = function ofHoursMinutesSeconds(hours, minutes, seconds) {
+        ZoneOffset._validate(hours, minutes, seconds);
+        var totalSeconds = hours * LocalTime.SECONDS_PER_HOUR + minutes * LocalTime.SECONDS_PER_MINUTE + seconds;
+        return ZoneOffset.ofTotalSeconds(totalSeconds);
+      };
+      ZoneOffset.ofTotalMinutes = function ofTotalMinutes(totalMinutes) {
+        var totalSeconds = totalMinutes * LocalTime.SECONDS_PER_MINUTE;
+        return ZoneOffset.ofTotalSeconds(totalSeconds);
+      };
+      ZoneOffset.ofTotalSeconds = function ofTotalSeconds(totalSeconds) {
+        if (totalSeconds % (15 * LocalTime.SECONDS_PER_MINUTE) === 0) {
+          var totalSecs = totalSeconds;
+          var result = SECONDS_CACHE[totalSecs];
+          if (result == null) {
+            result = new ZoneOffset(totalSeconds);
+            SECONDS_CACHE[totalSecs] = result;
+            ID_CACHE[result.id()] = result;
           }
+          return result;
         } else {
-          if (hod != null) {
-            var _hodVal = hod;
-            if (moh != null) {
-              if (som != null) {
-                if (nos == null) {
-                  nos = 0;
-                }
-                var totalNanos = MathUtil.safeMultiply(_hodVal, 3600000000000);
-                totalNanos = MathUtil.safeAdd(totalNanos, MathUtil.safeMultiply(moh, 60000000000));
-                totalNanos = MathUtil.safeAdd(totalNanos, MathUtil.safeMultiply(som, 1000000000));
-                totalNanos = MathUtil.safeAdd(totalNanos, nos);
-                var excessDays = MathUtil.floorDiv(totalNanos, 86400000000000);
-                var nod = MathUtil.floorMod(totalNanos, 86400000000000);
-                this._addObject(LocalTime.ofNanoOfDay(nod));
-                this.excessDays = Period.ofDays(excessDays);
-              } else {
-                var totalSecs = MathUtil.safeMultiply(_hodVal, 3600);
-                totalSecs = MathUtil.safeAdd(totalSecs, MathUtil.safeMultiply(moh, 60));
-                var _excessDays = MathUtil.floorDiv(totalSecs, 86400);
-                var sod = MathUtil.floorMod(totalSecs, 86400);
-                this._addObject(LocalTime.ofSecondOfDay(sod));
-                this.excessDays = Period.ofDays(_excessDays);
-              }
-            } else {
-              var _excessDays2 = MathUtil.safeToInt(MathUtil.floorDiv(_hodVal, 24));
-              _hodVal = MathUtil.floorMod(_hodVal, 24);
-              this._addObject(LocalTime.of(_hodVal, 0));
-              this.excessDays = Period.ofDays(_excessDays2);
-            }
-          }
+          return new ZoneOffset(totalSeconds);
         }
-        this.fieldValues.remove(ChronoField.HOUR_OF_DAY);
-        this.fieldValues.remove(ChronoField.MINUTE_OF_HOUR);
-        this.fieldValues.remove(ChronoField.SECOND_OF_MINUTE);
-        this.fieldValues.remove(ChronoField.NANO_OF_SECOND);
       };
-      _proto._addObject = function _addObject(dateOrTime) {
-        if (dateOrTime instanceof ChronoLocalDate) {
-          this.date = dateOrTime;
-        } else if (dateOrTime instanceof LocalTime) {
-          this.time = dateOrTime;
-        }
+      _proto.rules = function rules() {
+        return this._rules;
       };
-      _proto._resolveInstant = function _resolveInstant() {
-        if (this.date != null && this.time != null) {
-          var offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);
-          if (offsetSecs != null) {
-            var offset = ZoneOffset.ofTotalSeconds(offsetSecs);
-            var instant = this.date.atTime(this.time).atZone(offset).getLong(ChronoField.INSTANT_SECONDS);
-            this.fieldValues.put(ChronoField.INSTANT_SECONDS, instant);
-          } else if (this.zone != null) {
-            var _instant = this.date.atTime(this.time).atZone(this.zone).getLong(ChronoField.INSTANT_SECONDS);
-            this.fieldValues.put(ChronoField.INSTANT_SECONDS, _instant);
-          }
-        }
+      _proto.get = function get(field) {
+        return this.getLong(field);
       };
-      _proto.build = function build(type) {
-        return type.queryFrom(this);
+      _proto.getLong = function getLong(field) {
+        if (field === ChronoField.OFFSET_SECONDS) {
+          return this._totalSeconds;
+        } else if (field instanceof ChronoField) {
+          throw new DateTimeException("Unsupported field: " + field);
+        }
+        return field.getFrom(this);
       };
-      _proto.isSupported = function isSupported(field) {
-        if (field == null) {
-          return false;
+      _proto.query = function query(_query) {
+        requireNonNull(_query, 'query');
+        if (_query === TemporalQueries.offset() || _query === TemporalQueries.zone()) {
+          return this;
+        } else if (_query === TemporalQueries.localDate() || _query === TemporalQueries.localTime() || _query === TemporalQueries.precision() || _query === TemporalQueries.chronology() || _query === TemporalQueries.zoneId()) {
+          return null;
         }
-        return this.fieldValues.containsKey(field) && this.fieldValues.get(field) !== undefined || this.date != null && this.date.isSupported(field) || this.time != null && this.time.isSupported(field);
+        return _query.queryFrom(this);
       };
-      _proto.getLong = function getLong(field) {
-        requireNonNull(field, 'field');
-        var value = this.getFieldValue0(field);
-        if (value == null) {
-          if (this.date != null && this.date.isSupported(field)) {
-            return this.date.getLong(field);
-          }
-          if (this.time != null && this.time.isSupported(field)) {
-            return this.time.getLong(field);
-          }
-          throw new DateTimeException("Field not found: " + field);
-        }
-        return value;
-      };
-      _proto.query = function query(_query) {
-        if (_query === TemporalQueries.zoneId()) {
-          return this.zone;
-        } else if (_query === TemporalQueries.chronology()) {
-          return this.chrono;
-        } else if (_query === TemporalQueries.localDate()) {
-          return this.date != null ? LocalDate.from(this.date) : null;
-        } else if (_query === TemporalQueries.localTime()) {
-          return this.time;
-        } else if (_query === TemporalQueries.zone() || _query === TemporalQueries.offset()) {
-          return _query.queryFrom(this);
-        } else if (_query === TemporalQueries.precision()) {
-          return null;
-        }
-        return _query.queryFrom(this);
-      };
-      return DateTimeBuilder;
-    }(TemporalAccessor);
-
-    var DateTimeParseContext = function () {
-      function DateTimeParseContext() {
-        if (arguments.length === 1) {
-          if (arguments[0] instanceof DateTimeParseContext) {
-            this._constructorSelf.apply(this, arguments);
-            return;
-          } else {
-            this._constructorFormatter.apply(this, arguments);
-          }
-        } else {
-          this._constructorParam.apply(this, arguments);
-        }
-        this._caseSensitive = true;
-        this._strict = true;
-        this._parsed = [new Parsed(this)];
-      }
-      var _proto = DateTimeParseContext.prototype;
-      _proto._constructorParam = function _constructorParam(locale, symbols, chronology) {
-        this._locale = locale;
-        this._symbols = symbols;
-        this._overrideChronology = chronology;
-      };
-      _proto._constructorFormatter = function _constructorFormatter(formatter) {
-        this._locale = formatter.locale();
-        this._symbols = formatter.decimalStyle();
-        this._overrideChronology = formatter.chronology();
-      };
-      _proto._constructorSelf = function _constructorSelf(other) {
-        this._locale = other._locale;
-        this._symbols = other._symbols;
-        this._overrideChronology = other._overrideChronology;
-        this._overrideZone = other._overrideZone;
-        this._caseSensitive = other._caseSensitive;
-        this._strict = other._strict;
-        this._parsed = [new Parsed(this)];
-      };
-      _proto.copy = function copy() {
-        return new DateTimeParseContext(this);
-      };
-      _proto.symbols = function symbols() {
-        return this._symbols;
-      };
-      _proto.isStrict = function isStrict() {
-        return this._strict;
-      };
-      _proto.setStrict = function setStrict(strict) {
-        this._strict = strict;
-      };
-      _proto.locale = function locale() {
-        return this._locale;
-      };
-      _proto.setLocale = function setLocale(locale) {
-        this._locale = locale;
-      };
-      _proto.startOptional = function startOptional() {
-        this._parsed.push(this.currentParsed().copy());
-      };
-      _proto.endOptional = function endOptional(successful) {
-        if (successful) {
-          this._parsed.splice(this._parsed.length - 2, 1);
-        } else {
-          this._parsed.splice(this._parsed.length - 1, 1);
-        }
-      };
-      _proto.isCaseSensitive = function isCaseSensitive() {
-        return this._caseSensitive;
+      _proto.adjustInto = function adjustInto(temporal) {
+        return temporal.with(ChronoField.OFFSET_SECONDS, this._totalSeconds);
       };
-      _proto.setCaseSensitive = function setCaseSensitive(caseSensitive) {
-        this._caseSensitive = caseSensitive;
+      _proto.compareTo = function compareTo(other) {
+        requireNonNull(other, 'other');
+        return other._totalSeconds - this._totalSeconds;
       };
-      _proto.subSequenceEquals = function subSequenceEquals(cs1, offset1, cs2, offset2, length) {
-        if (offset1 + length > cs1.length || offset2 + length > cs2.length) {
-          return false;
-        }
-        if (!this.isCaseSensitive()) {
-          cs1 = cs1.toLowerCase();
-          cs2 = cs2.toLowerCase();
-        }
-        for (var i = 0; i < length; i++) {
-          var ch1 = cs1[offset1 + i];
-          var ch2 = cs2[offset2 + i];
-          if (ch1 !== ch2) {
-            return false;
-          }
+      _proto.equals = function equals(obj) {
+        if (this === obj) {
+          return true;
         }
-        return true;
-      };
-      _proto.charEquals = function charEquals(ch1, ch2) {
-        if (this.isCaseSensitive()) {
-          return ch1 === ch2;
+        if (obj instanceof ZoneOffset) {
+          return this._totalSeconds === obj._totalSeconds;
         }
-        return this.charEqualsIgnoreCase(ch1, ch2);
-      };
-      _proto.charEqualsIgnoreCase = function charEqualsIgnoreCase(c1, c2) {
-        return c1 === c2 || c1.toLowerCase() === c2.toLowerCase();
-      };
-      _proto.setParsedField = function setParsedField(field, value, errorPos, successPos) {
-        var currentParsedFieldValues = this.currentParsed().fieldValues;
-        var old = currentParsedFieldValues.get(field);
-        currentParsedFieldValues.set(field, value);
-        return old != null && old !== value ? ~errorPos : successPos;
-      };
-      _proto.setParsedZone = function setParsedZone(zone) {
-        requireNonNull(zone, 'zone');
-        this.currentParsed().zone = zone;
-      };
-      _proto.getParsed = function getParsed(field) {
-        return this.currentParsed().fieldValues.get(field);
-      };
-      _proto.toParsed = function toParsed() {
-        return this.currentParsed();
-      };
-      _proto.currentParsed = function currentParsed() {
-        return this._parsed[this._parsed.length - 1];
+        return false;
       };
-      _proto.setParsedLeapSecond = function setParsedLeapSecond() {
-        this.currentParsed().leapSecond = true;
+      _proto.hashCode = function hashCode() {
+        return this._totalSeconds;
       };
-      _proto.getEffectiveChronology = function getEffectiveChronology() {
-        var chrono = this.currentParsed().chrono;
-        if (chrono == null) {
-          chrono = this._overrideChronology;
-          if (chrono == null) {
-            chrono = IsoChronology.INSTANCE;
-          }
-        }
-        return chrono;
+      _proto.toString = function toString() {
+        return this._id;
       };
-      return DateTimeParseContext;
-    }();
-    var Parsed = function (_Temporal) {
-      function Parsed(dateTimeParseContext) {
+      return ZoneOffset;
+    }(ZoneId);
+    function _init$f() {
+      ZoneOffset.MAX_SECONDS = 18 * LocalTime.SECONDS_PER_HOUR;
+      ZoneOffset.UTC = ZoneOffset.ofTotalSeconds(0);
+      ZoneOffset.MIN = ZoneOffset.ofTotalSeconds(-ZoneOffset.MAX_SECONDS);
+      ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);
+    }
+
+    var DateTimeBuilder = function (_TemporalAccessor) {
+      function DateTimeBuilder() {
         var _this;
-        _this = _Temporal.call(this) || this;
+        _this = _TemporalAccessor.call(this) || this;
+        _this.fieldValues = new EnumMap();
         _this.chrono = null;
         _this.zone = null;
-        _this.fieldValues = new EnumMap();
+        _this.date = null;
+        _this.time = null;
         _this.leapSecond = false;
-        _this.dateTimeParseContext = dateTimeParseContext;
+        _this.excessDays = null;
         return _this;
       }
-      _inheritsLoose(Parsed, _Temporal);
-      var _proto2 = Parsed.prototype;
-      _proto2.copy = function copy() {
-        var cloned = new Parsed();
-        cloned.chrono = this.chrono;
-        cloned.zone = this.zone;
-        cloned.fieldValues.putAll(this.fieldValues);
-        cloned.leapSecond = this.leapSecond;
-        cloned.dateTimeParseContext = this.dateTimeParseContext;
-        return cloned;
+      _inheritsLoose(DateTimeBuilder, _TemporalAccessor);
+      DateTimeBuilder.create = function create(field, value) {
+        var dtb = new DateTimeBuilder();
+        dtb._addFieldValue(field, value);
+        return dtb;
       };
-      _proto2.toString = function toString() {
-        return this.fieldValues + ", " + this.chrono + ", " + this.zone;
+      var _proto = DateTimeBuilder.prototype;
+      _proto.getFieldValue0 = function getFieldValue0(field) {
+        return this.fieldValues.get(field);
       };
-      _proto2.isSupported = function isSupported(field) {
-        return this.fieldValues.containsKey(field);
+      _proto._addFieldValue = function _addFieldValue(field, value) {
+        requireNonNull(field, 'field');
+        var old = this.getFieldValue0(field);
+        if (old != null && old !== value) {
+          throw new DateTimeException("Conflict found: " + field + " " + old + " differs from " + field + " " + value + ": " + this);
+        }
+        return this._putFieldValue0(field, value);
       };
-      _proto2.get = function get(field) {
-        var val = this.fieldValues.get(field);
-        assert(val != null);
-        return val;
+      _proto._putFieldValue0 = function _putFieldValue0(field, value) {
+        this.fieldValues.put(field, value);
+        return this;
       };
-      _proto2.query = function query(_query) {
-        if (_query === TemporalQueries.chronology()) {
-          return this.chrono;
+      _proto.resolve = function resolve(resolverStyle, resolverFields) {
+        if (resolverFields != null) {
+          this.fieldValues.retainAll(resolverFields);
         }
-        if (_query === TemporalQueries.zoneId() || _query === TemporalQueries.zone()) {
-          return this.zone;
+        if (this._resolveFields(resolverStyle)) ;
+        this._mergeDate(resolverStyle);
+        this._mergeTime(resolverStyle);
+        this._resolveTimeInferZeroes(resolverStyle);
+        if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
+          this.date = this.date.plus(this.excessDays);
+          this.excessDays = Period.ZERO;
         }
-        return _Temporal.prototype.query.call(this, _query);
+        this._resolveInstant();
+        return this;
       };
-      _proto2.toBuilder = function toBuilder() {
-        var builder = new DateTimeBuilder();
-        builder.fieldValues.putAll(this.fieldValues);
-        builder.chrono = this.dateTimeParseContext.getEffectiveChronology();
-        if (this.zone != null) {
-          builder.zone = this.zone;
-        } else {
-          builder.zone = this.overrideZone;
+      _proto._resolveFields = function _resolveFields(resolverStyle) {
+        var resolved = false;
+        for (var _i = 0, _arr = [IsoFields.WEEK_OF_WEEK_BASED_YEAR, IsoFields.DAY_OF_QUARTER]; _i < _arr.length; _i++) {
+          var field = _arr[_i];
+          if (this.fieldValues.containsKey(field)) {
+            var date = field.resolve(this.fieldValues, this, resolverStyle);
+            if (date != null) {
+              this._checkDate(date);
+              resolved = true;
+            }
+          }
         }
-        builder.leapSecond = this.leapSecond;
-        builder.excessDays = this.excessDays;
-        return builder;
+        return resolved;
       };
-      return Parsed;
-    }(Temporal);
-
-    /*
-     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
-     * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
-     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
-     */
-
-    var DateTimePrintContext = function () {
-      function DateTimePrintContext(temporal, localeOrFormatter, symbols) {
-        if (arguments.length === 2 && arguments[1] instanceof DateTimeFormatter) {
-          this._temporal = DateTimePrintContext.adjust(temporal, localeOrFormatter);
-          this._locale = localeOrFormatter.locale();
-          this._symbols = localeOrFormatter.decimalStyle();
-        } else {
-          this._temporal = temporal;
-          this._locale = localeOrFormatter;
-          this._symbols = symbols;
-        }
-        this._optional = 0;
-      }
-      DateTimePrintContext.adjust = function adjust(temporal, formatter) {
-        return temporal;
-      };
-      var _proto = DateTimePrintContext.prototype;
-      _proto.symbols = function symbols() {
-        return this._symbols;
-      };
-      _proto.startOptional = function startOptional() {
-        this._optional++;
-      };
-      _proto.endOptional = function endOptional() {
-        this._optional--;
+      _proto._mergeDate = function _mergeDate(resolverStyle) {
+        this._checkDate(IsoChronology.INSTANCE.resolveDate(this.fieldValues, resolverStyle));
       };
-      _proto.getValueQuery = function getValueQuery(query) {
-        var result = this._temporal.query(query);
-        if (result == null && this._optional === 0) {
-          throw new DateTimeException("Unable to extract value: " + this._temporal);
+      _proto._checkDate = function _checkDate(date) {
+        if (date != null) {
+          this._addObject(date);
+          for (var fieldName in this.fieldValues.keySet()) {
+            var field = ChronoField.byName(fieldName);
+            if (field) {
+              if (this.fieldValues.get(field) !== undefined) {
+                if (field.isDateBased()) {
+                  var val1 = void 0;
+                  try {
+                    val1 = date.getLong(field);
+                  } catch (ex) {
+                    if (ex instanceof DateTimeException) {
+                      continue;
+                    } else {
+                      throw ex;
+                    }
+                  }
+                  var val2 = this.fieldValues.get(field);
+                  if (val1 !== val2) {
+                    throw new DateTimeException("Conflict found: Field " + field + " " + val1 + " differs from " + field + " " + val2 + " derived from " + date);
+                  }
+                }
+              }
+            }
+          }
         }
-        return result;
       };
-      _proto.getValue = function getValue(field) {
-        try {
-          return this._temporal.getLong(field);
-        } catch (ex) {
-          if (ex instanceof DateTimeException && this._optional > 0) {
-            return null;
+      _proto._mergeTime = function _mergeTime(resolverStyle) {
+        if (this.fieldValues.containsKey(ChronoField.CLOCK_HOUR_OF_DAY)) {
+          var ch = this.fieldValues.remove(ChronoField.CLOCK_HOUR_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            if (resolverStyle === ResolverStyle.SMART && ch === 0) ; else {
+              ChronoField.CLOCK_HOUR_OF_DAY.checkValidValue(ch);
+            }
           }
-          throw ex;
+          this._addFieldValue(ChronoField.HOUR_OF_DAY, ch === 24 ? 0 : ch);
         }
-      };
-      _proto.temporal = function temporal() {
-        return this._temporal;
-      };
-      _proto.locale = function locale() {
-        return this._locale;
-      };
-      _proto.setDateTime = function setDateTime(temporal) {
-        this._temporal = temporal;
-      };
-      _proto.setLocale = function setLocale(locale) {
-        this._locale = locale;
-      };
-      return DateTimePrintContext;
-    }();
-
-    var IsoFields = {};
-    var QUARTER_DAYS = [0, 90, 181, 273, 0, 91, 182, 274];
-    var Field = function (_TemporalField) {
-      function Field() {
-        return _TemporalField.apply(this, arguments) || this;
-      }
-      _inheritsLoose(Field, _TemporalField);
-      var _proto = Field.prototype;
-      _proto.isDateBased = function isDateBased() {
-        return true;
-      };
-      _proto.isTimeBased = function isTimeBased() {
-        return false;
-      };
-      _proto._isIso = function _isIso() {
-        return true;
-      };
-      Field._getWeekRangeByLocalDate = function _getWeekRangeByLocalDate(date) {
-        var wby = Field._getWeekBasedYear(date);
-        return ValueRange.of(1, Field._getWeekRangeByYear(wby));
-      };
-      Field._getWeekRangeByYear = function _getWeekRangeByYear(wby) {
-        var date = LocalDate.of(wby, 1, 1);
-        if (date.dayOfWeek() === DayOfWeek.THURSDAY || date.dayOfWeek() === DayOfWeek.WEDNESDAY && date.isLeapYear()) {
-          return 53;
+        if (this.fieldValues.containsKey(ChronoField.CLOCK_HOUR_OF_AMPM)) {
+          var _ch = this.fieldValues.remove(ChronoField.CLOCK_HOUR_OF_AMPM);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            if (resolverStyle === ResolverStyle.SMART && _ch === 0) ; else {
+              ChronoField.CLOCK_HOUR_OF_AMPM.checkValidValue(_ch);
+            }
+          }
+          this._addFieldValue(ChronoField.HOUR_OF_AMPM, _ch === 12 ? 0 : _ch);
         }
-        return 52;
-      };
-      Field._getWeek = function _getWeek(date) {
-        var dow0 = date.dayOfWeek().ordinal();
-        var doy0 = date.dayOfYear() - 1;
-        var doyThu0 = doy0 + (3 - dow0);
-        var alignedWeek = MathUtil.intDiv(doyThu0, 7);
-        var firstThuDoy0 = doyThu0 - alignedWeek * 7;
-        var firstMonDoy0 = firstThuDoy0 - 3;
-        if (firstMonDoy0 < -3) {
-          firstMonDoy0 += 7;
+        if (resolverStyle !== ResolverStyle.LENIENT) {
+          if (this.fieldValues.containsKey(ChronoField.AMPM_OF_DAY)) {
+            ChronoField.AMPM_OF_DAY.checkValidValue(this.fieldValues.get(ChronoField.AMPM_OF_DAY));
+          }
+          if (this.fieldValues.containsKey(ChronoField.HOUR_OF_AMPM)) {
+            ChronoField.HOUR_OF_AMPM.checkValidValue(this.fieldValues.get(ChronoField.HOUR_OF_AMPM));
+          }
         }
-        if (doy0 < firstMonDoy0) {
-          return Field._getWeekRangeByLocalDate(date.withDayOfYear(180).minusYears(1)).maximum();
+        if (this.fieldValues.containsKey(ChronoField.AMPM_OF_DAY) && this.fieldValues.containsKey(ChronoField.HOUR_OF_AMPM)) {
+          var ap = this.fieldValues.remove(ChronoField.AMPM_OF_DAY);
+          var hap = this.fieldValues.remove(ChronoField.HOUR_OF_AMPM);
+          this._addFieldValue(ChronoField.HOUR_OF_DAY, ap * 12 + hap);
         }
-        var week = MathUtil.intDiv(doy0 - firstMonDoy0, 7) + 1;
-        if (week === 53) {
-          if ((firstMonDoy0 === -3 || firstMonDoy0 === -2 && date.isLeapYear()) === false) {
-            week = 1;
+        if (this.fieldValues.containsKey(ChronoField.NANO_OF_DAY)) {
+          var nod = this.fieldValues.remove(ChronoField.NANO_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            ChronoField.NANO_OF_DAY.checkValidValue(nod);
           }
+          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(nod, 1000000000));
+          this._addFieldValue(ChronoField.NANO_OF_SECOND, MathUtil.intMod(nod, 1000000000));
         }
-        return week;
-      };
-      Field._getWeekBasedYear = function _getWeekBasedYear(date) {
-        var year = date.year();
-        var doy = date.dayOfYear();
-        if (doy <= 3) {
-          var dow = date.dayOfWeek().ordinal();
-          if (doy - dow < -2) {
-            year--;
+        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_DAY)) {
+          var cod = this.fieldValues.remove(ChronoField.MICRO_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            ChronoField.MICRO_OF_DAY.checkValidValue(cod);
           }
-        } else if (doy >= 363) {
-          var _dow = date.dayOfWeek().ordinal();
-          doy = doy - 363 - (date.isLeapYear() ? 1 : 0);
-          if (doy - _dow >= 0) {
-            year++;
+          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(cod, 1000000));
+          this._addFieldValue(ChronoField.MICRO_OF_SECOND, MathUtil.intMod(cod, 1000000));
+        }
+        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_DAY)) {
+          var lod = this.fieldValues.remove(ChronoField.MILLI_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            ChronoField.MILLI_OF_DAY.checkValidValue(lod);
           }
+          this._addFieldValue(ChronoField.SECOND_OF_DAY, MathUtil.intDiv(lod, 1000));
+          this._addFieldValue(ChronoField.MILLI_OF_SECOND, MathUtil.intMod(lod, 1000));
+        }
+        if (this.fieldValues.containsKey(ChronoField.SECOND_OF_DAY)) {
+          var sod = this.fieldValues.remove(ChronoField.SECOND_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            ChronoField.SECOND_OF_DAY.checkValidValue(sod);
+          }
+          this._addFieldValue(ChronoField.HOUR_OF_DAY, MathUtil.intDiv(sod, 3600));
+          this._addFieldValue(ChronoField.MINUTE_OF_HOUR, MathUtil.intMod(MathUtil.intDiv(sod, 60), 60));
+          this._addFieldValue(ChronoField.SECOND_OF_MINUTE, MathUtil.intMod(sod, 60));
+        }
+        if (this.fieldValues.containsKey(ChronoField.MINUTE_OF_DAY)) {
+          var mod = this.fieldValues.remove(ChronoField.MINUTE_OF_DAY);
+          if (resolverStyle !== ResolverStyle.LENIENT) {
+            ChronoField.MINUTE_OF_DAY.checkValidValue(mod);
+          }
+          this._addFieldValue(ChronoField.HOUR_OF_DAY, MathUtil.intDiv(mod, 60));
+          this._addFieldValue(ChronoField.MINUTE_OF_HOUR, MathUtil.intMod(mod, 60));
+        }
+        if (resolverStyle !== ResolverStyle.LENIENT) {
+          if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND)) {
+            ChronoField.MILLI_OF_SECOND.checkValidValue(this.fieldValues.get(ChronoField.MILLI_OF_SECOND));
+          }
+          if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
+            ChronoField.MICRO_OF_SECOND.checkValidValue(this.fieldValues.get(ChronoField.MICRO_OF_SECOND));
+          }
+        }
+        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND) && this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
+          var los = this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
+          var cos = this.fieldValues.get(ChronoField.MICRO_OF_SECOND);
+          this._putFieldValue0(ChronoField.MICRO_OF_SECOND, los * 1000 + MathUtil.intMod(cos, 1000));
+        }
+        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND) && this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
+          var nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
+          this._putFieldValue0(ChronoField.MICRO_OF_SECOND, MathUtil.intDiv(nos, 1000));
+          this.fieldValues.remove(ChronoField.MICRO_OF_SECOND);
+        }
+        if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND) && this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
+          var _nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
+          this._putFieldValue0(ChronoField.MILLI_OF_SECOND, MathUtil.intDiv(_nos, 1000000));
+          this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
+        }
+        if (this.fieldValues.containsKey(ChronoField.MICRO_OF_SECOND)) {
+          var _cos = this.fieldValues.remove(ChronoField.MICRO_OF_SECOND);
+          this._putFieldValue0(ChronoField.NANO_OF_SECOND, _cos * 1000);
+        } else if (this.fieldValues.containsKey(ChronoField.MILLI_OF_SECOND)) {
+          var _los = this.fieldValues.remove(ChronoField.MILLI_OF_SECOND);
+          this._putFieldValue0(ChronoField.NANO_OF_SECOND, _los * 1000000);
         }
-        return year;
-      };
-      _proto.displayName = function displayName() {
-        return this.toString();
-      };
-      _proto.resolve = function resolve() {
-        return null;
-      };
-      _proto.name = function name() {
-        return this.toString();
-      };
-      return Field;
-    }(TemporalField);
-    var DAY_OF_QUARTER_FIELD = function (_Field) {
-      function DAY_OF_QUARTER_FIELD() {
-        return _Field.apply(this, arguments) || this;
-      }
-      _inheritsLoose(DAY_OF_QUARTER_FIELD, _Field);
-      var _proto2 = DAY_OF_QUARTER_FIELD.prototype;
-      _proto2.toString = function toString() {
-        return 'DayOfQuarter';
-      };
-      _proto2.baseUnit = function baseUnit() {
-        return ChronoUnit.DAYS;
-      };
-      _proto2.rangeUnit = function rangeUnit() {
-        return QUARTER_YEARS;
-      };
-      _proto2.range = function range() {
-        return ValueRange.of(1, 90, 92);
       };
-      _proto2.isSupportedBy = function isSupportedBy(temporal) {
-        return temporal.isSupported(ChronoField.DAY_OF_YEAR) && temporal.isSupported(ChronoField.MONTH_OF_YEAR) && temporal.isSupported(ChronoField.YEAR) && this._isIso(temporal);
+      _proto._resolveTimeInferZeroes = function _resolveTimeInferZeroes(resolverStyle) {
+        var hod = this.fieldValues.get(ChronoField.HOUR_OF_DAY);
+        var moh = this.fieldValues.get(ChronoField.MINUTE_OF_HOUR);
+        var som = this.fieldValues.get(ChronoField.SECOND_OF_MINUTE);
+        var nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
+        if (hod == null) {
+          return;
+        }
+        if (moh == null && (som != null || nos != null)) {
+          return;
+        }
+        if (moh != null && som == null && nos != null) {
+          return;
+        }
+        if (resolverStyle !== ResolverStyle.LENIENT) {
+          if (hod != null) {
+            if (resolverStyle === ResolverStyle.SMART && hod === 24 && (moh == null || moh === 0) && (som == null || som === 0) && (nos == null || nos === 0)) {
+              hod = 0;
+              this.excessDays = Period.ofDays(1);
+            }
+            var hodVal = ChronoField.HOUR_OF_DAY.checkValidIntValue(hod);
+            if (moh != null) {
+              var mohVal = ChronoField.MINUTE_OF_HOUR.checkValidIntValue(moh);
+              if (som != null) {
+                var somVal = ChronoField.SECOND_OF_MINUTE.checkValidIntValue(som);
+                if (nos != null) {
+                  var nosVal = ChronoField.NANO_OF_SECOND.checkValidIntValue(nos);
+                  this._addObject(LocalTime.of(hodVal, mohVal, somVal, nosVal));
+                } else {
+                  this._addObject(LocalTime.of(hodVal, mohVal, somVal));
+                }
+              } else {
+                if (nos == null) {
+                  this._addObject(LocalTime.of(hodVal, mohVal));
+                }
+              }
+            } else {
+              if (som == null && nos == null) {
+                this._addObject(LocalTime.of(hodVal, 0));
+              }
+            }
+          }
+        } else {
+          if (hod != null) {
+            var _hodVal = hod;
+            if (moh != null) {
+              if (som != null) {
+                if (nos == null) {
+                  nos = 0;
+                }
+                var totalNanos = MathUtil.safeMultiply(_hodVal, 3600000000000);
+                totalNanos = MathUtil.safeAdd(totalNanos, MathUtil.safeMultiply(moh, 60000000000));
+                totalNanos = MathUtil.safeAdd(totalNanos, MathUtil.safeMultiply(som, 1000000000));
+                totalNanos = MathUtil.safeAdd(totalNanos, nos);
+                var excessDays = MathUtil.floorDiv(totalNanos, 86400000000000);
+                var nod = MathUtil.floorMod(totalNanos, 86400000000000);
+                this._addObject(LocalTime.ofNanoOfDay(nod));
+                this.excessDays = Period.ofDays(excessDays);
+              } else {
+                var totalSecs = MathUtil.safeMultiply(_hodVal, 3600);
+                totalSecs = MathUtil.safeAdd(totalSecs, MathUtil.safeMultiply(moh, 60));
+                var _excessDays = MathUtil.floorDiv(totalSecs, 86400);
+                var sod = MathUtil.floorMod(totalSecs, 86400);
+                this._addObject(LocalTime.ofSecondOfDay(sod));
+                this.excessDays = Period.ofDays(_excessDays);
+              }
+            } else {
+              var _excessDays2 = MathUtil.safeToInt(MathUtil.floorDiv(_hodVal, 24));
+              _hodVal = MathUtil.floorMod(_hodVal, 24);
+              this._addObject(LocalTime.of(_hodVal, 0));
+              this.excessDays = Period.ofDays(_excessDays2);
+            }
+          }
+        }
+        this.fieldValues.remove(ChronoField.HOUR_OF_DAY);
+        this.fieldValues.remove(ChronoField.MINUTE_OF_HOUR);
+        this.fieldValues.remove(ChronoField.SECOND_OF_MINUTE);
+        this.fieldValues.remove(ChronoField.NANO_OF_SECOND);
       };
-      _proto2.rangeRefinedBy = function rangeRefinedBy(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: DayOfQuarter');
+      _proto._addObject = function _addObject(dateOrTime) {
+        if (dateOrTime instanceof ChronoLocalDate) {
+          this.date = dateOrTime;
+        } else if (dateOrTime instanceof LocalTime) {
+          this.time = dateOrTime;
         }
-        var qoy = temporal.getLong(QUARTER_OF_YEAR);
-        if (qoy === 1) {
-          var year = temporal.getLong(ChronoField.YEAR);
-          return IsoChronology.isLeapYear(year) ? ValueRange.of(1, 91) : ValueRange.of(1, 90);
-        } else if (qoy === 2) {
-          return ValueRange.of(1, 91);
-        } else if (qoy === 3 || qoy === 4) {
-          return ValueRange.of(1, 92);
+      };
+      _proto._resolveInstant = function _resolveInstant() {
+        if (this.date != null && this.time != null) {
+          var offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);
+          if (offsetSecs != null) {
+            var offset = ZoneOffset.ofTotalSeconds(offsetSecs);
+            var instant = this.date.atTime(this.time).atZone(offset).getLong(ChronoField.INSTANT_SECONDS);
+            this.fieldValues.put(ChronoField.INSTANT_SECONDS, instant);
+          } else if (this.zone != null) {
+            var _instant = this.date.atTime(this.time).atZone(this.zone).getLong(ChronoField.INSTANT_SECONDS);
+            this.fieldValues.put(ChronoField.INSTANT_SECONDS, _instant);
+          }
         }
-        return this.range();
       };
-      _proto2.getFrom = function getFrom(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: DayOfQuarter');
+      _proto.build = function build(type) {
+        return type.queryFrom(this);
+      };
+      _proto.isSupported = function isSupported(field) {
+        if (field == null) {
+          return false;
         }
-        var doy = temporal.get(ChronoField.DAY_OF_YEAR);
-        var moy = temporal.get(ChronoField.MONTH_OF_YEAR);
-        var year = temporal.getLong(ChronoField.YEAR);
-        return doy - QUARTER_DAYS[MathUtil.intDiv(moy - 1, 3) + (IsoChronology.isLeapYear(year) ? 4 : 0)];
+        return this.fieldValues.containsKey(field) && this.fieldValues.get(field) !== undefined || this.date != null && this.date.isSupported(field) || this.time != null && this.time.isSupported(field);
       };
-      _proto2.adjustInto = function adjustInto(temporal, newValue) {
-        var curValue = this.getFrom(temporal);
-        this.range().checkValidValue(newValue, this);
-        return temporal.with(ChronoField.DAY_OF_YEAR, temporal.getLong(ChronoField.DAY_OF_YEAR) + (newValue - curValue));
+      _proto.getLong = function getLong(field) {
+        requireNonNull(field, 'field');
+        var value = this.getFieldValue0(field);
+        if (value == null) {
+          if (this.date != null && this.date.isSupported(field)) {
+            return this.date.getLong(field);
+          }
+          if (this.time != null && this.time.isSupported(field)) {
+            return this.time.getLong(field);
+          }
+          throw new DateTimeException("Field not found: " + field);
+        }
+        return value;
       };
-      _proto2.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
-        var yearLong = fieldValues.get(ChronoField.YEAR);
-        var qoyLong = fieldValues.get(QUARTER_OF_YEAR);
-        if (yearLong == null || qoyLong == null) {
+      _proto.query = function query(_query) {
+        if (_query === TemporalQueries.zoneId()) {
+          return this.zone;
+        } else if (_query === TemporalQueries.chronology()) {
+          return this.chrono;
+        } else if (_query === TemporalQueries.localDate()) {
+          return this.date != null ? LocalDate.from(this.date) : null;
+        } else if (_query === TemporalQueries.localTime()) {
+          return this.time;
+        } else if (_query === TemporalQueries.zone() || _query === TemporalQueries.offset()) {
+          return _query.queryFrom(this);
+        } else if (_query === TemporalQueries.precision()) {
           return null;
         }
-        var y = ChronoField.YEAR.checkValidIntValue(yearLong);
-        var doq = fieldValues.get(DAY_OF_QUARTER);
-        var date;
-        if (resolverStyle === ResolverStyle.LENIENT) {
-          var qoy = qoyLong;
-          date = LocalDate.of(y, 1, 1);
-          date = date.plusMonths(MathUtil.safeMultiply(MathUtil.safeSubtract(qoy, 1), 3));
-          date = date.plusDays(MathUtil.safeSubtract(doq, 1));
-        } else {
-          var _qoy = QUARTER_OF_YEAR.range().checkValidIntValue(qoyLong, QUARTER_OF_YEAR);
-          if (resolverStyle === ResolverStyle.STRICT) {
-            var max = 92;
-            if (_qoy === 1) {
-              max = IsoChronology.isLeapYear(y) ? 91 : 90;
-            } else if (_qoy === 2) {
-              max = 91;
-            }
-            ValueRange.of(1, max).checkValidValue(doq, this);
+        return _query.queryFrom(this);
+      };
+      return DateTimeBuilder;
+    }(TemporalAccessor);
+
+    var DateTimeParseContext = function () {
+      function DateTimeParseContext() {
+        if (arguments.length === 1) {
+          if (arguments[0] instanceof DateTimeParseContext) {
+            this._constructorSelf.apply(this, arguments);
+            return;
           } else {
-            this.range().checkValidValue(doq, this);
+            this._constructorFormatter.apply(this, arguments);
           }
-          date = LocalDate.of(y, (_qoy - 1) * 3 + 1, 1).plusDays(doq - 1);
+        } else {
+          this._constructorParam.apply(this, arguments);
         }
-        fieldValues.remove(this);
-        fieldValues.remove(ChronoField.YEAR);
-        fieldValues.remove(QUARTER_OF_YEAR);
-        return date;
-      };
-      return DAY_OF_QUARTER_FIELD;
-    }(Field);
-    var QUARTER_OF_YEAR_FIELD = function (_Field2) {
-      function QUARTER_OF_YEAR_FIELD() {
-        return _Field2.apply(this, arguments) || this;
+        this._caseSensitive = true;
+        this._strict = true;
+        this._parsed = [new Parsed(this)];
       }
-      _inheritsLoose(QUARTER_OF_YEAR_FIELD, _Field2);
-      var _proto3 = QUARTER_OF_YEAR_FIELD.prototype;
-      _proto3.toString = function toString() {
-        return 'QuarterOfYear';
+      var _proto = DateTimeParseContext.prototype;
+      _proto._constructorParam = function _constructorParam(locale, symbols, chronology) {
+        this._locale = locale;
+        this._symbols = symbols;
+        this._overrideChronology = chronology;
       };
-      _proto3.baseUnit = function baseUnit() {
-        return QUARTER_YEARS;
+      _proto._constructorFormatter = function _constructorFormatter(formatter) {
+        this._locale = formatter.locale();
+        this._symbols = formatter.decimalStyle();
+        this._overrideChronology = formatter.chronology();
       };
-      _proto3.rangeUnit = function rangeUnit() {
-        return ChronoUnit.YEARS;
+      _proto._constructorSelf = function _constructorSelf(other) {
+        this._locale = other._locale;
+        this._symbols = other._symbols;
+        this._overrideChronology = other._overrideChronology;
+        this._overrideZone = other._overrideZone;
+        this._caseSensitive = other._caseSensitive;
+        this._strict = other._strict;
+        this._parsed = [new Parsed(this)];
       };
-      _proto3.range = function range() {
-        return ValueRange.of(1, 4);
+      _proto.copy = function copy() {
+        return new DateTimeParseContext(this);
       };
-      _proto3.isSupportedBy = function isSupportedBy(temporal) {
-        return temporal.isSupported(ChronoField.MONTH_OF_YEAR) && this._isIso(temporal);
+      _proto.symbols = function symbols() {
+        return this._symbols;
       };
-      _proto3.rangeRefinedBy = function rangeRefinedBy(temporal) {
-        return this.range();
+      _proto.isStrict = function isStrict() {
+        return this._strict;
       };
-      _proto3.getFrom = function getFrom(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: QuarterOfYear');
-        }
-        var moy = temporal.getLong(ChronoField.MONTH_OF_YEAR);
-        return MathUtil.intDiv(moy + 2, 3);
+      _proto.setStrict = function setStrict(strict) {
+        this._strict = strict;
       };
-      _proto3.adjustInto = function adjustInto(temporal, newValue) {
-        var curValue = this.getFrom(temporal);
-        this.range().checkValidValue(newValue, this);
-        return temporal.with(ChronoField.MONTH_OF_YEAR, temporal.getLong(ChronoField.MONTH_OF_YEAR) + (newValue - curValue) * 3);
+      _proto.locale = function locale() {
+        return this._locale;
       };
-      return QUARTER_OF_YEAR_FIELD;
-    }(Field);
-    var WEEK_OF_WEEK_BASED_YEAR_FIELD = function (_Field3) {
-      function WEEK_OF_WEEK_BASED_YEAR_FIELD() {
-        return _Field3.apply(this, arguments) || this;
-      }
-      _inheritsLoose(WEEK_OF_WEEK_BASED_YEAR_FIELD, _Field3);
-      var _proto4 = WEEK_OF_WEEK_BASED_YEAR_FIELD.prototype;
-      _proto4.toString = function toString() {
-        return 'WeekOfWeekBasedYear';
+      _proto.setLocale = function setLocale(locale) {
+        this._locale = locale;
       };
-      _proto4.baseUnit = function baseUnit() {
-        return ChronoUnit.WEEKS;
+      _proto.startOptional = function startOptional() {
+        this._parsed.push(this.currentParsed().copy());
       };
-      _proto4.rangeUnit = function rangeUnit() {
-        return WEEK_BASED_YEARS;
+      _proto.endOptional = function endOptional(successful) {
+        if (successful) {
+          this._parsed.splice(this._parsed.length - 2, 1);
+        } else {
+          this._parsed.splice(this._parsed.length - 1, 1);
+        }
       };
-      _proto4.range = function range() {
-        return ValueRange.of(1, 52, 53);
+      _proto.isCaseSensitive = function isCaseSensitive() {
+        return this._caseSensitive;
       };
-      _proto4.isSupportedBy = function isSupportedBy(temporal) {
-        return temporal.isSupported(ChronoField.EPOCH_DAY) && this._isIso(temporal);
+      _proto.setCaseSensitive = function setCaseSensitive(caseSensitive) {
+        this._caseSensitive = caseSensitive;
       };
-      _proto4.rangeRefinedBy = function rangeRefinedBy(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: WeekOfWeekBasedYear');
+      _proto.subSequenceEquals = function subSequenceEquals(cs1, offset1, cs2, offset2, length) {
+        if (offset1 + length > cs1.length || offset2 + length > cs2.length) {
+          return false;
         }
-        return Field._getWeekRangeByLocalDate(LocalDate.from(temporal));
+        if (!this.isCaseSensitive()) {
+          cs1 = cs1.toLowerCase();
+          cs2 = cs2.toLowerCase();
+        }
+        for (var i = 0; i < length; i++) {
+          var ch1 = cs1[offset1 + i];
+          var ch2 = cs2[offset2 + i];
+          if (ch1 !== ch2) {
+            return false;
+          }
+        }
+        return true;
       };
-      _proto4.getFrom = function getFrom(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: WeekOfWeekBasedYear');
+      _proto.charEquals = function charEquals(ch1, ch2) {
+        if (this.isCaseSensitive()) {
+          return ch1 === ch2;
         }
-        return Field._getWeek(LocalDate.from(temporal));
+        return this.charEqualsIgnoreCase(ch1, ch2);
       };
-      _proto4.adjustInto = function adjustInto(temporal, newValue) {
-        this.range().checkValidValue(newValue, this);
-        return temporal.plus(MathUtil.safeSubtract(newValue, this.getFrom(temporal)), ChronoUnit.WEEKS);
+      _proto.charEqualsIgnoreCase = function charEqualsIgnoreCase(c1, c2) {
+        return c1 === c2 || c1.toLowerCase() === c2.toLowerCase();
       };
-      _proto4.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
-        var wbyLong = fieldValues.get(WEEK_BASED_YEAR);
-        var dowLong = fieldValues.get(ChronoField.DAY_OF_WEEK);
-        if (wbyLong == null || dowLong == null) {
-          return null;
-        }
-        var wby = WEEK_BASED_YEAR.range().checkValidIntValue(wbyLong, WEEK_BASED_YEAR);
-        var wowby = fieldValues.get(WEEK_OF_WEEK_BASED_YEAR);
-        var date;
-        if (resolverStyle === ResolverStyle.LENIENT) {
-          var dow = dowLong;
-          var weeks = 0;
-          if (dow > 7) {
-            weeks = MathUtil.intDiv(dow - 1, 7);
-            dow = MathUtil.intMod(dow - 1, 7) + 1;
-          } else if (dow < 1) {
-            weeks = MathUtil.intDiv(dow, 7) - 1;
-            dow = MathUtil.intMod(dow, 7) + 7;
-          }
-          date = LocalDate.of(wby, 1, 4).plusWeeks(wowby - 1).plusWeeks(weeks).with(ChronoField.DAY_OF_WEEK, dow);
-        } else {
-          var _dow2 = ChronoField.DAY_OF_WEEK.checkValidIntValue(dowLong);
-          if (resolverStyle === ResolverStyle.STRICT) {
-            var temp = LocalDate.of(wby, 1, 4);
-            var range = Field._getWeekRangeByLocalDate(temp);
-            range.checkValidValue(wowby, this);
-          } else {
-            this.range().checkValidValue(wowby, this);
-          }
-          date = LocalDate.of(wby, 1, 4).plusWeeks(wowby - 1).with(ChronoField.DAY_OF_WEEK, _dow2);
-        }
-        fieldValues.remove(this);
-        fieldValues.remove(WEEK_BASED_YEAR);
-        fieldValues.remove(ChronoField.DAY_OF_WEEK);
-        return date;
+      _proto.setParsedField = function setParsedField(field, value, errorPos, successPos) {
+        var currentParsedFieldValues = this.currentParsed().fieldValues;
+        var old = currentParsedFieldValues.get(field);
+        currentParsedFieldValues.set(field, value);
+        return old != null && old !== value ? ~errorPos : successPos;
       };
-      _proto4.displayName = function displayName() {
-        return 'Week';
+      _proto.setParsedZone = function setParsedZone(zone) {
+        requireNonNull(zone, 'zone');
+        this.currentParsed().zone = zone;
       };
-      return WEEK_OF_WEEK_BASED_YEAR_FIELD;
-    }(Field);
-    var WEEK_BASED_YEAR_FIELD = function (_Field4) {
-      function WEEK_BASED_YEAR_FIELD() {
-        return _Field4.apply(this, arguments) || this;
-      }
-      _inheritsLoose(WEEK_BASED_YEAR_FIELD, _Field4);
-      var _proto5 = WEEK_BASED_YEAR_FIELD.prototype;
-      _proto5.toString = function toString() {
-        return 'WeekBasedYear';
+      _proto.getParsed = function getParsed(field) {
+        return this.currentParsed().fieldValues.get(field);
       };
-      _proto5.baseUnit = function baseUnit() {
-        return WEEK_BASED_YEARS;
+      _proto.toParsed = function toParsed() {
+        return this.currentParsed();
+      };
+      _proto.currentParsed = function currentParsed() {
+        return this._parsed[this._parsed.length - 1];
+      };
+      _proto.setParsedLeapSecond = function setParsedLeapSecond() {
+        this.currentParsed().leapSecond = true;
+      };
+      _proto.getEffectiveChronology = function getEffectiveChronology() {
+        var chrono = this.currentParsed().chrono;
+        if (chrono == null) {
+          chrono = this._overrideChronology;
+          if (chrono == null) {
+            chrono = IsoChronology.INSTANCE;
+          }
+        }
+        return chrono;
       };
-      _proto5.rangeUnit = function rangeUnit() {
-        return ChronoUnit.FOREVER;
+      return DateTimeParseContext;
+    }();
+    var Parsed = function (_Temporal) {
+      function Parsed(dateTimeParseContext) {
+        var _this;
+        _this = _Temporal.call(this) || this;
+        _this.chrono = null;
+        _this.zone = null;
+        _this.fieldValues = new EnumMap();
+        _this.leapSecond = false;
+        _this.excessDays = Period.ZERO;
+        _this.dateTimeParseContext = dateTimeParseContext;
+        return _this;
+      }
+      _inheritsLoose(Parsed, _Temporal);
+      var _proto2 = Parsed.prototype;
+      _proto2.copy = function copy() {
+        var cloned = new Parsed();
+        cloned.chrono = this.chrono;
+        cloned.zone = this.zone;
+        cloned.fieldValues.putAll(this.fieldValues);
+        cloned.leapSecond = this.leapSecond;
+        cloned.dateTimeParseContext = this.dateTimeParseContext;
+        return cloned;
       };
-      _proto5.range = function range() {
-        return ChronoField.YEAR.range();
+      _proto2.toString = function toString() {
+        return this.fieldValues + ", " + this.chrono + ", " + this.zone;
       };
-      _proto5.isSupportedBy = function isSupportedBy(temporal) {
-        return temporal.isSupported(ChronoField.EPOCH_DAY) && this._isIso(temporal);
+      _proto2.isSupported = function isSupported(field) {
+        return this.fieldValues.containsKey(field);
       };
-      _proto5.rangeRefinedBy = function rangeRefinedBy(temporal) {
-        return ChronoField.YEAR.range();
+      _proto2.get = function get(field) {
+        var val = this.fieldValues.get(field);
+        assert(val != null);
+        return val;
       };
-      _proto5.getFrom = function getFrom(temporal) {
-        if (temporal.isSupported(this) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: WeekBasedYear');
+      _proto2.query = function query(_query) {
+        if (_query === TemporalQueries.chronology()) {
+          return this.chrono;
         }
-        return Field._getWeekBasedYear(LocalDate.from(temporal));
-      };
-      _proto5.adjustInto = function adjustInto(temporal, newValue) {
-        if (this.isSupportedBy(temporal) === false) {
-          throw new UnsupportedTemporalTypeException('Unsupported field: WeekBasedYear');
+        if (_query === TemporalQueries.zoneId() || _query === TemporalQueries.zone()) {
+          return this.zone;
         }
-        var newWby = this.range().checkValidIntValue(newValue, WEEK_BASED_YEAR);
-        var date = LocalDate.from(temporal);
-        var dow = date.get(ChronoField.DAY_OF_WEEK);
-        var week = Field._getWeek(date);
-        if (week === 53 && Field._getWeekRangeByYear(newWby) === 52) {
-          week = 52;
+        return _Temporal.prototype.query.call(this, _query);
+      };
+      _proto2.toBuilder = function toBuilder() {
+        var builder = new DateTimeBuilder();
+        builder.fieldValues.putAll(this.fieldValues);
+        builder.chrono = this.dateTimeParseContext.getEffectiveChronology();
+        if (this.zone != null) {
+          builder.zone = this.zone;
+        } else {
+          builder.zone = this.overrideZone;
         }
-        var resolved = LocalDate.of(newWby, 1, 4);
-        var days = dow - resolved.get(ChronoField.DAY_OF_WEEK) + (week - 1) * 7;
-        resolved = resolved.plusDays(days);
-        return temporal.with(resolved);
+        builder.leapSecond = this.leapSecond;
+        builder.excessDays = this.excessDays;
+        return builder;
       };
-      return WEEK_BASED_YEAR_FIELD;
-    }(Field);
-    var Unit = function (_TemporalUnit) {
-      function Unit(name, estimatedDuration) {
-        var _this;
-        _this = _TemporalUnit.call(this) || this;
-        _this._name = name;
-        _this._duration = estimatedDuration;
-        return _this;
+      return Parsed;
+    }(Temporal);
+
+    /*
+     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+     * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+     */
+
+    var DateTimePrintContext = function () {
+      function DateTimePrintContext(temporal, localeOrFormatter, symbols) {
+        if (arguments.length === 2 && arguments[1] instanceof DateTimeFormatter) {
+          this._temporal = DateTimePrintContext.adjust(temporal, localeOrFormatter);
+          this._locale = localeOrFormatter.locale();
+          this._symbols = localeOrFormatter.decimalStyle();
+        } else {
+          this._temporal = temporal;
+          this._locale = localeOrFormatter;
+          this._symbols = symbols;
+        }
+        this._optional = 0;
       }
-      _inheritsLoose(Unit, _TemporalUnit);
-      var _proto6 = Unit.prototype;
-      _proto6.duration = function duration() {
-        return this._duration;
-      };
-      _proto6.isDurationEstimated = function isDurationEstimated() {
-        return true;
+      DateTimePrintContext.adjust = function adjust(temporal, formatter) {
+        return temporal;
       };
-      _proto6.isDateBased = function isDateBased() {
-        return true;
+      var _proto = DateTimePrintContext.prototype;
+      _proto.symbols = function symbols() {
+        return this._symbols;
       };
-      _proto6.isTimeBased = function isTimeBased() {
-        return false;
+      _proto.startOptional = function startOptional() {
+        this._optional++;
       };
-      _proto6.isSupportedBy = function isSupportedBy(temporal) {
-        return temporal.isSupported(ChronoField.EPOCH_DAY);
+      _proto.endOptional = function endOptional() {
+        this._optional--;
       };
-      _proto6.addTo = function addTo(temporal, periodToAdd) {
-        switch (this) {
-          case WEEK_BASED_YEARS:
-            {
-              var added = MathUtil.safeAdd(temporal.get(WEEK_BASED_YEAR), periodToAdd);
-              return temporal.with(WEEK_BASED_YEAR, added);
-            }
-          case QUARTER_YEARS:
-            return temporal.plus(MathUtil.intDiv(periodToAdd, 256), ChronoUnit.YEARS).plus(MathUtil.intMod(periodToAdd, 256) * 3, ChronoUnit.MONTHS);
-          default:
-            throw new IllegalStateException('Unreachable');
+      _proto.getValueQuery = function getValueQuery(query) {
+        var result = this._temporal.query(query);
+        if (result == null && this._optional === 0) {
+          throw new DateTimeException("Unable to extract value: " + this._temporal);
         }
+        return result;
       };
-      _proto6.between = function between(temporal1, temporal2) {
-        switch (this) {
-          case WEEK_BASED_YEARS:
-            return MathUtil.safeSubtract(temporal2.getLong(WEEK_BASED_YEAR), temporal1.getLong(WEEK_BASED_YEAR));
-          case QUARTER_YEARS:
-            return MathUtil.intDiv(temporal1.until(temporal2, ChronoUnit.MONTHS), 3);
-          default:
-            throw new IllegalStateException('Unreachable');
+      _proto.getValue = function getValue(field) {
+        try {
+          return this._temporal.getLong(field);
+        } catch (ex) {
+          if (ex instanceof DateTimeException && this._optional > 0) {
+            return null;
+          }
+          throw ex;
         }
       };
-      _proto6.toString = function toString() {
-        return this._name;
+      _proto.temporal = function temporal() {
+        return this._temporal;
       };
-      return Unit;
-    }(TemporalUnit);
-    var DAY_OF_QUARTER = null;
-    var QUARTER_OF_YEAR = null;
-    var WEEK_OF_WEEK_BASED_YEAR = null;
-    var WEEK_BASED_YEAR = null;
-    var WEEK_BASED_YEARS = null;
-    var QUARTER_YEARS = null;
-    function _init$f() {
-      DAY_OF_QUARTER = new DAY_OF_QUARTER_FIELD();
-      QUARTER_OF_YEAR = new QUARTER_OF_YEAR_FIELD();
-      WEEK_OF_WEEK_BASED_YEAR = new WEEK_OF_WEEK_BASED_YEAR_FIELD();
-      WEEK_BASED_YEAR = new WEEK_BASED_YEAR_FIELD();
-      WEEK_BASED_YEARS = new Unit('WeekBasedYears', Duration.ofSeconds(31556952));
-      QUARTER_YEARS = new Unit('QuarterYears', Duration.ofSeconds(31556952 / 4));
-      IsoFields.DAY_OF_QUARTER = DAY_OF_QUARTER;
-      IsoFields.QUARTER_OF_YEAR = QUARTER_OF_YEAR;
-      IsoFields.WEEK_OF_WEEK_BASED_YEAR = WEEK_OF_WEEK_BASED_YEAR;
-      IsoFields.WEEK_BASED_YEAR = WEEK_BASED_YEAR;
-      IsoFields.WEEK_BASED_YEARS = WEEK_BASED_YEARS;
-      IsoFields.QUARTER_YEARS = QUARTER_YEARS;
-      LocalDate.prototype.isoWeekOfWeekyear = function () {
-        return this.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);
+      _proto.locale = function locale() {
+        return this._locale;
       };
-      LocalDate.prototype.isoWeekyear = function () {
-        return this.get(IsoFields.WEEK_BASED_YEAR);
+      _proto.setDateTime = function setDateTime(temporal) {
+        this._temporal = temporal;
       };
-    }
+      _proto.setLocale = function setLocale(locale) {
+        this._locale = locale;
+      };
+      return DateTimePrintContext;
+    }();
 
     /**
      * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
@@ -4462,6 +4478,45 @@
         if (position === length) {
           return ~position;
         }
+        var region = this._parseRegion(text, position);
+        var fixedEndPos = this._parseFixedId(context, text, position);
+        var fixedLength = fixedEndPos >= 0 ? fixedEndPos - position : 0;
+        if (region != null && region.parseLength > fixedLength) {
+          context.setParsedZone(ZoneRegion.ofId(region.parsedZoneId));
+          return position + region.parseLength;
+        }
+        return fixedEndPos;
+      };
+      _proto._parseRegion = function _parseRegion(text, position) {
+        var availableZoneIds = ZoneRulesProvider.getAvailableZoneIds();
+        if (availableZoneIds.length === 0) {
+          return null;
+        }
+        if (zoneIdTree.size !== availableZoneIds.length) {
+          zoneIdTree = ZoneIdTree.createTreeMap(availableZoneIds);
+        }
+        var maxParseLength = text.length - position;
+        var treeMap = zoneIdTree.treeMap;
+        var parsedZoneId = null;
+        var parseLength = 0;
+        while (treeMap != null) {
+          var parsedSubZoneId = text.substr(position, Math.min(treeMap.length, maxParseLength));
+          treeMap = treeMap.get(parsedSubZoneId);
+          if (treeMap != null && treeMap.isLeaf) {
+            parsedZoneId = parsedSubZoneId;
+            parseLength = treeMap.length;
+          }
+        }
+        if (parsedZoneId == null) {
+          return null;
+        }
+        return {
+          parsedZoneId: parsedZoneId,
+          parseLength: parseLength
+        };
+      };
+      _proto._parseFixedId = function _parseFixedId(context, text, position) {
+        var length = text.length;
         var nextChar = text.charAt(position);
         if (nextChar === '+' || nextChar === '-') {
           var newContext = context.copy();
@@ -4470,8 +4525,7 @@
             return endPos;
           }
           var offset = newContext.getParsed(ChronoField.OFFSET_SECONDS);
-          var zone = ZoneOffset.ofTotalSeconds(offset);
-          context.setParsedZone(zone);
+          context.setParsedZone(ZoneOffset.ofTotalSeconds(offset));
           return endPos;
         } else if (length >= position + 2) {
           var nextNextChar = text.charAt(position + 1);
@@ -4492,26 +4546,6 @@
           context.setParsedZone(ZoneOffset.UTC);
           return position + 1;
         }
-        var availableZoneIds = ZoneRulesProvider.getAvailableZoneIds();
-        if (zoneIdTree.size !== availableZoneIds.length) {
-          zoneIdTree = ZoneIdTree.createTreeMap(availableZoneIds);
-        }
-        var maxParseLength = length - position;
-        var treeMap = zoneIdTree.treeMap;
-        var parsedZoneId = null;
-        var parseLength = 0;
-        while (treeMap != null) {
-          var parsedSubZoneId = text.substr(position, Math.min(treeMap.length, maxParseLength));
-          treeMap = treeMap.get(parsedSubZoneId);
-          if (treeMap != null && treeMap.isLeaf) {
-            parsedZoneId = parsedSubZoneId;
-            parseLength = treeMap.length;
-          }
-        }
-        if (parsedZoneId != null) {
-          context.setParsedZone(ZoneRegion.ofId(parsedZoneId));
-          return position + parseLength;
-        }
         return ~position;
       };
       _proto._parsePrefixedOffset = function _parsePrefixedOffset(context, text, prefixPos, position) {
@@ -5235,7 +5269,7 @@
         var newContext = context.copy();
         var minDigits = this.fractionalDigits < 0 ? 0 : this.fractionalDigits;
         var maxDigits = this.fractionalDigits < 0 ? 9 : this.fractionalDigits;
-        var parser = new DateTimeFormatterBuilder().append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T').appendValue(ChronoField.HOUR_OF_DAY, 2).appendLiteral(':').appendValue(ChronoField.MINUTE_OF_HOUR, 2).appendLiteral(':').appendValue(ChronoField.SECOND_OF_MINUTE, 2).appendFraction(ChronoField.NANO_OF_SECOND, minDigits, maxDigits, true).appendLiteral('Z').toFormatter()._toPrinterParser(false);
+        var parser = new DateTimeFormatterBuilder().append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T').appendValue(ChronoField.HOUR_OF_DAY, 2).appendLiteral(':').appendValue(ChronoField.MINUTE_OF_HOUR, 2).appendLiteral(':').appendValue(ChronoField.SECOND_OF_MINUTE, 2).appendFraction(ChronoField.NANO_OF_SECOND, minDigits, maxDigits, true).appendOffsetId().toFormatter()._toPrinterParser(false);
         var pos = parser.parse(newContext, text, position);
         if (pos < 0) {
           return pos;
@@ -5247,6 +5281,8 @@
         var min = newContext.getParsed(ChronoField.MINUTE_OF_HOUR);
         var secVal = newContext.getParsed(ChronoField.SECOND_OF_MINUTE);
         var nanoVal = newContext.getParsed(ChronoField.NANO_OF_SECOND);
+        var offsetSecs = newContext.getParsed(ChronoField.OFFSET_SECONDS);
+        var offset = offsetSecs != null ? offsetSecs : 0;
         var sec = secVal != null ? secVal : 0;
         var nano = nanoVal != null ? nanoVal : 0;
         var year = MathUtil.intMod(yearParsed, 10000);
@@ -5261,7 +5297,7 @@
         var instantSecs;
         try {
           var ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0).plusDays(days);
-          instantSecs = ldt.toEpochSecond(ZoneOffset.UTC);
+          instantSecs = ldt.toEpochSecond(ZoneOffset.ofTotalSeconds(offset));
           instantSecs += MathUtil.safeMultiply(MathUtil.intDiv(yearParsed, 10000), SECONDS_PER_10000_YEARS);
         } catch (ex) {
           return ~position;
@@ -5508,7 +5544,7 @@
       DateTimeFormatter.ISO_OFFSET_DATE = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_DATE).appendOffsetId().toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
       DateTimeFormatter.ISO_OFFSET_TIME = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_TIME).appendOffsetId().toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
       DateTimeFormatter.ISO_ORDINAL_DATE = new DateTimeFormatterBuilder().appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral('-').appendValue(ChronoField.DAY_OF_YEAR).toFormatter(ResolverStyle.STRICT);
-      DateTimeFormatter.ISO_WEEK_DATE = new DateTimeFormatterBuilder().appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral('-W').appendValue(ChronoField.ALIGNED_WEEK_OF_YEAR).appendLiteral('-').appendValue(ChronoField.DAY_OF_WEEK).toFormatter(ResolverStyle.STRICT);
+      DateTimeFormatter.ISO_WEEK_DATE = new DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral('-W').appendValue(IsoFields.WEEK_OF_WEEK_BASED_YEAR, 2).appendLiteral('-').appendValue(ChronoField.DAY_OF_WEEK, 1).toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
       DateTimeFormatter.ISO_DATE = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_DATE).optionalStart().appendOffsetId().optionalEnd().toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
       DateTimeFormatter.ISO_TIME = new DateTimeFormatterBuilder().parseCaseInsensitive().append(DateTimeFormatter.ISO_LOCAL_TIME).optionalStart().appendOffsetId().optionalEnd().toFormatter(ResolverStyle.STRICT);
       DateTimeFormatter.ISO_DATE_TIME = new DateTimeFormatterBuilder().append(DateTimeFormatter.ISO_LOCAL_DATE_TIME).optionalStart().appendOffsetId().optionalEnd().toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
@@ -9683,7 +9719,7 @@
           throw new DateTimeException('Unit must divide into a standard day without remainder');
         }
         var nod = MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_DAY) * LocalTime.NANOS_PER_SECOND + this._nanos;
-        var result = MathUtil.intDiv(nod, dur) * dur;
+        var result = MathUtil.floorDiv(nod, dur) * dur;
         return this.plusNanos(result - nod);
       };
       _proto._plusUnit = function _plusUnit(amountToAdd, unit) {
@@ -9792,8 +9828,16 @@
       };
       _proto._microsUntil = function _microsUntil(end) {
         var secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());
+        var nanosDiff = end.nano() - this.nano();
+        if (secsDiff > 0 && nanosDiff < 0) {
+          secsDiff--;
+          nanosDiff += LocalTime.NANOS_PER_SECOND;
+        } else if (secsDiff < 0 && nanosDiff > 0) {
+          secsDiff++;
+          nanosDiff -= LocalTime.NANOS_PER_SECOND;
+        }
         var totalMicros = MathUtil.safeMultiply(secsDiff, 1000000);
-        return MathUtil.safeAdd(totalMicros, MathUtil.intDiv(end.nano() - this.nano(), 1000));
+        return MathUtil.safeAdd(totalMicros, MathUtil.intDiv(nanosDiff, 1000));
       };
       _proto._nanosUntil = function _nanosUntil(end) {
         var secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());
@@ -10332,7 +10376,7 @@
       _init$l();
       _init$k();
       _init$3();
-      _init$f();
+      _init$g();
       _init$1();
       _init$j();
       _init$2();
@@ -10343,7 +10387,7 @@
       _init$b();
       _init$c();
       _init$h();
-      _init$g();
+      _init$f();
       _init$7();
       _init();
       _init$9();