@js-joda/extra 0.7.0 → 0.7.1

package/dist/js-joda-extra.esm.js

@@ -0,0 +1,321 @@
+//! @version @js-joda/extra - 0.7.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)
+
+import { NullPointerException, IllegalArgumentException, Instant, DateTimeException, Duration, ZonedDateTime, DateTimeParseException, use } from '@js-joda/core';
+
+/**
+ * @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 NullPointerException(parameterName + " must not be null");
+  }
+
+  return value;
+}
+function requireInstance(value, _class, parameterName) {
+  if (!(value instanceof _class)) {
+    throw new 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;
+}
+
+/*
+ * @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 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, Instant, 'startInclusive');
+    requireInstance(endExclusive, Instant, 'endExclusive');
+
+    if (endExclusive.isBefore(startInclusive)) {
+      throw new 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, Instant, 'startInclusive');
+    requireInstance(duration, Duration, 'duration');
+
+    if (duration.isNegative()) {
+      throw new 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 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 = Duration.parse(text.substring(0, i));
+          var end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
+          return Interval.of(end.minus(duration), end);
+        } else {
+          var start = 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 = Duration.parse(text.substring(i + 1, text.length));
+
+              return Interval.of(start, start.plus(_duration));
+            }
+          }
+
+          var _end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();
+
+          return Interval.of(start, _end);
+        }
+      }
+    }
+
+    throw new 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(Instant.MIN);
+  };
+
+  _proto.isUnboundedEnd = function isUnboundedEnd() {
+    return this._end.equals(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, 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 DateTimeException("Intervals do not connect: " + this + " and " + other);
+    }
+
+    var cmpStart = this._start.compareTo(other.start());
+
+    var cmpEnd = this._end.compareTo(other.end());
+
+    if (cmpStart >= 0 && cmpEnd <= 0) {
+      return this;
+    } else if (cmpStart <= 0 && cmpEnd >= 0) {
+      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 DateTimeException("Intervals do not connect: " + this + " and " + other);
+    }
+
+    var cmpStart = this._start.compareTo(other.start());
+
+    var cmpEnd = this._end.compareTo(other.end());
+
+    if (cmpStart >= 0 && cmpEnd <= 0) {
+      return other;
+    } else if (cmpStart <= 0 && cmpEnd >= 0) {
+      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.span = function span(other) {
+    requireNonNull(other, 'other');
+    requireInstance(other, Interval, 'other');
+
+    var cmpStart = this._start.compareTo(other.start());
+
+    var cmpEnd = this._end.compareTo(other.end());
+
+    var newStart = cmpStart >= 0 ? other.start() : this._start;
+    var newEnd = cmpEnd <= 0 ? other.end() : this._end;
+    return Interval.of(newStart, newEnd);
+  };
+
+  _proto.isAfter = function isAfter(instantOrInterval) {
+    if (instantOrInterval instanceof Instant) {
+      return this.isAfterInstant(instantOrInterval);
+    } else {
+      return this.isAfterInterval(instantOrInterval);
+    }
+  };
+
+  _proto.isBefore = function isBefore(instantOrInterval) {
+    if (instantOrInterval instanceof Instant) {
+      return this.isBeforeInstant(instantOrInterval);
+    } else {
+      return this.isBeforeInterval(instantOrInterval);
+    }
+  };
+
+  _proto.isAfterInstant = function isAfterInstant(instant) {
+    return this._start.compareTo(instant) > 0;
+  };
+
+  _proto.isBeforeInstant = function isBeforeInstant(instant) {
+    return this._end.compareTo(instant) <= 0 && this._start.compareTo(instant) < 0;
+  };
+
+  _proto.isAfterInterval = function isAfterInterval(interval) {
+    return this._start.compareTo(interval.end()) >= 0 && !interval.equals(this);
+  };
+
+  _proto.isBeforeInterval = function isBeforeInterval(interval) {
+    return this._end.compareTo(interval.start()) <= 0 && !interval.equals(this);
+  };
+
+  _proto.toDuration = function toDuration() {
+    return Duration.between(this._start, this._end);
+  };
+
+  _proto.equals = function equals(obj) {
+    if (this === obj) {
+      return true;
+    }
+
+    if (obj instanceof Interval) {
+      return this._start.equals(obj.start()) && this._end.equals(obj.end());
+    }
+
+    return false;
+  };
+
+  _proto.hashCode = function hashCode() {
+    return this._start.hashCode() ^ this._end.hashCode();
+  };
+
+  _proto.toString = function toString() {
+    return this._start.toString() + "/" + this._end.toString();
+  };
+
+  return Interval;
+}();
+function _init() {
+  Interval.ALL = Interval.of(Instant.MIN, 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;
+  }
+
+  isInit = true;
+  _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)
+ */
+use(plug);
+
+export { Interval };
+//# sourceMappingURL=js-joda-extra.esm.js.map

