@js-joda/core 6.0.1 → 6.2.0

package/dist/js-joda.cjs.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)
@@ -664,10 +664,15 @@ var Duration = function (_TemporalAmount) {
     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() {
@@ -749,9 +754,12 @@ var Duration = function (_TemporalAmount) {
     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";
@@ -759,31 +767,23 @@ var Duration = function (_TemporalAmount) {
     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;
@@ -2069,1410 +2069,1426 @@ var ChronoLocalDate = function (_Temporal) {
   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
@@ -4458,6 +4474,45 @@ var ZoneIdPrinterParser = function () {
     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();
@@ -4466,8 +4521,7 @@ var ZoneIdPrinterParser = function () {
         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);
@@ -4488,26 +4542,6 @@ var ZoneIdPrinterParser = function () {
       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) {
@@ -5231,7 +5265,7 @@ var InstantPrinterParser = function () {
     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;
@@ -5243,6 +5277,8 @@ var InstantPrinterParser = function () {
     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);
@@ -5257,7 +5293,7 @@ var InstantPrinterParser = function () {
     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;
@@ -5504,7 +5540,7 @@ function _init$d() {
   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);
@@ -9679,7 +9715,7 @@ var Instant = function (_Temporal) {
       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) {
@@ -9788,8 +9824,16 @@ var Instant = function (_Temporal) {
   };
   _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());
@@ -10328,7 +10372,7 @@ function init() {
   _init$l();
   _init$k();
   _init$3();
-  _init$f();
+  _init$g();
   _init$1();
   _init$j();
   _init$2();
@@ -10339,7 +10383,7 @@ function init() {
   _init$b();
   _init$c();
   _init$h();
-  _init$g();
+  _init$f();
   _init$7();
   _init();
   _init$9();