@js-joda/timezone 2.15.0 → 2.15.1

package/dist/js-joda-timezone-2012-2022.js

@@ -1,4 +1,4 @@
-//! @version @js-joda/timezone - 2.15.0-2022e-2012-2022
+//! @version @js-joda/timezone - 2.15.1-2022e-2012-2022
 //! @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)
@@ -868,19 +868,15 @@
 	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);
@@ -889,19 +885,14 @@
 	  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;
@@ -915,147 +906,110 @@
 	      };
 	    };
 	  }
-
 	  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 core.ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(index));
 	  };
-
 	  _proto.offsetOfLocalDateTime = function offsetOfLocalDateTime(localDateTime) {
 	    var info = this._offsetInfo(localDateTime);
-
 	    if (info instanceof core.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 = core.ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(offsetIndex));
 	      var offsetAfter = core.ZoneOffset.ofTotalSeconds(this._offsetByIndexInSeconds(Math.min(offsetIndex + 1, this._tzdbInfo.offsets.length - 1)));
-
 	      if (offsetBefore.compareTo(offsetAfter) > 0) {
 	        return core.ZoneOffsetTransition.of(ldtBefore, offsetBefore, offsetAfter);
 	      } else {
 	        return core.ZoneOffsetTransition.of(ldtAfter, offsetBefore, offsetAfter);
 	      }
 	    }
-
 	    return core.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 core.ZoneOffsetTransition) {
 	      return info.validOffsets();
 	    }
-
 	    return [info];
 	  };
-
 	  _proto.transition = function transition(localDateTime) {
 	    var info = this._offsetInfo(localDateTime);
-
 	    if (info instanceof core.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;
 	}(core.ZoneRules);
-
 	var LDTUntils = function () {
 	  function LDTUntils(_tzdbUntils, tzdbOffsets) {
 	    this._tzdbUntils = _tzdbUntils;
@@ -1063,16 +1017,12 @@
 	    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 [core.LocalDateTime.MAX, core.LocalDateTime.MAX];
 	    }
-
 	    var instant = core.Instant.ofEpochMilli(epochMillis);
 	    var offset1 = offsetInSeconds(this._tzdbOffsets[index]);
 	    var zone1 = core.ZoneOffset.ofTotalSeconds(-offset1);
@@ -1081,36 +1031,28 @@
 	    var offset2 = offsetInSeconds(this._tzdbOffsets[nextIndex]);
 	    var zone2 = core.ZoneOffset.ofTotalSeconds(-offset2);
 	    var ldt2 = core.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;
@@ -1118,14 +1060,11 @@
 	      hi = mid;
 	    }
 	  }
-
 	  return hi;
 	}
-
 	function offsetInSeconds(tzdbOffset) {
 	  return roundDown(+tzdbOffset * 60);
 	}
-
 	function roundDown(r) {
 	  if (r < 0) {
 	    return Math.ceil(r);
@@ -1133,12 +1072,10 @@
 	    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;
@@ -1146,10 +1083,8 @@
 	      hi = mid;
 	    }
 	  }
-
 	  return hi;
 	}
-
 	function notSupported(msg) {
 	  throw new Error("not supported: " + msg);
 	}
@@ -1160,69 +1095,56 @@
 	  } 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);
@@ -1243,37 +1165,28 @@
 	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 core.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);
@@ -1281,7 +1194,6 @@
 	      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('|');
@@ -1289,7 +1201,6 @@
 	      links[link[1]] = link[0];
 	    }
 	  };
-
 	  return MomentZoneRulesProvider;
 	}(core.ZoneRulesProvider);
 
@@ -1298,17 +1209,13 @@
 	    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-2012-2022.js.map