package/dist/js-joda-extra.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-joda-extra.esm.js","sources":["../src/assert.js","../src/Interval.js","../src/_init.js","../src/plug.js","../src/js-joda-extra.js"],"sourcesContent":["/**\n * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\nimport { NullPointerException, IllegalArgumentException } from '@js-joda/core';\n\n/**\n * @private\n *\n * @param assertion\n * @param msg\n * @param error\n */\nexport function assert(assertion, msg, error) {\n    if (!assertion) {\n        if (error) {\n            // eslint-disable-next-line new-cap\n            throw new error(msg);\n        } else {\n            throw new Error(msg);\n        }\n    }\n}\n\n/**\n * @private\n *\n * @param value\n * @param parameterName\n * @returns {*}\n */\nexport function requireNonNull(value, parameterName) {\n    if (value == null) {\n        throw new NullPointerException(`${parameterName} must not be null`);\n    }\n    return value;\n}\n\n/**\n * @private\n *\n * @param value\n * @param _class\n * @param parameterName\n * @returns {_class}\n */\nexport function requireInstance(value, _class, parameterName) {\n    if (!(value instanceof _class)) {\n        throw new IllegalArgumentException(`${parameterName} must be an instance of ${_class.name ? _class.name : _class}${value && value.constructor && value.constructor.name ? `, but is ${value.constructor.name}` : ''}`);\n    }\n    return value;\n}\n\n/**\n * @private\n *\n * @param methodName\n */\nexport function abstractMethodFail(methodName) {\n    throw new TypeError(`abstract method \"${methodName}\" is not implemented`);\n}\n","/*\n * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper\n * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport { DateTimeException, DateTimeParseException, Duration, IllegalArgumentException, Instant, ZonedDateTime } from '@js-joda/core';\n\n// TODO: hm... is this a good idea?? copied from joda currently, could we add a js-joda-utils module??\nimport { requireNonNull, requireInstance } from './assert';\n\n/**\n * An immutable interval of time between two instants.\n * <p>\n * An interval represents the time on the time-line between two {@link Instant}s.\n * The class stores the start and end instants, with the start inclusive and the end exclusive.\n * The end instant is always greater than or equal to the start instant.\n * <p>\n * The {@link Duration} of an interval can be obtained, but is a separate concept.\n * An interval is connected to the time-line, whereas a duration is not.\n * <p>\n * Intervals are not comparable. To compare the length of two intervals, it is\n * generally recommended to compare their durations.\n *\n */\nexport class Interval {\n    //-----------------------------------------------------------------------\n    /**\n     * function overloading for {@link Interval.of}\n     *\n     * if called without arguments, then {@link Interval.ofInstantInstant} is executed.\n\n     * if called with 1 arguments and first argument is an instance of ZoneId, then {@link Interval.ofInstantDuration} is executed.\n     *\n     * Otherwise {@link Interval.ofInstantDuration} is executed.\n     *\n     * @param {!(Instant)} startInstant\n     * @param {!(Instant|Duration)} endInstantOrDuration\n     * @returns {Interval}\n     */\n    static of(startInstant, endInstantOrDuration) {\n        if (endInstantOrDuration instanceof Duration) {\n            return Interval.ofInstantDuration(startInstant, endInstantOrDuration);\n        } else {\n            return Interval.ofInstantInstant(startInstant, endInstantOrDuration);\n        }\n    }\n\n    /**\n     * Obtains an instance of {@code Interval} from the start and end instant.\n     * <p>\n     * The end instant must not be before the start instant.\n     *\n     * @param {Instant} startInclusive  the start instant, inclusive, MIN_DATE treated as unbounded, not null\n     * @param {Instant} endExclusive  the end instant, exclusive, MAX_DATE treated as unbounded, not null\n     * @return {Interval} the half-open interval, not null\n     * @throws DateTimeException if the end is before the start\n     */\n    static ofInstantInstant(startInclusive, endExclusive) {\n        requireNonNull(startInclusive, 'startInclusive');\n        requireNonNull(endExclusive, 'endExclusive');\n        requireInstance(startInclusive, Instant, 'startInclusive');\n        requireInstance(endExclusive, Instant, 'endExclusive');\n        if (endExclusive.isBefore(startInclusive)) {\n            throw new DateTimeException('End instant must on or after start instant');\n        }\n        return new Interval(startInclusive, endExclusive);\n    }\n\n    /**\n     * Obtains an instance of {@code Interval} from the start and a duration.\n     * <p>\n     * The end instant is calculated as the start plus the duration.\n     * The duration must not be negative.\n     *\n     * @param {Instant} startInclusive  the start instant, inclusive, not null\n     * @param {Duration} duration  the duration from the start to the end, not null\n     * @return {Interval} the interval, not null\n     * @throws DateTimeException if the end is before the start,\n     *  or if the duration addition cannot be made\n     * @throws ArithmeticException if numeric overflow occurs when adding the duration\n     */\n    static ofInstantDuration(startInclusive, duration) {\n        requireNonNull(startInclusive, 'startInclusive');\n        requireNonNull(duration, 'duration');\n        requireInstance(startInclusive, Instant, 'startInclusive');\n        requireInstance(duration, Duration, 'duration');\n        if (duration.isNegative()) {\n            throw new DateTimeException('Duration must not be zero or negative');\n        }\n        return new Interval(startInclusive, startInclusive.plus(duration));\n    }\n\n    //-----------------------------------------------------------------------\n\n    /**\n     * Obtains an instance of {@code Interval} from a text string such as\n     * {@code 2007-12-03T10:15:30Z/2007-12-04T10:15:30Z}, where the end instant is exclusive.\n     * <p>\n     * The string must consist of one of the following three formats:\n     * <ul>\n     * <li>a representations of an {@link ZonedDateTime}, followed by a forward slash,\n     *  followed by a representation of a {@link ZonedDateTime}\n     * <li>a representation of an {@link ZonedDateTime}, followed by a forward slash,\n     *  followed by a representation of a {@link Duration}\n     * <li>a representation of a {@link Duration}, followed by a forward slash,\n     *  followed by a representation of an {@link ZonedDateTime}\n     * </ul>\n     *\n     * NOTE: in contrast to the threeten-extra base we are not using `OffsetDateTime` but `ZonedDateTime` to parse\n     * the string, this does not change the format but adds the possibility to optionally specify a zone\n     *\n     * @param {string} text  the text to parse, not null\n     * @return {Interval} the parsed interval, not null\n     * @throws DateTimeParseException if the text cannot be parsed\n     */\n    static parse(text) {\n        requireNonNull(text, 'text');\n        if (!(typeof text === 'string')) {\n            throw new IllegalArgumentException(`text must be a string, but is ${text.constructor.name}`);\n        }\n        for (let i = 0; i < text.length; i += 1) {\n            if (text.charAt(i) === '/') {\n                const firstChar = text.charAt(0);\n                if (firstChar === 'P' || firstChar === 'p') {\n                    // duration followed by instant\n                    const duration = Duration.parse(text.substring(0, i));\n                    const end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();\n                    return Interval.of(end.minus(duration), end);\n                } else {\n                    // instant followed by instant or duration\n                    const start = ZonedDateTime.parse(text.substring(0, i)).toInstant();\n                    if (i + 1 < text.length) {\n                        const c = text.charAt(i + 1);\n                        if (c === 'P' || c === 'p') {\n                            const duration = Duration.parse(text.substring(i + 1, text.length));\n                            return Interval.of(start, start.plus(duration));\n                        }\n                    }\n                    const end = ZonedDateTime.parse(text.substring(i + 1, text.length)).toInstant();\n                    return Interval.of(start, end);\n                }\n            }\n        }\n        throw new DateTimeParseException('Interval cannot be parsed, no forward slash found', text, 0);\n    }\n    //-----------------------------------------------------------------------\n    /**\n     * Constructor.\n     *\n     * @param {Instant} startInclusive  the start instant, inclusive, validated not null\n     * @param {Instant} endExclusive  the end instant, exclusive, validated not null\n     */\n    constructor(startInclusive, endExclusive) {\n        this._start = startInclusive;\n        this._end = endExclusive;\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Gets the start of this time interval, inclusive.\n     * <p>\n     * This will return {@link Instant#MIN} if the range is unbounded at the start.\n     * In this case, the range includes all dates into the far-past.\n     *\n     * @return {Instant} the start of the time interval\n     */\n    start() {\n        return this._start;\n    }\n\n    /**\n     * Gets the end of this time interval, exclusive.\n     * <p>\n     * This will return {@link Instant#MAX} if the range is unbounded at the end.\n     * In this case, the range includes all dates into the far-future.\n     *\n     * @return {Instant} the end of the time interval, exclusive\n     */\n    end() {\n        return this._end;\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Checks if the range is empty.\n     * <p>\n     * An empty range occurs when the start date equals the inclusive end date.\n     *\n     * @return {boolean} true if the range is empty\n     */\n    isEmpty() {\n        return this._start.equals(this._end);\n    }\n\n    /**\n     * Checks if the start of the interval is unbounded.\n     *\n     * @return {boolean} true if start is unbounded\n     */\n    isUnboundedStart() {\n        return this._start.equals(Instant.MIN);\n    }\n\n    /**\n     * Checks if the end of the interval is unbounded.\n     *\n     * @return {boolean} true if end is unbounded\n     */\n    isUnboundedEnd() {\n        return this._end.equals(Instant.MAX);\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Returns a copy of this range with the specified start instant.\n     *\n     * @param {Instant} start  the start instant for the new interval, not null\n     * @return {Interval} an interval with the end from this interval and the specified start\n     * @throws DateTimeException if the resulting interval has end before start\n     */\n    withStart(start) {\n        return Interval.of(start, this._end);\n    }\n\n    /**\n     * Returns a copy of this range with the specified end instant.\n     *\n     * @param {Instant} end  the end instant for the new interval, not null\n     * @return {Interval} an interval with the start from this interval and the specified end\n     * @throws DateTimeException if the resulting interval has end before start\n     */\n    withEnd(end) {\n        return Interval.of(this._start, end);\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Checks if this interval contains the specified instant.\n     * <p>\n     * This checks if the specified instant is within the bounds of this interval.\n     * If this range has an unbounded start then {@code contains(Instant#MIN)} returns true.\n     * If this range has an unbounded end then {@code contains(Instant#MAX)} returns true.\n     * If this range is empty then this method always returns false.\n     *\n     * @param {Instant} instant  the instant, not null\n     * @return {boolean} true if this interval contains the instant\n     */\n    contains(instant) {\n        requireNonNull(instant, 'instant');\n        requireInstance(instant, Instant, 'instant');\n        return this._start.compareTo(instant) <= 0 && (instant.compareTo(this._end) < 0 || this.isUnboundedEnd());\n    }\n\n    /**\n     * Checks if this interval encloses the specified interval.\n     * <p>\n     * This checks if the bounds of the specified interval are within the bounds of this interval.\n     * An empty interval encloses itself.\n     *\n     * @param {Interval} other  the other interval, not null\n     * @return {boolean} true if this interval contains the other interval\n     */\n    encloses(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        return this._start.compareTo(other.start()) <= 0 && other.end().compareTo(this._end) <= 0;\n    }\n\n    /**\n     * Checks if this interval abuts the specified interval.\n     * <p>\n     * The result is true if the end of this interval is the start of the other, or vice versa.\n     * An empty interval does not abut itself.\n     *\n     * @param {Interval} other  the other interval, not null\n     * @return {boolean} true if this interval abuts the other interval\n     */\n    abuts(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        return !this._end.equals(other.start()) !== !this._start.equals(other.end());\n    }\n\n    /**\n     * Checks if this interval is connected to the specified interval.\n     * <p>\n     * The result is true if the two intervals have an enclosed interval in common, even if that interval is empty.\n     * An empty interval is connected to itself.\n     * <p>\n     * This is equivalent to {@code (overlaps(other) || abuts(other))}.\n     *\n     * @param {Interval} other  the other interval, not null\n     * @return {boolean} true if this interval is connected to the other interval\n     */\n    isConnected(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        return this.equals(other) || (this._start.compareTo(other.end()) <= 0 && other.start().compareTo(this._end) <= 0);\n    }\n\n    /**\n     * Checks if this interval overlaps the specified interval.\n     * <p>\n     * The result is true if the the two intervals share some part of the time-line.\n     * An empty interval overlaps itself.\n     * <p>\n     * This is equivalent to {@code (isConnected(other) && !abuts(other))}.\n     *\n     * @param {Interval} other  the time interval to compare to, null means a zero length interval now\n     * @return {boolean} true if the time intervals overlap\n     */\n    overlaps(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        return other.equals(this) || (this._start.compareTo(other.end()) < 0 && other.start().compareTo(this._end) < 0);\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Calculates the interval that is the intersection of this interval and the specified interval.\n     * <p>\n     * This finds the intersection of two intervals.\n     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.\n     *\n     * @param {Interval} other  the other interval to check for, not null\n     * @return {Interval} the interval that is the intersection of the two intervals\n     * @throws DateTimeException if the intervals do not connect\n     */\n    intersection(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        if (this.isConnected(other) === false) {\n            throw new DateTimeException(`Intervals do not connect: ${this} and ${other}`);\n        }\n        const cmpStart = this._start.compareTo(other.start());\n        const cmpEnd = this._end.compareTo(other.end());\n        if (cmpStart >= 0 && cmpEnd <= 0) {\n            return this;\n        } else if (cmpStart <= 0 && cmpEnd >= 0) {\n            return other;\n        } else {\n            const newStart = (cmpStart >= 0 ? this._start : other.start());\n            const newEnd = (cmpEnd <= 0 ? this._end : other.end());\n            return Interval.of(newStart, newEnd);\n        }\n    }\n\n    /**\n     * Calculates the interval that is the union of this interval and the specified interval.\n     * <p>\n     * This finds the union of two intervals.\n     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.\n     *\n     * @param {Interval} other  the other interval to check for, not null\n     * @return {Interval} the interval that is the union of the two intervals\n     * @throws DateTimeException if the intervals do not connect\n     */\n    union(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        if (this.isConnected(other) === false) {\n            throw new DateTimeException(`Intervals do not connect: ${this} and ${other}`);\n        }\n        const cmpStart = this._start.compareTo(other.start());\n        const cmpEnd = this._end.compareTo(other.end());\n        if (cmpStart >= 0 && cmpEnd <= 0) {\n            return other;\n        } else if (cmpStart <= 0 && cmpEnd >= 0) {\n            return this;\n        } else {\n            const newStart = (cmpStart >= 0 ? other.start() : this._start);\n            const newEnd = (cmpEnd <= 0 ? other.end() : this._end);\n            return Interval.of(newStart, newEnd);\n        }\n    }\n\n    /**\n     * Calculates the smallest interval that encloses this interval and the specified interval.\n     * <p>\n     * The result of this method will {@linkplain #encloses(Interval) enclose}\n     * this interval and the specified interval.\n     *\n     * @param {Interval} other  the other interval to check for, not null\n     * @return {Interval} the interval that spans the two intervals\n     */\n    span(other) {\n        requireNonNull(other, 'other');\n        requireInstance(other, Interval, 'other');\n        const cmpStart = this._start.compareTo(other.start());\n        const cmpEnd = this._end.compareTo(other.end());\n        const newStart = (cmpStart >= 0 ? other.start() : this._start);\n        const newEnd = (cmpEnd <= 0 ? other.end() : this._end);\n        return Interval.of(newStart, newEnd);\n    }\n\n    //-------------------------------------------------------------------------\n    /**\n     * function overloading for {@link Interval#isAfter}\n     *\n     * if called with an Instant, then {@link Interval#isAfterInstant} is executed.\n     *\n     * Otherwise {@link Interval#isAfterInterval} is executed.\n     *\n     * @param {!(Instant|Interval)} instantOrInterval\n     * @returns {boolean}\n     */\n    isAfter(instantOrInterval) {\n        if (instantOrInterval instanceof Instant) {\n            return this.isAfterInstant(instantOrInterval);\n        } else {\n            return this.isAfterInterval(instantOrInterval);\n        }\n    }\n\n    /**\n     * function overloading for {@link Interval#isBefore}\n     *\n     * if called with an Instant, then {@link Interval#isBeforeInstant} is executed.\n     *\n     * Otherwise {@link Interval#isBeforeInterval} is executed.\n     *\n     * @param {!(Instant|Interval)} instantOrInterval\n     * @returns {boolean}\n     */\n    isBefore(instantOrInterval) {\n        if (instantOrInterval instanceof Instant) {\n            return this.isBeforeInstant(instantOrInterval);\n        } else {\n            return this.isBeforeInterval(instantOrInterval);\n        }\n    }\n\n    /**\n     * Checks if this interval is after the specified instant.\n     * <p>\n     * The result is true if the this instant starts after the specified instant.\n     * An empty interval behaves as though it is an instant for comparison purposes.\n     *\n     * @param {Instant} instant  the other instant to compare to, not null\n     * @return {boolean} true if the start of this interval is after the specified instant\n     */\n    isAfterInstant(instant) {\n        return this._start.compareTo(instant) > 0;\n    }\n\n    /**\n     * Checks if this interval is before the specified instant.\n     * <p>\n     * The result is true if the this instant ends before the specified instant.\n     * Since intervals do not include their end points, this will return true if the\n     * instant equals the end of the interval.\n     * An empty interval behaves as though it is an instant for comparison purposes.\n     *\n     * @param {Instant} instant  the other instant to compare to, not null\n     * @return {boolean} true if the start of this interval is before the specified instant\n     */\n    isBeforeInstant(instant) {\n        return this._end.compareTo(instant) <= 0 && this._start.compareTo(instant) < 0;\n    }\n\n    //-------------------------------------------------------------------------\n    /**\n     * Checks if this interval is after the specified interval.\n     * <p>\n     * The result is true if the this instant starts after the end of the specified interval.\n     * Since intervals do not include their end points, this will return true if the\n     * instant equals the end of the interval.\n     * An empty interval behaves as though it is an instant for comparison purposes.\n     *\n     * @param {Interval} interval  the other interval to compare to, not null\n     * @return {boolean} true if this instant is after the specified instant\n     */\n    isAfterInterval(interval) {\n        return this._start.compareTo(interval.end()) >= 0 && !interval.equals(this);\n    }\n\n    /**\n     * Checks if this interval is before the specified interval.\n     * <p>\n     * The result is true if the this instant ends before the start of the specified interval.\n     * Since intervals do not include their end points, this will return true if the\n     * two intervals abut.\n     * An empty interval behaves as though it is an instant for comparison purposes.\n     *\n     * @param {Interval} interval  the other interval to compare to, not null\n     * @return {boolean} true if this instant is before the specified instant\n     */\n    isBeforeInterval(interval) {\n        return this._end.compareTo(interval.start()) <= 0 && !interval.equals(this);\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Obtains the duration of this interval.\n     * <p>\n     * An {@code Interval} is associated with two specific instants on the time-line.\n     * A {@code Duration} is simply an amount of time, separate from the time-line.\n     *\n     * @return {Duration} the duration of the time interval\n     * @throws ArithmeticException if the calculation exceeds the capacity of {@code Duration}\n     */\n    toDuration() {\n        return Duration.between(this._start, this._end);\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Checks if this interval is equal to another interval.\n     * <p>\n     * Compares this {@code Interval} with another ensuring that the two instants are the same.\n     * Only objects of type {@code Interval} are compared, other types return false.\n     *\n     * @param {*} obj  the object to check, null returns false\n     * @return {boolean} true if this is equal to the other interval\n     */\n    equals(obj) {\n        if (this === obj) {\n            return true;\n        }\n        if (obj instanceof Interval) {\n            return this._start.equals(obj.start()) && this._end.equals(obj.end());\n        }\n        return false;\n    }\n\n    /**\n     * A hash code for this interval.\n     *\n     * @return {number} a suitable hash code\n     */\n    hashCode() {\n        // eslint-disable-next-line no-bitwise\n        return this._start.hashCode() ^ this._end.hashCode();\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Outputs this interval as a {@code String}, such as {@code 2007-12-03T10:15:30/2007-12-04T10:15:30}.\n     * <p>\n     * The output will be the ISO-8601 format formed by combining the\n     * {@code toString()} methods of the two instants, separated by a forward slash.\n     *\n     * @return {string} a string representation of this instant, not null\n     */\n    toString() {\n        return `${this._start.toString()}/${this._end.toString()}`;\n    }\n}\n\nexport function _init() {\n    Interval.ALL = Interval.of(Instant.MIN, Instant.MAX);\n}\n","/*\n * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper\n * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)\n */\n\nimport { _init as intervalInit } from './Interval';\n\nlet isInit = false;\n\nfunction init() {\n    if (isInit) {\n        return;\n    }\n\n    isInit = true;\n\n    intervalInit();\n}\n\ninit();\n","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)\n */\n\n// import { Interval } from './Interval';\n\nimport './_init';\n\n/**\n * @private\n *\n * plugin Function, call using js-jodas use()\n */\nexport default function (/* jsJoda */) {\n    // assign new prop to jsJoda context is useless, because it lives only in the local context\n    // jsJoda.Interval = Interval;\n}\n","/*\n * @copyright (c) 2016, Philipp Thuerwaechter & Pattrick Hueper\n * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)\n */\n\nimport { use } from '@js-joda/core';\n\nimport { Interval } from './Interval';\nimport plug from './plug';\n\nuse(plug);\n\nexport {\n    Interval,\n};\n"],"names":["requireNonNull","value","parameterName","NullPointerException","requireInstance","_class","IllegalArgumentException","name","constructor","Interval","of","startInstant","endInstantOrDuration","Duration","ofInstantDuration","ofInstantInstant","startInclusive","endExclusive","Instant","isBefore","DateTimeException","duration","isNegative","plus","parse","text","i","length","charAt","firstChar","substring","end","ZonedDateTime","toInstant","minus","start","c","DateTimeParseException","_start","_end","isEmpty","equals","isUnboundedStart","MIN","isUnboundedEnd","MAX","withStart","withEnd","contains","instant","compareTo","encloses","other","abuts","isConnected","overlaps","intersection","cmpStart","cmpEnd","newStart","newEnd","union","span","isAfter","instantOrInterval","isAfterInstant","isAfterInterval","isBeforeInstant","isBeforeInterval","interval","toDuration","between","obj","hashCode","toString","_init","ALL","isInit","init","intervalInit","use","plug"],"mappings":"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"}

package/dist/js-joda-extra.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/extra - 0.7.0
+//! @version @js-joda/extra - 0.7.1
 //! @copyright (c) 2015-2016, 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)

package/dist/js-joda-extra.min.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/extra - 0.7.0
+//! @version @js-joda/extra - 0.7.1
 //! @copyright (c) 2015-2016, 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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/extra",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "additional date-time classes that complement those in js-joda",
   "repository": {
     "type": "git",
@@ -50,7 +50,7 @@
     "@js-joda/core": ">=1.11.0"
   },
   "devDependencies": {
-    "@js-joda/core": "^5.0.0"
+    "@js-joda/core": "^5.1.0"
   },
-  "gitHead": "03943ccba7dab0178e3a112bce8a251410f89fe7"
+  "gitHead": "dda0bbb3894919782d859060bbabbaa3859775a8"
 }