@js-joda/extra 0.8.1 → 0.9.1

package/dist/js-joda-extra.js

@@ -1,329 +1,707 @@
-//! @version @js-joda/extra - 0.8.1
+//! @version @js-joda/extra - 0.9.1
 //! @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)
 
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@js-joda/core')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@js-joda/core'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JSJodaExtra = {}, global.JSJoda));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@js-joda/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@js-joda/core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JSJodaExtra = {}, global.JSJoda));
 })(this, (function (exports, core) { 'use strict';
 
-    /**
-     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
-     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
-     */
-    function requireNonNull(value, parameterName) {
-      if (value == null) {
-        throw new core.NullPointerException(parameterName + " must not be null");
-      }
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+
+    _setPrototypeOf(subClass, superClass);
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  /**
+   * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+   * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+   */
+  function requireNonNull(value, parameterName) {
+    if (value == null) {
+      throw new core.NullPointerException(parameterName + " must not be null");
+    }
 
-      return value;
+    return value;
+  }
+  function requireInstance(value, _class, parameterName) {
+    if (!(value instanceof _class)) {
+      throw new core.IllegalArgumentException(parameterName + " must be an instance of " + (_class.name ? _class.name : _class) + (value && value.constructor && value.constructor.name ? ", but is " + value.constructor.name : ''));
     }
-    function requireInstance(value, _class, parameterName) {
-      if (!(value instanceof _class)) {
-        throw new core.IllegalArgumentException(parameterName + " must be an instance of " + (_class.name ? _class.name : _class) + (value && value.constructor && value.constructor.name ? ", but is " + value.constructor.name : ''));
+
+    return value;
+  }
+
+  var MathUtil$1 = core._.MathUtil;
+  var DayOfMonth = function (_TemporalAccessor) {
+    _inheritsLoose(DayOfMonth, _TemporalAccessor);
+
+    DayOfMonth.now = function now(zoneIdOrClock) {
+      switch (arguments.length) {
+        case 0:
+          return DayOfMonth.now0();
+
+        case 1:
+          requireNonNull(zoneIdOrClock, 'clockOrZone');
+
+          if (zoneIdOrClock instanceof core.ZoneId) {
+            return DayOfMonth.nowZoneId(zoneIdOrClock);
+          }
+
+          if (zoneIdOrClock instanceof core.Clock) {
+            return DayOfMonth.nowClock(zoneIdOrClock);
+          }
+
+          throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
+
+        default:
+          throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
       }
+    };
+
+    DayOfMonth.now0 = function now0() {
+      return this.now(core.Clock.systemDefaultZone());
+    };
+
+    DayOfMonth.nowZoneId = function nowZoneId(zone) {
+      return this.now(core.Clock.system(zone));
+    };
+
+    DayOfMonth.nowClock = function nowClock(clock) {
+      var now = core.LocalDate.now(clock);
+      return DayOfMonth.of(now.dayOfMonth());
+    };
+
+    DayOfMonth.of = function of(dayOfMonth) {
+      if (1 <= dayOfMonth && dayOfMonth <= 31) {
+        return DayOfMonth.VALUES[dayOfMonth - 1];
+      } else {
+        throw new core.DateTimeException("Invalid value for DayOfMonth: " + dayOfMonth);
+      }
+    };
+
+    DayOfMonth.from = function from(temporal) {
+      if (temporal instanceof DayOfMonth) {
+        return temporal;
+      }
+
+      requireNonNull(temporal, 'temporal');
 
-      return value;
+      try {
+        return DayOfMonth.of(temporal.get(core.ChronoField.DAY_OF_MONTH));
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain DayOfMonth from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+      }
+    };
+
+    function DayOfMonth(dayOfMonth) {
+      var _this;
+
+      _this = _TemporalAccessor.call(this) || this;
+      _this._day = MathUtil$1.safeToInt(dayOfMonth);
+      return _this;
     }
 
-    /*
-     * @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 Interval = function () {
-      Interval.of = function of(startInstant, endInstantOrDuration) {
-        if (endInstantOrDuration instanceof core.Duration) {
-          return Interval.ofInstantDuration(startInstant, endInstantOrDuration);
-        } else {
-          return Interval.ofInstantInstant(startInstant, endInstantOrDuration);
-        }
-      };
+    var _proto = DayOfMonth.prototype;
 
-      Interval.ofInstantInstant = function ofInstantInstant(startInclusive, endExclusive) {
-        requireNonNull(startInclusive, 'startInclusive');
-        requireNonNull(endExclusive, 'endExclusive');
-        requireInstance(startInclusive, core.Instant, 'startInclusive');
-        requireInstance(endExclusive, core.Instant, 'endExclusive');
+    _proto.value = function value() {
+      return this._day;
+    };
 
-        if (endExclusive.isBefore(startInclusive)) {
-          throw new core.DateTimeException('End instant must on or after start instant');
-        }
+    _proto.isSupported = function isSupported(field) {
+      if (field instanceof core.ChronoField) {
+        return field === core.ChronoField.DAY_OF_MONTH;
+      }
 
-        return new Interval(startInclusive, endExclusive);
-      };
+      return field != null && field.isSupportedBy(this);
+    };
 
-      Interval.ofInstantDuration = function ofInstantDuration(startInclusive, duration) {
-        requireNonNull(startInclusive, 'startInclusive');
-        requireNonNull(duration, 'duration');
-        requireInstance(startInclusive, core.Instant, 'startInclusive');
-        requireInstance(duration, core.Duration, 'duration');
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
 
-        if (duration.isNegative()) {
-          throw new core.DateTimeException('Duration must not be zero or negative');
-        }
+      if (field === core.ChronoField.DAY_OF_MONTH) {
+        return field.range();
+      }
 
-        return new Interval(startInclusive, startInclusive.plus(duration));
-      };
+      return _TemporalAccessor.prototype.range.call(this, field);
+    };
 
-      Interval.parse = function parse(text) {
-        requireNonNull(text, 'text');
+    _proto.get = function get(field) {
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
 
-        if (!(typeof text === 'string')) {
-          throw new core.IllegalArgumentException("text must be a string, but is " + text.constructor.name);
-        }
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
 
-        for (var i = 0; i < text.length; i += 1) {
-          if (text.charAt(i) === '/') {
-            var firstChar = text.charAt(0);
+      if (field === core.ChronoField.DAY_OF_MONTH) {
+        return this._day;
+      } else if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
 
-            if (firstChar === 'P' || firstChar === 'p') {
-              var duration = core.Duration.parse(text.substring(0, i));
-              var end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
-              return Interval.of(end.minus(duration), end);
-            } else {
-              var start = core.ZonedDateTime.parse(text.substring(0, i)).toInstant();
+      return field.getFrom(this);
+    };
 
-              if (i + 1 < text.length) {
-                var c = text.charAt(i + 1);
+    _proto.isValidYearMonth = function isValidYearMonth(yearMonth) {
+      return yearMonth != null && yearMonth.isValidDay(this._day);
+    };
 
-                if (c === 'P' || c === 'p') {
-                  var _duration = core.Duration.parse(text.substring(i + 1, text.length));
+    _proto.query = function query(_query) {
+      requireNonNull(_query, 'query');
+      requireInstance(_query, core.TemporalQuery, 'query');
 
-                  return Interval.of(start, start.plus(_duration));
-                }
-              }
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      }
 
-              var _end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
+      return _TemporalAccessor.prototype.query.call(this, _query);
+    };
 
-              return Interval.of(start, _end);
-            }
+    _proto.adjustInto = function adjustInto(temporal) {
+      requireNonNull(temporal, 'temporal');
+      return temporal.with(core.ChronoField.DAY_OF_MONTH, this._day);
+    };
+
+    _proto.atMonth = function atMonth(month) {
+      requireNonNull(month, 'month');
+
+      if (month instanceof core.Month) {
+        return core.MonthDay.of(month, Math.min(this._day, month.maxLength()));
+      } else {
+        return core.MonthDay.of(month, Math.min(this._day, core.Month.of(month).maxLength()));
+      }
+    };
+
+    _proto.atYearMonth = function atYearMonth(yearMonth) {
+      requireNonNull(yearMonth, 'yearMonth');
+      return yearMonth.atDay(Math.min(this._day, yearMonth.lengthOfMonth()));
+    };
+
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, DayOfMonth, 'other');
+      return this._day - other._day;
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof DayOfMonth) {
+        return this._day === obj._day;
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._day;
+    };
+
+    _proto.toString = function toString() {
+      return "DayOfMonth:" + this._day;
+    };
+
+    return DayOfMonth;
+  }(core.TemporalAccessor);
+  function _init$2() {
+    DayOfMonth.VALUES = new Array(31);
+
+    for (var i = 0; i < 31; i++) {
+      DayOfMonth.VALUES[i] = new DayOfMonth(i + 1);
+    }
+  }
+
+  var MathUtil = core._.MathUtil;
+  var DayOfYear = function (_TemporalAccessor) {
+    _inheritsLoose(DayOfYear, _TemporalAccessor);
+
+    DayOfYear.now = function now(zoneIdOrClock) {
+      switch (arguments.length) {
+        case 0:
+          return DayOfYear.now0();
+
+        case 1:
+          requireNonNull(zoneIdOrClock, 'clockOrZone');
+
+          if (zoneIdOrClock instanceof core.ZoneId) {
+            return DayOfYear.nowZoneId(zoneIdOrClock);
           }
-        }
 
-        throw new core.DateTimeParseException('Interval cannot be parsed, no forward slash found', text, 0);
-      };
+          if (zoneIdOrClock instanceof core.Clock) {
+            return DayOfYear.nowClock(zoneIdOrClock);
+          }
+
+          throw new core.IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
 
-      function Interval(startInclusive, endExclusive) {
-        this._start = startInclusive;
-        this._end = endExclusive;
+        default:
+          throw new core.IllegalArgumentException("Invalid number of arguments: " + arguments.length);
       }
+    };
+
+    DayOfYear.now0 = function now0() {
+      return DayOfYear.now(core.Clock.systemDefaultZone());
+    };
+
+    DayOfYear.nowZoneId = function nowZoneId(zone) {
+      return DayOfYear.now(core.Clock.system(zone));
+    };
+
+    DayOfYear.nowClock = function nowClock(clock) {
+      var now = core.LocalDate.now(clock);
+      return DayOfYear.of(now.dayOfYear());
+    };
+
+    DayOfYear.of = function of(dayOfYear) {
+      if (1 <= dayOfYear && dayOfYear <= 366) {
+        return DayOfYear.VALUES[dayOfYear - 1];
+      } else {
+        throw new core.DateTimeException("Invalid value for DayOfYear: " + dayOfYear);
+      }
+    };
 
-      var _proto = Interval.prototype;
+    DayOfYear.from = function from(temporal) {
+      requireNonNull(temporal, 'temporal');
+      requireInstance(temporal, core.TemporalAccessor, 'temporal');
 
-      _proto.start = function start() {
-        return this._start;
-      };
+      if (temporal instanceof DayOfYear) {
+        return temporal;
+      }
 
-      _proto.end = function end() {
-        return this._end;
-      };
+      try {
+        return DayOfYear.of(temporal.get(core.ChronoField.DAY_OF_YEAR));
+      } catch (ex) {
+        throw new core.DateTimeException("Unable to obtain DayOfYear from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+      }
+    };
 
-      _proto.isEmpty = function isEmpty() {
-        return this._start.equals(this._end);
-      };
+    function DayOfYear(dayOfYear) {
+      var _this;
 
-      _proto.isUnboundedStart = function isUnboundedStart() {
-        return this._start.equals(core.Instant.MIN);
-      };
+      _this = _TemporalAccessor.call(this) || this;
+      _this._day = MathUtil.safeToInt(dayOfYear);
+      return _this;
+    }
 
-      _proto.isUnboundedEnd = function isUnboundedEnd() {
-        return this._end.equals(core.Instant.MAX);
-      };
+    var _proto = DayOfYear.prototype;
 
-      _proto.withStart = function withStart(start) {
-        return Interval.of(start, this._end);
-      };
+    _proto.value = function value() {
+      return this._day;
+    };
 
-      _proto.withEnd = function withEnd(end) {
-        return Interval.of(this._start, end);
-      };
+    _proto.isSupported = function isSupported(field) {
+      if (field instanceof core.ChronoField) {
+        return field === core.ChronoField.DAY_OF_YEAR;
+      }
 
-      _proto.contains = function contains(instant) {
-        requireNonNull(instant, 'instant');
-        requireInstance(instant, core.Instant, 'instant');
-        return this._start.compareTo(instant) <= 0 && (instant.compareTo(this._end) < 0 || this.isUnboundedEnd());
-      };
+      return field != null && field.isSupportedBy(this);
+    };
 
-      _proto.encloses = function encloses(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
-        return this._start.compareTo(other.start()) <= 0 && other.end().compareTo(this._end) <= 0;
-      };
+    _proto.range = function range(field) {
+      requireNonNull(field, 'field');
 
-      _proto.abuts = function abuts(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
-        return !this._end.equals(other.start()) !== !this._start.equals(other.end());
-      };
+      if (field === core.ChronoField.DAY_OF_YEAR) {
+        return field.range();
+      }
 
-      _proto.isConnected = function isConnected(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
-        return this.equals(other) || this._start.compareTo(other.end()) <= 0 && other.start().compareTo(this._end) <= 0;
-      };
+      return _TemporalAccessor.prototype.range.call(this, field);
+    };
 
-      _proto.overlaps = function overlaps(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
-        return other.equals(this) || this._start.compareTo(other.end()) < 0 && other.start().compareTo(this._end) < 0;
-      };
+    _proto.get = function get(field) {
+      return this.range(field).checkValidIntValue(this.getLong(field), field);
+    };
 
-      _proto.intersection = function intersection(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
+    _proto.getLong = function getLong(field) {
+      requireNonNull(field, 'field');
 
-        if (this.isConnected(other) === false) {
-          throw new core.DateTimeException("Intervals do not connect: " + this + " and " + other);
-        }
+      if (field === core.ChronoField.DAY_OF_YEAR) {
+        return this._day;
+      } else if (field instanceof core.ChronoField) {
+        throw new core.UnsupportedTemporalTypeException("Unsupported field: " + field);
+      }
 
-        var cmpStart = this._start.compareTo(other.start());
+      return field.getFrom(this);
+    };
 
-        var cmpEnd = this._end.compareTo(other.end());
+    _proto.isValidYear = function isValidYear(year) {
+      return this._day < 366 || core.Year.isLeap(year);
+    };
 
-        if (cmpStart >= 0 && cmpEnd <= 0) {
-          return this;
-        } else if (cmpStart <= 0 && cmpEnd >= 0) {
-          return other;
-        } else {
-          var newStart = cmpStart >= 0 ? this._start : other.start();
-          var newEnd = cmpEnd <= 0 ? this._end : other.end();
-          return Interval.of(newStart, newEnd);
-        }
-      };
+    _proto.query = function query(_query) {
+      requireNonNull(_query, 'query');
+      requireInstance(_query, core.TemporalQuery, 'query');
 
-      _proto.union = function union(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
+      if (_query === core.TemporalQueries.chronology()) {
+        return core.IsoChronology.INSTANCE;
+      }
 
-        if (this.isConnected(other) === false) {
-          throw new core.DateTimeException("Intervals do not connect: " + this + " and " + other);
-        }
+      return _TemporalAccessor.prototype.query.call(this, _query);
+    };
+
+    _proto.adjustInto = function adjustInto(temporal) {
+      requireNonNull(temporal, 'temporal');
+      return temporal.with(core.ChronoField.DAY_OF_YEAR, this._day);
+    };
 
-        var cmpStart = this._start.compareTo(other.start());
+    _proto.atYear = function atYear(year) {
+      requireNonNull(year, 'year');
 
-        var cmpEnd = this._end.compareTo(other.end());
+      if (year instanceof core.Year) {
+        return year.atDay(this._day);
+      } else {
+        return core.LocalDate.ofYearDay(year, this._day);
+      }
+    };
 
-        if (cmpStart >= 0 && cmpEnd <= 0) {
-          return other;
-        } else if (cmpStart <= 0 && cmpEnd >= 0) {
-          return this;
-        } else {
-          var newStart = cmpStart >= 0 ? other.start() : this._start;
-          var newEnd = cmpEnd <= 0 ? other.end() : this._end;
-          return Interval.of(newStart, newEnd);
+    _proto.compareTo = function compareTo(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, DayOfYear, 'other');
+      return this._day - other._day;
+    };
+
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
+
+      if (obj instanceof DayOfYear) {
+        return this._day === obj._day;
+      }
+
+      return false;
+    };
+
+    _proto.hashCode = function hashCode() {
+      return this._day;
+    };
+
+    _proto.toString = function toString() {
+      return "DayOfYear:" + this._day;
+    };
+
+    return DayOfYear;
+  }(core.TemporalAccessor);
+  function _init$1() {
+    DayOfYear.VALUES = new Array(366);
+
+    for (var i = 0; i < 366; i++) {
+      DayOfYear.VALUES[i] = new DayOfYear(i + 1);
+    }
+  }
+
+  /*
+   * @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 Interval = function () {
+    Interval.of = function of(startInstant, endInstantOrDuration) {
+      if (endInstantOrDuration instanceof core.Duration) {
+        return Interval.ofInstantDuration(startInstant, endInstantOrDuration);
+      } else {
+        return Interval.ofInstantInstant(startInstant, endInstantOrDuration);
+      }
+    };
+
+    Interval.ofInstantInstant = function ofInstantInstant(startInclusive, endExclusive) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(endExclusive, 'endExclusive');
+      requireInstance(startInclusive, core.Instant, 'startInclusive');
+      requireInstance(endExclusive, core.Instant, 'endExclusive');
+
+      if (endExclusive.isBefore(startInclusive)) {
+        throw new core.DateTimeException('End instant must on or after start instant');
+      }
+
+      return new Interval(startInclusive, endExclusive);
+    };
+
+    Interval.ofInstantDuration = function ofInstantDuration(startInclusive, duration) {
+      requireNonNull(startInclusive, 'startInclusive');
+      requireNonNull(duration, 'duration');
+      requireInstance(startInclusive, core.Instant, 'startInclusive');
+      requireInstance(duration, core.Duration, 'duration');
+
+      if (duration.isNegative()) {
+        throw new core.DateTimeException('Duration must not be zero or negative');
+      }
+
+      return new Interval(startInclusive, startInclusive.plus(duration));
+    };
+
+    Interval.parse = function parse(text) {
+      requireNonNull(text, 'text');
+
+      if (!(typeof text === 'string')) {
+        throw new core.IllegalArgumentException("text must be a string, but is " + text.constructor.name);
+      }
+
+      for (var i = 0; i < text.length; i += 1) {
+        if (text.charAt(i) === '/') {
+          var firstChar = text.charAt(0);
+
+          if (firstChar === 'P' || firstChar === 'p') {
+            var duration = core.Duration.parse(text.substring(0, i));
+            var end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
+            return Interval.of(end.minus(duration), end);
+          } else {
+            var start = core.ZonedDateTime.parse(text.substring(0, i)).toInstant();
+
+            if (i + 1 < text.length) {
+              var c = text.charAt(i + 1);
+
+              if (c === 'P' || c === 'p') {
+                var _duration = core.Duration.parse(text.substring(i + 1, text.length));
+
+                return Interval.of(start, start.plus(_duration));
+              }
+            }
+
+            var _end = core.ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
+
+            return Interval.of(start, _end);
+          }
         }
-      };
+      }
+
+      throw new core.DateTimeParseException('Interval cannot be parsed, no forward slash found', text, 0);
+    };
+
+    function Interval(startInclusive, endExclusive) {
+      this._start = startInclusive;
+      this._end = endExclusive;
+    }
+
+    var _proto = Interval.prototype;
+
+    _proto.start = function start() {
+      return this._start;
+    };
+
+    _proto.end = function end() {
+      return this._end;
+    };
+
+    _proto.isEmpty = function isEmpty() {
+      return this._start.equals(this._end);
+    };
+
+    _proto.isUnboundedStart = function isUnboundedStart() {
+      return this._start.equals(core.Instant.MIN);
+    };
+
+    _proto.isUnboundedEnd = function isUnboundedEnd() {
+      return this._end.equals(core.Instant.MAX);
+    };
+
+    _proto.withStart = function withStart(start) {
+      return Interval.of(start, this._end);
+    };
+
+    _proto.withEnd = function withEnd(end) {
+      return Interval.of(this._start, end);
+    };
+
+    _proto.contains = function contains(instant) {
+      requireNonNull(instant, 'instant');
+      requireInstance(instant, core.Instant, 'instant');
+      return this._start.compareTo(instant) <= 0 && (instant.compareTo(this._end) < 0 || this.isUnboundedEnd());
+    };
+
+    _proto.encloses = function encloses(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+      return this._start.compareTo(other.start()) <= 0 && other.end().compareTo(this._end) <= 0;
+    };
+
+    _proto.abuts = function abuts(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+      return !this._end.equals(other.start()) !== !this._start.equals(other.end());
+    };
+
+    _proto.isConnected = function isConnected(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+      return this.equals(other) || this._start.compareTo(other.end()) <= 0 && other.start().compareTo(this._end) <= 0;
+    };
+
+    _proto.overlaps = function overlaps(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+      return other.equals(this) || this._start.compareTo(other.end()) < 0 && other.start().compareTo(this._end) < 0;
+    };
+
+    _proto.intersection = function intersection(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+
+      if (this.isConnected(other) === false) {
+        throw new core.DateTimeException("Intervals do not connect: " + this + " and " + other);
+      }
 
-      _proto.span = function span(other) {
-        requireNonNull(other, 'other');
-        requireInstance(other, Interval, 'other');
+      var cmpStart = this._start.compareTo(other.start());
+
+      var cmpEnd = this._end.compareTo(other.end());
+
+      if (cmpStart >= 0 && cmpEnd <= 0) {
+        return this;
+      } else if (cmpStart <= 0 && cmpEnd >= 0) {
+        return other;
+      } else {
+        var newStart = cmpStart >= 0 ? this._start : other.start();
+        var newEnd = cmpEnd <= 0 ? this._end : other.end();
+        return Interval.of(newStart, newEnd);
+      }
+    };
+
+    _proto.union = function union(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
+
+      if (this.isConnected(other) === false) {
+        throw new core.DateTimeException("Intervals do not connect: " + this + " and " + other);
+      }
 
-        var cmpStart = this._start.compareTo(other.start());
+      var cmpStart = this._start.compareTo(other.start());
 
-        var cmpEnd = this._end.compareTo(other.end());
+      var cmpEnd = this._end.compareTo(other.end());
 
+      if (cmpStart >= 0 && cmpEnd <= 0) {
+        return other;
+      } else if (cmpStart <= 0 && cmpEnd >= 0) {
+        return this;
+      } else {
         var newStart = cmpStart >= 0 ? other.start() : this._start;
         var newEnd = cmpEnd <= 0 ? other.end() : this._end;
         return Interval.of(newStart, newEnd);
-      };
+      }
+    };
 
-      _proto.isAfter = function isAfter(instantOrInterval) {
-        if (instantOrInterval instanceof core.Instant) {
-          return this.isAfterInstant(instantOrInterval);
-        } else {
-          return this.isAfterInterval(instantOrInterval);
-        }
-      };
+    _proto.span = function span(other) {
+      requireNonNull(other, 'other');
+      requireInstance(other, Interval, 'other');
 
-      _proto.isBefore = function isBefore(instantOrInterval) {
-        if (instantOrInterval instanceof core.Instant) {
-          return this.isBeforeInstant(instantOrInterval);
-        } else {
-          return this.isBeforeInterval(instantOrInterval);
-        }
-      };
+      var cmpStart = this._start.compareTo(other.start());
 
-      _proto.isAfterInstant = function isAfterInstant(instant) {
-        return this._start.compareTo(instant) > 0;
-      };
+      var cmpEnd = this._end.compareTo(other.end());
 
-      _proto.isBeforeInstant = function isBeforeInstant(instant) {
-        return this._end.compareTo(instant) <= 0 && this._start.compareTo(instant) < 0;
-      };
+      var newStart = cmpStart >= 0 ? other.start() : this._start;
+      var newEnd = cmpEnd <= 0 ? other.end() : this._end;
+      return Interval.of(newStart, newEnd);
+    };
 
-      _proto.isAfterInterval = function isAfterInterval(interval) {
-        return this._start.compareTo(interval.end()) >= 0 && !interval.equals(this);
-      };
+    _proto.isAfter = function isAfter(instantOrInterval) {
+      if (instantOrInterval instanceof core.Instant) {
+        return this.isAfterInstant(instantOrInterval);
+      } else {
+        return this.isAfterInterval(instantOrInterval);
+      }
+    };
 
-      _proto.isBeforeInterval = function isBeforeInterval(interval) {
-        return this._end.compareTo(interval.start()) <= 0 && !interval.equals(this);
-      };
+    _proto.isBefore = function isBefore(instantOrInterval) {
+      if (instantOrInterval instanceof core.Instant) {
+        return this.isBeforeInstant(instantOrInterval);
+      } else {
+        return this.isBeforeInterval(instantOrInterval);
+      }
+    };
 
-      _proto.toDuration = function toDuration() {
-        return core.Duration.between(this._start, this._end);
-      };
+    _proto.isAfterInstant = function isAfterInstant(instant) {
+      return this._start.compareTo(instant) > 0;
+    };
 
-      _proto.equals = function equals(obj) {
-        if (this === obj) {
-          return true;
-        }
+    _proto.isBeforeInstant = function isBeforeInstant(instant) {
+      return this._end.compareTo(instant) <= 0 && this._start.compareTo(instant) < 0;
+    };
 
-        if (obj instanceof Interval) {
-          return this._start.equals(obj.start()) && this._end.equals(obj.end());
-        }
+    _proto.isAfterInterval = function isAfterInterval(interval) {
+      return this._start.compareTo(interval.end()) >= 0 && !interval.equals(this);
+    };
 
-        return false;
-      };
+    _proto.isBeforeInterval = function isBeforeInterval(interval) {
+      return this._end.compareTo(interval.start()) <= 0 && !interval.equals(this);
+    };
 
-      _proto.hashCode = function hashCode() {
-        return this._start.hashCode() ^ this._end.hashCode();
-      };
+    _proto.toDuration = function toDuration() {
+      return core.Duration.between(this._start, this._end);
+    };
 
-      _proto.toString = function toString() {
-        return this._start.toString() + "/" + this._end.toString();
-      };
+    _proto.equals = function equals(obj) {
+      if (this === obj) {
+        return true;
+      }
 
-      return Interval;
-    }();
-    function _init() {
-      Interval.ALL = Interval.of(core.Instant.MIN, core.Instant.MAX);
-    }
+      if (obj instanceof Interval) {
+        return this._start.equals(obj.start()) && this._end.equals(obj.end());
+      }
 
-    /*
-     * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
-     * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
-     */
-    var isInit = false;
+      return false;
+    };
 
-    function init() {
-      if (isInit) {
-        return;
-      }
+    _proto.hashCode = function hashCode() {
+      return this._start.hashCode() ^ this._end.hashCode();
+    };
+
+    _proto.toString = function toString() {
+      return this._start.toString() + "/" + this._end.toString();
+    };
 
-      isInit = true;
-      _init();
+    return Interval;
+  }();
+  function _init() {
+    Interval.ALL = Interval.of(core.Instant.MIN, core.Instant.MAX);
+  }
+
+  /*
+   * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+   * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+   */
+  var isInit = false;
+
+  function init() {
+    if (isInit) {
+      return;
     }
 
-    init();
+    isInit = true;
+    _init$2();
+    _init$1();
+    _init();
+  }
+
+  init();
 
-    /*
-     * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper
-     * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
-     */
-    function plug () {}
+  /*
+   * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper
+   * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+   */
+  function plug () {}
 
-    /*
-     * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper
-     * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
-     */
-    core.use(plug);
+  /*
+   * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper
+   * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+   */
+  core.use(plug);
 
-    exports.Interval = Interval;
+  exports.DayOfMonth = DayOfMonth;
+  exports.DayOfYear = DayOfYear;
+  exports.Interval = Interval;
 
-    Object.defineProperty(exports, '__esModule', { value: true });
+  Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
 //# sourceMappingURL=js-joda-extra.js.map