@@ -1 +1 @@
-{"version":3,"file":"js-joda-timezone-2012-2022.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-2012-2022.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUA,IAAaA,eAAe,GAAA,UAAA,UAAA,EAAA;CAAA,EAAA,cAAA,CAAA,eAAA,EAAA,UAAA,CAAA,CAAA;CACxB,EAAA,SAAA,eAAA,CAAYC,QAAQ,EAAC;CAAA,IAAA,IAAA,KAAA,CAAA;KACjB,KAAO,GAAA,UAAA,CAAA,IAAA,CAAA,IAAA,CAAA,IAAA,IAAA,CAAA;KACP,KAAKC,CAAAA,SAAS,GAAGD,QAAQ,CAAA;CACzB,IAAA,KAAA,CAAKE,UAAU,GAAG,IAAIC,SAAS,CAAC,KAAKF,CAAAA,SAAS,CAACG,MAAM,EAAE,KAAA,CAAKH,SAAS,CAACI,OAAO,CAAC,CAAA;CAAC,IAAA,OAAA,KAAA,CAAA;CACnF,GAAA;CAAC,EAAA,IAAA,MAAA,GAAA,eAAA,CAAA,SAAA,CAAA;GAAA,MAMDC,CAAAA,aAAa,GAAb,SAAe,aAAA,GAAA;KACX,OAAO,IAAI,CAACL,SAAS,CAACI,OAAO,CAACE,MAAM,KAAK,CAAC,CAAA;IAC7C,CAAA;CAAA,EAAA,MAAA,CAeDC,eAAe,GAAf,SAAgBC,eAAAA,CAAAA,OAAO,EAAC;CACpB,IAAA,IAAMC,UAAU,GAAGD,OAAO,CAACE,YAAY,EAAE,CAAA;CACzC,IAAA,OAAO,IAAI,CAACC,kBAAkB,CAACF,UAAU,CAAC,CAAA;IAC7C,CAAA;CAAA,EAAA,MAAA,CAWDE,kBAAkB,GAAlB,SAAmBF,kBAAAA,CAAAA,UAAU,EAAC;KAC1B,IAAMG,KAAK,GAAIC,YAAY,CAAC,IAAI,CAACb,SAAS,CAACG,MAAM,EAAEM,UAAU,CAAC,CAAA;KAC9D,OAAOK,eAAU,CAACC,cAAc,CAAC,IAAI,CAACC,uBAAuB,CAACJ,KAAK,CAAC,CAAC,CAAA;IACxE,CAAA;CAAA,EAAA,MAAA,CA+BDK,qBAAqB,GAArB,SAAsBC,qBAAAA,CAAAA,aAAa,EAAC;CAChC,IAAA,IAAMC,IAAI,GAAG,IAAI,CAACC,WAAW,CAACF,aAAa,CAAC,CAAA;KAC5C,IAAIC,IAAI,YAAYE,yBAAoB,EAAE;OACtC,OAAOF,IAAI,CAACG,YAAY,EAAE,CAAA;CAC9B,KAAA;CACA,IAAA,OAAOH,IAAI,CAAA;IACd,CAAA;CAAA,EAAA,MAAA,CAEDC,WAAW,GAAX,SAAYF,WAAAA,CAAAA,aAAa,EAAE;KACvB,IAAMN,KAAK,GAAIW,eAAe,CAAC,IAAI,CAACtB,UAAU,EAAEiB,aAAa,CAAC,CAAA;CAC9D,IAAA,IAAMM,WAAW,GAAGZ,KAAK,IAAI,CAAC,CAAA;CAE9B,IAAA,IAAIA,KAAK,GAAG,CAAC,KAAK,CAAC,EAAC;CAChB,MAAA,IAAMa,SAAS,GAAG,IAAI,CAACxB,UAAU,CAACyB,GAAG,CAACC,IAAI,CAACC,GAAG,CAAChB,KAAK,GAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;OAC3D,IAAMiB,QAAQ,GAAG,IAAI,CAAC5B,UAAU,CAACyB,GAAG,CAACC,IAAI,CAACG,GAAG,CAAClB,KAAK,EAAE,IAAI,CAACX,UAAU,CAAC8B,IAAI,GAAC,CAAC,CAAC,CAAC,CAAA;CAC7E,MAAA,IAAMT,YAAY,GAAGR,eAAU,CAACC,cAAc,CAAC,IAAI,CAACC,uBAAuB,CAACQ,WAAW,CAAC,CAAC,CAAA;CACzF,MAAA,IAAMQ,WAAW,GAAGlB,eAAU,CAACC,cAAc,CAAC,IAAI,CAACC,uBAAuB,CAACW,IAAI,CAACG,GAAG,CAACN,WAAW,GAAC,CAAC,EAAE,IAAI,CAACxB,SAAS,CAACI,OAAO,CAACE,MAAM,GAAC,CAAC,CAAC,CAAC,CAAC,CAAA;OAErI,IAAIgB,YAAY,CAACW,SAAS,CAACD,WAAW,CAAC,GAAG,CAAC,EAAE;SAGzC,OAAOX,yBAAoB,CAACa,EAAE,CAACT,SAAS,EAAEH,YAAY,EAAEU,WAAW,CAAC,CAAA;CACxE,OAAC,MAAM;SAGH,OAAOX,yBAAoB,CAACa,EAAE,CAACL,QAAQ,EAAEP,YAAY,EAAEU,WAAW,CAAC,CAAA;CACvE,OAAA;CACJ,KAAA;KACA,OAAOlB,eAAU,CAACC,cAAc,CAAC,IAAI,CAACC,uBAAuB,CAACQ,WAAW,CAAC,CAAC,CAAA;IAC9E,CAAA;CAAA,EAAA,MAAA,CAEDR,uBAAuB,GAAvB,SAAwBJ,uBAAAA,CAAAA,KAAK,EAAC;KAC1B,OAAO,CAACuB,eAAe,CAAC,IAAI,CAACnC,SAAS,CAACI,OAAO,CAACQ,KAAK,CAAC,CAAC,CAAA;IACzD,CAAA;CAAA,EAAA,MAAA,CA4CDwB,YAAY,GAAZ,SAAalB,YAAAA,CAAAA,aAAa,EAAC;CACvB,IAAA,IAAMC,IAAI,GAAG,IAAI,CAACC,WAAW,CAACF,aAAa,CAAC,CAAA;KAC5C,IAAIC,IAAI,YAAYE,yBAAoB,EAAE;OACtC,OAAOF,IAAI,CAACiB,YAAY,EAAE,CAAA;CAC9B,KAAA;KACA,OAAO,CAACjB,IAAI,CAAC,CAAA;IAChB,CAAA;CAAA,EAAA,MAAA,CAqCDkB,UAAU,GAAV,SAAWnB,UAAAA,CAAAA,aAAa,EAAC;CACrB,IAAA,IAAMC,IAAI,GAAG,IAAI,CAACC,WAAW,CAACF,aAAa,CAAC,CAAA;KAC5C,IAAIC,IAAI,YAAYE,yBAAoB,EAAE;CACtC,MAAA,OAAOF,IAAI,CAAA;CACf,KAAA;CACA,IAAA,OAAO,IAAI,CAAA;IACd,CAAA;CAAA,EAAA,MAAA,CAgBDmB,cAAc,GAAd,SAAe9B,cAAAA,CAAAA,OAAO,EAAC;KACnB+B,YAAY,CAAC,0BAA0B,CAAC,CAAA;IAC3C,CAAA;CAAA,EAAA,MAAA,CAgBDC,eAAe,GAAf,SAAgBhC,eAAAA,CAAAA,OAAO,EAAC;KACpB+B,YAAY,CAAC,2BAA2B,CAAC,CAAA;IAC5C,CAAA;CAAA,EAAA,MAAA,CAYDE,iBAAiB,GAAjB,SAAkBjC,iBAAAA,CAAAA,OAAO,EAAE;KACvB+B,YAAY,CAAC,6BAA6B,CAAC,CAAA;IAC9C,CAAA;CAAA,EAAA,MAAA,CAaDG,aAAa,GAAb,SAAA,aAAA,CAAcxB,aAAa,EAAEyB,MAAM,EAAC;KAChC,OAAO,IAAI,CAACP,YAAY,CAAClB,aAAa,CAAC,CAAC0B,IAAI,CAAE,UAAAC,CAAC,EAAA;CAAA,MAAA,OAAIA,CAAC,CAACC,MAAM,CAACH,MAAM,CAAC,CAAA;MAAC,CAAA,CAAA;IACvE,CAAA;CAAA,EAAA,MAAA,CAeDI,cAAc,GAAd,SAAevC,cAAAA,CAAAA,OAAO,EAAC;KACnB+B,YAAY,CAAC,0BAA0B,CAAC,CAAA;IAC3C,CAAA;CAAA,EAAA,MAAA,CAcDS,kBAAkB,GAAlB,SAAmBxC,kBAAAA,CAAAA,OAAO,EAAC;KACvB+B,YAAY,CAAC,8BAA8B,CAAC,CAAA;IAC/C,CAAA;GAAA,MAcDU,CAAAA,WAAW,GAAX,SAAa,WAAA,GAAA;KACTV,YAAY,CAAC,uBAAuB,CAAC,CAAA;IACxC,CAAA;GAAA,MAuBDW,CAAAA,eAAe,GAAf,SAAiB,eAAA,GAAA;KACbX,YAAY,CAAC,2BAA2B,CAAC,CAAA;IAC5C,CAAA;CAAA,EAAA,MAAA,CAODO,MAAM,GAAN,SAAOK,MAAAA,CAAAA,KAAK,EAAE;KACV,IAAI,IAAI,KAAKA,KAAK,EAAE;CAChB,MAAA,OAAO,IAAI,CAAA;CACf,KAAA;KACA,IAAIA,KAAK,YAAYrD,eAAe,EAAE;CAClC,MAAA,OAAO,IAAI,CAACE,SAAS,KAAKmD,KAAK,CAACnD,SAAS,CAAA;CAC7C,KAAA;CACA,IAAA,OAAO,KAAK,CAAA;IACf,CAAA;GAAA,MAMDoD,CAAAA,QAAQ,GAAR,SAAW,QAAA,GAAA;CACP,IAAA,OAAO,IAAI,CAACpD,SAAS,CAACqD,IAAI,CAAA;IAC7B,CAAA;CAAA,EAAA,OAAA,eAAA,CAAA;CAAA,CAAA,CA5WgCC,cAAS,CAAA,CAAA;CA6W7C,IAEKpD,SAAS,GAAA,YAAA;GACX,SAAYqD,SAAAA,CAAAA,WAAW,EAAEC,WAAW,EAAE;KAClC,IAAI,CAACD,WAAW,GAAGA,WAAW,CAAA;KAC9B,IAAI,CAACE,YAAY,GAAGD,WAAW,CAAA;KAC/B,IAAI,CAACvD,UAAU,GAAG,EAAE,CAAA;KACpB,IAAI,CAAC8B,IAAI,GAAG,IAAI,CAACwB,WAAW,CAACjD,MAAM,GAAG,CAAC,CAAA;CAC3C,GAAA;CAAC,EAAA,IAAA,OAAA,GAAA,SAAA,CAAA,SAAA,CAAA;CAAA,EAAA,OAAA,CAGDoD,eAAe,GAAf,SAAgB9C,eAAAA,CAAAA,KAAK,EAAE;CACnB,IAAA,IAAM+C,WAAW,GAAG,IAAI,CAACJ,WAAW,CAAC3C,KAAK,CAAC,CAAA;KAC3C,IAAI+C,WAAW,KAAKC,QAAQ,EAAE;OAC1B,OAAO,CAACC,kBAAa,CAACC,GAAG,EAAED,kBAAa,CAACC,GAAG,CAAC,CAAA;CACjD,KAAA;CACA,IAAA,IAAMtD,OAAO,GAAGuD,YAAO,CAACC,YAAY,CAACL,WAAW,CAAC,CAAA;KAEjD,IAAMM,OAAO,GAAG9B,eAAe,CAAC,IAAI,CAACsB,YAAY,CAAC7C,KAAK,CAAC,CAAC,CAAA;KACzD,IAAMsD,KAAK,GAAGpD,eAAU,CAACC,cAAc,CAAC,CAACkD,OAAO,CAAC,CAAA;KACjD,IAAME,IAAI,GAAGN,kBAAa,CAACO,SAAS,CAAC5D,OAAO,EAAE0D,KAAK,CAAC,CAAA;CAEpD,IAAA,IAAMG,SAAS,GAAG1C,IAAI,CAACG,GAAG,CAAClB,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC6C,YAAY,CAACnD,MAAM,GAAG,CAAC,CAAC,CAAA;KACnE,IAAMgE,OAAO,GAAGnC,eAAe,CAAC,IAAI,CAACsB,YAAY,CAACY,SAAS,CAAC,CAAC,CAAA;KAC7D,IAAME,KAAK,GAAGzD,eAAU,CAACC,cAAc,CAAC,CAACuD,OAAO,CAAC,CAAA;KACjD,IAAME,IAAI,GAAGX,kBAAa,CAACO,SAAS,CAAC5D,OAAO,EAAE+D,KAAK,CAAC,CAAA;KAEpD,IAAGN,OAAO,GAAGK,OAAO,EAAE;CAClB,MAAA,OAAO,CAACH,IAAI,EAAEK,IAAI,CAAC,CAAA;CACvB,KAAC,MAAM;CACH,MAAA,OAAO,CAACA,IAAI,EAAEL,IAAI,CAAC,CAAA;CACvB,KAAA;IACH,CAAA;CAAA,EAAA,OAAA,CAEDM,UAAU,GAAV,SAAW7D,UAAAA,CAAAA,KAAK,EAAC;KACb,IAAI,IAAI,CAACX,UAAU,CAACW,KAAK,CAAC,IAAI,IAAI,EAAE;OAChC,IAAI,CAACX,UAAU,CAACW,KAAK,CAAC,GAAG,IAAI,CAAC8C,eAAe,CAAC9C,KAAK,CAAC,CAAA;CACxD,KAAA;CACA,IAAA,OAAO,IAAI,CAACX,UAAU,CAACW,KAAK,CAAC,CAAA;IAChC,CAAA;CAAA,EAAA,OAAA,CAEDc,GAAG,GAAH,SAAId,GAAAA,CAAAA,KAAK,EAAE;KACP,IAAM8D,SAAS,GAAG,IAAI,CAACD,UAAU,CAAC7D,KAAK,IAAI,CAAC,CAAC,CAAA;CAC7C,IAAA,OAAO8D,SAAS,CAAC9D,KAAK,GAAG,CAAC,CAAC,CAAA;IAC9B,CAAA;CAAA,EAAA,OAAA,SAAA,CAAA;CAAA,CAAA,EAAA,CAAA;CAKL,SAASW,eAAe,CAACoD,KAAK,EAAEC,KAAK,EAAE;CACnC,EAAA,IAAIC,EAAE,GAAGF,KAAK,CAAC5C,IAAI,GAAG,CAAC;KAAE+C,EAAE,GAAG,CAAC,CAAC;KAAEC,GAAG,CAAA;CACrC,EAAA,OAAOF,EAAE,GAAGC,EAAE,GAAG,CAAC,EAAE;CAChB,IAAA,IAAI,CAACF,KAAK,CAACI,QAAQ,CAACL,KAAK,CAACjD,GAAG,CAACqD,GAAG,GAAGF,EAAE,GAAGC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE;CAChDA,MAAAA,EAAE,GAAGC,GAAG,CAAA;CACZ,KAAC,MAAM;CACHF,MAAAA,EAAE,GAAGE,GAAG,CAAA;CACZ,KAAA;CACJ,GAAA;CACA,EAAA,OAAOF,EAAE,CAAA;CACb,CAAA;CAEA,SAAS1C,eAAe,CAAC8C,UAAU,EAAC;CAChC,EAAA,OAAOC,SAAS,CAAC,CAACD,UAAU,GAAC,EAAE,CAAC,CAAA;CACpC,CAAA;CAEA,SAASC,SAAS,CAACC,CAAC,EAAC;GACjB,IAAIA,CAAC,GAAG,CAAC,EAAE;CACP,IAAA,OAAOxD,IAAI,CAACyD,IAAI,CAACD,CAAC,CAAC,CAAA;CACvB,GAAC,MAAM;CACH,IAAA,OAAOxD,IAAI,CAAC0D,KAAK,CAACF,CAAC,CAAC,CAAA;CACxB,GAAA;CACJ,CAAA;CAIA,SAAStE,YAAY,CAAC8D,KAAK,EAAEC,KAAK,EAAE;CAChC,EAAA,IAAIC,EAAE,GAAGF,KAAK,CAACrE,MAAM,GAAG,CAAC;KAAEwE,EAAE,GAAG,CAAC,CAAC;KAAEC,GAAG,CAAA;CACvC,EAAA,OAAOF,EAAE,GAAGC,EAAE,GAAG,CAAC,EAAE;CAChB,IAAA,IAAIH,KAAK,CAACI,GAAG,GAAGF,EAAE,GAAGC,EAAE,IAAI,CAAC,CAAC,IAAIF,KAAK,EAAE;CACpCE,MAAAA,EAAE,GAAGC,GAAG,CAAA;CACZ,KAAC,MAAM;CACHF,MAAAA,EAAE,GAAGE,GAAG,CAAA;CACZ,KAAA;CACJ,GAAA;CACA,EAAA,OAAOF,EAAE,CAAA;CACb,CAAA;CAEA,SAAStC,YAAY,CAAC+C,GAAG,EAAC;CACtB,EAAA,MAAM,IAAIC,KAAK,CAAmBD,iBAAAA,GAAAA,GAAG,CAAG,CAAA;CAC5C;;CC9bA,SAASE,aAAa,CAACC,QAAQ,EAAE;GAC7B,IAAIA,QAAQ,GAAG,EAAE,EAAE;KACf,OAAOA,QAAQ,GAAG,EAAE,CAAA;CACxB,GAAC,MAAM,IAAIA,QAAQ,GAAG,EAAE,EAAE;KACtB,OAAOA,QAAQ,GAAG,EAAE,CAAA;CACxB,GAAA;GACA,OAAOA,QAAQ,GAAG,EAAE,CAAA;CACxB,CAAA;CAEA,SAASC,YAAY,CAACC,MAAM,EAAE;GAC1B,IAAIC,CAAC,GAAG,CAAC;CACLC,IAAAA,KAAK,GAAGF,MAAM,CAACG,KAAK,CAAC,GAAG,CAAC;CACzBC,IAAAA,KAAK,GAAGF,KAAK,CAAC,CAAC,CAAC;CAChBG,IAAAA,UAAU,GAAGH,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;CAC3BI,IAAAA,UAAU,GAAG,CAAC;KACdC,GAAG;CACHC,IAAAA,GAAG,GAAG,CAAC;CACPC,IAAAA,IAAI,GAAG,CAAC,CAAA;GAGZ,IAAIT,MAAM,CAACU,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE;CAC7BT,IAAAA,CAAC,GAAG,CAAC,CAAA;KACLQ,IAAI,GAAG,CAAC,CAAC,CAAA;CACb,GAAA;GAGA,KAAKR,CAAC,EAAEA,CAAC,GAAGG,KAAK,CAACzF,MAAM,EAAEsF,CAAC,EAAE,EAAE;KAC3BM,GAAG,GAAGV,aAAa,CAACO,KAAK,CAACM,UAAU,CAACT,CAAC,CAAC,CAAC,CAAA;CACxCO,IAAAA,GAAG,GAAG,EAAE,GAAGA,GAAG,GAAGD,GAAG,CAAA;CACxB,GAAA;CAGA,EAAA,KAAKN,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,CAAC1F,MAAM,EAAEsF,CAAC,EAAE,EAAE;KACpCK,UAAU,GAAGA,UAAU,GAAG,EAAE,CAAA;KAC5BC,GAAG,GAAGV,aAAa,CAACQ,UAAU,CAACK,UAAU,CAACT,CAAC,CAAC,CAAC,CAAA;KAC7CO,GAAG,IAAID,GAAG,GAAGD,UAAU,CAAA;CAC3B,GAAA;GAEA,OAAOE,GAAG,GAAGC,IAAI,CAAA;CACrB,CAAA;CAEA,SAASE,UAAU,CAAE3B,KAAK,EAAE;CACxB,EAAA,KAAK,IAAIiB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGjB,KAAK,CAACrE,MAAM,EAAEsF,CAAC,EAAE,EAAE;KACnCjB,KAAK,CAACiB,CAAC,CAAC,GAAGF,YAAY,CAACf,KAAK,CAACiB,CAAC,CAAC,CAAC,CAAA;CACrC,GAAA;CACJ,CAAA;CAEA,SAASW,UAAU,CAAE5B,KAAK,EAAErE,MAAM,EAAE;GAChC,KAAK,IAAIsF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGtF,MAAM,EAAEsF,CAAC,EAAE,EAAE;KAC7BjB,KAAK,CAACiB,CAAC,CAAC,GAAGjE,IAAI,CAAC6E,KAAK,CAAC,CAAC7B,KAAK,CAACiB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAKjB,KAAK,CAACiB,CAAC,CAAC,GAAG,KAAM,CAAC,CAAA;CACnE,GAAA;CAEAjB,EAAAA,KAAK,CAACrE,MAAM,GAAG,CAAC,CAAC,GAAGsD,QAAQ,CAAA;CAChC,CAAA;CAEA,SAAS6C,UAAU,CAAEC,MAAM,EAAEC,OAAO,EAAE;GAClC,IAAIR,GAAG,GAAG,EAAE;KAAEP,CAAC,CAAA;CAEf,EAAA,KAAKA,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGe,OAAO,CAACrG,MAAM,EAAEsF,CAAC,EAAE,EAAE;KACjCO,GAAG,CAACP,CAAC,CAAC,GAAGc,MAAM,CAACC,OAAO,CAACf,CAAC,CAAC,CAAC,CAAA;CAC/B,GAAA;CAEA,EAAA,OAAOO,GAAG,CAAA;CACd,CAAA;CAQO,SAASS,MAAM,CAAEjB,MAAM,EAAE;CAC5B,EAAA,IAAIkB,IAAI,GAAGlB,MAAM,CAACG,KAAK,CAAC,GAAG,CAAC;KACxB1F,OAAO,GAAGyG,IAAI,CAAC,CAAC,CAAC,CAACf,KAAK,CAAC,GAAG,CAAC;KAC5Ba,OAAO,GAAGE,IAAI,CAAC,CAAC,CAAC,CAACf,KAAK,CAAC,EAAE,CAAC;KAC3B3F,MAAM,GAAI0G,IAAI,CAAC,CAAC,CAAC,CAACf,KAAK,CAAC,GAAG,CAAC,CAAA;GAEhCQ,UAAU,CAAClG,OAAO,CAAC,CAAA;GACnBkG,UAAU,CAACK,OAAO,CAAC,CAAA;GACnBL,UAAU,CAACnG,MAAM,CAAC,CAAA;CAElBoG,EAAAA,UAAU,CAACpG,MAAM,EAAEwG,OAAO,CAACrG,MAAM,CAAC,CAAA;GAElC,OAAO;CACH+C,IAAAA,IAAI,EAASwD,IAAI,CAAC,CAAC,CAAC;CACpBC,IAAAA,KAAK,EAAQL,UAAU,CAACI,IAAI,CAAC,CAAC,CAAC,CAACf,KAAK,CAAC,GAAG,CAAC,EAAEa,OAAO,CAAC;CACpDvG,IAAAA,OAAO,EAAMqG,UAAU,CAACrG,OAAO,EAAEuG,OAAO,CAAC;CACzCxG,IAAAA,MAAM,EAAOA,MAAM;CACnB4G,IAAAA,UAAU,EAAGF,IAAI,CAAC,CAAC,CAAC,GAAG,CAAA;IAC1B,CAAA;CACL;;CC7FA,IAAIG,SAAS,CAAA;CACb,IAAIC,YAAY,CAAA;CAChB,IAAMC,kBAAkB,GAAG,EAAE,CAAA;CAE7B,IAAMC,KAAK,GAAG,EAAE,CAAA;CAChB,IAAMC,KAAK,GAAG,EAAE,CAAA;CAEhB,IAAaC,uBAAuB,GAAA,UAAA,kBAAA,EAAA;CAAA,EAAA,cAAA,CAAA,uBAAA,EAAA,kBAAA,CAAA,CAAA;CAAA,EAAA,SAAA,uBAAA,GAAA;CAAA,IAAA,OAAA,kBAAA,CAAA,KAAA,CAAA,IAAA,EAAA,SAAA,CAAA,IAAA,IAAA,CAAA;CAAA,GAAA;CAAA,EAAA,uBAAA,CAWzBC,QAAQ,GAAf,SAAgBC,QAAAA,CAAAA,MAAM,EAAC;KACnB,IAAMC,YAAY,GAAGL,KAAK,CAACC,KAAK,CAACG,MAAM,CAAC,CAAC,CAAA;KACzC,IAAGC,YAAY,IAAI,IAAI,EAAC;CACpB,MAAA,MAAM,IAAIC,sBAAiB,CAA0BF,wBAAAA,GAAAA,MAAM,CAAG,CAAA;CAClE,KAAA;CACA,IAAA,OAAO,IAAIzH,eAAe,CAAC0H,YAAY,CAAC,CAAA;IAC3C,CAAA;GAAA,uBAUME,CAAAA,mBAAmB,GAA1B,SAA4B,mBAAA,GAAA;CACxB,IAAA,OAAOR,kBAAkB,CAAA;IAC5B,CAAA;GAAA,uBAMMS,CAAAA,UAAU,GAAjB,SAAoB,UAAA,GAAA;CAChB,IAAA,OAAOV,YAAY,CAAA;IACtB,CAAA;GAAA,uBAQMW,CAAAA,WAAW,GAAlB,SAAoB,WAAA,GAAA;CAChB,IAAA,OAAOZ,SAAS,CAAA;IACnB,CAAA;CAAA,EAAA,uBAAA,CAQMa,YAAY,GAAnB,SAAoBC,YAAAA,CAAAA,UAAU,EAAC;CAC3Bd,IAAAA,SAAS,GAAGc,UAAU,CAAA;KACtBb,YAAY,GAAGa,UAAU,CAACC,OAAO,CAAA;KAEjC,KAA6BD,IAAAA,SAAAA,GAAAA,+BAAAA,CAAAA,UAAU,CAACX,KAAK,CAAE,EAAA,KAAA,EAAA,CAAA,CAAA,KAAA,GAAA,SAAA,EAAA,EAAA,IAAA,GAAA;CAAA,MAAA,IAApCa,cAAc,GAAA,KAAA,CAAA,KAAA,CAAA;CACrB,MAAA,IAAMR,YAAY,GAAGZ,MAAM,CAACoB,cAAc,CAAC,CAAA;CAC3Cd,MAAAA,kBAAkB,CAACe,IAAI,CAACT,YAAY,CAACnE,IAAI,CAAC,CAAA;CAC1C8D,MAAAA,KAAK,CAACK,YAAY,CAACnE,IAAI,CAAC,GAAGmE,YAAY,CAAA;OACvCJ,KAAK,CAACI,YAAY,CAACnE,IAAI,CAAC,GAAGmE,YAAY,CAACnE,IAAI,CAAA;CAChD,KAAA;KAEA,KAAyByE,IAAAA,UAAAA,GAAAA,+BAAAA,CAAAA,UAAU,CAACV,KAAK,CAAE,EAAA,MAAA,EAAA,CAAA,CAAA,MAAA,GAAA,UAAA,EAAA,EAAA,IAAA,GAAA;CAAA,MAAA,IAAhCc,UAAU,GAAA,MAAA,CAAA,KAAA,CAAA;CACjB,MAAA,IAAMC,IAAI,GAAGD,UAAU,CAACpC,KAAK,CAAC,GAAG,CAAC,CAAA;CAClCoB,MAAAA,kBAAkB,CAACe,IAAI,CAACE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;OAChCf,KAAK,CAACe,IAAI,CAAC,CAAC,CAAC,CAAC,GAAGA,IAAI,CAAC,CAAC,CAAC,CAAA;CAC5B,KAAA;IACH,CAAA;CAAA,EAAA,OAAA,uBAAA,CAAA;CAAA,CAAA,CAvEwCC,sBAAiB,CAAA;;CChB9D,SAASC,iBAAiB,CAACC,MAAM,EAAE;GAC/B,IAAI;KACA,IAAMC,gBAAgB,GAAGC,IAAI,CAACC,cAAc,EAAE,CAACC,eAAe,EAAE,CAACC,QAAQ,CAAA;CACzE,IAAA,OAAOL,MAAM,CAACpG,EAAE,CAACqG,gBAAgB,CAAC,CAAA;CACtC,GAAC,CAAC,OAAOK,GAAG,EAAE,EAEd;CACA,EAAA,OAAO,IAAI,CAAA;CACf,CAAA;CAOe,SAASC,yBAAyB,CAACP,MAAM,EAAE;CACtD,EAAA,IAAMQ,cAAc,GAAGT,iBAAiB,CAACC,MAAM,CAAC,CAAA;GAEhD,IAAIQ,cAAc,IAAI,IAAI,EAAE;CACxB,IAAA,OAAA;CACJ,GAAA;GAEAR,MAAM,CAACS,aAAa,GAAG,YAAY;CAC/B,IAAA,OAAOD,cAAc,CAAA;IACxB,CAAA;CACL;;CC/BA;CACA;CACA;CACA;CAQe,aAAA,EAAUE,MAAM,EAAE;CAC7BA,EAAAA,MAAM,CAACZ,iBAAiB,CAACd,QAAQ,GAAGD,uBAAuB,CAACC,QAAQ,CAAA;CACpE0B,EAAAA,MAAM,CAACZ,iBAAiB,CAACV,mBAAmB,GAAGL,uBAAuB,CAACK,mBAAmB,CAAA;CAC1FsB,EAAAA,MAAM,CAACZ,iBAAiB,CAACR,WAAW,GAAGP,uBAAuB,CAACO,WAAW,CAAA;CAC1EoB,EAAAA,MAAM,CAACZ,iBAAiB,CAACP,YAAY,GAAGR,uBAAuB,CAACQ,YAAY,CAAA;CAE5EgB,EAAAA,yBAAyB,CAACG,MAAM,CAACV,MAAM,CAAC,CAAA;CACxC,EAAA,OAAOU,MAAM,CAAA;CACjB;;CCnBA;CACA;CACA;CACA;CASe,SAASC,QAAQ,GAAG;GAC/BC,QAAG,CAACC,IAAI,CAAC,CAAA;CACb;;CCdA;CACA;CACA;CACA;CAOA9B,uBAAuB,CAACQ,YAAY,CAACuB,MAAM,CAAC,CAAA;CAE5CH,QAAQ,EAAE;;;;;;"}