@js-joda/timezone 2.15.0 → 2.15.1

package/dist/js-joda-timezone-2017-2027.esm.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/timezone - 2.15.0-2022e-2017-2027
+//! @version @js-joda/timezone - 2.15.1-2022e-2017-2027
 //! @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)
@@ -864,19 +864,15 @@ var latest = {
 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) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
     o.__proto__ = p;
     return o;
   };
-
   return _setPrototypeOf(o, p);
 }
-
 function _unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -885,19 +881,14 @@ function _unsupportedIterableToArray(o, minLen) {
   if (n === "Map" || n === "Set") return Array.from(o);
   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
-
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
-
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
   return arr2;
 }
-
 function _createForOfIteratorHelperLoose(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
   if (it) return (it = it.call(o)).next.bind(it);
-
   if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
     if (it) o = it;
     var i = 0;
@@ -911,147 +902,110 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
       };
     };
   }
-
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
 var MomentZoneRules = function (_ZoneRules) {
   _inheritsLoose(MomentZoneRules, _ZoneRules);
-
   function MomentZoneRules(tzdbInfo) {
     var _this;
-
     _this = _ZoneRules.call(this) || this;
     _this._tzdbInfo = tzdbInfo;
     _this._ldtUntils = new LDTUntils(_this._tzdbInfo.untils, _this._tzdbInfo.offsets);
     return _this;
   }
-
   var _proto = MomentZoneRules.prototype;
-
   _proto.isFixedOffset = function isFixedOffset() {
     return this._tzdbInfo.offsets.length === 1;
   };
-
   _proto.offsetOfInstant = function offsetOfInstant(instant) {
     var epochMilli = instant.toEpochMilli();
     return this.offsetOfEpochMilli(epochMilli);
   };
-
   _proto.offsetOfEpochMilli = function offsetOfEpochMilli(epochMilli) {
     var index = binarySearch(this._tzdbInfo.untils, epochMilli);
     return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index));
   };
-
   _proto.offsetOfLocalDateTime = function offsetOfLocalDateTime(localDateTime) {
     var info = this._offsetInfo(localDateTime);
-
     if (info instanceof ZoneOffsetTransition) {
       return info.offsetBefore();
     }
-
     return info;
   };
-
   _proto._offsetInfo = function _offsetInfo(localDateTime) {
     var index = ldtBinarySearch(this._ldtUntils, localDateTime);
     var offsetIndex = index >> 1;
-
     if (index % 2 === 1) {
       var ldtBefore = this._ldtUntils.get(Math.max(index - 1, 0));
-
       var ldtAfter = this._ldtUntils.get(Math.min(index, this._ldtUntils.size - 1));
-
       var offsetBefore = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));
       var offsetAfter = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(Math.min(offsetIndex + 1, this._tzdbInfo.offsets.length - 1)));
-
       if (offsetBefore.compareTo(offsetAfter) > 0) {
         return ZoneOffsetTransition.of(ldtBefore, offsetBefore, offsetAfter);
       } else {
         return ZoneOffsetTransition.of(ldtAfter, offsetBefore, offsetAfter);
       }
     }
-
     return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));
   };
-
   _proto._offsetByIndexInSeconds = function _offsetByIndexInSeconds(index) {
     return -offsetInSeconds(this._tzdbInfo.offsets[index]);
   };
-
   _proto.validOffsets = function validOffsets(localDateTime) {
     var info = this._offsetInfo(localDateTime);
-
     if (info instanceof ZoneOffsetTransition) {
       return info.validOffsets();
     }
-
     return [info];
   };
-
   _proto.transition = function transition(localDateTime) {
     var info = this._offsetInfo(localDateTime);
-
     if (info instanceof ZoneOffsetTransition) {
       return info;
     }
-
     return null;
   };
-
   _proto.standardOffset = function standardOffset(instant) {
     notSupported('ZoneRules.standardOffset');
   };
-
   _proto.daylightSavings = function daylightSavings(instant) {
     notSupported('ZoneRules.daylightSavings');
   };
-
   _proto.isDaylightSavings = function isDaylightSavings(instant) {
     notSupported('ZoneRules.isDaylightSavings');
   };
-
   _proto.isValidOffset = function isValidOffset(localDateTime, offset) {
     return this.validOffsets(localDateTime).some(function (o) {
       return o.equals(offset);
     });
   };
-
   _proto.nextTransition = function nextTransition(instant) {
     notSupported('ZoneRules.nextTransition');
   };
-
   _proto.previousTransition = function previousTransition(instant) {
     notSupported('ZoneRules.previousTransition');
   };
-
   _proto.transitions = function transitions() {
     notSupported('ZoneRules.transitions');
   };
-
   _proto.transitionRules = function transitionRules() {
     notSupported('ZoneRules.transitionRules');
   };
-
   _proto.equals = function equals(other) {
     if (this === other) {
       return true;
     }
-
     if (other instanceof MomentZoneRules) {
       return this._tzdbInfo === other._tzdbInfo;
     }
-
     return false;
   };
-
   _proto.toString = function toString() {
     return this._tzdbInfo.name;
   };
-
   return MomentZoneRules;
 }(ZoneRules);
