\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 *
\n * The mapping from a local date-time to an offset is not straightforward.\n * There are three cases:\n *
\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 *
\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 *
\n * The mapping from a local date-time to an offset is not straightforward.\n * There are three cases:\n *
\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 *
\n * There are various ways to handle the conversion from a {@code LocalDateTime}.\n * One technique, using this method, would be:\n *
\n * List\n *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 *
\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 *
\n * The mapping from a local date-time to an offset is not straightforward.\n * There are three cases:\n *
\n * A transition is used to model the cases of a Gap or Overlap.\n * The Normal case will return null.\n *
\n * There are various ways to handle the conversion from a {@code LocalDateTime}.\n * One technique, using this method, would be:\n *
\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 * \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 * \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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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 *
\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","/*\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 *
\n * This returns the latest available rules for the zone ID.\n *
\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 *
\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 * @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\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","/*\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\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","\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\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}","import latest from '../data/packed/latest.json';\n\nexport default latest;\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\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\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","module.exports = __WEBPACK_EXTERNAL_MODULE__js_joda_core__;"],"sourceRoot":""}