@js-joda/core 1.12.0 → 3.2.0

package/dist/js-joda.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/core - 1.12.0
+//! @version @js-joda/core - 3.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)
@@ -7,7 +7,7 @@
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
     (global = global || self, factory(global.JSJoda = {}));
-}(this, function (exports) { 'use strict';
+}(this, (function (exports) { 'use strict';
 
     /**
      * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
@@ -18,7 +18,7 @@
         superErrorClass = Error;
       }
 
-      function E(message) {
+      function JsJodaException(message) {
         if (!Error.captureStackTrace) {
           this.stack = new Error().stack;
         } else {
@@ -33,10 +33,10 @@
         };
       }
 
-      E.prototype = new superErrorClass();
-      E.prototype.name = name;
-      E.prototype.constructor = E;
-      return E;
+      JsJodaException.prototype = Object.create(superErrorClass.prototype);
+      JsJodaException.prototype.name = name;
+      JsJodaException.prototype.constructor = JsJodaException;
+      return JsJodaException;
     }
 
     var DateTimeException = createErrorType('DateTimeException', messageWithCause);
@@ -138,6 +138,7 @@
     }
 
     var assert$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
         assert: assert,
         requireNonNull: requireNonNull,
         requireInstance: requireInstance,
@@ -622,7 +623,7 @@
           nanoAdjustment = 0;
         }
 
-        if ((seconds | nanoAdjustment) === 0) {
+        if (seconds === 0 && nanoAdjustment === 0) {
           return Duration.ZERO;
         }
 
@@ -646,7 +647,7 @@
       };
 
       _proto.isZero = function isZero() {
-        return (this._seconds | this._nanos) === 0;
+        return this._seconds === 0 && this._nanos === 0;
       };
 
       _proto.isNegative = function isNegative() {
@@ -751,7 +752,7 @@
         requireNonNull(secondsToAdd, 'secondsToAdd');
         requireNonNull(nanosToAdd, 'nanosToAdd');
 
-        if ((secondsToAdd | nanosToAdd) === 0) {
+        if (secondsToAdd === 0 && nanosToAdd === 0) {
           return this;
         }
 
@@ -1092,7 +1093,62 @@
      * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
      * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
      */
-    var TemporalField = function TemporalField() {};
+
+    var TemporalField = function () {
+      function TemporalField() {}
+
+      var _proto = TemporalField.prototype;
+
+      _proto.isDateBased = function isDateBased() {
+        abstractMethodFail('isDateBased');
+      };
+
+      _proto.isTimeBased = function isTimeBased() {
+        abstractMethodFail('isTimeBased');
+      };
+
+      _proto.baseUnit = function baseUnit() {
+        abstractMethodFail('baseUnit');
+      };
+
+      _proto.rangeUnit = function rangeUnit() {
+        abstractMethodFail('rangeUnit');
+      };
+
+      _proto.range = function range() {
+        abstractMethodFail('range');
+      };
+
+      _proto.rangeRefinedBy = function rangeRefinedBy(temporal) {
+        abstractMethodFail('rangeRefinedBy');
+      };
+
+      _proto.getFrom = function getFrom(temporal) {
+        abstractMethodFail('getFrom');
+      };
+
+      _proto.adjustInto = function adjustInto(temporal, newValue) {
+        abstractMethodFail('adjustInto');
+      };
+
+      _proto.isSupportedBy = function isSupportedBy(temporal) {
+        abstractMethodFail('isSupportedBy');
+      };
+
+      _proto.displayName = function displayName() {
+        abstractMethodFail('displayName');
+      };
+
+      _proto.equals = function equals(other) {
+        abstractMethodFail('equals');
+      };
+
+      _proto.name = function name() {
+        abstractMethodFail('name');
+      };
+
+      return TemporalField;
+    }();
 
     /**
      * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
@@ -1148,6 +1204,8 @@
 
           return assert(false, msg, DateTimeException);
         }
+
+        return value;
       };
 
       _proto.checkValidIntValue = function checkValidIntValue(value, field) {
@@ -1251,7 +1309,11 @@
       };
 
       _proto.checkValidValue = function checkValidValue(value) {
-        return this.range().checkValidValue(value, this.name());
+        return this.range().checkValidValue(value, this);
+      };
+
+      _proto.checkValidIntValue = function checkValidIntValue(value) {
+        return this.range().checkValidIntValue(value, this);
       };
 
       _proto.isDateBased = function isDateBased() {
@@ -1268,10 +1330,6 @@
         return temporal.range(this);
       };
 
-      _proto.checkValidIntValue = function checkValidIntValue(value) {
-        return this.range().checkValidIntValue(value, this);
-      };
-
       _proto.getFrom = function getFrom(temporal) {
         return temporal.getLong(this);
       };
@@ -1284,6 +1342,14 @@
         return this === other;
       };
 
+      _proto.adjustInto = function adjustInto(temporal, newValue) {
+        return temporal.with(this, newValue);
+      };
+
+      _proto.isSupportedBy = function isSupportedBy(temporal) {
+        return temporal.isSupported(this);
+      };
+
       return ChronoField;
     }(TemporalField);
     function _init$3() {
@@ -1395,16 +1461,6 @@
       return TemporalAccessor;
     }();
 
-    var Temporal = function (_TemporalAccessor) {
-      _inheritsLoose(Temporal, _TemporalAccessor);
-
-      function Temporal() {
-        return _TemporalAccessor.apply(this, arguments) || this;
-      }
-
-      return Temporal;
-    }(TemporalAccessor);
-
     var TemporalQuery = function (_Enum) {
       _inheritsLoose(TemporalQuery, _Enum);
 
@@ -1435,13 +1491,13 @@
       return new ExtendedTemporalQuery(name);
     }
 
-    var DayOfWeek = function (_Temporal) {
-      _inheritsLoose(DayOfWeek, _Temporal);
+    var DayOfWeek = function (_TemporalAccessor) {
+      _inheritsLoose(DayOfWeek, _TemporalAccessor);
 
       function DayOfWeek(ordinal, name) {
         var _this;
 
-        _this = _Temporal.call(this) || this;
+        _this = _TemporalAccessor.call(this) || this;
         _this._ordinal = ordinal;
         _this._name = name;
         return _this;
@@ -1503,7 +1559,7 @@
         return this._ordinal + 1;
       };
 
-      _proto.getDisplayName = function getDisplayName(style, locale) {
+      _proto.displayName = function displayName(style, locale) {
         throw new IllegalArgumentException('Pattern using (localized) text not implemented yet!');
       };
 
@@ -1587,7 +1643,7 @@
       };
 
       return DayOfWeek;
-    }(Temporal);
+    }(TemporalAccessor);
     var ENUMS;
     function _init$4() {
       DayOfWeek.MONDAY = new DayOfWeek(0, 'MONDAY');
@@ -1603,13 +1659,13 @@
       ENUMS = [DayOfWeek.MONDAY, DayOfWeek.TUESDAY, DayOfWeek.WEDNESDAY, DayOfWeek.THURSDAY, DayOfWeek.FRIDAY, DayOfWeek.SATURDAY, DayOfWeek.SUNDAY];
     }
 
-    var Month = function (_Temporal) {
-      _inheritsLoose(Month, _Temporal);
+    var Month = function (_TemporalAccessor) {
+      _inheritsLoose(Month, _TemporalAccessor);
 
       function Month(value, name) {
         var _this;
 
-        _this = _Temporal.call(this) || this;
+        _this = _TemporalAccessor.call(this) || this;
         _this._value = MathUtil.safeToInt(value);
         _this._name = name;
         return _this;
@@ -1629,7 +1685,7 @@
         return this._name;
       };
 
-      _proto.getDisplayName = function getDisplayName(style, locale) {
+      _proto.displayName = function displayName(style, locale) {
         throw new IllegalArgumentException('Pattern using (localized) text not implemented yet!');
       };
 
@@ -1799,7 +1855,7 @@
           return ChronoUnit.MONTHS;
         }
 
-        return _Temporal.prototype.query.call(this, _query);
+        return _TemporalAccessor.prototype.query.call(this, _query);
       };
 
       _proto.toString = function toString() {
@@ -1900,7 +1956,7 @@
       };
 
       return Month;
-    }(Temporal);
+    }(TemporalAccessor);
     var MONTHS;
     function _init$5() {
       Month.JANUARY = new Month(1, 'JANUARY');
@@ -1933,7 +1989,7 @@
 
         var _days = MathUtil.safeToInt(days);
 
-        if ((_years | _months | _days) === 0) {
+        if (_years === 0 && _months === 0 && _days === 0) {
           if (!Period.ZERO) {
             _this._years = _years;
             _this._months = _months;
@@ -2405,13 +2461,135 @@
     ResolverStyle.SMART = new ResolverStyle('SMART');
     ResolverStyle.LENIENT = new ResolverStyle('LENIENT');
 
-    var ChronoLocalDate = function (_Temporal) {
-      _inheritsLoose(ChronoLocalDate, _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 TemporalAdjuster = function () {
+      function TemporalAdjuster() {}
+
+      var _proto = TemporalAdjuster.prototype;
 
-      function ChronoLocalDate() {
+      _proto.adjustInto = function adjustInto(temporal) {
+        abstractMethodFail('adjustInto');
+      };
+
+      return TemporalAdjuster;
+    }();
+
+    var Temporal = function (_TemporalAccessor) {
+      _inheritsLoose(Temporal, _TemporalAccessor);
+
+      function Temporal() {
+        return _TemporalAccessor.apply(this, arguments) || this;
+      }
+
+      var _proto = Temporal.prototype;
+
+      _proto.isSupported = function isSupported(unit) {
+        abstractMethodFail('isSupported');
+      };
+
+      _proto.minus = function minus(p1, p2) {
+        if (arguments.length < 2) {
+          return this.minusAmount(p1);
+        } else {
+          return this.minusAmountUnit(p1, p2);
+        }
+      };
+
+      _proto.minusAmount = function minusAmount(amount) {
+        abstractMethodFail('minusAmount');
+      };
+
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        abstractMethodFail('minusAmountUnit');
+      };
+
+      _proto.plus = function plus(p1, p2) {
+        if (arguments.length < 2) {
+          return this.plusAmount(p1);
+        } else {
+          return this.plusAmountUnit(p1, p2);
+        }
+      };
+
+      _proto.plusAmount = function plusAmount(amount) {
+        abstractMethodFail('plusAmount');
+      };
+
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
+        abstractMethodFail('plusAmountUnit');
+      };
+
+      _proto.until = function until(endTemporal, unit) {
+        abstractMethodFail('until');
+      };
+
+      _proto.with = function _with(p1, p2) {
+        if (arguments.length < 2) {
+          return this.withAdjuster(p1);
+        } else {
+          return this.withFieldValue(p1, p2);
+        }
+      };
+
+      _proto.withAdjuster = function withAdjuster(adjuster) {
+        abstractMethodFail('withAdjuster');
+      };
+
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
+        abstractMethodFail('withFieldValue');
+      };
+
+      return Temporal;
+    }(TemporalAccessor);
+
+    var DefaultInterfaceTemporal = function (_Temporal) {
+      _inheritsLoose(DefaultInterfaceTemporal, _Temporal);
+
+      function DefaultInterfaceTemporal() {
         return _Temporal.apply(this, arguments) || this;
       }
 
+      var _proto = DefaultInterfaceTemporal.prototype;
+
+      _proto.withAdjuster = function withAdjuster(adjuster) {
+        requireNonNull(adjuster, 'adjuster');
+        requireInstance(adjuster, TemporalAdjuster, 'adjuster');
+        return adjuster.adjustInto(this);
+      };
+
+      _proto.plusAmount = function plusAmount(amount) {
+        requireNonNull(amount, 'amount');
+        requireInstance(amount, TemporalAmount, 'amount');
+        return amount.addTo(this);
+      };
+
+      _proto.minusAmount = function minusAmount(amount) {
+        requireNonNull(amount, 'amount');
+        requireInstance(amount, TemporalAmount, 'amount');
+        return amount.subtractFrom(this);
+      };
+
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        requireNonNull(amountToSubtract, 'amountToSubtract');
+        requireNonNull(unit, 'unit');
+        requireInstance(unit, TemporalUnit, 'unit');
+        return amountToSubtract === MIN_SAFE_INTEGER ? this.plusAmountUnit(MAX_SAFE_INTEGER, unit).plusAmountUnit(1, unit) : this.plusAmount(-amountToSubtract, unit);
+      };
+
+      return DefaultInterfaceTemporal;
+    }(Temporal);
+
+    var ChronoLocalDate = function (_DefaultInterfaceTemp) {
+      _inheritsLoose(ChronoLocalDate, _DefaultInterfaceTemp);
+
+      function ChronoLocalDate() {
+        return _DefaultInterfaceTemp.apply(this, arguments) || this;
+      }
+
       var _proto = ChronoLocalDate.prototype;
 
       _proto.isSupported = function isSupported(fieldOrUnit) {
@@ -2435,7 +2613,7 @@
           return null;
         }
 
-        return _Temporal.prototype.query.call(this, _query);
+        return _DefaultInterfaceTemp.prototype.query.call(this, _query);
       };
 
       _proto.adjustInto = function adjustInto(temporal) {
@@ -2449,7 +2627,7 @@
       };
 
       return ChronoLocalDate;
-    }(Temporal);
+    }(DefaultInterfaceTemporal);
 
     /*
      * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
@@ -2994,8 +3172,8 @@
       ZoneOffset.MAX = ZoneOffset.ofTotalSeconds(ZoneOffset.MAX_SECONDS);
     }
 
-    var DateTimeBuilder = function (_Temporal) {
-      _inheritsLoose(DateTimeBuilder, _Temporal);
+    var DateTimeBuilder = function (_TemporalAccessor) {
+      _inheritsLoose(DateTimeBuilder, _TemporalAccessor);
 
       DateTimeBuilder.create = function create(field, value) {
         var dtb = new DateTimeBuilder();
@@ -3008,7 +3186,7 @@
       function DateTimeBuilder() {
         var _this;
 
-        _this = _Temporal.call(this) || this;
+        _this = _TemporalAccessor.call(this) || this;
         _this.fieldValues = new EnumMap();
         _this.chrono = null;
         _this.zone = null;
@@ -3423,7 +3601,7 @@
       };
 
       return DateTimeBuilder;
-    }(Temporal);
+    }(TemporalAccessor);
 
     var DateTimeParseContext = function () {
       function DateTimeParseContext() {
@@ -3742,7 +3920,7 @@
       return DateTimePrintContext;
     }();
 
-    var IsoFields = function IsoFields() {};
+    var IsoFields = {};
     var QUARTER_DAYS = [0, 90, 181, 273, 0, 91, 182, 274];
 
     var Field = function (_TemporalField) {
@@ -3832,7 +4010,7 @@
         return year;
       };
 
-      _proto.getDisplayName = function getDisplayName() {
+      _proto.displayName = function displayName() {
         return this.toString();
       };
 
@@ -4106,7 +4284,7 @@
         return date;
       };
 
-      _proto4.getDisplayName = function getDisplayName() {
+      _proto4.displayName = function displayName() {
         return 'Week';
       };
 
@@ -6860,8 +7038,8 @@
       });
     }
 
-    var MonthDay = function (_Temporal) {
-      _inheritsLoose(MonthDay, _Temporal);
+    var MonthDay = function (_TemporalAccessor) {
+      _inheritsLoose(MonthDay, _TemporalAccessor);
 
       MonthDay.now = function now(zoneIdOrClock) {
         if (arguments.length === 0) {
@@ -6950,7 +7128,7 @@
       function MonthDay(month, dayOfMonth) {
         var _this;
 
-        _this = _Temporal.call(this) || this;
+        _this = _TemporalAccessor.call(this) || this;
         _this._month = MathUtil.safeToInt(month);
         _this._day = MathUtil.safeToInt(dayOfMonth);
         return _this;
@@ -6985,7 +7163,7 @@
           return ValueRange.of(1, this.month().minLength(), this.month().maxLength());
         }
 
-        return _Temporal.prototype.range.call(this, field);
+        return _TemporalAccessor.prototype.range.call(this, field);
       };
 
       _proto.get = function get(field) {
@@ -7045,7 +7223,7 @@
           return IsoChronology.INSTANCE;
         }
 
-        return _Temporal.prototype.query.call(this, _query);
+        return _TemporalAccessor.prototype.query.call(this, _query);
       };
 
       _proto.adjustInto = function adjustInto(temporal) {
@@ -7110,7 +7288,7 @@
       };
 
       return MonthDay;
-    }(Temporal);
+    }(TemporalAccessor);
     var PARSER;
     function _init$b() {
       PARSER = new DateTimeFormatterBuilder().appendLiteral('--').appendValue(ChronoField.MONTH_OF_YEAR, 2).appendLiteral('-').appendValue(ChronoField.DAY_OF_MONTH, 2).toFormatter();
@@ -7307,25 +7485,12 @@
         return this.isLeapYear() ? 366 : 365;
       };
 
-      _proto.with = function _with(adjusterOrFieldOrNumber, value) {
+      _proto.with = function _with(adjusterOrField, value) {
         if (arguments.length === 1) {
-          return this.withAdjuster(adjusterOrFieldOrNumber);
-        } else if (arguments.length === 2 && adjusterOrFieldOrNumber instanceof TemporalField) {
-          return this.withFieldValue(adjusterOrFieldOrNumber, value);
+          return this.withAdjuster(adjusterOrField);
         } else {
-          return this.withYearMonth(adjusterOrFieldOrNumber, value);
-        }
-      };
-
-      _proto.withYearMonth = function withYearMonth(newYear, newMonth) {
-        requireNonNull(newYear);
-        requireNonNull(newMonth);
-
-        if (this._year === newYear && this._month === newMonth) {
-          return this;
+          return this.withFieldValue(adjusterOrField, value);
         }
-
-        return new YearMonth(newYear, newMonth);
       };
 
       _proto.withAdjuster = function withAdjuster(adjuster) {
@@ -7366,20 +7531,12 @@
 
       _proto.withYear = function withYear(year) {
         ChronoField.YEAR.checkValidValue(year);
-        return this.withYearMonth(year, this._month);
+        return new YearMonth(year, this._month);
       };
 
       _proto.withMonth = function withMonth(month) {
         ChronoField.MONTH_OF_YEAR.checkValidValue(month);
-        return this.withYearMonth(this._year, month);
-      };
-
-      _proto.plus = function plus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-          return this.plusAmount(amountOrNumber);
-        } else {
-          return this.plusAmountUnit(amountOrNumber, unit);
-        }
+        return new YearMonth(this._year, month);
       };
 
       _proto.plusAmount = function plusAmount(amount) {
@@ -7425,7 +7582,7 @@
         }
 
         var newYear = ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd);
-        return this.withYearMonth(newYear, this._month);
+        return this.withYear(newYear);
       };
 
       _proto.plusMonths = function plusMonths(monthsToAdd) {
@@ -7437,15 +7594,7 @@
         var calcMonths = monthCount + monthsToAdd;
         var newYear = ChronoField.YEAR.checkValidIntValue(MathUtil.floorDiv(calcMonths, 12));
         var newMonth = MathUtil.floorMod(calcMonths, 12) + 1;
-        return this.withYearMonth(newYear, newMonth);
-      };
-
-      _proto.minus = function minus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-          return this.minusAmount(amountOrNumber);
-        } else {
-          return this.minusAmountUnit(amountOrNumber, unit);
-        }
+        return new YearMonth(newYear, newMonth);
       };
 
       _proto.minusAmount = function minusAmount(amount) {
@@ -7746,14 +7895,6 @@
         return Year.isLeap(this._year);
       };
 
-      _proto.with = function _with(adjusterOrFieldOrNumber, value) {
-        if (arguments.length === 2 && adjusterOrFieldOrNumber instanceof TemporalField) {
-          return this.withFieldValue(adjusterOrFieldOrNumber, value);
-        } else {
-          return this.withAdjuster(adjusterOrFieldOrNumber);
-        }
-      };
-
       _proto.withAdjuster = function withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         return adjuster.adjustInto(this);
@@ -7783,21 +7924,13 @@
         return field.adjustInto(this, newValue);
       };
 
-      _proto.plus = function plus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-          return this.plusAmount(amountOrNumber);
-        } else {
-          return this.plusAmountToAddUnit(amountOrNumber, unit);
-        }
-      };
-
       _proto.plusAmount = function plusAmount(amount) {
         requireNonNull(amount, 'amount');
         requireInstance(amount, TemporalAmount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plusAmountToAddUnit = function plusAmountToAddUnit(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
@@ -7834,21 +7967,13 @@
         return Year.of(ChronoField.YEAR.checkValidIntValue(MathUtil.safeAdd(this._year, yearsToAdd)));
       };
 
-      _proto.minus = function minus(amountOrNumber, unit) {
-        if (arguments.length === 1) {
-          return this.minusAmount(amountOrNumber);
-        } else {
-          return this.minusAmountToSubtractUnit(amountOrNumber, unit);
-        }
-      };
-
       _proto.minusAmount = function minusAmount(amount) {
         requireNonNull(amount, 'amount');
         requireInstance(amount, TemporalAmount, 'amount');
         return amount.subtractFrom(this);
       };
 
-      _proto.minusAmountToSubtractUnit = function minusAmountToSubtractUnit(amountToSubtract, unit) {
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
         requireNonNull(amountToSubtract, 'amountToSubtract');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit, 'unit');
@@ -7960,6 +8085,35 @@
         return this.toString();
       };
 
+      _proto.until = function until(endExclusive, unit) {
+        var end = Year.from(endExclusive);
+
+        if (unit instanceof ChronoUnit) {
+          var yearsUntil = end.value() - this.value();
+
+          switch (unit) {
+            case ChronoUnit.YEARS:
+              return yearsUntil;
+
+            case ChronoUnit.DECADES:
+              return MathUtil.intDiv(yearsUntil, 10);
+
+            case ChronoUnit.CENTURIES:
+              return MathUtil.intDiv(yearsUntil, 100);
+
+            case ChronoUnit.MILLENNIA:
+              return MathUtil.intDiv(yearsUntil, 1000);
+
+            case ChronoUnit.ERAS:
+              return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
+          }
+
+          throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+        }
+
+        return unit.between(this, end);
+      };
+
       return Year;
     }(Temporal);
     var PARSER$2;
@@ -7972,25 +8126,8 @@
       });
     }
 
-    /*
-     * @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 TemporalAdjuster = function () {
-      function TemporalAdjuster() {}
-
-      var _proto = TemporalAdjuster.prototype;
-
-      _proto.adjustInto = function adjustInto(temporal) {
-        abstractMethodFail('adjustInto');
-      };
-
-      return TemporalAdjuster;
-    }();
-
-    var TemporalAdjusters = function () {
-      function TemporalAdjusters() {}
+    var TemporalAdjusters = function () {
+      function TemporalAdjusters() {}
 
       TemporalAdjusters.firstDayOfMonth = function firstDayOfMonth() {
         return Impl.FIRST_DAY_OF_MONTH;
@@ -8344,341 +8481,1298 @@
       IsoChronology.INSTANCE = new IsoChronology('IsoChronology');
     }
 
-    var ChronoZonedDateTime = function (_Temporal) {
-      _inheritsLoose(ChronoZonedDateTime, _Temporal);
+    var OffsetTime = function (_DefaultInterfaceTemp) {
+      _inheritsLoose(OffsetTime, _DefaultInterfaceTemp);
 
-      function ChronoZonedDateTime() {
-        return _Temporal.apply(this, arguments) || this;
-      }
+      OffsetTime.from = function from(temporal) {
+        requireNonNull(temporal, 'temporal');
 
-      var _proto = ChronoZonedDateTime.prototype;
+        if (temporal instanceof OffsetTime) {
+          return temporal;
+        } else if (temporal instanceof OffsetDateTime) {
+          return temporal.toOffsetTime();
+        }
 
-      _proto.query = function query(_query) {
-        if (_query === TemporalQueries.zoneId() || _query === TemporalQueries.zone()) {
-          return this.zone();
-        } else if (_query === TemporalQueries.chronology()) {
-          return this.toLocalDate().chronology();
-        } else if (_query === TemporalQueries.precision()) {
-          return ChronoUnit.NANOS;
-        } else if (_query === TemporalQueries.offset()) {
-          return this.offset();
-        } else if (_query === TemporalQueries.localDate()) {
-          return LocalDate.ofEpochDay(this.toLocalDate().toEpochDay());
-        } else if (_query === TemporalQueries.localTime()) {
-          return this.toLocalTime();
+        try {
+          var time = LocalTime.from(temporal);
+          var offset = ZoneOffset.from(temporal);
+          return new OffsetTime(time, offset);
+        } catch (ex) {
+          throw new DateTimeException("Unable to obtain OffsetTime TemporalAccessor: " + temporal + ", type " + (temporal.constructor != null ? temporal.constructor.name : ''));
         }
+      };
 
-        return _Temporal.prototype.query.call(this, _query);
+      OffsetTime.now = function now(clockOrZone) {
+        if (arguments.length === 0) {
+          return OffsetTime._now(Clock.systemDefaultZone());
+        } else if (clockOrZone instanceof Clock) {
+          return OffsetTime._now(clockOrZone);
+        } else {
+          return OffsetTime._now(Clock.system(clockOrZone));
+        }
       };
 
-      _proto.format = function format(formatter) {
-        requireNonNull(formatter, 'formatter');
-        return formatter.format(this);
+      OffsetTime._now = function _now(clock) {
+        requireNonNull(clock, 'clock');
+        var now = clock.instant();
+        return OffsetTime.ofInstant(now, clock.zone().rules().offset(now));
       };
 
-      _proto.toInstant = function toInstant() {
-        return Instant.ofEpochSecond(this.toEpochSecond(), this.toLocalTime().nano());
+      OffsetTime.of = function of() {
+        if (arguments.length <= 2) {
+          return OffsetTime.ofTimeAndOffset.apply(this, arguments);
+        } else {
+          return OffsetTime.ofNumbers.apply(this, arguments);
+        }
       };
 
-      _proto.toEpochSecond = function toEpochSecond() {
-        var epochDay = this.toLocalDate().toEpochDay();
-        var secs = epochDay * 86400 + this.toLocalTime().toSecondOfDay();
-        secs -= this.offset().totalSeconds();
-        return secs;
+      OffsetTime.ofNumbers = function ofNumbers(hour, minute, second, nanoOfSecond, offset) {
+        var time = LocalTime.of(hour, minute, second, nanoOfSecond);
+        return new OffsetTime(time, offset);
       };
 
-      _proto.compareTo = function compareTo(other) {
-        requireNonNull(other, 'other');
-        var cmp = MathUtil.compareNumbers(this.toEpochSecond(), other.toEpochSecond());
+      OffsetTime.ofTimeAndOffset = function ofTimeAndOffset(time, offset) {
+        return new OffsetTime(time, offset);
+      };
 
-        if (cmp === 0) {
-          cmp = this.toLocalTime().nano() - other.toLocalTime().nano();
+      OffsetTime.ofInstant = function ofInstant(instant, zone) {
+        requireNonNull(instant, 'instant');
+        requireInstance(instant, Instant, 'instant');
+        requireNonNull(zone, 'zone');
+        requireInstance(zone, ZoneId, 'zone');
+        var rules = zone.rules();
+        var offset = rules.offset(instant);
+        var secsOfDay = instant.epochSecond() % LocalTime.SECONDS_PER_DAY;
+        secsOfDay = (secsOfDay + offset.totalSeconds()) % LocalTime.SECONDS_PER_DAY;
 
-          if (cmp === 0) {
-            cmp = this.toLocalDateTime().compareTo(other.toLocalDateTime());
+        if (secsOfDay < 0) {
+          secsOfDay += LocalTime.SECONDS_PER_DAY;
+        }
 
-            if (cmp === 0) {
-              cmp = strcmp(this.zone().id(), other.zone().id());
-            }
+        var time = LocalTime.ofSecondOfDay(secsOfDay, instant.nano());
+        return new OffsetTime(time, offset);
+      };
+
+      OffsetTime.parse = function parse(text, formatter) {
+        if (formatter === void 0) {
+          formatter = DateTimeFormatter.ISO_OFFSET_TIME;
+        }
+
+        requireNonNull(formatter, 'formatter');
+        return formatter.parse(text, OffsetTime.FROM);
+      };
+
+      function OffsetTime(time, offset) {
+        var _this;
+
+        _this = _DefaultInterfaceTemp.call(this) || this;
+        requireNonNull(time, 'time');
+        requireInstance(time, LocalTime, 'time');
+        requireNonNull(offset, 'offset');
+        requireInstance(offset, ZoneOffset, 'offset');
+        _this._time = time;
+        _this._offset = offset;
+        return _this;
+      }
+
+      var _proto = OffsetTime.prototype;
+
+      _proto.adjustInto = function adjustInto(temporal) {
+        return temporal.with(ChronoField.NANO_OF_DAY, this._time.toNanoOfDay()).with(ChronoField.OFFSET_SECONDS, this.offset().totalSeconds());
+      };
+
+      _proto.atDate = function atDate(date) {
+        return OffsetDateTime.of(date, this._time, this._offset);
+      };
+
+      _proto.format = function format(formatter) {
+        requireNonNull(formatter, 'formatter');
+        return formatter.format(this, OffsetTime.FROM);
+      };
+
+      _proto.get = function get(field) {
+        return _DefaultInterfaceTemp.prototype.get.call(this, field);
+      };
+
+      _proto.getLong = function getLong(field) {
+        if (field instanceof ChronoField) {
+          if (field === ChronoField.OFFSET_SECONDS) {
+            return this._offset.totalSeconds();
           }
+
+          return this._time.getLong(field);
         }
 
-        return cmp;
+        return field.getFrom(this);
+      };
+
+      _proto.hour = function hour() {
+        return this._time.hour();
+      };
+
+      _proto.minute = function minute() {
+        return this._time.minute();
+      };
+
+      _proto.second = function second() {
+        return this._time.second();
+      };
+
+      _proto.nano = function nano() {
+        return this._time.nano();
+      };
+
+      _proto.offset = function offset() {
+        return this._offset;
       };
 
       _proto.isAfter = function isAfter(other) {
         requireNonNull(other, 'other');
-        var thisEpochSec = this.toEpochSecond();
-        var otherEpochSec = other.toEpochSecond();
-        return thisEpochSec > otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() > other.toLocalTime().nano();
+        return this._toEpochNano() > other._toEpochNano();
       };
 
       _proto.isBefore = function isBefore(other) {
         requireNonNull(other, 'other');
-        var thisEpochSec = this.toEpochSecond();
-        var otherEpochSec = other.toEpochSecond();
-        return thisEpochSec < otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() < other.toLocalTime().nano();
+        return this._toEpochNano() < other._toEpochNano();
       };
 
       _proto.isEqual = function isEqual(other) {
         requireNonNull(other, 'other');
-        return this.toEpochSecond() === other.toEpochSecond() && this.toLocalTime().nano() === other.toLocalTime().nano();
+        return this._toEpochNano() === other._toEpochNano();
       };
 
-      _proto.equals = function equals(other) {
-        if (this === other) {
-          return true;
+      _proto.isSupported = function isSupported(fieldOrUnit) {
+        if (fieldOrUnit instanceof ChronoField) {
+          return fieldOrUnit.isTimeBased() || fieldOrUnit === ChronoField.OFFSET_SECONDS;
+        } else if (fieldOrUnit instanceof ChronoUnit) {
+          return fieldOrUnit.isTimeBased();
         }
 
-        if (other instanceof ChronoZonedDateTime) {
-          return this.compareTo(other) === 0;
-        }
+        return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);
+      };
 
-        return false;
+      _proto.minusHours = function minusHours(hours) {
+        return this._withLocalTimeOffset(this._time.minusHours(hours), this._offset);
       };
 
-      return ChronoZonedDateTime;
-    }(Temporal);
+      _proto.minusMinutes = function minusMinutes(minutes) {
+        return this._withLocalTimeOffset(this._time.minusMinutes(minutes), this._offset);
+      };
 
-    function strcmp(a, b) {
-      if (a < b) {
-        return -1;
-      }
+      _proto.minusSeconds = function minusSeconds(seconds) {
+        return this._withLocalTimeOffset(this._time.minusSeconds(seconds), this._offset);
+      };
 
-      if (a > b) {
-        return 1;
-      }
+      _proto.minusNanos = function minusNanos(nanos) {
+        return this._withLocalTimeOffset(this._time.minusNanos(nanos), this._offset);
+      };
 
-      return 0;
-    }
+      _proto.minusAmount = function minusAmount(amount) {
+        requireNonNull(amount);
+        return amount.subtractFrom(this);
+      };
 
-    var ZonedDateTime = function (_ChronoZonedDateTime) {
-      _inheritsLoose(ZonedDateTime, _ChronoZonedDateTime);
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        return this.plus(-1 * amountToSubtract, unit);
+      };
 
-      ZonedDateTime.now = function now(clockOrZone) {
-        var clock;
+      _proto.plusAmount = function plusAmount(amount) {
+        requireNonNull(amount);
+        return amount.addTo(this);
+      };
 
-        if (clockOrZone instanceof ZoneId) {
-          clock = Clock.system(clockOrZone);
-        } else {
-          clock = clockOrZone == null ? Clock.systemDefaultZone() : clockOrZone;
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
+        if (unit instanceof ChronoUnit) {
+          return this._withLocalTimeOffset(this._time.plus(amountToAdd, unit), this._offset);
         }
 
-        return ZonedDateTime.ofInstant(clock.instant(), clock.zone());
+        return unit.addTo(this, amountToAdd);
       };
 
-      ZonedDateTime.of = function of() {
-        if (arguments.length <= 2) {
-          return ZonedDateTime.of2.apply(this, arguments);
-        } else if (arguments.length === 3 && arguments[0] instanceof LocalDate) {
-          return ZonedDateTime.of3.apply(this, arguments);
-        } else {
-          return ZonedDateTime.of8.apply(this, arguments);
-        }
+      _proto.plusHours = function plusHours(hours) {
+        return this._withLocalTimeOffset(this._time.plusHours(hours), this._offset);
       };
 
-      ZonedDateTime.of3 = function of3(date, time, zone) {
-        return ZonedDateTime.of2(LocalDateTime.of(date, time), zone);
+      _proto.plusMinutes = function plusMinutes(minutes) {
+        return this._withLocalTimeOffset(this._time.plusMinutes(minutes), this._offset);
       };
 
-      ZonedDateTime.of2 = function of2(localDateTime, zone) {
-        return ZonedDateTime.ofLocal(localDateTime, zone, null);
+      _proto.plusSeconds = function plusSeconds(seconds) {
+        return this._withLocalTimeOffset(this._time.plusSeconds(seconds), this._offset);
       };
 
-      ZonedDateTime.of8 = function of8(year, month, dayOfMonth, hour, minute, second, nanoOfSecond, zone) {
-        var dt = LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);
-        return ZonedDateTime.ofLocal(dt, zone, null);
+      _proto.plusNanos = function plusNanos(nanos) {
+        return this._withLocalTimeOffset(this._time.plusNanos(nanos), this._offset);
       };
 
-      ZonedDateTime.ofLocal = function ofLocal(localDateTime, zone, preferredOffset) {
-        requireNonNull(localDateTime, 'localDateTime');
-        requireNonNull(zone, 'zone');
+      _proto.query = function query(_query) {
+        requireNonNull(_query, 'query');
 
-        if (zone instanceof ZoneOffset) {
-          return new ZonedDateTime(localDateTime, zone, zone);
+        if (_query === TemporalQueries.precision()) {
+          return ChronoUnit.NANOS;
+        } else if (_query === TemporalQueries.offset() || _query === TemporalQueries.zone()) {
+          return this.offset();
+        } else if (_query === TemporalQueries.localTime()) {
+          return this._time;
+        } else if (_query === TemporalQueries.chronology() || _query === TemporalQueries.localDate() || _query === TemporalQueries.zoneId()) {
+          return null;
         }
 
-        var offset = null;
-        var rules = zone.rules();
-        var validOffsets = rules.validOffsets(localDateTime);
+        return _DefaultInterfaceTemp.prototype.query.call(this, _query);
+      };
 
-        if (validOffsets.length === 1) {
-          offset = validOffsets[0];
-        } else if (validOffsets.length === 0) {
-          var trans = rules.transition(localDateTime);
-          localDateTime = localDateTime.plusSeconds(trans.duration().seconds());
-          offset = trans.offsetAfter();
-        } else {
-          if (preferredOffset != null && validOffsets.some(function (validOffset) {
-            return validOffset.equals(preferredOffset);
-          })) {
-            offset = preferredOffset;
-          } else {
-            offset = requireNonNull(validOffsets[0], 'offset');
+      _proto.range = function range(field) {
+        if (field instanceof ChronoField) {
+          if (field === ChronoField.OFFSET_SECONDS) {
+            return field.range();
           }
+
+          return this._time.range(field);
         }
 
-        return new ZonedDateTime(localDateTime, offset, zone);
+        return field.rangeRefinedBy(this);
       };
 
-      ZonedDateTime.ofInstant = function ofInstant() {
-        if (arguments.length === 2) {
-          return ZonedDateTime.ofInstant2.apply(this, arguments);
-        } else {
-          return ZonedDateTime.ofInstant3.apply(this, arguments);
-        }
+      _proto.toLocalTime = function toLocalTime() {
+        return this._time;
       };
 
-      ZonedDateTime.ofInstant2 = function ofInstant2(instant, zone) {
-        requireNonNull(instant, 'instant');
-        requireNonNull(zone, 'zone');
-        return ZonedDateTime._create(instant.epochSecond(), instant.nano(), zone);
+      _proto.truncatedTo = function truncatedTo(unit) {
+        return this._withLocalTimeOffset(this._time.truncatedTo(unit), this._offset);
       };
 
-      ZonedDateTime.ofInstant3 = function ofInstant3(localDateTime, offset, zone) {
-        requireNonNull(localDateTime, 'localDateTime');
+      _proto.until = function until(endExclusive, unit) {
+        requireNonNull(endExclusive, 'endExclusive');
+        requireNonNull(unit, 'unit');
+        var end = OffsetTime.from(endExclusive);
+
+        if (unit instanceof ChronoUnit) {
+          var nanosUntil = end._toEpochNano() - this._toEpochNano();
+
+          switch (unit) {
+            case ChronoUnit.NANOS:
+              return nanosUntil;
+
+            case ChronoUnit.MICROS:
+              return Math.floor(nanosUntil / 1000);
+
+            case ChronoUnit.MILLIS:
+              return Math.floor(nanosUntil / 1000000);
+
+            case ChronoUnit.SECONDS:
+              return Math.floor(nanosUntil / LocalTime.NANOS_PER_SECOND);
+
+            case ChronoUnit.MINUTES:
+              return Math.floor(nanosUntil / LocalTime.NANOS_PER_MINUTE);
+
+            case ChronoUnit.HOURS:
+              return Math.floor(nanosUntil / LocalTime.NANOS_PER_HOUR);
+
+            case ChronoUnit.HALF_DAYS:
+              return Math.floor(nanosUntil / (12 * LocalTime.NANOS_PER_HOUR));
+          }
+
+          throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+        }
+
+        return unit.between(this, end);
+      };
+
+      _proto.withHour = function withHour(hour) {
+        return this._withLocalTimeOffset(this._time.withHour(hour), this._offset);
+      };
+
+      _proto.withMinute = function withMinute(minute) {
+        return this._withLocalTimeOffset(this._time.withMinute(minute), this._offset);
+      };
+
+      _proto.withSecond = function withSecond(second) {
+        return this._withLocalTimeOffset(this._time.withSecond(second), this._offset);
+      };
+
+      _proto.withNano = function withNano(nano) {
+        return this._withLocalTimeOffset(this._time.withNano(nano), this._offset);
+      };
+
+      _proto.withOffsetSameInstant = function withOffsetSameInstant(offset) {
         requireNonNull(offset, 'offset');
-        requireNonNull(zone, 'zone');
-        return ZonedDateTime._create(localDateTime.toEpochSecond(offset), localDateTime.nano(), zone);
+
+        if (offset.equals(this._offset)) {
+          return this;
+        }
+
+        var difference = offset.totalSeconds() - this._offset.totalSeconds();
+
+        var adjusted = this._time.plusSeconds(difference);
+
+        return new OffsetTime(adjusted, offset);
       };
 
-      ZonedDateTime._create = function _create(epochSecond, nanoOfSecond, zone) {
-        var rules = zone.rules();
-        var instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond);
-        var offset = rules.offset(instant);
-        var ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset);
-        return new ZonedDateTime(ldt, offset, zone);
+      _proto.withOffsetSameLocal = function withOffsetSameLocal(offset) {
+        return offset != null && offset.equals(this._offset) ? this : new OffsetTime(this._time, offset);
+      };
+
+      _proto._toEpochNano = function _toEpochNano() {
+        var nod = this._time.toNanoOfDay();
+
+        var offsetNanos = this._offset.totalSeconds() * LocalTime.NANOS_PER_SECOND;
+        return nod - offsetNanos;
+      };
+
+      _proto.withAdjuster = function withAdjuster(adjuster) {
+        requireNonNull(adjuster, 'adjuster');
+
+        if (adjuster instanceof LocalTime) {
+          return this._withLocalTimeOffset(adjuster, this._offset);
+        } else if (adjuster instanceof ZoneOffset) {
+          return this._withLocalTimeOffset(this._time, adjuster);
+        } else if (adjuster instanceof OffsetTime) {
+          return adjuster;
+        }
+
+        return adjuster.adjustInto(this);
+      };
+
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
+        requireNonNull(field, 'field');
+
+        if (field instanceof ChronoField) {
+          if (field === ChronoField.OFFSET_SECONDS) {
+            return this._withLocalTimeOffset(this._time, ZoneOffset.ofTotalSeconds(field.checkValidIntValue(newValue)));
+          }
+
+          return this._withLocalTimeOffset(this._time.with(field, newValue), this._offset);
+        }
+
+        return field.adjustInto(this, newValue);
+      };
+
+      _proto._withLocalTimeOffset = function _withLocalTimeOffset(time, offset) {
+        if (this._time === time && this._offset.equals(offset)) {
+          return this;
+        }
+
+        return new OffsetTime(time, offset);
+      };
+
+      _proto.compareTo = function compareTo(other) {
+        requireNonNull(other, 'other');
+        requireInstance(other, OffsetTime, 'other');
+
+        if (this._offset.equals(other._offset)) {
+          return this._time.compareTo(other._time);
+        }
+
+        var compare = MathUtil.compareNumbers(this._toEpochNano(), other._toEpochNano());
+
+        if (compare === 0) {
+          return this._time.compareTo(other._time);
+        }
+
+        return compare;
+      };
+
+      _proto.equals = function equals(other) {
+        if (this === other) {
+          return true;
+        }
+
+        if (other instanceof OffsetTime) {
+          return this._time.equals(other._time) && this._offset.equals(other._offset);
+        }
+
+        return false;
+      };
+
+      _proto.hashCode = function hashCode() {
+        return this._time.hashCode() ^ this._offset.hashCode();
+      };
+
+      _proto.toString = function toString() {
+        return this._time.toString() + this._offset.toString();
+      };
+
+      _proto.toJSON = function toJSON() {
+        return this.toString();
+      };
+
+      return OffsetTime;
+    }(DefaultInterfaceTemporal);
+    function _init$f() {
+      OffsetTime.MIN = OffsetTime.ofNumbers(0, 0, 0, 0, ZoneOffset.MAX);
+      OffsetTime.MAX = OffsetTime.ofNumbers(23, 59, 59, 999999999, ZoneOffset.MIN);
+      OffsetTime.FROM = createTemporalQuery('OffsetTime.FROM', function (temporal) {
+        return OffsetTime.from(temporal);
+      });
+    }
+
+    var ChronoZonedDateTime = function (_DefaultInterfaceTemp) {
+      _inheritsLoose(ChronoZonedDateTime, _DefaultInterfaceTemp);
+
+      function ChronoZonedDateTime() {
+        return _DefaultInterfaceTemp.apply(this, arguments) || this;
+      }
+
+      var _proto = ChronoZonedDateTime.prototype;
+
+      _proto.query = function query(_query) {
+        if (_query === TemporalQueries.zoneId() || _query === TemporalQueries.zone()) {
+          return this.zone();
+        } else if (_query === TemporalQueries.chronology()) {
+          return this.toLocalDate().chronology();
+        } else if (_query === TemporalQueries.precision()) {
+          return ChronoUnit.NANOS;
+        } else if (_query === TemporalQueries.offset()) {
+          return this.offset();
+        } else if (_query === TemporalQueries.localDate()) {
+          return LocalDate.ofEpochDay(this.toLocalDate().toEpochDay());
+        } else if (_query === TemporalQueries.localTime()) {
+          return this.toLocalTime();
+        }
+
+        return _DefaultInterfaceTemp.prototype.query.call(this, _query);
+      };
+
+      _proto.format = function format(formatter) {
+        requireNonNull(formatter, 'formatter');
+        return formatter.format(this);
+      };
+
+      _proto.toInstant = function toInstant() {
+        return Instant.ofEpochSecond(this.toEpochSecond(), this.toLocalTime().nano());
+      };
+
+      _proto.toEpochSecond = function toEpochSecond() {
+        var epochDay = this.toLocalDate().toEpochDay();
+        var secs = epochDay * 86400 + this.toLocalTime().toSecondOfDay();
+        secs -= this.offset().totalSeconds();
+        return secs;
+      };
+
+      _proto.compareTo = function compareTo(other) {
+        requireNonNull(other, 'other');
+        var cmp = MathUtil.compareNumbers(this.toEpochSecond(), other.toEpochSecond());
+
+        if (cmp === 0) {
+          cmp = this.toLocalTime().nano() - other.toLocalTime().nano();
+
+          if (cmp === 0) {
+            cmp = this.toLocalDateTime().compareTo(other.toLocalDateTime());
+
+            if (cmp === 0) {
+              cmp = strcmp(this.zone().id(), other.zone().id());
+            }
+          }
+        }
+
+        return cmp;
+      };
+
+      _proto.isAfter = function isAfter(other) {
+        requireNonNull(other, 'other');
+        var thisEpochSec = this.toEpochSecond();
+        var otherEpochSec = other.toEpochSecond();
+        return thisEpochSec > otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() > other.toLocalTime().nano();
+      };
+
+      _proto.isBefore = function isBefore(other) {
+        requireNonNull(other, 'other');
+        var thisEpochSec = this.toEpochSecond();
+        var otherEpochSec = other.toEpochSecond();
+        return thisEpochSec < otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() < other.toLocalTime().nano();
+      };
+
+      _proto.isEqual = function isEqual(other) {
+        requireNonNull(other, 'other');
+        return this.toEpochSecond() === other.toEpochSecond() && this.toLocalTime().nano() === other.toLocalTime().nano();
+      };
+
+      _proto.equals = function equals(other) {
+        if (this === other) {
+          return true;
+        }
+
+        if (other instanceof ChronoZonedDateTime) {
+          return this.compareTo(other) === 0;
+        }
+
+        return false;
+      };
+
+      return ChronoZonedDateTime;
+    }(DefaultInterfaceTemporal);
+
+    function strcmp(a, b) {
+      if (a < b) {
+        return -1;
+      }
+
+      if (a > b) {
+        return 1;
+      }
+
+      return 0;
+    }
+
+    var ZonedDateTime = function (_ChronoZonedDateTime) {
+      _inheritsLoose(ZonedDateTime, _ChronoZonedDateTime);
+
+      ZonedDateTime.now = function now(clockOrZone) {
+        var clock;
+
+        if (clockOrZone instanceof ZoneId) {
+          clock = Clock.system(clockOrZone);
+        } else {
+          clock = clockOrZone == null ? Clock.systemDefaultZone() : clockOrZone;
+        }
+
+        return ZonedDateTime.ofInstant(clock.instant(), clock.zone());
+      };
+
+      ZonedDateTime.of = function of() {
+        if (arguments.length <= 2) {
+          return ZonedDateTime.of2.apply(this, arguments);
+        } else if (arguments.length === 3 && arguments[0] instanceof LocalDate) {
+          return ZonedDateTime.of3.apply(this, arguments);
+        } else {
+          return ZonedDateTime.of8.apply(this, arguments);
+        }
+      };
+
+      ZonedDateTime.of3 = function of3(date, time, zone) {
+        return ZonedDateTime.of2(LocalDateTime.of(date, time), zone);
+      };
+
+      ZonedDateTime.of2 = function of2(localDateTime, zone) {
+        return ZonedDateTime.ofLocal(localDateTime, zone, null);
+      };
+
+      ZonedDateTime.of8 = function of8(year, month, dayOfMonth, hour, minute, second, nanoOfSecond, zone) {
+        var dt = LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);
+        return ZonedDateTime.ofLocal(dt, zone, null);
+      };
+
+      ZonedDateTime.ofLocal = function ofLocal(localDateTime, zone, preferredOffset) {
+        requireNonNull(localDateTime, 'localDateTime');
+        requireNonNull(zone, 'zone');
+
+        if (zone instanceof ZoneOffset) {
+          return new ZonedDateTime(localDateTime, zone, zone);
+        }
+
+        var offset = null;
+        var rules = zone.rules();
+        var validOffsets = rules.validOffsets(localDateTime);
+
+        if (validOffsets.length === 1) {
+          offset = validOffsets[0];
+        } else if (validOffsets.length === 0) {
+          var trans = rules.transition(localDateTime);
+          localDateTime = localDateTime.plusSeconds(trans.duration().seconds());
+          offset = trans.offsetAfter();
+        } else {
+          if (preferredOffset != null && validOffsets.some(function (validOffset) {
+            return validOffset.equals(preferredOffset);
+          })) {
+            offset = preferredOffset;
+          } else {
+            offset = requireNonNull(validOffsets[0], 'offset');
+          }
+        }
+
+        return new ZonedDateTime(localDateTime, offset, zone);
+      };
+
+      ZonedDateTime.ofInstant = function ofInstant() {
+        if (arguments.length === 2) {
+          return ZonedDateTime.ofInstant2.apply(this, arguments);
+        } else {
+          return ZonedDateTime.ofInstant3.apply(this, arguments);
+        }
+      };
+
+      ZonedDateTime.ofInstant2 = function ofInstant2(instant, zone) {
+        requireNonNull(instant, 'instant');
+        requireNonNull(zone, 'zone');
+        return ZonedDateTime._create(instant.epochSecond(), instant.nano(), zone);
+      };
+
+      ZonedDateTime.ofInstant3 = function ofInstant3(localDateTime, offset, zone) {
+        requireNonNull(localDateTime, 'localDateTime');
+        requireNonNull(offset, 'offset');
+        requireNonNull(zone, 'zone');
+        return ZonedDateTime._create(localDateTime.toEpochSecond(offset), localDateTime.nano(), zone);
+      };
+
+      ZonedDateTime._create = function _create(epochSecond, nanoOfSecond, zone) {
+        var rules = zone.rules();
+        var instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond);
+        var offset = rules.offset(instant);
+        var ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset);
+        return new ZonedDateTime(ldt, offset, zone);
+      };
+
+      ZonedDateTime.ofStrict = function ofStrict(localDateTime, offset, zone) {
+        requireNonNull(localDateTime, 'localDateTime');
+        requireNonNull(offset, 'offset');
+        requireNonNull(zone, 'zone');
+        var rules = zone.rules();
+
+        if (rules.isValidOffset(localDateTime, offset) === false) {
+          var trans = rules.transition(localDateTime);
+
+          if (trans != null && trans.isGap()) {
+            throw new DateTimeException('LocalDateTime ' + localDateTime + ' does not exist in zone ' + zone + ' due to a gap in the local time-line, typically caused by daylight savings');
+          }
+
+          throw new DateTimeException('ZoneOffset "' + offset + '" is not valid for LocalDateTime "' + localDateTime + '" in zone "' + zone + '"');
+        }
+
+        return new ZonedDateTime(localDateTime, offset, zone);
+      };
+
+      ZonedDateTime.ofLenient = function ofLenient(localDateTime, offset, zone) {
+        requireNonNull(localDateTime, 'localDateTime');
+        requireNonNull(offset, 'offset');
+        requireNonNull(zone, 'zone');
+
+        if (zone instanceof ZoneOffset && offset.equals(zone) === false) {
+          throw new IllegalArgumentException('ZoneId must match ZoneOffset');
+        }
+
+        return new ZonedDateTime(localDateTime, offset, zone);
+      };
+
+      ZonedDateTime.from = function from(temporal) {
+        requireNonNull(temporal, 'temporal');
+
+        if (temporal instanceof ZonedDateTime) {
+          return temporal;
+        }
+
+        var zone = ZoneId.from(temporal);
+
+        if (temporal.isSupported(ChronoField.INSTANT_SECONDS)) {
+          var zdt = ZonedDateTime._from(temporal, zone);
+
+          if (zdt != null) return zdt;
+        }
+
+        var ldt = LocalDateTime.from(temporal);
+        return ZonedDateTime.of2(ldt, zone);
+      };
+
+      ZonedDateTime._from = function _from(temporal, zone) {
+        try {
+          return ZonedDateTime.__from(temporal, zone);
+        } catch (ex) {
+          if (!(ex instanceof DateTimeException)) throw ex;
+        }
+      };
+
+      ZonedDateTime.__from = function __from(temporal, zone) {
+        var epochSecond = temporal.getLong(ChronoField.INSTANT_SECONDS);
+        var nanoOfSecond = temporal.get(ChronoField.NANO_OF_SECOND);
+        return ZonedDateTime._create(epochSecond, nanoOfSecond, zone);
+      };
+
+      ZonedDateTime.parse = function parse(text, formatter) {
+        if (formatter === void 0) {
+          formatter = DateTimeFormatter.ISO_ZONED_DATE_TIME;
+        }
+
+        requireNonNull(formatter, 'formatter');
+        return formatter.parse(text, ZonedDateTime.FROM);
+      };
+
+      function ZonedDateTime(dateTime, offset, zone) {
+        var _this;
+
+        requireNonNull(dateTime, 'dateTime');
+        requireNonNull(offset, 'offset');
+        requireNonNull(zone, 'zone');
+        _this = _ChronoZonedDateTime.call(this) || this;
+        _this._dateTime = dateTime;
+        _this._offset = offset;
+        _this._zone = zone;
+        return _this;
+      }
+
+      var _proto = ZonedDateTime.prototype;
+
+      _proto._resolveLocal = function _resolveLocal(newDateTime) {
+        requireNonNull(newDateTime, 'newDateTime');
+        return ZonedDateTime.ofLocal(newDateTime, this._zone, this._offset);
+      };
+
+      _proto._resolveInstant = function _resolveInstant(newDateTime) {
+        return ZonedDateTime.ofInstant3(newDateTime, this._offset, this._zone);
+      };
+
+      _proto._resolveOffset = function _resolveOffset(offset) {
+        if (offset.equals(this._offset) === false && this._zone.rules().isValidOffset(this._dateTime, offset)) {
+          return new ZonedDateTime(this._dateTime, offset, this._zone);
+        }
+
+        return this;
+      };
+
+      _proto.isSupported = function isSupported(fieldOrUnit) {
+        if (fieldOrUnit instanceof ChronoField) {
+          return true;
+        } else if (fieldOrUnit instanceof ChronoUnit) {
+          return fieldOrUnit.isDateBased() || fieldOrUnit.isTimeBased();
+        }
+
+        return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);
+      };
+
+      _proto.range = function range(field) {
+        if (field instanceof ChronoField) {
+          if (field === ChronoField.INSTANT_SECONDS || field === ChronoField.OFFSET_SECONDS) {
+            return field.range();
+          }
+
+          return this._dateTime.range(field);
+        }
+
+        return field.rangeRefinedBy(this);
+      };
+
+      _proto.get = function get(field) {
+        return this.getLong(field);
+      };
+
+      _proto.getLong = function getLong(field) {
+        if (field instanceof ChronoField) {
+          switch (field) {
+            case ChronoField.INSTANT_SECONDS:
+              return this.toEpochSecond();
+
+            case ChronoField.OFFSET_SECONDS:
+              return this._offset.totalSeconds();
+          }
+
+          return this._dateTime.getLong(field);
+        }
+
+        requireNonNull(field, 'field');
+        return field.getFrom(this);
+      };
+
+      _proto.offset = function offset() {
+        return this._offset;
+      };
+
+      _proto.withEarlierOffsetAtOverlap = function withEarlierOffsetAtOverlap() {
+        var trans = this._zone.rules().transition(this._dateTime);
+
+        if (trans != null && trans.isOverlap()) {
+          var earlierOffset = trans.offsetBefore();
+
+          if (earlierOffset.equals(this._offset) === false) {
+            return new ZonedDateTime(this._dateTime, earlierOffset, this._zone);
+          }
+        }
+
+        return this;
+      };
+
+      _proto.withLaterOffsetAtOverlap = function withLaterOffsetAtOverlap() {
+        var trans = this._zone.rules().transition(this.toLocalDateTime());
+
+        if (trans != null) {
+          var laterOffset = trans.offsetAfter();
+
+          if (laterOffset.equals(this._offset) === false) {
+            return new ZonedDateTime(this._dateTime, laterOffset, this._zone);
+          }
+        }
+
+        return this;
+      };
+
+      _proto.zone = function zone() {
+        return this._zone;
+      };
+
+      _proto.withZoneSameLocal = function withZoneSameLocal(zone) {
+        requireNonNull(zone, 'zone');
+        return this._zone.equals(zone) ? this : ZonedDateTime.ofLocal(this._dateTime, zone, this._offset);
+      };
+
+      _proto.withZoneSameInstant = function withZoneSameInstant(zone) {
+        requireNonNull(zone, 'zone');
+        return this._zone.equals(zone) ? this : ZonedDateTime._create(this._dateTime.toEpochSecond(this._offset), this._dateTime.nano(), zone);
+      };
+
+      _proto.withFixedOffsetZone = function withFixedOffsetZone() {
+        return this._zone.equals(this._offset) ? this : new ZonedDateTime(this._dateTime, this._offset, this._offset);
+      };
+
+      _proto.year = function year() {
+        return this._dateTime.year();
+      };
+
+      _proto.monthValue = function monthValue() {
+        return this._dateTime.monthValue();
+      };
+
+      _proto.month = function month() {
+        return this._dateTime.month();
+      };
+
+      _proto.dayOfMonth = function dayOfMonth() {
+        return this._dateTime.dayOfMonth();
+      };
+
+      _proto.dayOfYear = function dayOfYear() {
+        return this._dateTime.dayOfYear();
+      };
+
+      _proto.dayOfWeek = function dayOfWeek() {
+        return this._dateTime.dayOfWeek();
+      };
+
+      _proto.hour = function hour() {
+        return this._dateTime.hour();
+      };
+
+      _proto.minute = function minute() {
+        return this._dateTime.minute();
+      };
+
+      _proto.second = function second() {
+        return this._dateTime.second();
+      };
+
+      _proto.nano = function nano() {
+        return this._dateTime.nano();
+      };
+
+      _proto.withAdjuster = function withAdjuster(adjuster) {
+        if (adjuster instanceof LocalDate) {
+          return this._resolveLocal(LocalDateTime.of(adjuster, this._dateTime.toLocalTime()));
+        } else if (adjuster instanceof LocalTime) {
+          return this._resolveLocal(LocalDateTime.of(this._dateTime.toLocalDate(), adjuster));
+        } else if (adjuster instanceof LocalDateTime) {
+          return this._resolveLocal(adjuster);
+        } else if (adjuster instanceof Instant) {
+          var instant = adjuster;
+          return ZonedDateTime._create(instant.epochSecond(), instant.nano(), this._zone);
+        } else if (adjuster instanceof ZoneOffset) {
+          return this._resolveOffset(adjuster);
+        }
+
+        requireNonNull(adjuster, 'adjuster');
+        return adjuster.adjustInto(this);
+      };
+
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
+        if (field instanceof ChronoField) {
+          switch (field) {
+            case ChronoField.INSTANT_SECONDS:
+              return ZonedDateTime._create(newValue, this.nano(), this._zone);
+
+            case ChronoField.OFFSET_SECONDS:
+              {
+                var offset = ZoneOffset.ofTotalSeconds(field.checkValidIntValue(newValue));
+                return this._resolveOffset(offset);
+              }
+          }
+
+          return this._resolveLocal(this._dateTime.with(field, newValue));
+        }
+
+        return field.adjustInto(this, newValue);
+      };
+
+      _proto.withYear = function withYear(year) {
+        return this._resolveLocal(this._dateTime.withYear(year));
+      };
+
+      _proto.withMonth = function withMonth(month) {
+        return this._resolveLocal(this._dateTime.withMonth(month));
+      };
+
+      _proto.withDayOfMonth = function withDayOfMonth(dayOfMonth) {
+        return this._resolveLocal(this._dateTime.withDayOfMonth(dayOfMonth));
+      };
+
+      _proto.withDayOfYear = function withDayOfYear(dayOfYear) {
+        return this._resolveLocal(this._dateTime.withDayOfYear(dayOfYear));
+      };
+
+      _proto.withHour = function withHour(hour) {
+        return this._resolveLocal(this._dateTime.withHour(hour));
+      };
+
+      _proto.withMinute = function withMinute(minute) {
+        return this._resolveLocal(this._dateTime.withMinute(minute));
+      };
+
+      _proto.withSecond = function withSecond(second) {
+        return this._resolveLocal(this._dateTime.withSecond(second));
+      };
+
+      _proto.withNano = function withNano(nanoOfSecond) {
+        return this._resolveLocal(this._dateTime.withNano(nanoOfSecond));
+      };
+
+      _proto.truncatedTo = function truncatedTo(unit) {
+        return this._resolveLocal(this._dateTime.truncatedTo(unit));
+      };
+
+      _proto.plusAmount = function plusAmount(amount) {
+        requireNonNull(amount);
+        return amount.addTo(this);
+      };
+
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
+        if (unit instanceof ChronoUnit) {
+          if (unit.isDateBased()) {
+            return this._resolveLocal(this._dateTime.plus(amountToAdd, unit));
+          } else {
+            return this._resolveInstant(this._dateTime.plus(amountToAdd, unit));
+          }
+        }
+
+        requireNonNull(unit, 'unit');
+        return unit.addTo(this, amountToAdd);
+      };
+
+      _proto.plusYears = function plusYears(years) {
+        return this._resolveLocal(this._dateTime.plusYears(years));
+      };
+
+      _proto.plusMonths = function plusMonths(months) {
+        return this._resolveLocal(this._dateTime.plusMonths(months));
+      };
+
+      _proto.plusWeeks = function plusWeeks(weeks) {
+        return this._resolveLocal(this._dateTime.plusWeeks(weeks));
+      };
+
+      _proto.plusDays = function plusDays(days) {
+        return this._resolveLocal(this._dateTime.plusDays(days));
+      };
+
+      _proto.plusHours = function plusHours(hours) {
+        return this._resolveInstant(this._dateTime.plusHours(hours));
+      };
+
+      _proto.plusMinutes = function plusMinutes(minutes) {
+        return this._resolveInstant(this._dateTime.plusMinutes(minutes));
+      };
+
+      _proto.plusSeconds = function plusSeconds(seconds) {
+        return this._resolveInstant(this._dateTime.plusSeconds(seconds));
+      };
+
+      _proto.plusNanos = function plusNanos(nanos) {
+        return this._resolveInstant(this._dateTime.plusNanos(nanos));
+      };
+
+      _proto.minusAmount = function minusAmount(amount) {
+        requireNonNull(amount, 'amount');
+        return amount.subtractFrom(this);
+      };
+
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
+      };
+
+      _proto.minusYears = function minusYears(years) {
+        return this.plusYears(-1 * years);
+      };
+
+      _proto.minusMonths = function minusMonths(months) {
+        return this.plusMonths(-1 * months);
+      };
+
+      _proto.minusWeeks = function minusWeeks(weeks) {
+        return this.plusWeeks(-1 * weeks);
+      };
+
+      _proto.minusDays = function minusDays(days) {
+        return this.plusDays(-1 * days);
+      };
+
+      _proto.minusHours = function minusHours(hours) {
+        return this.plusHours(-1 * hours);
+      };
+
+      _proto.minusMinutes = function minusMinutes(minutes) {
+        return this.plusMinutes(-1 * minutes);
+      };
+
+      _proto.minusSeconds = function minusSeconds(seconds) {
+        return this.plusSeconds(-1 * seconds);
+      };
+
+      _proto.minusNanos = function minusNanos(nanos) {
+        return this.plusNanos(-1 * nanos);
+      };
+
+      _proto.query = function query(_query) {
+        if (_query === TemporalQueries.localDate()) {
+          return this.toLocalDate();
+        }
+
+        requireNonNull(_query, 'query');
+        return _ChronoZonedDateTime.prototype.query.call(this, _query);
+      };
+
+      _proto.until = function until(endExclusive, unit) {
+        var end = ZonedDateTime.from(endExclusive);
+
+        if (unit instanceof ChronoUnit) {
+          end = end.withZoneSameInstant(this._zone);
+
+          if (unit.isDateBased()) {
+            return this._dateTime.until(end._dateTime, unit);
+          } else {
+            var difference = this._offset.totalSeconds() - end._offset.totalSeconds();
+
+            var adjustedEnd = end._dateTime.plusSeconds(difference);
+
+            return this._dateTime.until(adjustedEnd, unit);
+          }
+        }
+
+        return unit.between(this, end);
+      };
+
+      _proto.toLocalDateTime = function toLocalDateTime() {
+        return this._dateTime;
+      };
+
+      _proto.toLocalDate = function toLocalDate() {
+        return this._dateTime.toLocalDate();
+      };
+
+      _proto.toLocalTime = function toLocalTime() {
+        return this._dateTime.toLocalTime();
+      };
+
+      _proto.toOffsetDateTime = function toOffsetDateTime() {
+        return OffsetDateTime.of(this._dateTime, this._offset);
+      };
+
+      _proto.equals = function equals(other) {
+        if (this === other) {
+          return true;
+        }
+
+        if (other instanceof ZonedDateTime) {
+          return this._dateTime.equals(other._dateTime) && this._offset.equals(other._offset) && this._zone.equals(other._zone);
+        }
+
+        return false;
+      };
+
+      _proto.hashCode = function hashCode() {
+        return MathUtil.hashCode(this._dateTime.hashCode(), this._offset.hashCode(), this._zone.hashCode());
+      };
+
+      _proto.toString = function toString() {
+        var str = this._dateTime.toString() + this._offset.toString();
+
+        if (this._offset !== this._zone) {
+          str += '[' + this._zone.toString() + ']';
+        }
+
+        return str;
+      };
+
+      _proto.toJSON = function toJSON() {
+        return this.toString();
+      };
+
+      _proto.format = function format(formatter) {
+        return _ChronoZonedDateTime.prototype.format.call(this, formatter);
       };
 
-      ZonedDateTime.ofStrict = function ofStrict(localDateTime, offset, zone) {
-        requireNonNull(localDateTime, 'localDateTime');
-        requireNonNull(offset, 'offset');
-        requireNonNull(zone, 'zone');
-        var rules = zone.rules();
+      return ZonedDateTime;
+    }(ChronoZonedDateTime);
+    function _init$g() {
+      ZonedDateTime.FROM = createTemporalQuery('ZonedDateTime.FROM', function (temporal) {
+        return ZonedDateTime.from(temporal);
+      });
+    }
 
-        if (rules.isValidOffset(localDateTime, offset) === false) {
-          var trans = rules.transition(localDateTime);
+    var OffsetDateTime = function (_DefaultInterfaceTemp) {
+      _inheritsLoose(OffsetDateTime, _DefaultInterfaceTemp);
 
-          if (trans != null && trans.isGap()) {
-            throw new DateTimeException('LocalDateTime ' + localDateTime + ' does not exist in zone ' + zone + ' due to a gap in the local time-line, typically caused by daylight savings');
-          }
+      OffsetDateTime.from = function from(temporal) {
+        requireNonNull(temporal, 'temporal');
 
-          throw new DateTimeException('ZoneOffset "' + offset + '" is not valid for LocalDateTime "' + localDateTime + '" in zone "' + zone + '"');
+        if (temporal instanceof OffsetDateTime) {
+          return temporal;
         }
 
-        return new ZonedDateTime(localDateTime, offset, zone);
+        try {
+          var offset = ZoneOffset.from(temporal);
+
+          try {
+            var ldt = LocalDateTime.from(temporal);
+            return OffsetDateTime.of(ldt, offset);
+          } catch (_) {
+            var instant = Instant.from(temporal);
+            return OffsetDateTime.ofInstant(instant, offset);
+          }
+        } catch (ex) {
+          throw new DateTimeException("Unable to obtain OffsetDateTime TemporalAccessor: " + temporal + ", type " + (temporal.constructor != null ? temporal.constructor.name : ''));
+        }
       };
 
-      ZonedDateTime.ofLenient = function ofLenient(localDateTime, offset, zone) {
-        requireNonNull(localDateTime, 'localDateTime');
-        requireNonNull(offset, 'offset');
-        requireNonNull(zone, 'zone');
+      OffsetDateTime.now = function now(clockOrZone) {
+        if (arguments.length === 0) {
+          return OffsetDateTime.now(Clock.systemDefaultZone());
+        } else {
+          requireNonNull(clockOrZone, 'clockOrZone');
 
-        if (zone instanceof ZoneOffset && offset.equals(zone) === false) {
-          throw new IllegalArgumentException('ZoneId must match ZoneOffset');
+          if (clockOrZone instanceof ZoneId) {
+            return OffsetDateTime.now(Clock.system(clockOrZone));
+          } else if (clockOrZone instanceof Clock) {
+            var now = clockOrZone.instant();
+            return OffsetDateTime.ofInstant(now, clockOrZone.zone().rules().offset(now));
+          } else {
+            throw new IllegalArgumentException('clockOrZone must be an instance of ZoneId or Clock');
+          }
         }
-
-        return new ZonedDateTime(localDateTime, offset, zone);
       };
 
-      ZonedDateTime.from = function from(temporal) {
-        requireNonNull(temporal, 'temporal');
-
-        if (temporal instanceof ZonedDateTime) {
-          return temporal;
+      OffsetDateTime.of = function of() {
+        if (arguments.length <= 2) {
+          return OffsetDateTime.ofDateTime.apply(this, arguments);
+        } else if (arguments.length === 3) {
+          return OffsetDateTime.ofDateAndTime.apply(this, arguments);
+        } else {
+          return OffsetDateTime.ofNumbers.apply(this, arguments);
         }
+      };
 
-        var zone = ZoneId.from(temporal);
+      OffsetDateTime.ofDateTime = function ofDateTime(dateTime, offset) {
+        return new OffsetDateTime(dateTime, offset);
+      };
 
-        if (temporal.isSupported(ChronoField.INSTANT_SECONDS)) {
-          var zdt = ZonedDateTime._from(temporal, zone);
+      OffsetDateTime.ofDateAndTime = function ofDateAndTime(date, time, offset) {
+        var dt = LocalDateTime.of(date, time);
+        return new OffsetDateTime(dt, offset);
+      };
 
-          if (zdt != null) return zdt;
+      OffsetDateTime.ofNumbers = function ofNumbers(year, month, dayOfMonth, hour, minute, second, nanoOfSecond, offset) {
+        if (hour === void 0) {
+          hour = 0;
         }
 
-        var ldt = LocalDateTime.from(temporal);
-        return ZonedDateTime.of2(ldt, zone);
-      };
+        if (minute === void 0) {
+          minute = 0;
+        }
 
-      ZonedDateTime._from = function _from(temporal, zone) {
-        try {
-          return ZonedDateTime.__from(temporal, zone);
-        } catch (ex) {
-          if (!(ex instanceof DateTimeException)) throw ex;
+        if (second === void 0) {
+          second = 0;
+        }
+
+        if (nanoOfSecond === void 0) {
+          nanoOfSecond = 0;
         }
+
+        var dt = LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond);
+        return new OffsetDateTime(dt, offset);
       };
 
-      ZonedDateTime.__from = function __from(temporal, zone) {
-        var epochSecond = temporal.getLong(ChronoField.INSTANT_SECONDS);
-        var nanoOfSecond = temporal.get(ChronoField.NANO_OF_SECOND);
-        return ZonedDateTime._create(epochSecond, nanoOfSecond, zone);
+      OffsetDateTime.ofInstant = function ofInstant(instant, zone) {
+        requireNonNull(instant, 'instant');
+        requireNonNull(zone, 'zone');
+        var rules = zone.rules();
+        var offset = rules.offset(instant);
+        var ldt = LocalDateTime.ofEpochSecond(instant.epochSecond(), instant.nano(), offset);
+        return new OffsetDateTime(ldt, offset);
       };
 
-      ZonedDateTime.parse = function parse(text, formatter) {
+      OffsetDateTime.parse = function parse(text, formatter) {
         if (formatter === void 0) {
-          formatter = DateTimeFormatter.ISO_ZONED_DATE_TIME;
+          formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
         }
 
         requireNonNull(formatter, 'formatter');
-        return formatter.parse(text, ZonedDateTime.FROM);
+        return formatter.parse(text, OffsetDateTime.FROM);
       };
 
-      function ZonedDateTime(dateTime, offset, zone) {
+      function OffsetDateTime(dateTime, offset) {
         var _this;
 
+        _this = _DefaultInterfaceTemp.call(this) || this;
         requireNonNull(dateTime, 'dateTime');
+        requireInstance(dateTime, LocalDateTime, 'dateTime');
         requireNonNull(offset, 'offset');
-        requireNonNull(zone, 'zone');
-        _this = _ChronoZonedDateTime.call(this) || this;
+        requireInstance(offset, ZoneOffset, 'offset');
         _this._dateTime = dateTime;
         _this._offset = offset;
-        _this._zone = zone;
         return _this;
       }
 
-      var _proto = ZonedDateTime.prototype;
+      var _proto = OffsetDateTime.prototype;
 
-      _proto._resolveLocal = function _resolveLocal(newDateTime) {
-        requireNonNull(newDateTime, 'newDateTime');
-        return ZonedDateTime.ofLocal(newDateTime, this._zone, this._offset);
+      _proto.adjustInto = function adjustInto(temporal) {
+        return temporal.with(ChronoField.EPOCH_DAY, this.toLocalDate().toEpochDay()).with(ChronoField.NANO_OF_DAY, this.toLocalTime().toNanoOfDay()).with(ChronoField.OFFSET_SECONDS, this.offset().totalSeconds());
       };
 
-      _proto._resolveInstant = function _resolveInstant(newDateTime) {
-        return ZonedDateTime.ofInstant3(newDateTime, this._offset, this._zone);
-      };
+      _proto.until = function until(endExclusive, unit) {
+        var end = OffsetDateTime.from(endExclusive);
 
-      _proto._resolveOffset = function _resolveOffset(offset) {
-        if (offset.equals(this._offset) === false && this._zone.rules().isValidOffset(this._dateTime, offset)) {
-          return new ZonedDateTime(this._dateTime, offset, this._zone);
+        if (unit instanceof ChronoUnit) {
+          end = end.withOffsetSameInstant(this._offset);
+          return this._dateTime.until(end._dateTime, unit);
         }
 
-        return this;
+        return unit.between(this, end);
       };
 
-      _proto.isSupported = function isSupported(fieldOrUnit) {
-        if (fieldOrUnit instanceof ChronoField) {
-          return true;
-        } else if (fieldOrUnit instanceof ChronoUnit) {
-          return fieldOrUnit.isDateBased() || fieldOrUnit.isTimeBased();
-        }
+      _proto.atZoneSameInstant = function atZoneSameInstant(zone) {
+        return ZonedDateTime.ofInstant(this._dateTime, this._offset, zone);
+      };
 
-        return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);
+      _proto.atZoneSimilarLocal = function atZoneSimilarLocal(zone) {
+        return ZonedDateTime.ofLocal(this._dateTime, zone, this._offset);
       };
 
-      _proto.range = function range(field) {
-        if (field instanceof ChronoField) {
-          if (field === ChronoField.INSTANT_SECONDS || field === ChronoField.OFFSET_SECONDS) {
-            return field.range();
-          }
+      _proto.query = function query(_query) {
+        requireNonNull(_query, 'query');
 
-          return this._dateTime.range(field);
+        if (_query === TemporalQueries.chronology()) {
+          return IsoChronology.INSTANCE;
+        } else if (_query === TemporalQueries.precision()) {
+          return ChronoUnit.NANOS;
+        } else if (_query === TemporalQueries.offset() || _query === TemporalQueries.zone()) {
+          return this.offset();
+        } else if (_query === TemporalQueries.localDate()) {
+          return this.toLocalDate();
+        } else if (_query === TemporalQueries.localTime()) {
+          return this.toLocalTime();
+        } else if (_query === TemporalQueries.zoneId()) {
+          return null;
         }
 
-        return field.rangeRefinedBy(this);
+        return _DefaultInterfaceTemp.prototype.query.call(this, _query);
       };
 
       _proto.get = function get(field) {
-        return this.getLong(field);
+        if (field instanceof ChronoField) {
+          switch (field) {
+            case ChronoField.INSTANT_SECONDS:
+              throw new DateTimeException('Field too large for an int: ' + field);
+
+            case ChronoField.OFFSET_SECONDS:
+              return this.offset().totalSeconds();
+          }
+
+          return this._dateTime.get(field);
+        }
+
+        return _DefaultInterfaceTemp.prototype.get.call(this, field);
       };
 
       _proto.getLong = function getLong(field) {
@@ -8688,13 +9782,12 @@
               return this.toEpochSecond();
 
             case ChronoField.OFFSET_SECONDS:
-              return this._offset.totalSeconds();
+              return this.offset().totalSeconds();
           }
 
           return this._dateTime.getLong(field);
         }
 
-        requireNonNull(field, 'field');
         return field.getFrom(this);
       };
 
@@ -8702,52 +9795,6 @@
         return this._offset;
       };
 
-      _proto.withEarlierOffsetAtOverlap = function withEarlierOffsetAtOverlap() {
-        var trans = this._zone.rules().transition(this._dateTime);
-
-        if (trans != null && trans.isOverlap()) {
-          var earlierOffset = trans.offsetBefore();
-
-          if (earlierOffset.equals(this._offset) === false) {
-            return new ZonedDateTime(this._dateTime, earlierOffset, this._zone);
-          }
-        }
-
-        return this;
-      };
-
-      _proto.withLaterOffsetAtOverlap = function withLaterOffsetAtOverlap() {
-        var trans = this._zone.rules().transition(this.toLocalDateTime());
-
-        if (trans != null) {
-          var laterOffset = trans.offsetAfter();
-
-          if (laterOffset.equals(this._offset) === false) {
-            return new ZonedDateTime(this._dateTime, laterOffset, this._zone);
-          }
-        }
-
-        return this;
-      };
-
-      _proto.zone = function zone() {
-        return this._zone;
-      };
-
-      _proto.withZoneSameLocal = function withZoneSameLocal(zone) {
-        requireNonNull(zone, 'zone');
-        return this._zone.equals(zone) ? this : ZonedDateTime.ofLocal(this._dateTime, zone, this._offset);
-      };
-
-      _proto.withZoneSameInstant = function withZoneSameInstant(zone) {
-        requireNonNull(zone, 'zone');
-        return this._zone.equals(zone) ? this : ZonedDateTime._create(this._dateTime.toEpochSecond(this._offset), this._dateTime.nano(), zone);
-      };
-
-      _proto.withFixedOffsetZone = function withFixedOffsetZone() {
-        return this._zone.equals(this._offset) ? this : new ZonedDateTime(this._dateTime, this._offset, this._offset);
-      };
-
       _proto.year = function year() {
         return this._dateTime.year();
       };
@@ -8788,233 +9835,283 @@
         return this._dateTime.nano();
       };
 
-      _proto.with = function _with() {
-        if (arguments.length === 1) {
-          return this.withTemporalAdjuster.apply(this, arguments);
-        } else {
-          return this.with2.apply(this, arguments);
+      _proto.toLocalDateTime = function toLocalDateTime() {
+        return this._dateTime;
+      };
+
+      _proto.toLocalDate = function toLocalDate() {
+        return this._dateTime.toLocalDate();
+      };
+
+      _proto.toLocalTime = function toLocalTime() {
+        return this._dateTime.toLocalTime();
+      };
+
+      _proto.toOffsetTime = function toOffsetTime() {
+        return OffsetTime.of(this._dateTime.toLocalTime(), this._offset);
+      };
+
+      _proto.toZonedDateTime = function toZonedDateTime() {
+        return ZonedDateTime.of(this._dateTime, this._offset);
+      };
+
+      _proto.toInstant = function toInstant() {
+        return this._dateTime.toInstant(this._offset);
+      };
+
+      _proto.toEpochSecond = function toEpochSecond() {
+        return this._dateTime.toEpochSecond(this._offset);
+      };
+
+      _proto.isSupported = function isSupported(fieldOrUnit) {
+        if (fieldOrUnit instanceof ChronoField) {
+          return fieldOrUnit.isDateBased() || fieldOrUnit.isTimeBased();
+        }
+
+        if (fieldOrUnit instanceof ChronoUnit) {
+          return fieldOrUnit.isDateBased() || fieldOrUnit.isTimeBased();
         }
+
+        return fieldOrUnit != null && fieldOrUnit.isSupportedBy(this);
       };
 
-      _proto.withTemporalAdjuster = function withTemporalAdjuster(adjuster) {
-        if (adjuster instanceof LocalDate) {
-          return this._resolveLocal(LocalDateTime.of(adjuster, this._dateTime.toLocalTime()));
-        } else if (adjuster instanceof LocalTime) {
-          return this._resolveLocal(LocalDateTime.of(this._dateTime.toLocalDate(), adjuster));
-        } else if (adjuster instanceof LocalDateTime) {
-          return this._resolveLocal(adjuster);
+      _proto.range = function range(field) {
+        if (field instanceof ChronoField) {
+          if (field === ChronoField.INSTANT_SECONDS || field === ChronoField.OFFSET_SECONDS) {
+            return field.range();
+          }
+
+          return this._dateTime.range(field);
+        }
+
+        return field.rangeRefinedBy(this);
+      };
+
+      _proto.withAdjuster = function withAdjuster(adjuster) {
+        requireNonNull(adjuster);
+
+        if (adjuster instanceof LocalDate || adjuster instanceof LocalTime || adjuster instanceof LocalDateTime) {
+          return this._withDateTimeOffset(this._dateTime.with(adjuster), this._offset);
         } else if (adjuster instanceof Instant) {
-          var instant = adjuster;
-          return ZonedDateTime._create(instant.epochSecond(), instant.nano(), this._zone);
+          return OffsetDateTime.ofInstant(adjuster, this._offset);
         } else if (adjuster instanceof ZoneOffset) {
-          return this._resolveOffset(adjuster);
+          return this._withDateTimeOffset(this._dateTime, adjuster);
+        } else if (adjuster instanceof OffsetDateTime) {
+          return adjuster;
         }
 
-        requireNonNull(adjuster, 'adjuster');
         return adjuster.adjustInto(this);
       };
 
-      _proto.with2 = function with2(field, newValue) {
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
+        requireNonNull(field);
+
         if (field instanceof ChronoField) {
-          switch (field) {
+          var f = field;
+
+          switch (f) {
             case ChronoField.INSTANT_SECONDS:
-              return ZonedDateTime._create(newValue, this.nano(), this._zone);
+              return OffsetDateTime.ofInstant(Instant.ofEpochSecond(newValue, this.nano()), this._offset);
 
             case ChronoField.OFFSET_SECONDS:
               {
-                var offset = ZoneOffset.ofTotalSeconds(field.checkValidIntValue(newValue));
-                return this._resolveOffset(offset);
+                return this._withDateTimeOffset(this._dateTime, ZoneOffset.ofTotalSeconds(f.checkValidIntValue(newValue)));
               }
           }
 
-          return this._resolveLocal(this._dateTime.with(field, newValue));
+          return this._withDateTimeOffset(this._dateTime.with(field, newValue), this._offset);
         }
 
         return field.adjustInto(this, newValue);
       };
 
+      _proto._withDateTimeOffset = function _withDateTimeOffset(dateTime, offset) {
+        if (this._dateTime === dateTime && this._offset.equals(offset)) {
+          return this;
+        }
+
+        return new OffsetDateTime(dateTime, offset);
+      };
+
       _proto.withYear = function withYear(year) {
-        return this._resolveLocal(this._dateTime.withYear(year));
+        return this._withDateTimeOffset(this._dateTime.withYear(year), this._offset);
       };
 
       _proto.withMonth = function withMonth(month) {
-        return this._resolveLocal(this._dateTime.withMonth(month));
+        return this._withDateTimeOffset(this._dateTime.withMonth(month), this._offset);
       };
 
       _proto.withDayOfMonth = function withDayOfMonth(dayOfMonth) {
-        return this._resolveLocal(this._dateTime.withDayOfMonth(dayOfMonth));
+        return this._withDateTimeOffset(this._dateTime.withDayOfMonth(dayOfMonth), this._offset);
       };
 
       _proto.withDayOfYear = function withDayOfYear(dayOfYear) {
-        return this._resolveLocal(this._dateTime.withDayOfYear(dayOfYear));
+        return this._withDateTimeOffset(this._dateTime.withDayOfYear(dayOfYear), this._offset);
       };
 
       _proto.withHour = function withHour(hour) {
-        return this._resolveLocal(this._dateTime.withHour(hour));
+        return this._withDateTimeOffset(this._dateTime.withHour(hour), this._offset);
       };
 
       _proto.withMinute = function withMinute(minute) {
-        return this._resolveLocal(this._dateTime.withMinute(minute));
+        return this._withDateTimeOffset(this._dateTime.withMinute(minute), this._offset);
       };
 
       _proto.withSecond = function withSecond(second) {
-        return this._resolveLocal(this._dateTime.withSecond(second));
+        return this._withDateTimeOffset(this._dateTime.withSecond(second), this._offset);
       };
 
       _proto.withNano = function withNano(nanoOfSecond) {
-        return this._resolveLocal(this._dateTime.withNano(nanoOfSecond));
+        return this._withDateTimeOffset(this._dateTime.withNano(nanoOfSecond), this._offset);
       };
 
-      _proto.truncatedTo = function truncatedTo(unit) {
-        return this._resolveLocal(this._dateTime.truncatedTo(unit));
+      _proto.withOffsetSameLocal = function withOffsetSameLocal(offset) {
+        requireNonNull(offset, 'offset');
+        return this._withDateTimeOffset(this._dateTime, offset);
       };
 
-      _proto.plus = function plus() {
-        if (arguments.length === 1) {
-          return this.plusTemporalAmount.apply(this, arguments);
-        } else {
-          return this.plus2.apply(this, arguments);
+      _proto.withOffsetSameInstant = function withOffsetSameInstant(offset) {
+        requireNonNull(offset, 'offset');
+
+        if (offset.equals(this._offset)) {
+          return this;
         }
+
+        var difference = offset.totalSeconds() - this._offset.totalSeconds();
+
+        var adjusted = this._dateTime.plusSeconds(difference);
+
+        return new OffsetDateTime(adjusted, offset);
       };
 
-      _proto.plusTemporalAmount = function plusTemporalAmount(amount) {
-        requireNonNull(amount);
+      _proto.truncatedTo = function truncatedTo(unit) {
+        return this._withDateTimeOffset(this._dateTime.truncatedTo(unit), this._offset);
+      };
+
+      _proto.plusAmount = function plusAmount(amount) {
+        requireNonNull(amount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plus2 = function plus2(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         if (unit instanceof ChronoUnit) {
-          if (unit.isDateBased()) {
-            return this._resolveLocal(this._dateTime.plus(amountToAdd, unit));
-          } else {
-            return this._resolveInstant(this._dateTime.plus(amountToAdd, unit));
-          }
+          return this._withDateTimeOffset(this._dateTime.plus(amountToAdd, unit), this._offset);
         }
 
-        requireNonNull(unit, 'unit');
         return unit.addTo(this, amountToAdd);
       };
 
       _proto.plusYears = function plusYears(years) {
-        return this._resolveLocal(this._dateTime.plusYears(years));
+        return this._withDateTimeOffset(this._dateTime.plusYears(years), this._offset);
       };
 
       _proto.plusMonths = function plusMonths(months) {
-        return this._resolveLocal(this._dateTime.plusMonths(months));
+        return this._withDateTimeOffset(this._dateTime.plusMonths(months), this._offset);
       };
 
       _proto.plusWeeks = function plusWeeks(weeks) {
-        return this._resolveLocal(this._dateTime.plusWeeks(weeks));
+        return this._withDateTimeOffset(this._dateTime.plusWeeks(weeks), this._offset);
       };
 
       _proto.plusDays = function plusDays(days) {
-        return this._resolveLocal(this._dateTime.plusDays(days));
+        return this._withDateTimeOffset(this._dateTime.plusDays(days), this._offset);
       };
 
       _proto.plusHours = function plusHours(hours) {
-        return this._resolveInstant(this._dateTime.plusHours(hours));
+        return this._withDateTimeOffset(this._dateTime.plusHours(hours), this._offset);
       };
 
       _proto.plusMinutes = function plusMinutes(minutes) {
-        return this._resolveInstant(this._dateTime.plusMinutes(minutes));
+        return this._withDateTimeOffset(this._dateTime.plusMinutes(minutes), this._offset);
       };
 
       _proto.plusSeconds = function plusSeconds(seconds) {
-        return this._resolveInstant(this._dateTime.plusSeconds(seconds));
+        return this._withDateTimeOffset(this._dateTime.plusSeconds(seconds), this._offset);
       };
 
       _proto.plusNanos = function plusNanos(nanos) {
-        return this._resolveInstant(this._dateTime.plusNanos(nanos));
+        return this._withDateTimeOffset(this._dateTime.plusNanos(nanos), this._offset);
       };
 
-      _proto.minus = function minus() {
-        if (arguments.length === 1) {
-          return this.minusTemporalAmount.apply(this, arguments);
-        } else {
-          return this.minus2.apply(this, arguments);
-        }
-      };
-
-      _proto.minusTemporalAmount = function minusTemporalAmount(amount) {
-        requireNonNull(amount, 'amount');
+      _proto.minusAmount = function minusAmount(amount) {
+        requireNonNull(amount);
         return amount.subtractFrom(this);
       };
 
-      _proto.minus2 = function minus2(amountToSubtract, unit) {
-        return this.plus2(-1 * amountToSubtract, unit);
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        return this.plus(-1 * amountToSubtract, unit);
       };
 
       _proto.minusYears = function minusYears(years) {
-        return this.plusYears(-1 * years);
+        return this._withDateTimeOffset(this._dateTime.minusYears(years), this._offset);
       };
 
       _proto.minusMonths = function minusMonths(months) {
-        return this.plusMonths(-1 * months);
+        return this._withDateTimeOffset(this._dateTime.minusMonths(months), this._offset);
       };
 
       _proto.minusWeeks = function minusWeeks(weeks) {
-        return this.plusWeeks(-1 * weeks);
+        return this._withDateTimeOffset(this._dateTime.minusWeeks(weeks), this._offset);
       };
 
       _proto.minusDays = function minusDays(days) {
-        return this.plusDays(-1 * days);
+        return this._withDateTimeOffset(this._dateTime.minusDays(days), this._offset);
       };
 
       _proto.minusHours = function minusHours(hours) {
-        return this.plusHours(-1 * hours);
+        return this._withDateTimeOffset(this._dateTime.minusHours(hours), this._offset);
       };
 
       _proto.minusMinutes = function minusMinutes(minutes) {
-        return this.plusMinutes(-1 * minutes);
+        return this._withDateTimeOffset(this._dateTime.minusMinutes(minutes), this._offset);
       };
 
       _proto.minusSeconds = function minusSeconds(seconds) {
-        return this.plusSeconds(-1 * seconds);
+        return this._withDateTimeOffset(this._dateTime.minusSeconds(seconds), this._offset);
       };
 
       _proto.minusNanos = function minusNanos(nanos) {
-        return this.plusNanos(-1 * nanos);
-      };
-
-      _proto.query = function query(_query) {
-        if (_query === TemporalQueries.localDate()) {
-          return this.toLocalDate();
-        }
-
-        requireNonNull(_query, 'query');
-        return _ChronoZonedDateTime.prototype.query.call(this, _query);
+        return this._withDateTimeOffset(this._dateTime.minusNanos(nanos), this._offset);
       };
 
-      _proto.until = function until(endExclusive, unit) {
-        var end = ZonedDateTime.from(endExclusive);
+      _proto.compareTo = function compareTo(other) {
+        requireNonNull(other, 'other');
+        requireInstance(other, OffsetDateTime, 'other');
 
-        if (unit instanceof ChronoUnit) {
-          end = end.withZoneSameInstant(this._zone);
+        if (this.offset().equals(other.offset())) {
+          return this.toLocalDateTime().compareTo(other.toLocalDateTime());
+        }
 
-          if (unit.isDateBased()) {
-            return this._dateTime.until(end._dateTime, unit);
-          } else {
-            var difference = this._offset.totalSeconds() - end._offset.totalSeconds();
+        var cmp = MathUtil.compareNumbers(this.toEpochSecond(), other.toEpochSecond());
 
-            var adjustedEnd = end._dateTime.plusSeconds(difference);
+        if (cmp === 0) {
+          cmp = this.toLocalTime().nano() - other.toLocalTime().nano();
 
-            return this._dateTime.until(adjustedEnd, unit);
+          if (cmp === 0) {
+            cmp = this.toLocalDateTime().compareTo(other.toLocalDateTime());
           }
         }
 
-        return unit.between(this, end);
+        return cmp;
       };
 
-      _proto.toLocalDateTime = function toLocalDateTime() {
-        return this._dateTime;
+      _proto.isAfter = function isAfter(other) {
+        requireNonNull(other, 'other');
+        var thisEpochSec = this.toEpochSecond();
+        var otherEpochSec = other.toEpochSecond();
+        return thisEpochSec > otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() > other.toLocalTime().nano();
       };
 
-      _proto.toLocalDate = function toLocalDate() {
-        return this._dateTime.toLocalDate();
+      _proto.isBefore = function isBefore(other) {
+        requireNonNull(other, 'other');
+        var thisEpochSec = this.toEpochSecond();
+        var otherEpochSec = other.toEpochSecond();
+        return thisEpochSec < otherEpochSec || thisEpochSec === otherEpochSec && this.toLocalTime().nano() < other.toLocalTime().nano();
       };
 
-      _proto.toLocalTime = function toLocalTime() {
-        return this._dateTime.toLocalTime();
+      _proto.isEqual = function isEqual(other) {
+        requireNonNull(other, 'other');
+        return this.toEpochSecond() === other.toEpochSecond() && this.toLocalTime().nano() === other.toLocalTime().nano();
       };
 
       _proto.equals = function equals(other) {
@@ -9022,25 +10119,19 @@
           return true;
         }
 
-        if (other instanceof ZonedDateTime) {
-          return this._dateTime.equals(other._dateTime) && this._offset.equals(other._offset) && this._zone.equals(other._zone);
+        if (other instanceof OffsetDateTime) {
+          return this._dateTime.equals(other._dateTime) && this._offset.equals(other._offset);
         }
 
         return false;
       };
 
       _proto.hashCode = function hashCode() {
-        return MathUtil.hashCode(this._dateTime.hashCode(), this._offset.hashCode(), this._zone.hashCode());
+        return this._dateTime.hashCode() ^ this._offset.hashCode();
       };
 
       _proto.toString = function toString() {
-        var str = this._dateTime.toString() + this._offset.toString();
-
-        if (this._offset !== this._zone) {
-          str += '[' + this._zone.toString() + ']';
-        }
-
-        return str;
+        return this._dateTime.toString() + this._offset.toString();
       };
 
       _proto.toJSON = function toJSON() {
@@ -9048,14 +10139,17 @@
       };
 
       _proto.format = function format(formatter) {
-        return _ChronoZonedDateTime.prototype.format.call(this, formatter);
+        requireNonNull(formatter, 'formatter');
+        return formatter.format(this);
       };
 
-      return ZonedDateTime;
-    }(ChronoZonedDateTime);
-    function _init$f() {
-      ZonedDateTime.FROM = createTemporalQuery('ZonedDateTime.FROM', function (temporal) {
-        return ZonedDateTime.from(temporal);
+      return OffsetDateTime;
+    }(DefaultInterfaceTemporal);
+    function _init$h() {
+      OffsetDateTime.MIN = LocalDateTime.MIN.atOffset(ZoneOffset.MAX);
+      OffsetDateTime.MAX = LocalDateTime.MAX.atOffset(ZoneOffset.MIN);
+      OffsetDateTime.FROM = createTemporalQuery('OffsetDateTime.FROM', function (temporal) {
+        return OffsetDateTime.from(temporal);
       });
     }
 
@@ -9188,6 +10282,9 @@
         var _this;
 
         _this = _ChronoLocalDate.call(this) || this;
+        requireNonNull(year, 'year');
+        requireNonNull(month, 'month');
+        requireNonNull(dayOfMonth, 'dayOfMonth');
 
         if (month instanceof Month) {
           month = month.value();
@@ -9381,15 +10478,7 @@
         return this.isLeapYear() ? 366 : 365;
       };
 
-      _proto.with = function _with(fieldOrAdjuster, newValue) {
-        if (arguments.length < 2) {
-          return this.withTemporalAdjuster(fieldOrAdjuster);
-        } else {
-          return this.withFieldAndValue(fieldOrAdjuster, newValue);
-        }
-      };
-
-      _proto.withTemporalAdjuster = function withTemporalAdjuster(adjuster) {
+      _proto.withAdjuster = function withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
 
         if (adjuster instanceof LocalDate) {
@@ -9400,7 +10489,7 @@
         return adjuster.adjustInto(this);
       };
 
-      _proto.withFieldAndValue = function withFieldAndValue(field, newValue) {
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
         assert(field != null, 'field', NullPointerException);
 
         if (field instanceof ChronoField) {
@@ -9490,20 +10579,12 @@
         return LocalDate.ofYearDay(this._year, dayOfYear);
       };
 
-      _proto.plus = function plus(p1, p2) {
-        if (arguments.length < 2) {
-          return this.plus1(p1);
-        } else {
-          return this.plus2(p1, p2);
-        }
-      };
-
-      _proto.plus1 = function plus1(amount) {
+      _proto.plusAmount = function plusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plus2 = function plus2(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
 
@@ -9574,23 +10655,15 @@
         return LocalDate.ofEpochDay(mjDay);
       };
 
-      _proto.minus = function minus(p1, p2) {
-        if (arguments.length < 2) {
-          return this.minus1(p1);
-        } else {
-          return this.minus2(p1, p2);
-        }
-      };
-
-      _proto.minus1 = function minus1(amount) {
+      _proto.minusAmount = function minusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.subtractFrom(this);
       };
 
-      _proto.minus2 = function minus2(amountToSubtract, unit) {
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
         requireNonNull(amountToSubtract, 'amountToSubtract');
         requireNonNull(unit, 'unit');
-        return this.plus2(-1 * amountToSubtract, unit);
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
       };
 
       _proto.minusYears = function minusYears(yearsToSubtract) {
@@ -9707,7 +10780,15 @@
       };
 
       _proto.atTime1 = function atTime1(time) {
-        return LocalDateTime.of(this, time);
+        requireNonNull(time, 'time');
+
+        if (time instanceof LocalTime) {
+          return LocalDateTime.of(this, time);
+        } else if (time instanceof OffsetTime) {
+          return this._atTimeOffsetTime(time);
+        } else {
+          throw new IllegalArgumentException('time must be an instance of LocalTime or OffsetTime' + (time && time.constructor && time.constructor.name ? ', but is ' + time.constructor.name : ''));
+        }
       };
 
       _proto.atTime4 = function atTime4(hour, minute, second, nanoOfSecond) {
@@ -9722,6 +10803,10 @@
         return this.atTime1(LocalTime.of(hour, minute, second, nanoOfSecond));
       };
 
+      _proto._atTimeOffsetTime = function _atTimeOffsetTime(time) {
+        return OffsetDateTime.of(LocalDateTime.of(this, time.toLocalTime()), time.offset());
+      };
+
       _proto.atStartOfDay = function atStartOfDay(zone) {
         if (zone != null) {
           return this.atStartOfDayWithZone(zone);
@@ -9870,7 +10955,7 @@
 
       return LocalDate;
     }(ChronoLocalDate);
-    function _init$g() {
+    function _init$i() {
       LocalDate.MIN = LocalDate.of(YearConstants.MIN_VALUE, 1, 1);
       LocalDate.MAX = LocalDate.of(YearConstants.MAX_VALUE, 12, 31);
       LocalDate.EPOCH_0 = LocalDate.ofEpochDay(0);
@@ -9879,11 +10964,11 @@
       });
     }
 
-    var ChronoLocalDateTime = function (_Temporal) {
-      _inheritsLoose(ChronoLocalDateTime, _Temporal);
+    var ChronoLocalDateTime = function (_DefaultInterfaceTemp) {
+      _inheritsLoose(ChronoLocalDateTime, _DefaultInterfaceTemp);
 
       function ChronoLocalDateTime() {
-        return _Temporal.apply(this, arguments) || this;
+        return _DefaultInterfaceTemp.apply(this, arguments) || this;
       }
 
       var _proto = ChronoLocalDateTime.prototype;
@@ -9905,7 +10990,7 @@
           return null;
         }
 
-        return _Temporal.prototype.query.call(this, _query);
+        return _DefaultInterfaceTemp.prototype.query.call(this, _query);
       };
 
       _proto.adjustInto = function adjustInto(temporal) {
@@ -9926,7 +11011,7 @@
       };
 
       return ChronoLocalDateTime;
-    }(Temporal);
+    }(DefaultInterfaceTemporal);
 
     var LocalDateTime = function (_ChronoLocalDateTime) {
       _inheritsLoose(LocalDateTime, _ChronoLocalDateTime);
@@ -10068,7 +11153,7 @@
       var _proto = LocalDateTime.prototype;
 
       _proto._withDateTime = function _withDateTime(newDate, newTime) {
-        if (this._date === newDate && this._time === newTime) {
+        if (this._date.equals(newDate) && this._time.equals(newTime)) {
           return this;
         }
 
@@ -10151,15 +11236,7 @@
         return this._time.nano();
       };
 
-      _proto.with = function _with(adjusterOrField, newValue) {
-        if (arguments.length === 1) {
-          return this.withTemporalAdjuster(adjusterOrField);
-        } else {
-          return this.with2(adjusterOrField, newValue);
-        }
-      };
-
-      _proto.withTemporalAdjuster = function withTemporalAdjuster(adjuster) {
+      _proto.withAdjuster = function withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
 
         if (adjuster instanceof LocalDate) {
@@ -10174,7 +11251,7 @@
         return adjuster.adjustInto(this);
       };
 
-      _proto.with2 = function with2(field, newValue) {
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
         requireNonNull(field, 'field');
 
         if (field instanceof ChronoField) {
@@ -10232,20 +11309,12 @@
         return this._withDateTime(this._date, this._time.truncatedTo(unit));
       };
 
-      _proto.plus = function plus(amount, unit) {
-        if (arguments.length === 1) {
-          return this.plusTemporalAmount(amount);
-        } else {
-          return this.plus2(amount, unit);
-        }
-      };
-
-      _proto.plusTemporalAmount = function plusTemporalAmount(amount) {
+      _proto.plusAmount = function plusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plus2 = function plus2(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         requireNonNull(unit, 'unit');
 
         if (unit instanceof ChronoUnit) {
@@ -10318,22 +11387,14 @@
         return this._plusWithOverflow(this._date, 0, 0, 0, nanos, 1);
       };
 
-      _proto.minus = function minus(amount, unit) {
-        if (arguments.length === 1) {
-          return this.minusTemporalAmount(amount);
-        } else {
-          return this.minus2(amount, unit);
-        }
-      };
-
-      _proto.minusTemporalAmount = function minusTemporalAmount(amount) {
+      _proto.minusAmount = function minusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.subtractFrom(this);
       };
 
-      _proto.minus2 = function minus2(amountToSubtract, unit) {
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
         requireNonNull(unit, 'unit');
-        return this.plus2(-1 * amountToSubtract, unit);
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
       };
 
       _proto.minusYears = function minusYears(years) {
@@ -10369,7 +11430,7 @@
       };
 
       _proto._plusWithOverflow = function _plusWithOverflow(newDate, hours, minutes, seconds, nanos, sign) {
-        if ((hours | minutes | seconds | nanos) === 0) {
+        if (hours === 0 && minutes === 0 && seconds === 0 && nanos === 0) {
           return this._withDateTime(newDate, this._time);
         }
 
@@ -10469,6 +11530,10 @@
         return unit.between(this, end);
       };
 
+      _proto.atOffset = function atOffset(offset) {
+        return OffsetDateTime.of(this, offset);
+      };
+
       _proto.atZone = function atZone(zone) {
         return ZonedDateTime.of(this, zone);
       };
@@ -10540,7 +11605,7 @@
 
       return LocalDateTime;
     }(ChronoLocalDateTime);
-    function _init$h() {
+    function _init$j() {
       LocalDateTime.MIN = LocalDateTime.of(LocalDate.MIN, LocalTime.MIN);
       LocalDateTime.MAX = LocalDateTime.of(LocalDate.MAX, LocalTime.MAX);
       LocalDateTime.FROM = createTemporalQuery('LocalDateTime.FROM', function (temporal) {
@@ -10674,7 +11739,7 @@
 
         LocalTime._validate(_hour, _minute, _second, _nanoOfSecond);
 
-        if ((_minute | _second | _nanoOfSecond) === 0) {
+        if (_minute === 0 && _second === 0 && _nanoOfSecond === 0) {
           if (!LocalTime.HOURS[_hour]) {
             _this._hour = _hour;
             _this._minute = _minute;
@@ -10801,15 +11866,7 @@
         return this._nano;
       };
 
-      _proto.with = function _with(adjusterOrField, newValue) {
-        if (arguments.length < 2) {
-          return this.withTemporalAdjuster(adjusterOrField);
-        } else {
-          return this.with2(adjusterOrField, newValue);
-        }
-      };
-
-      _proto.withTemporalAdjuster = function withTemporalAdjuster(adjuster) {
+      _proto.withAdjuster = function withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
 
         if (adjuster instanceof LocalTime) {
@@ -10820,7 +11877,7 @@
         return adjuster.adjustInto(this);
       };
 
-      _proto.with2 = function with2(field, newValue) {
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
         requireNonNull(field, 'field');
         requireInstance(field, TemporalField, 'field');
 
@@ -10951,20 +12008,12 @@
         return LocalTime.ofNanoOfDay(MathUtil.intDiv(nod, dur) * dur);
       };
 
-      _proto.plus = function plus(amount, unit) {
-        if (arguments.length < 2) {
-          return this.plus1(amount);
-        } else {
-          return this.plus2(amount, unit);
-        }
-      };
-
-      _proto.plus1 = function plus1(amount) {
+      _proto.plusAmount = function plusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plus2 = function plus2(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         requireNonNull(unit, 'unit');
 
         if (unit instanceof ChronoUnit) {
@@ -11060,22 +12109,14 @@
         return new LocalTime(newHour, newMinute, newSecond, newNano);
       };
 
-      _proto.minus = function minus(amount, unit) {
-        if (arguments.length < 2) {
-          return this.minus1(amount);
-        } else {
-          return this.minus2(amount, unit);
-        }
-      };
-
-      _proto.minus1 = function minus1(amount) {
+      _proto.minusAmount = function minusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.subtractFrom(this);
       };
 
-      _proto.minus2 = function minus2(amountToSubtract, unit) {
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
         requireNonNull(unit, 'unit');
-        return this.plus2(-1 * amountToSubtract, unit);
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
       };
 
       _proto.minusHours = function minusHours(hoursToSubtract) {
@@ -11257,7 +12298,7 @@
 
       return LocalTime;
     }(Temporal);
-    function _init$i() {
+    function _init$k() {
       LocalTime.HOURS = [];
 
       for (var hour = 0; hour < 24; hour++) {
@@ -11409,20 +12450,12 @@
         return this._nanos;
       };
 
-      _proto.with = function _with(adjusterOrField, newValue) {
-        if (arguments.length === 1) {
-          return this.withTemporalAdjuster(adjusterOrField);
-        } else {
-          return this.with2(adjusterOrField, newValue);
-        }
-      };
-
-      _proto.withTemporalAdjuster = function withTemporalAdjuster(adjuster) {
+      _proto.withAdjuster = function withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         return adjuster.adjustInto(this);
       };
 
-      _proto.with2 = function with2(field, newValue) {
+      _proto.withFieldValue = function withFieldValue(field, newValue) {
         requireNonNull(field, 'field');
 
         if (field instanceof ChronoField) {
@@ -11480,20 +12513,12 @@
         return this.plusNanos(result - nod);
       };
 
-      _proto.plus = function plus(amount, unit) {
-        if (arguments.length === 1) {
-          return this.plus1(amount);
-        } else {
-          return this.plus2(amount, unit);
-        }
-      };
-
-      _proto.plus1 = function plus1(amount) {
+      _proto.plusAmount = function plusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.addTo(this);
       };
 
-      _proto.plus2 = function plus2(amountToAdd, unit) {
+      _proto.plusAmountUnit = function plusAmountUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
         requireInstance(unit, TemporalUnit);
@@ -11544,7 +12569,7 @@
       };
 
       _proto._plus = function _plus(secondsToAdd, nanosToAdd) {
-        if ((secondsToAdd | nanosToAdd) === 0) {
+        if (secondsToAdd === 0 && nanosToAdd === 0) {
           return this;
         }
 
@@ -11554,21 +12579,13 @@
         return Instant.ofEpochSecond(epochSec, nanoAdjustment);
       };
 
-      _proto.minus = function minus(amount, unit) {
-        if (arguments.length === 1) {
-          return this.minus1(amount);
-        } else {
-          return this.minus2(amount, unit);
-        }
-      };
-
-      _proto.minus1 = function minus1(amount) {
+      _proto.minusAmount = function minusAmount(amount) {
         requireNonNull(amount, 'amount');
         return amount.subtractFrom(this);
       };
 
-      _proto.minus2 = function minus2(amountToSubtract, unit) {
-        return this.plus2(-1 * amountToSubtract, unit);
+      _proto.minusAmountUnit = function minusAmountUnit(amountToSubtract, unit) {
+        return this.plusAmountUnit(-1 * amountToSubtract, unit);
       };
 
       _proto.minusSeconds = function minusSeconds(secondsToSubtract) {
@@ -11659,6 +12676,10 @@
         return secsDiff;
       };
 
+      _proto.atOffset = function atOffset(offset) {
+        return OffsetDateTime.ofInstant(this, offset);
+      };
+
       _proto.atZone = function atZone(zone) {
         return ZonedDateTime.ofInstant(this, zone);
       };
@@ -11714,7 +12735,7 @@
 
       return Instant;
     }(Temporal);
-    function _init$j() {
+    function _init$l() {
       Instant.MIN_SECONDS = -31619119219200;
       Instant.MAX_SECONDS = 31494816403199;
       Instant.EPOCH = new Instant(0, 0);
@@ -12036,7 +13057,7 @@
      * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
      * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
      */
-    function _init$k() {
+    function _init$m() {
       TemporalQueries.ZONE_ID = createTemporalQuery('ZONE_ID', function (temporal) {
         return temporal.query(TemporalQueries.ZONE_ID);
       });
@@ -12290,7 +13311,7 @@
       return ZoneIdFactory;
     }();
     var SYSTEM_DEFAULT_ZONE_ID_INSTANCE = null;
-    function _init$l() {
+    function _init$n() {
       SYSTEM_DEFAULT_ZONE_ID_INSTANCE = new SystemDefaultZoneId();
       ZoneId.systemDefault = ZoneIdFactory.systemDefault;
       ZoneId.getAvailableZoneIds = ZoneIdFactory.getAvailableZoneIds;
@@ -12318,24 +13339,26 @@
       _init();
       _init$2();
       _init$3();
-      _init$i();
-      _init$8();
       _init$k();
+      _init$8();
+      _init$m();
       _init$4();
+      _init$l();
+      _init$i();
       _init$j();
-      _init$g();
-      _init$h();
       _init$d();
       _init$5();
       _init$c();
       _init$b();
       _init$6();
       _init$7();
-      _init$f();
-      _init$l();
+      _init$g();
+      _init$n();
       _init$e();
       _init$a();
       _init$9();
+      _init$h();
+      _init$f();
     }
 
     init();
@@ -12502,6 +13525,8 @@
       LocalDate: LocalDate,
       LocalTime: LocalTime,
       LocalDateTime: LocalDateTime,
+      OffsetTime: OffsetTime,
+      OffsetDateTime: OffsetDateTime,
       Month: Month,
       MonthDay: MonthDay,
       Period: Period,
@@ -12567,6 +13592,8 @@
     exports.Month = Month;
     exports.MonthDay = MonthDay;
     exports.NullPointerException = NullPointerException;
+    exports.OffsetDateTime = OffsetDateTime;
+    exports.OffsetTime = OffsetTime;
     exports.Period = Period;
     exports.ResolverStyle = ResolverStyle;
     exports.SignStyle = SignStyle;
@@ -12599,5 +13626,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));
 //# sourceMappingURL=js-joda.js.map