-
 var LDTUntils = function () {
   function LDTUntils(_tzdbUntils, tzdbOffsets) {
     this._tzdbUntils = _tzdbUntils;
@@ -1059,16 +1013,12 @@ var LDTUntils = function () {
     this._ldtUntils = [];
     this.size = this._tzdbUntils.length * 2;
   }
-
   var _proto2 = LDTUntils.prototype;
-
   _proto2._generateTupple = function _generateTupple(index) {
     var epochMillis = this._tzdbUntils[index];
-
     if (epochMillis === Infinity) {
       return [LocalDateTime.MAX, LocalDateTime.MAX];
     }
-
     var instant = Instant.ofEpochMilli(epochMillis);
     var offset1 = offsetInSeconds(this._tzdbOffsets[index]);
     var zone1 = ZoneOffset.ofTotalSeconds(-offset1);
@@ -1077,36 +1027,28 @@ var LDTUntils = function () {
     var offset2 = offsetInSeconds(this._tzdbOffsets[nextIndex]);
     var zone2 = ZoneOffset.ofTotalSeconds(-offset2);
     var ldt2 = LocalDateTime.ofInstant(instant, zone2);
-
     if (offset1 > offset2) {
       return [ldt1, ldt2];
     } else {
       return [ldt2, ldt1];
     }
   };
-
   _proto2._getTupple = function _getTupple(index) {
     if (this._ldtUntils[index] == null) {
       this._ldtUntils[index] = this._generateTupple(index);
     }
-
     return this._ldtUntils[index];
   };
-
   _proto2.get = function get(index) {
     var ldtTupple = this._getTupple(index >> 1);
-
     return ldtTupple[index % 2];
   };
-
   return LDTUntils;
 }();
-
 function ldtBinarySearch(array, value) {
   var hi = array.size - 1,
-      lo = -1,
-      mid;
-
+    lo = -1,
+    mid;
   while (hi - lo > 1) {
     if (!value.isBefore(array.get(mid = hi + lo >> 1))) {
       lo = mid;
@@ -1114,14 +1056,11 @@ function ldtBinarySearch(array, value) {
       hi = mid;
     }
   }
-
   return hi;
 }
-
 function offsetInSeconds(tzdbOffset) {
   return roundDown(+tzdbOffset * 60);
 }
-
 function roundDown(r) {
   if (r < 0) {
     return Math.ceil(r);
@@ -1129,12 +1068,10 @@ function roundDown(r) {
     return Math.floor(r);
   }
 }
-
 function binarySearch(array, value) {
   var hi = array.length - 1,
-      lo = -1,
-      mid;
-
+    lo = -1,
+    mid;
   while (hi - lo > 1) {
     if (array[mid = hi + lo >> 1] <= value) {
       lo = mid;
@@ -1142,10 +1079,8 @@ function binarySearch(array, value) {
       hi = mid;
     }
   }
-
   return hi;
 }
-
 function notSupported(msg) {
   throw new Error("not supported: " + msg);
 }
@@ -1156,69 +1091,56 @@ function charCodeToInt(charCode) {
   } else if (charCode > 64) {
     return charCode - 29;
   }
-
   return charCode - 48;
 }
-
 function unpackBase60(string) {
   var i = 0,
-      parts = string.split('.'),
-      whole = parts[0],
-      fractional = parts[1] || '',
-      multiplier = 1,
-      num,
-      out = 0,
-      sign = 1;
-
+    parts = string.split('.'),
+    whole = parts[0],
+    fractional = parts[1] || '',
+    multiplier = 1,
+    num,
+    out = 0,
+    sign = 1;
   if (string.charCodeAt(0) === 45) {
     i = 1;
     sign = -1;
   }
-
   for (i; i < whole.length; i++) {
     num = charCodeToInt(whole.charCodeAt(i));
     out = 60 * out + num;
   }
-
   for (i = 0; i < fractional.length; i++) {
     multiplier = multiplier / 60;
     num = charCodeToInt(fractional.charCodeAt(i));
     out += num * multiplier;
   }
-
   return out * sign;
 }
-
 function arrayToInt(array) {
   for (var i = 0; i < array.length; i++) {
     array[i] = unpackBase60(array[i]);
   }
 }
-
 function intToUntil(array, length) {
   for (var i = 0; i < length; i++) {
     array[i] = Math.round((array[i - 1] || 0) + array[i] * 60000);
   }
-
   array[length - 1] = Infinity;
 }
-
 function mapIndices(source, indices) {
   var out = [],
-      i;
-
+    i;
   for (i = 0; i < indices.length; i++) {
     out[i] = source[indices[i]];
   }
-
   return out;
 }
-
 function unpack(string) {
   var data = string.split('|'),
-      offsets = data[2].split(' '),
-      indices = data[3].split(''),
-      untils = data[4].split(' ');
+    offsets = data[2].split(' '),
+    indices = data[3].split(''),
+    untils = data[4].split(' ');
   arrayToInt(offsets);
   arrayToInt(indices);
   arrayToInt(untils);
@@ -1239,37 +1161,28 @@ var zones = {};
 var links = {};
 var MomentZoneRulesProvider = function (_ZoneRulesProvider) {
   _inheritsLoose(MomentZoneRulesProvider, _ZoneRulesProvider);
-
   function MomentZoneRulesProvider() {
     return _ZoneRulesProvider.apply(this, arguments) || this;
   }
-
   MomentZoneRulesProvider.getRules = function getRules(zoneId) {
     var tzdbZoneInfo = zones[links[zoneId]];
-
     if (tzdbZoneInfo == null) {
       throw new DateTimeException("Unknown time-zone ID: " + zoneId);
     }
-
     return new MomentZoneRules(tzdbZoneInfo);
   };
-
   MomentZoneRulesProvider.getAvailableZoneIds = function getAvailableZoneIds() {
     return AVAILABLE_ZONE_IDS;
   };
-
   MomentZoneRulesProvider.getVersion = function getVersion() {
     return TZDB_VERSION;
   };
-
   MomentZoneRulesProvider.getTzdbData = function getTzdbData() {
     return TZDB_DATA;
   };
-
   MomentZoneRulesProvider.loadTzdbData = function loadTzdbData(packedJson) {
     TZDB_DATA = packedJson;
     TZDB_VERSION = packedJson.version;
-
     for (var _iterator = _createForOfIteratorHelperLoose(packedJson.zones), _step; !(_step = _iterator()).done;) {
       var packedZoneInfo = _step.value;
       var tzdbZoneInfo = unpack(packedZoneInfo);
@@ -1277,7 +1190,6 @@ var MomentZoneRulesProvider = function (_ZoneRulesProvider) {
       zones[tzdbZoneInfo.name] = tzdbZoneInfo;
       links[tzdbZoneInfo.name] = tzdbZoneInfo.name;
     }
-
     for (var _iterator2 = _createForOfIteratorHelperLoose(packedJson.links), _step2; !(_step2 = _iterator2()).done;) {
       var packedLink = _step2.value;
       var link = packedLink.split('|');
@@ -1285,7 +1197,6 @@ var MomentZoneRulesProvider = function (_ZoneRulesProvider) {
       links[link[1]] = link[0];
     }
   };
-
   return MomentZoneRulesProvider;
 }(ZoneRulesProvider);
 
@@ -1294,17 +1205,13 @@ function getResolvedZoneId(ZoneId) {
     var resolvedTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     return ZoneId.of(resolvedTimeZone);
   } catch (err) {}
-
   return null;
 }
-
 function extendSystemDefaultZoneId(ZoneId) {
   var resolvedZoneId = getResolvedZoneId(ZoneId);
-
   if (resolvedZoneId == null) {
     return;
   }
-
   ZoneId.systemDefault = function () {
     return resolvedZoneId;
   };

package/dist/js-joda-timezone-2017-2027.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"js-joda-timezone-2017-2027.esm.js","sources":["../src/MomentZoneRules.js","../src/unpack.js","../src/MomentZoneRulesProvider.js","../src/system-default-zone.js","../src/plug.js","../src/auto-plug.js","../src/js-joda-timezone.js"],"sourcesContent":["/*\n * @copyright (c) 2016-present, 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 {\n    LocalDateTime, Instant, ZoneOffset, ZoneOffsetTransition, ZoneRules\n} from '@js-joda/core';\n\nexport class MomentZoneRules extends ZoneRules{\n    constructor(tzdbInfo){\n        super();\n        this._tzdbInfo = tzdbInfo;\n        this._ldtUntils = new LDTUntils(this._tzdbInfo.untils, this._tzdbInfo.offsets);\n    }\n    /**\n     * Checks of the zone rules are fixed, such that the offset never varies.\n     *\n     * @return {boolean} true if the time-zone is fixed and the offset never changes\n     */\n    isFixedOffset(){\n        return this._tzdbInfo.offsets.length === 1;\n    }\n\n    //-----------------------------------------------------------------------\n\n    /**\n     * Gets the offset applicable at the specified instant in these rules.\n     * <p>\n     * The mapping from an instant to an offset is simple, there is only\n     * one valid offset for each instant.\n     * This method returns that offset.\n     *\n     * @param {Instant} instant - the instant to find the offset for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the offset, not null\n     */\n    offsetOfInstant(instant){\n        const epochMilli = instant.toEpochMilli();\n        return this.offsetOfEpochMilli(epochMilli);\n    }\n\n    /**\n     * Gets the offset applicable at the specified epochMilli in these rules.\n     *\n     * The method is for javascript performance optimisation.\n     *\n     * @param {number} epochMilli - the epoch millisecond to find the offset for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the offset, not null\n     */\n    offsetOfEpochMilli(epochMilli){\n        const index  = binarySearch(this._tzdbInfo.untils, epochMilli);\n        return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index));\n    }\n\n\n    /**\n     * Gets a suitable offset for the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * Thus, for any given local date-time there can be zero, one or two valid offsets.\n     * This method returns the single offset in the Normal case, and in the Gap or Overlap\n     * case it returns the offset before the transition.\n     * <p>\n     * Since, in the case of Gap and Overlap, the offset returned is a \"best\" value, rather\n     * than the \"correct\" value, it should be treated with care. Applications that care\n     * about the correct offset should use a combination of this method,\n     * {@link #getValidOffsets(LocalDateTime)} and {@link #getTransition(LocalDateTime)}.\n     *\n     * @param {LocalDateTime} localDateTime - the local date-time to query, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the best available offset for the local date-time, not null\n     */\n    offsetOfLocalDateTime(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info.offsetBefore();\n        }\n        return info;\n    }\n\n    _offsetInfo(localDateTime) {\n        const index  = ldtBinarySearch(this._ldtUntils, localDateTime);\n        const offsetIndex = index >> 1;\n\n        if (index % 2 === 1){\n            const ldtBefore = this._ldtUntils.get(Math.max(index-1, 0));\n            const ldtAfter = this._ldtUntils.get(Math.min(index, this._ldtUntils.size-1));\n            const offsetBefore = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));\n            const offsetAfter = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(Math.min(offsetIndex+1, this._tzdbInfo.offsets.length-1)));\n            // console.log(offsetBefore.toString(), offsetAfter.toString());\n            if (offsetBefore.compareTo(offsetAfter) > 0) {\n                // gap\n                // console.log('gap', ldtBefore.toString(), localDateTime.toString(), ldtAfter.toString());\n                return ZoneOffsetTransition.of(ldtBefore, offsetBefore, offsetAfter);\n            } else {\n                // overlap\n                // console.log('overlap', ldtBefore.toString(), localDateTime.toString(), ldtAfter.toString());\n                return ZoneOffsetTransition.of(ldtAfter, offsetBefore, offsetAfter);\n            }\n        }\n        return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));\n    }\n\n    _offsetByIndexInSeconds(index){\n        return -offsetInSeconds(this._tzdbInfo.offsets[index]);\n    }\n\n    /**\n     * Gets the offset applicable at the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * Thus, for any given local date-time there can be zero, one or two valid offsets.\n     * This method returns that list of valid offsets, which is a list of size 0, 1 or 2.\n     * In the case where there are two offsets, the earlier offset is returned at index 0\n     * and the later offset at index 1.\n     * <p>\n     * There are various ways to handle the conversion from a {@code LocalDateTime}.\n     * One technique, using this method, would be:\n     * <pre>\n     *  List<ZoneOffset> validOffsets = rules.getOffset(localDT);\n     *  if (validOffsets.size() == 1) {\n     *    // Normal case: only one valid offset\n     *    zoneOffset = validOffsets.get(0);\n     *  } else {\n     *    // Gap or Overlap: determine what to do from transition (which will be non-null)\n     *    ZoneOffsetTransition trans = rules.getTransition(localDT);\n     *  }\n     * </pre>\n     * <p>\n     * In theory, it is possible for there to be more than two valid offsets.\n     * This would happen if clocks to be put back more than once in quick succession.\n     * This has never happened in the history of time-zones and thus has no special handling.\n     * However, if it were to happen, then the list would return more than 2 entries.\n     *\n     * @param {LocalDateTime} localDateTime - the local date-time to query for valid offsets, not null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition | ZoneOffset[]} the list of valid offsets, may be immutable, not null\n     */\n    validOffsets(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info.validOffsets();\n        }\n        return [info];\n    }\n\n    /**\n     * Gets the offset transition applicable at the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * A transition is used to model the cases of a Gap or Overlap.\n     * The Normal case will return null.\n     * <p>\n     * There are various ways to handle the conversion from a {@code LocalDateTime}.\n     * One technique, using this method, would be:\n     * <pre>\n     *  ZoneOffsetTransition trans = rules.getTransition(localDT);\n     *  if (trans != null) {\n     *    // Gap or Overlap: determine what to do from transition\n     *  } else {\n     *    // Normal case: only one valid offset\n     *    zoneOffset = rule.getOffset(localDT);\n     *  }\n     * </pre>\n     *\n     * @param {LocalDateTime} localDateTime  the local date-time to query for offset transition, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the offset transition, null if the local date-time is not in transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    transition(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info;\n        }\n        return null;\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Gets the standard offset for the specified instant in this zone.\n     * <p>\n     * This provides access to historic information on how the standard offset\n     * has changed over time.\n     * The standard offset is the offset before any daylight saving time is applied.\n     * This is typically the offset applicable during winter.\n     *\n     * @param {Instant} instant - the instant to find the offset information for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the standard offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    standardOffset(instant){\n        notSupported('ZoneRules.standardOffset');\n    }\n\n    /**\n     * Gets the amount of daylight savings in use for the specified instant in this zone.\n     * <p>\n     * This provides access to historic information on how the amount of daylight\n     * savings has changed over time.\n     * This is the difference between the standard offset and the actual offset.\n     * Typically the amount is zero during winter and one hour during summer.\n     * Time-zones are second-based, so the nanosecond part of the duration will be zero.\n     *\n     * @param {Instant} instant - the instant to find the daylight savings for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {Duration} the difference between the standard and actual offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    daylightSavings(instant){\n        notSupported('ZoneRules.daylightSavings');\n    }\n\n    /**\n     * Checks if the specified instant is in daylight savings.\n     * <p>\n     * This checks if the standard and actual offsets are the same at the specified instant.\n     *\n     * @param {Instant} instant - the instant to find the offset information for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {boolean} the standard offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    isDaylightSavings(instant) {\n        notSupported('ZoneRules.isDaylightSavings');\n    }\n\n    /**\n     * Checks if the offset date-time is valid for these rules.\n     * <p>\n     * To be valid, the local date-time must not be in a gap and the offset\n     * must match the valid offsets.\n     *\n     * @param {LocalDateTime} localDateTime - the date-time to check, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @param {ZoneOffset} offset - the offset to check, null returns false\n     * @return {boolean} true if the offset date-time is valid for these rules\n     */\n    isValidOffset(localDateTime, offset){\n        return this.validOffsets(localDateTime).some( o => o.equals(offset));\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Gets the next transition after the specified instant.\n     * <p>\n     * This returns details of the next transition after the specified instant.\n     * For example, if the instant represents a point where \"Summer\" daylight savings time\n     * applies, then the method will return the transition to the next \"Winter\" time.\n     *\n     * @param {Instant} instant - the instant to get the next transition after, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the next transition after the specified instant, null if this is after the last transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    nextTransition(instant){\n        notSupported('ZoneRules.nextTransition');\n    }\n\n    /**\n     * Gets the previous transition before the specified instant.\n     * <p>\n     * This returns details of the previous transition after the specified instant.\n     * For example, if the instant represents a point where \"summer\" daylight saving time\n     * applies, then the method will return the transition from the previous \"winter\" time.\n     *\n     * @param {Instant} instant - the instant to get the previous transition after, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the previous transition after the specified instant, null if this is before the first transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    previousTransition(instant){\n        notSupported('ZoneRules.previousTransition');\n    }\n\n    /**\n     * Gets the complete list of fully defined transitions.\n     * <p>\n     * The complete set of transitions for this rules instance is defined by this method\n     * and {@link #getTransitionRules()}. This method returns those transitions that have\n     * been fully defined. These are typically historical, but may be in the future.\n     * <p>\n     * The list will be empty for fixed offset rules and for any time-zone where there has\n     * only ever been a single offset. The list will also be empty if the transition rules are unknown.\n     *\n     * @return {ZoneOffsetTransition[]} an immutable list of fully defined transitions, not null\n     */\n    transitions(){\n        notSupported('ZoneRules.transitions');\n    }\n\n    /**\n     * Gets the list of transition rules for years beyond those defined in the transition list.\n     * <p>\n     * The complete set of transitions for this rules instance is defined by this method\n     * and {@link #getTransitions()}. This method returns instances of {@link ZoneOffsetTransitionRule}\n     * that define an algorithm for when transitions will occur.\n     * <p>\n     * For any given {@code ZoneRules}, this list contains the transition rules for years\n     * beyond those years that have been fully defined. These rules typically refer to future\n     * daylight saving time rule changes.\n     * <p>\n     * If the zone defines daylight savings into the future, then the list will normally\n     * be of size two and hold information about entering and exiting daylight savings.\n     * If the zone does not have daylight savings, or information about future changes\n     * is uncertain, then the list will be empty.\n     * <p>\n     * The list will be empty for fixed offset rules and for any time-zone where there is no\n     * daylight saving time. The list will also be empty if the transition rules are unknown.\n     *\n     * @return {ZoneOffsetTransitionRule[]} an immutable list of transition rules, not null\n     */\n    transitionRules(){\n        notSupported('ZoneRules.transitionRules');\n    }\n\n    /**\n     *\n     * @param other\n     * @returns {boolean}\n     */\n    equals(other) {\n        if (this === other) {\n            return true;\n        }\n        if (other instanceof MomentZoneRules) {\n            return this._tzdbInfo === other._tzdbInfo;\n        }\n        return false;\n    }\n\n    /**\n     *\n     * @returns {string}\n     */\n    toString() {\n        return this._tzdbInfo.name;\n    }\n}\n\nclass LDTUntils {\n    constructor(_tzdbUntils, tzdbOffsets) {\n        this._tzdbUntils = _tzdbUntils;\n        this._tzdbOffsets = tzdbOffsets;\n        this._ldtUntils = [];\n        this.size = this._tzdbUntils.length * 2;\n    }\n\n\n    _generateTupple(index) {\n        const epochMillis = this._tzdbUntils[index];\n        if (epochMillis === Infinity) {\n            return [LocalDateTime.MAX, LocalDateTime.MAX];\n        }\n        const instant = Instant.ofEpochMilli(epochMillis);\n\n        const offset1 = offsetInSeconds(this._tzdbOffsets[index]);\n        const zone1 = ZoneOffset.ofTotalSeconds(-offset1);\n        const ldt1 = LocalDateTime.ofInstant(instant, zone1);\n\n        const nextIndex = Math.min(index + 1, this._tzdbOffsets.length - 1);\n        const offset2 = offsetInSeconds(this._tzdbOffsets[nextIndex]);\n        const zone2 = ZoneOffset.ofTotalSeconds(-offset2);\n        const ldt2 = LocalDateTime.ofInstant(instant, zone2);\n\n        if(offset1 > offset2) {\n            return [ldt1, ldt2];\n        } else {\n            return [ldt2, ldt1];\n        }\n    }\n\n    _getTupple(index){\n        if (this._ldtUntils[index] == null) {\n            this._ldtUntils[index] = this._generateTupple(index);\n        }\n        return this._ldtUntils[index];\n    }\n\n    get(index) {\n        const ldtTupple = this._getTupple(index >> 1);\n        return ldtTupple[index % 2];\n    }\n}\n\n// modified bin-search, to always find existing indices for non-empty arrays\n// value in array at index is larger than input value (or last index of array)\nfunction ldtBinarySearch(array, value) {\n    let hi = array.size - 1, lo = -1, mid;\n    while (hi - lo > 1) {\n        if (!value.isBefore(array.get(mid = hi + lo >> 1))) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return hi;\n}\n\nfunction offsetInSeconds(tzdbOffset){\n    return roundDown(+tzdbOffset*60);\n}\n\nfunction roundDown(r){\n    if (r < 0) {\n        return Math.ceil(r);\n    } else {\n        return Math.floor(r);\n    }\n}\n\n// modified bin-search, to always find existing indices for non-empty arrays\n// value in array at index is larger than input value (or last index of array)\nfunction binarySearch(array, value) {\n    let hi = array.length - 1, lo = -1, mid;\n    while (hi - lo > 1) {\n        if (array[mid = hi + lo >> 1] <= value) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return hi;\n}\n\nfunction notSupported(msg){\n    throw new Error(`not supported: ${msg}`);\n}\n","/* eslint-disable no-var */\n\n//! moment-timezone.js\n//! version : 0.5.2\n//! author : Tim Wood\n//! license : MIT\n//! github.com/moment/moment-timezone\n\n/************************************\n Unpacking\n ************************************/\n\n/**\n * @private\n *\n * @param charCode\n * @returns {number}\n */\nfunction charCodeToInt(charCode) {\n    if (charCode > 96) {\n        return charCode - 87;\n    } else if (charCode > 64) {\n        return charCode - 29;\n    }\n    return charCode - 48;\n}\n\nfunction unpackBase60(string) {\n    var i = 0,\n        parts = string.split('.'),\n        whole = parts[0],\n        fractional = parts[1] || '',\n        multiplier = 1,\n        num,\n        out = 0,\n        sign = 1;\n\n    // handle negative numbers\n    if (string.charCodeAt(0) === 45) {\n        i = 1;\n        sign = -1;\n    }\n\n    // handle digits before the decimal\n    for (i; i < whole.length; i++) {\n        num = charCodeToInt(whole.charCodeAt(i));\n        out = 60 * out + num;\n    }\n\n    // handle digits after the decimal\n    for (i = 0; i < fractional.length; i++) {\n        multiplier = multiplier / 60;\n        num = charCodeToInt(fractional.charCodeAt(i));\n        out += num * multiplier;\n    }\n\n    return out * sign;\n}\n\nfunction arrayToInt (array) {\n    for (var i = 0; i < array.length; i++) {\n        array[i] = unpackBase60(array[i]);\n    }\n}\n\nfunction intToUntil (array, length) {\n    for (var i = 0; i < length; i++) {\n        array[i] = Math.round((array[i - 1] || 0) + (array[i] * 60000)); // minutes to milliseconds\n    }\n\n    array[length - 1] = Infinity;\n}\n\nfunction mapIndices (source, indices) {\n    var out = [], i;\n\n    for (i = 0; i < indices.length; i++) {\n        out[i] = source[indices[i]];\n    }\n\n    return out;\n}\n\n/**\n * @private\n *\n * @param string\n * @returns {{offsets: *[], abbrs: *[], name, untils: *, population: number}}\n */\nexport function unpack (string) {\n    var data = string.split('|'),\n        offsets = data[2].split(' '),\n        indices = data[3].split(''),\n        untils  = data[4].split(' ');\n\n    arrayToInt(offsets);\n    arrayToInt(indices);\n    arrayToInt(untils);\n\n    intToUntil(untils, indices.length);\n\n    return {\n        name       : data[0],\n        abbrs      : mapIndices(data[1].split(' '), indices),\n        offsets    : mapIndices(offsets, indices),\n        untils     : untils,\n        population : data[5] | 0\n    };\n}\n\n","/*\n * @copyright (c) 2016-present, 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 {\n    DateTimeException,\n    ZoneRulesProvider,\n} from '@js-joda/core';\n\nimport { MomentZoneRules } from './MomentZoneRules';\n\nimport { unpack } from './unpack';\n\nlet TZDB_DATA;\nlet TZDB_VERSION;\nconst AVAILABLE_ZONE_IDS = [];\n\nconst zones = {};\nconst links = {};\n\nexport class MomentZoneRulesProvider extends ZoneRulesProvider {\n    /**\n     * Gets the rules for the zone ID.\n     * <p>\n     * This returns the latest available rules for the zone ID.\n     * <p>\n     * This method relies on time-zone data provider files that are configured.\n     *\n     * @param {string} zoneId\n     * @return {ZoneRules}\n     */\n    static getRules(zoneId){\n        const tzdbZoneInfo = zones[links[zoneId]];\n        if(tzdbZoneInfo == null){\n            throw new DateTimeException(`Unknown time-zone ID: ${zoneId}`);\n        }\n        return new MomentZoneRules(tzdbZoneInfo);\n    }\n\n\n    /**\n     * Gets the set of available zone IDs.\n     * <p>\n     * These zone IDs are loaded and available for use by {@code ZoneId}.\n     *\n     * @return {string[]} a modifiable copy of the set of zone IDs, not null\n     */\n    static getAvailableZoneIds(){\n        return AVAILABLE_ZONE_IDS;\n    }\n\n    /**\n     *\n     * @return {string} the tzdb version.\n     */\n    static getVersion() {\n        return TZDB_VERSION;\n    }\n\n    /**\n     * Provides the packed tzdb data,\n     * the data has the same format as provided from moment-timezone.\n     *\n     * @return {object} the packed tzdb data.\n     */\n    static getTzdbData(){\n        return TZDB_DATA;\n    }\n\n    /**\n     * Sets the packed tzdb data.\n     * Accepts tzdb data in the same format as provided from moment-timezone.\n     *\n     * @param packedJson\n     */\n    static loadTzdbData(packedJson){\n        TZDB_DATA = packedJson;\n        TZDB_VERSION = packedJson.version;\n\n        for (const packedZoneInfo of packedJson.zones) {\n            const tzdbZoneInfo = unpack(packedZoneInfo);\n            AVAILABLE_ZONE_IDS.push(tzdbZoneInfo.name);\n            zones[tzdbZoneInfo.name] = tzdbZoneInfo;\n            links[tzdbZoneInfo.name] = tzdbZoneInfo.name;\n        }\n\n        for (const packedLink of packedJson.links) {\n            const link = packedLink.split('|');\n            AVAILABLE_ZONE_IDS.push(link[1]);\n            links[link[1]] = link[0];\n        }\n    }\n}\n","/**\n * @private\n *\n * @param ZoneId\n * @returns {null|*}\n */\nfunction getResolvedZoneId(ZoneId) {\n    try {\n        const resolvedTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;\n        return ZoneId.of(resolvedTimeZone);\n    } catch (err) {\n        // ignore\n    }\n    return null;\n}\n\n/**\n * @private\n *\n * @param ZoneId\n */\nexport default function extendSystemDefaultZoneId(ZoneId) {\n    const resolvedZoneId = getResolvedZoneId(ZoneId);\n\n    if (resolvedZoneId == null) {\n        return;\n    }\n\n    ZoneId.systemDefault = function () {\n        return resolvedZoneId;\n    };\n}\n","/*\n * @copyright (c) 2016-present, 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 { MomentZoneRulesProvider } from './MomentZoneRulesProvider';\nimport extendSystemDefaultZoneId from './system-default-zone';\n\n/**\n * @private\n */\nexport default function (jsJoda) {\n    jsJoda.ZoneRulesProvider.getRules = MomentZoneRulesProvider.getRules;\n    jsJoda.ZoneRulesProvider.getAvailableZoneIds = MomentZoneRulesProvider.getAvailableZoneIds;\n    jsJoda.ZoneRulesProvider.getTzdbData = MomentZoneRulesProvider.getTzdbData;\n    jsJoda.ZoneRulesProvider.loadTzdbData = MomentZoneRulesProvider.loadTzdbData;\n\n    extendSystemDefaultZoneId(jsJoda.ZoneId);\n    return jsJoda;\n}\n","/*\n * @copyright (c) 2016-present, 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 { use } from '@js-joda/core';\n\nimport plug from './plug';\n\n/**\n * @private\n */\nexport default function autoPlug() {\n    use(plug);\n}\n\n","/*\n * @copyright (c) 2016-present, 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 latest from './tzdbData';\n\nimport { MomentZoneRulesProvider } from './MomentZoneRulesProvider';\nimport autoPlug from './auto-plug';\n\nMomentZoneRulesProvider.loadTzdbData(latest);\n\nautoPlug();\n"],"names":["MomentZoneRules","tzdbInfo","_tzdbInfo","_ldtUntils","LDTUntils","untils","offsets","isFixedOffset","length","offsetOfInstant","instant","epochMilli","toEpochMilli","offsetOfEpochMilli","index","binarySearch","ZoneOffset","ofTotalSeconds","_offsetByIndexInSeconds","offsetOfLocalDateTime","localDateTime","info","_offsetInfo","ZoneOffsetTransition","offsetBefore","ldtBinarySearch","offsetIndex","ldtBefore","get","Math","max","ldtAfter","min","size","offsetAfter","compareTo","of","offsetInSeconds","validOffsets","transition","standardOffset","notSupported","daylightSavings","isDaylightSavings","isValidOffset","offset","some","o","equals","nextTransition","previousTransition","transitions","transitionRules","other","toString","name","ZoneRules","_tzdbUntils","tzdbOffsets","_tzdbOffsets","_generateTupple","epochMillis","Infinity","LocalDateTime","MAX","Instant","ofEpochMilli","offset1","zone1","ldt1","ofInstant","nextIndex","offset2","zone2","ldt2","_getTupple","ldtTupple","array","value","hi","lo","mid","isBefore","tzdbOffset","roundDown","r","ceil","floor","msg","Error","charCodeToInt","charCode","unpackBase60","string","i","parts","split","whole","fractional","multiplier","num","out","sign","charCodeAt","arrayToInt","intToUntil","round","mapIndices","source","indices","unpack","data","abbrs","population","TZDB_DATA","TZDB_VERSION","AVAILABLE_ZONE_IDS","zones","links","MomentZoneRulesProvider","getRules","zoneId","tzdbZoneInfo","DateTimeException","getAvailableZoneIds","getVersion","getTzdbData","loadTzdbData","packedJson","version","packedZoneInfo","push","packedLink","link","ZoneRulesProvider","getResolvedZoneId","ZoneId","resolvedTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","err","extendSystemDefaultZoneId","resolvedZoneId","systemDefault","jsJoda","autoPlug","use","plug","latest"],"mappings":"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"}
+{"version":3,"file":"js-joda-timezone-2017-2027.esm.js","sources":["../src/MomentZoneRules.js","../src/unpack.js","../src/MomentZoneRulesProvider.js","../src/system-default-zone.js","../src/plug.js","../src/auto-plug.js","../src/js-joda-timezone.js"],"sourcesContent":["/*\n * @copyright (c) 2016-present, 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 {\n    LocalDateTime, Instant, ZoneOffset, ZoneOffsetTransition, ZoneRules\n} from '@js-joda/core';\n\nexport class MomentZoneRules extends ZoneRules{\n    constructor(tzdbInfo){\n        super();\n        this._tzdbInfo = tzdbInfo;\n        this._ldtUntils = new LDTUntils(this._tzdbInfo.untils, this._tzdbInfo.offsets);\n    }\n    /**\n     * Checks of the zone rules are fixed, such that the offset never varies.\n     *\n     * @return {boolean} true if the time-zone is fixed and the offset never changes\n     */\n    isFixedOffset(){\n        return this._tzdbInfo.offsets.length === 1;\n    }\n\n    //-----------------------------------------------------------------------\n\n    /**\n     * Gets the offset applicable at the specified instant in these rules.\n     * <p>\n     * The mapping from an instant to an offset is simple, there is only\n     * one valid offset for each instant.\n     * This method returns that offset.\n     *\n     * @param {Instant} instant - the instant to find the offset for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the offset, not null\n     */\n    offsetOfInstant(instant){\n        const epochMilli = instant.toEpochMilli();\n        return this.offsetOfEpochMilli(epochMilli);\n    }\n\n    /**\n     * Gets the offset applicable at the specified epochMilli in these rules.\n     *\n     * The method is for javascript performance optimisation.\n     *\n     * @param {number} epochMilli - the epoch millisecond to find the offset for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the offset, not null\n     */\n    offsetOfEpochMilli(epochMilli){\n        const index  = binarySearch(this._tzdbInfo.untils, epochMilli);\n        return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index));\n    }\n\n\n    /**\n     * Gets a suitable offset for the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * Thus, for any given local date-time there can be zero, one or two valid offsets.\n     * This method returns the single offset in the Normal case, and in the Gap or Overlap\n     * case it returns the offset before the transition.\n     * <p>\n     * Since, in the case of Gap and Overlap, the offset returned is a \"best\" value, rather\n     * than the \"correct\" value, it should be treated with care. Applications that care\n     * about the correct offset should use a combination of this method,\n     * {@link #getValidOffsets(LocalDateTime)} and {@link #getTransition(LocalDateTime)}.\n     *\n     * @param {LocalDateTime} localDateTime - the local date-time to query, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the best available offset for the local date-time, not null\n     */\n    offsetOfLocalDateTime(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info.offsetBefore();\n        }\n        return info;\n    }\n\n    _offsetInfo(localDateTime) {\n        const index  = ldtBinarySearch(this._ldtUntils, localDateTime);\n        const offsetIndex = index >> 1;\n\n        if (index % 2 === 1){\n            const ldtBefore = this._ldtUntils.get(Math.max(index-1, 0));\n            const ldtAfter = this._ldtUntils.get(Math.min(index, this._ldtUntils.size-1));\n            const offsetBefore = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));\n            const offsetAfter = ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(Math.min(offsetIndex+1, this._tzdbInfo.offsets.length-1)));\n            // console.log(offsetBefore.toString(), offsetAfter.toString());\n            if (offsetBefore.compareTo(offsetAfter) > 0) {\n                // gap\n                // console.log('gap', ldtBefore.toString(), localDateTime.toString(), ldtAfter.toString());\n                return ZoneOffsetTransition.of(ldtBefore, offsetBefore, offsetAfter);\n            } else {\n                // overlap\n                // console.log('overlap', ldtBefore.toString(), localDateTime.toString(), ldtAfter.toString());\n                return ZoneOffsetTransition.of(ldtAfter, offsetBefore, offsetAfter);\n            }\n        }\n        return ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));\n    }\n\n    _offsetByIndexInSeconds(index){\n        return -offsetInSeconds(this._tzdbInfo.offsets[index]);\n    }\n\n    /**\n     * Gets the offset applicable at the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * Thus, for any given local date-time there can be zero, one or two valid offsets.\n     * This method returns that list of valid offsets, which is a list of size 0, 1 or 2.\n     * In the case where there are two offsets, the earlier offset is returned at index 0\n     * and the later offset at index 1.\n     * <p>\n     * There are various ways to handle the conversion from a {@code LocalDateTime}.\n     * One technique, using this method, would be:\n     * <pre>\n     *  List<ZoneOffset> validOffsets = rules.getOffset(localDT);\n     *  if (validOffsets.size() == 1) {\n     *    // Normal case: only one valid offset\n     *    zoneOffset = validOffsets.get(0);\n     *  } else {\n     *    // Gap or Overlap: determine what to do from transition (which will be non-null)\n     *    ZoneOffsetTransition trans = rules.getTransition(localDT);\n     *  }\n     * </pre>\n     * <p>\n     * In theory, it is possible for there to be more than two valid offsets.\n     * This would happen if clocks to be put back more than once in quick succession.\n     * This has never happened in the history of time-zones and thus has no special handling.\n     * However, if it were to happen, then the list would return more than 2 entries.\n     *\n     * @param {LocalDateTime} localDateTime - the local date-time to query for valid offsets, not null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition | ZoneOffset[]} the list of valid offsets, may be immutable, not null\n     */\n    validOffsets(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info.validOffsets();\n        }\n        return [info];\n    }\n\n    /**\n     * Gets the offset transition applicable at the specified local date-time in these rules.\n     * <p>\n     * The mapping from a local date-time to an offset is not straightforward.\n     * There are three cases:\n     * <p><ul>\n     * <li>Normal, with one valid offset. For the vast majority of the year, the normal\n     *  case applies, where there is a single valid offset for the local date-time.</li>\n     * <li>Gap, with zero valid offsets. This is when clocks jump forward typically\n     *  due to the spring daylight savings change from \"winter\" to \"summer\".\n     *  In a gap there are local date-time values with no valid offset.</li>\n     * <li>Overlap, with two valid offsets. This is when clocks are set back typically\n     *  due to the autumn daylight savings change from \"summer\" to \"winter\".\n     *  In an overlap there are local date-time values with two valid offsets.</li>\n     * </ul><p>\n     * A transition is used to model the cases of a Gap or Overlap.\n     * The Normal case will return null.\n     * <p>\n     * There are various ways to handle the conversion from a {@code LocalDateTime}.\n     * One technique, using this method, would be:\n     * <pre>\n     *  ZoneOffsetTransition trans = rules.getTransition(localDT);\n     *  if (trans != null) {\n     *    // Gap or Overlap: determine what to do from transition\n     *  } else {\n     *    // Normal case: only one valid offset\n     *    zoneOffset = rule.getOffset(localDT);\n     *  }\n     * </pre>\n     *\n     * @param {LocalDateTime} localDateTime  the local date-time to query for offset transition, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the offset transition, null if the local date-time is not in transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    transition(localDateTime){\n        const info = this._offsetInfo(localDateTime);\n        if (info instanceof ZoneOffsetTransition) {\n            return info;\n        }\n        return null;\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Gets the standard offset for the specified instant in this zone.\n     * <p>\n     * This provides access to historic information on how the standard offset\n     * has changed over time.\n     * The standard offset is the offset before any daylight saving time is applied.\n     * This is typically the offset applicable during winter.\n     *\n     * @param {Instant} instant - the instant to find the offset information for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffset} the standard offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    standardOffset(instant){\n        notSupported('ZoneRules.standardOffset');\n    }\n\n    /**\n     * Gets the amount of daylight savings in use for the specified instant in this zone.\n     * <p>\n     * This provides access to historic information on how the amount of daylight\n     * savings has changed over time.\n     * This is the difference between the standard offset and the actual offset.\n     * Typically the amount is zero during winter and one hour during summer.\n     * Time-zones are second-based, so the nanosecond part of the duration will be zero.\n     *\n     * @param {Instant} instant - the instant to find the daylight savings for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {Duration} the difference between the standard and actual offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    daylightSavings(instant){\n        notSupported('ZoneRules.daylightSavings');\n    }\n\n    /**\n     * Checks if the specified instant is in daylight savings.\n     * <p>\n     * This checks if the standard and actual offsets are the same at the specified instant.\n     *\n     * @param {Instant} instant - the instant to find the offset information for, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {boolean} the standard offset, not null\n     */\n    // eslint-disable-next-line no-unused-vars\n    isDaylightSavings(instant) {\n        notSupported('ZoneRules.isDaylightSavings');\n    }\n\n    /**\n     * Checks if the offset date-time is valid for these rules.\n     * <p>\n     * To be valid, the local date-time must not be in a gap and the offset\n     * must match the valid offsets.\n     *\n     * @param {LocalDateTime} localDateTime - the date-time to check, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @param {ZoneOffset} offset - the offset to check, null returns false\n     * @return {boolean} true if the offset date-time is valid for these rules\n     */\n    isValidOffset(localDateTime, offset){\n        return this.validOffsets(localDateTime).some( o => o.equals(offset));\n    }\n\n    //-----------------------------------------------------------------------\n    /**\n     * Gets the next transition after the specified instant.\n     * <p>\n     * This returns details of the next transition after the specified instant.\n     * For example, if the instant represents a point where \"Summer\" daylight savings time\n     * applies, then the method will return the transition to the next \"Winter\" time.\n     *\n     * @param {Instant} instant - the instant to get the next transition after, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the next transition after the specified instant, null if this is after the last transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    nextTransition(instant){\n        notSupported('ZoneRules.nextTransition');\n    }\n\n    /**\n     * Gets the previous transition before the specified instant.\n     * <p>\n     * This returns details of the previous transition after the specified instant.\n     * For example, if the instant represents a point where \"summer\" daylight saving time\n     * applies, then the method will return the transition from the previous \"winter\" time.\n     *\n     * @param {Instant} instant - the instant to get the previous transition after, not null, but null\n     *  may be ignored if the rules have a single offset for all instants\n     * @return {ZoneOffsetTransition} the previous transition after the specified instant, null if this is before the first transition\n     */\n    // eslint-disable-next-line no-unused-vars\n    previousTransition(instant){\n        notSupported('ZoneRules.previousTransition');\n    }\n\n    /**\n     * Gets the complete list of fully defined transitions.\n     * <p>\n     * The complete set of transitions for this rules instance is defined by this method\n     * and {@link #getTransitionRules()}. This method returns those transitions that have\n     * been fully defined. These are typically historical, but may be in the future.\n     * <p>\n     * The list will be empty for fixed offset rules and for any time-zone where there has\n     * only ever been a single offset. The list will also be empty if the transition rules are unknown.\n     *\n     * @return {ZoneOffsetTransition[]} an immutable list of fully defined transitions, not null\n     */\n    transitions(){\n        notSupported('ZoneRules.transitions');\n    }\n\n    /**\n     * Gets the list of transition rules for years beyond those defined in the transition list.\n     * <p>\n     * The complete set of transitions for this rules instance is defined by this method\n     * and {@link #getTransitions()}. This method returns instances of {@link ZoneOffsetTransitionRule}\n     * that define an algorithm for when transitions will occur.\n     * <p>\n     * For any given {@code ZoneRules}, this list contains the transition rules for years\n     * beyond those years that have been fully defined. These rules typically refer to future\n     * daylight saving time rule changes.\n     * <p>\n     * If the zone defines daylight savings into the future, then the list will normally\n     * be of size two and hold information about entering and exiting daylight savings.\n     * If the zone does not have daylight savings, or information about future changes\n     * is uncertain, then the list will be empty.\n     * <p>\n     * The list will be empty for fixed offset rules and for any time-zone where there is no\n     * daylight saving time. The list will also be empty if the transition rules are unknown.\n     *\n     * @return {ZoneOffsetTransitionRule[]} an immutable list of transition rules, not null\n     */\n    transitionRules(){\n        notSupported('ZoneRules.transitionRules');\n    }\n\n    /**\n     *\n     * @param other\n     * @returns {boolean}\n     */\n    equals(other) {\n        if (this === other) {\n            return true;\n        }\n        if (other instanceof MomentZoneRules) {\n            return this._tzdbInfo === other._tzdbInfo;\n        }\n        return false;\n    }\n\n    /**\n     *\n     * @returns {string}\n     */\n    toString() {\n        return this._tzdbInfo.name;\n    }\n}\n\nclass LDTUntils {\n    constructor(_tzdbUntils, tzdbOffsets) {\n        this._tzdbUntils = _tzdbUntils;\n        this._tzdbOffsets = tzdbOffsets;\n        this._ldtUntils = [];\n        this.size = this._tzdbUntils.length * 2;\n    }\n\n\n    _generateTupple(index) {\n        const epochMillis = this._tzdbUntils[index];\n        if (epochMillis === Infinity) {\n            return [LocalDateTime.MAX, LocalDateTime.MAX];\n        }\n        const instant = Instant.ofEpochMilli(epochMillis);\n\n        const offset1 = offsetInSeconds(this._tzdbOffsets[index]);\n        const zone1 = ZoneOffset.ofTotalSeconds(-offset1);\n        const ldt1 = LocalDateTime.ofInstant(instant, zone1);\n\n        const nextIndex = Math.min(index + 1, this._tzdbOffsets.length - 1);\n        const offset2 = offsetInSeconds(this._tzdbOffsets[nextIndex]);\n        const zone2 = ZoneOffset.ofTotalSeconds(-offset2);\n        const ldt2 = LocalDateTime.ofInstant(instant, zone2);\n\n        if(offset1 > offset2) {\n            return [ldt1, ldt2];\n        } else {\n            return [ldt2, ldt1];\n        }\n    }\n\n    _getTupple(index){\n        if (this._ldtUntils[index] == null) {\n            this._ldtUntils[index] = this._generateTupple(index);\n        }\n        return this._ldtUntils[index];\n    }\n\n    get(index) {\n        const ldtTupple = this._getTupple(index >> 1);\n        return ldtTupple[index % 2];\n    }\n}\n\n// modified bin-search, to always find existing indices for non-empty arrays\n// value in array at index is larger than input value (or last index of array)\nfunction ldtBinarySearch(array, value) {\n    let hi = array.size - 1, lo = -1, mid;\n    while (hi - lo > 1) {\n        if (!value.isBefore(array.get(mid = hi + lo >> 1))) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return hi;\n}\n\nfunction offsetInSeconds(tzdbOffset){\n    return roundDown(+tzdbOffset*60);\n}\n\nfunction roundDown(r){\n    if (r < 0) {\n        return Math.ceil(r);\n    } else {\n        return Math.floor(r);\n    }\n}\n\n// modified bin-search, to always find existing indices for non-empty arrays\n// value in array at index is larger than input value (or last index of array)\nfunction binarySearch(array, value) {\n    let hi = array.length - 1, lo = -1, mid;\n    while (hi - lo > 1) {\n        if (array[mid = hi + lo >> 1] <= value) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return hi;\n}\n\nfunction notSupported(msg){\n    throw new Error(`not supported: ${msg}`);\n}\n","/* eslint-disable no-var */\n\n//! moment-timezone.js\n//! version : 0.5.2\n//! author : Tim Wood\n//! license : MIT\n//! github.com/moment/moment-timezone\n\n/************************************\n Unpacking\n ************************************/\n\n/**\n * @private\n *\n * @param charCode\n * @returns {number}\n */\nfunction charCodeToInt(charCode) {\n    if (charCode > 96) {\n        return charCode - 87;\n    } else if (charCode > 64) {\n        return charCode - 29;\n    }\n    return charCode - 48;\n}\n\nfunction unpackBase60(string) {\n    var i = 0,\n        parts = string.split('.'),\n        whole = parts[0],\n        fractional = parts[1] || '',\n        multiplier = 1,\n        num,\n        out = 0,\n        sign = 1;\n\n    // handle negative numbers\n    if (string.charCodeAt(0) === 45) {\n        i = 1;\n        sign = -1;\n    }\n\n    // handle digits before the decimal\n    for (i; i < whole.length; i++) {\n        num = charCodeToInt(whole.charCodeAt(i));\n        out = 60 * out + num;\n    }\n\n    // handle digits after the decimal\n    for (i = 0; i < fractional.length; i++) {\n        multiplier = multiplier / 60;\n        num = charCodeToInt(fractional.charCodeAt(i));\n        out += num * multiplier;\n    }\n\n    return out * sign;\n}\n\nfunction arrayToInt (array) {\n    for (var i = 0; i < array.length; i++) {\n        array[i] = unpackBase60(array[i]);\n    }\n}\n\nfunction intToUntil (array, length) {\n    for (var i = 0; i < length; i++) {\n        array[i] = Math.round((array[i - 1] || 0) + (array[i] * 60000)); // minutes to milliseconds\n    }\n\n    array[length - 1] = Infinity;\n}\n\nfunction mapIndices (source, indices) {\n    var out = [], i;\n\n    for (i = 0; i < indices.length; i++) {\n        out[i] = source[indices[i]];\n    }\n\n    return out;\n}\n\n/**\n * @private\n *\n * @param string\n * @returns {{offsets: *[], abbrs: *[], name, untils: *, population: number}}\n */\nexport function unpack (string) {\n    var data = string.split('|'),\n        offsets = data[2].split(' '),\n        indices = data[3].split(''),\n        untils  = data[4].split(' ');\n\n    arrayToInt(offsets);\n    arrayToInt(indices);\n    arrayToInt(untils);\n\n    intToUntil(untils, indices.length);\n\n    return {\n        name       : data[0],\n        abbrs      : mapIndices(data[1].split(' '), indices),\n        offsets    : mapIndices(offsets, indices),\n        untils     : untils,\n        population : data[5] | 0\n    };\n}\n\n","/*\n * @copyright (c) 2016-present, 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 {\n    DateTimeException,\n    ZoneRulesProvider,\n} from '@js-joda/core';\n\nimport { MomentZoneRules } from './MomentZoneRules';\n\nimport { unpack } from './unpack';\n\nlet TZDB_DATA;\nlet TZDB_VERSION;\nconst AVAILABLE_ZONE_IDS = [];\n\nconst zones = {};\nconst links = {};\n\nexport class MomentZoneRulesProvider extends ZoneRulesProvider {\n    /**\n     * Gets the rules for the zone ID.\n     * <p>\n     * This returns the latest available rules for the zone ID.\n     * <p>\n     * This method relies on time-zone data provider files that are configured.\n     *\n     * @param {string} zoneId\n     * @return {ZoneRules}\n     */\n    static getRules(zoneId){\n        const tzdbZoneInfo = zones[links[zoneId]];\n        if(tzdbZoneInfo == null){\n            throw new DateTimeException(`Unknown time-zone ID: ${zoneId}`);\n        }\n        return new MomentZoneRules(tzdbZoneInfo);\n    }\n\n\n    /**\n     * Gets the set of available zone IDs.\n     * <p>\n     * These zone IDs are loaded and available for use by {@code ZoneId}.\n     *\n     * @return {string[]} a modifiable copy of the set of zone IDs, not null\n     */\n    static getAvailableZoneIds(){\n        return AVAILABLE_ZONE_IDS;\n    }\n\n    /**\n     *\n     * @return {string} the tzdb version.\n     */\n    static getVersion() {\n        return TZDB_VERSION;\n    }\n\n    /**\n     * Provides the packed tzdb data,\n     * the data has the same format as provided from moment-timezone.\n     *\n     * @return {object} the packed tzdb data.\n     */\n    static getTzdbData(){\n        return TZDB_DATA;\n    }\n\n    /**\n     * Sets the packed tzdb data.\n     * Accepts tzdb data in the same format as provided from moment-timezone.\n     *\n     * @param packedJson\n     */\n    static loadTzdbData(packedJson){\n        TZDB_DATA = packedJson;\n        TZDB_VERSION = packedJson.version;\n\n        for (const packedZoneInfo of packedJson.zones) {\n            const tzdbZoneInfo = unpack(packedZoneInfo);\n            AVAILABLE_ZONE_IDS.push(tzdbZoneInfo.name);\n            zones[tzdbZoneInfo.name] = tzdbZoneInfo;\n            links[tzdbZoneInfo.name] = tzdbZoneInfo.name;\n        }\n\n        for (const packedLink of packedJson.links) {\n            const link = packedLink.split('|');\n            AVAILABLE_ZONE_IDS.push(link[1]);\n            links[link[1]] = link[0];\n        }\n    }\n}\n","/**\n * @private\n *\n * @param ZoneId\n * @returns {null|*}\n */\nfunction getResolvedZoneId(ZoneId) {\n    try {\n        const resolvedTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;\n        return ZoneId.of(resolvedTimeZone);\n    } catch (err) {\n        // ignore\n    }\n    return null;\n}\n\n/**\n * @private\n *\n * @param ZoneId\n */\nexport default function extendSystemDefaultZoneId(ZoneId) {\n    const resolvedZoneId = getResolvedZoneId(ZoneId);\n\n    if (resolvedZoneId == null) {\n        return;\n    }\n\n    ZoneId.systemDefault = function () {\n        return resolvedZoneId;\n    };\n}\n","/*\n * @copyright (c) 2016-present, 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 { MomentZoneRulesProvider } from './MomentZoneRulesProvider';\nimport extendSystemDefaultZoneId from './system-default-zone';\n\n/**\n * @private\n */\nexport default function (jsJoda) {\n    jsJoda.ZoneRulesProvider.getRules = MomentZoneRulesProvider.getRules;\n    jsJoda.ZoneRulesProvider.getAvailableZoneIds = MomentZoneRulesProvider.getAvailableZoneIds;\n    jsJoda.ZoneRulesProvider.getTzdbData = MomentZoneRulesProvider.getTzdbData;\n    jsJoda.ZoneRulesProvider.loadTzdbData = MomentZoneRulesProvider.loadTzdbData;\n\n    extendSystemDefaultZoneId(jsJoda.ZoneId);\n    return jsJoda;\n}\n","/*\n * @copyright (c) 2016-present, 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 { use } from '@js-joda/core';\n\nimport plug from './plug';\n\n/**\n * @private\n */\nexport default function autoPlug() {\n    use(plug);\n}\n\n","/*\n * @copyright (c) 2016-present, 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 latest from './tzdbData';\n\nimport { MomentZoneRulesProvider } from './MomentZoneRulesProvider';\nimport autoPlug from './auto-plug';\n\nMomentZoneRulesProvider.loadTzdbData(latest);\n\nautoPlug();\n"],"names":["MomentZoneRules","tzdbInfo","_tzdbInfo","_ldtUntils","LDTUntils","untils","offsets","isFixedOffset","length","offsetOfInstant","instant","epochMilli","toEpochMilli","offsetOfEpochMilli","index","binarySearch","ZoneOffset","ofTotalSeconds","_offsetByIndexInSeconds","offsetOfLocalDateTime","localDateTime","info","_offsetInfo","ZoneOffsetTransition","offsetBefore","ldtBinarySearch","offsetIndex","ldtBefore","get","Math","max","ldtAfter","min","size","offsetAfter","compareTo","of","offsetInSeconds","validOffsets","transition","standardOffset","notSupported","daylightSavings","isDaylightSavings","isValidOffset","offset","some","o","equals","nextTransition","previousTransition","transitions","transitionRules","other","toString","name","ZoneRules","_tzdbUntils","tzdbOffsets","_tzdbOffsets","_generateTupple","epochMillis","Infinity","LocalDateTime","MAX","Instant","ofEpochMilli","offset1","zone1","ldt1","ofInstant","nextIndex","offset2","zone2","ldt2","_getTupple","ldtTupple","array","value","hi","lo","mid","isBefore","tzdbOffset","roundDown","r","ceil","floor","msg","Error","charCodeToInt","charCode","unpackBase60","string","i","parts","split","whole","fractional","multiplier","num","out","sign","charCodeAt","arrayToInt","intToUntil","round","mapIndices","source","indices","unpack","data","abbrs","population","TZDB_DATA","TZDB_VERSION","AVAILABLE_ZONE_IDS","zones","links","MomentZoneRulesProvider","getRules","zoneId","tzdbZoneInfo","DateTimeException","getAvailableZoneIds","getVersion","getTzdbData","loadTzdbData","packedJson","version","packedZoneInfo","push","packedLink","link","ZoneRulesProvider","getResolvedZoneId","ZoneId","resolvedTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","err","extendSystemDefaultZoneId","resolvedZoneId","systemDefault","jsJoda","autoPlug","use","plug","latest"],"mappings":"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"}