{"version":3,"file":"npm.luxon-2d721503-d20292454097dc30222a.chunk.js","mappings":"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","sources":["webpack://netopia-payments/./node_modules/luxon/src/zones/IANAZone.js","webpack://netopia-payments/./node_modules/luxon/src/info.js","webpack://netopia-payments/./node_modules/luxon/src/settings.js","webpack://netopia-payments/./node_modules/luxon/src/zones/invalidZone.js","webpack://netopia-payments/./node_modules/luxon/src/zones/systemZone.js","webpack://netopia-payments/./node_modules/luxon/src/interval.js","webpack://netopia-payments/./node_modules/luxon/src/zone.js","webpack://netopia-payments/./node_modules/luxon/src/zones/fixedOffsetZone.js"],"sourcesContent":["import { formatOffset, parseZoneInfo, isUndefined, objToLocalTS } from \"../impl/util.js\";\nimport Zone from \"../zone.js\";\n\nconst dtfCache = new Map();\nfunction makeDTF(zoneName) {\n  let dtf = dtfCache.get(zoneName);\n  if (dtf === undefined) {\n    dtf = new Intl.DateTimeFormat(\"en-US\", {\n      hour12: false,\n      timeZone: zoneName,\n      year: \"numeric\",\n      month: \"2-digit\",\n      day: \"2-digit\",\n      hour: \"2-digit\",\n      minute: \"2-digit\",\n      second: \"2-digit\",\n      era: \"short\",\n    });\n    dtfCache.set(zoneName, dtf);\n  }\n  return dtf;\n}\n\nconst typeToPos = {\n  year: 0,\n  month: 1,\n  day: 2,\n  era: 3,\n  hour: 4,\n  minute: 5,\n  second: 6,\n};\n\nfunction hackyOffset(dtf, date) {\n  const formatted = dtf.format(date).replace(/\\u200E/g, \"\"),\n    parsed = /(\\d+)\\/(\\d+)\\/(\\d+) (AD|BC),? (\\d+):(\\d+):(\\d+)/.exec(formatted),\n    [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed;\n  return [fYear, fMonth, fDay, fadOrBc, fHour, fMinute, fSecond];\n}\n\nfunction partsOffset(dtf, date) {\n  const formatted = dtf.formatToParts(date);\n  const filled = [];\n  for (let i = 0; i < formatted.length; i++) {\n    const { type, value } = formatted[i];\n    const pos = typeToPos[type];\n\n    if (type === \"era\") {\n      filled[pos] = value;\n    } else if (!isUndefined(pos)) {\n      filled[pos] = parseInt(value, 10);\n    }\n  }\n  return filled;\n}\n\nconst ianaZoneCache = new Map();\n/**\n * A zone identified by an IANA identifier, like America/New_York\n * @implements {Zone}\n */\nexport default class IANAZone extends Zone {\n  /**\n   * @param {string} name - Zone name\n   * @return {IANAZone}\n   */\n  static create(name) {\n    let zone = ianaZoneCache.get(name);\n    if (zone === undefined) {\n      ianaZoneCache.set(name, (zone = new IANAZone(name)));\n    }\n    return zone;\n  }\n\n  /**\n   * Reset local caches. Should only be necessary in testing scenarios.\n   * @return {void}\n   */\n  static resetCache() {\n    ianaZoneCache.clear();\n    dtfCache.clear();\n  }\n\n  /**\n   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.\n   * @param {string} s - The string to check validity on\n   * @example IANAZone.isValidSpecifier(\"America/New_York\") //=> true\n   * @example IANAZone.isValidSpecifier(\"Sport~~blorp\") //=> false\n   * @deprecated For backward compatibility, this forwards to isValidZone, better use `isValidZone()` directly instead.\n   * @return {boolean}\n   */\n  static isValidSpecifier(s) {\n    return this.isValidZone(s);\n  }\n\n  /**\n   * Returns whether the provided string identifies a real zone\n   * @param {string} zone - The string to check\n   * @example IANAZone.isValidZone(\"America/New_York\") //=> true\n   * @example IANAZone.isValidZone(\"Fantasia/Castle\") //=> false\n   * @example IANAZone.isValidZone(\"Sport~~blorp\") //=> false\n   * @return {boolean}\n   */\n  static isValidZone(zone) {\n    if (!zone) {\n      return false;\n    }\n    try {\n      new Intl.DateTimeFormat(\"en-US\", { timeZone: zone }).format();\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  constructor(name) {\n    super();\n    /** @private **/\n    this.zoneName = name;\n    /** @private **/\n    this.valid = IANAZone.isValidZone(name);\n  }\n\n  /**\n   * The type of zone. `iana` for all instances of `IANAZone`.\n   * @override\n   * @type {string}\n   */\n  get type() {\n    return \"iana\";\n  }\n\n  /**\n   * The name of this zone (i.e. the IANA zone name).\n   * @override\n   * @type {string}\n   */\n  get name() {\n    return this.zoneName;\n  }\n\n  /**\n   * Returns whether the offset is known to be fixed for the whole year:\n   * Always returns false for all IANA zones.\n   * @override\n   * @type {boolean}\n   */\n  get isUniversal() {\n    return false;\n  }\n\n  /**\n   * Returns the offset's common name (such as EST) at the specified timestamp\n   * @override\n   * @param {number} ts - Epoch milliseconds for which to get the name\n   * @param {Object} opts - Options to affect the format\n   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.\n   * @param {string} opts.locale - What locale to return the offset name in.\n   * @return {string}\n   */\n  offsetName(ts, { format, locale }) {\n    return parseZoneInfo(ts, format, locale, this.name);\n  }\n\n  /**\n   * Returns the offset's value as a string\n   * @override\n   * @param {number} ts - Epoch milliseconds for which to get the offset\n   * @param {string} format - What style of offset to return.\n   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively\n   * @return {string}\n   */\n  formatOffset(ts, format) {\n    return formatOffset(this.offset(ts), format);\n  }\n\n  /**\n   * Return the offset in minutes for this zone at the specified timestamp.\n   * @override\n   * @param {number} ts - Epoch milliseconds for which to compute the offset\n   * @return {number}\n   */\n  offset(ts) {\n    if (!this.valid) return NaN;\n    const date = new Date(ts);\n\n    if (isNaN(date)) return NaN;\n\n    const dtf = makeDTF(this.name);\n    let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts\n      ? partsOffset(dtf, date)\n      : hackyOffset(dtf, date);\n\n    if (adOrBc === \"BC\") {\n      year = -Math.abs(year) + 1;\n    }\n\n    // because we're using hour12 and https://bugs.chromium.org/p/chromium/issues/detail?id=1025564&can=2&q=%2224%3A00%22%20datetimeformat\n    const adjustedHour = hour === 24 ? 0 : hour;\n\n    const asUTC = objToLocalTS({\n      year,\n      month,\n      day,\n      hour: adjustedHour,\n      minute,\n      second,\n      millisecond: 0,\n    });\n\n    let asTS = +date;\n    const over = asTS % 1000;\n    asTS -= over >= 0 ? over : 1000 + over;\n    return (asUTC - asTS) / (60 * 1000);\n  }\n\n  /**\n   * Return whether this Zone is equal to another zone\n   * @override\n   * @param {Zone} otherZone - the zone to compare\n   * @return {boolean}\n   */\n  equals(otherZone) {\n    return otherZone.type === \"iana\" && otherZone.name === this.name;\n  }\n\n  /**\n   * Return whether this Zone is valid.\n   * @override\n   * @type {boolean}\n   */\n  get isValid() {\n    return this.valid;\n  }\n}\n","import DateTime from \"./datetime.js\";\nimport Settings from \"./settings.js\";\nimport Locale from \"./impl/locale.js\";\nimport IANAZone from \"./zones/IANAZone.js\";\nimport { normalizeZone } from \"./impl/zoneUtil.js\";\n\nimport { hasLocaleWeekInfo, hasRelative } from \"./impl/util.js\";\n\n/**\n * The Info class contains static methods for retrieving general time and date related data. For example, it has methods for finding out if a time zone has a DST, for listing the months in any supported locale, and for discovering which of Luxon features are available in the current environment.\n */\nexport default class Info {\n  /**\n   * Return whether the specified zone contains a DST.\n   * @param {string|Zone} [zone='local'] - Zone to check. Defaults to the environment's local zone.\n   * @return {boolean}\n   */\n  static hasDST(zone = Settings.defaultZone) {\n    const proto = DateTime.now().setZone(zone).set({ month: 12 });\n\n    return !zone.isUniversal && proto.offset !== proto.set({ month: 6 }).offset;\n  }\n\n  /**\n   * Return whether the specified zone is a valid IANA specifier.\n   * @param {string} zone - Zone to check\n   * @return {boolean}\n   */\n  static isValidIANAZone(zone) {\n    return IANAZone.isValidZone(zone);\n  }\n\n  /**\n   * Converts the input into a {@link Zone} instance.\n   *\n   * * If `input` is already a Zone instance, it is returned unchanged.\n   * * If `input` is a string containing a valid time zone name, a Zone instance\n   *   with that name is returned.\n   * * If `input` is a string that doesn't refer to a known time zone, a Zone\n   *   instance with {@link Zone#isValid} == false is returned.\n   * * If `input is a number, a Zone instance with the specified fixed offset\n   *   in minutes is returned.\n   * * If `input` is `null` or `undefined`, the default zone is returned.\n   * @param {string|Zone|number} [input] - the value to be converted\n   * @return {Zone}\n   */\n  static normalizeZone(input) {\n    return normalizeZone(input, Settings.defaultZone);\n  }\n\n  /**\n   * Get the weekday on which the week starts according to the given locale.\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @returns {number} the start of the week, 1 for Monday through 7 for Sunday\n   */\n  static getStartOfWeek({ locale = null, locObj = null } = {}) {\n    return (locObj || Locale.create(locale)).getStartOfWeek();\n  }\n\n  /**\n   * Get the minimum number of days necessary in a week before it is considered part of the next year according\n   * to the given locale.\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @returns {number}\n   */\n  static getMinimumDaysInFirstWeek({ locale = null, locObj = null } = {}) {\n    return (locObj || Locale.create(locale)).getMinDaysInFirstWeek();\n  }\n\n  /**\n   * Get the weekdays, which are considered the weekend according to the given locale\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @returns {number[]} an array of weekdays, 1 for Monday through 7 for Sunday\n   */\n  static getWeekendWeekdays({ locale = null, locObj = null } = {}) {\n    // copy the array, because we cache it internally\n    return (locObj || Locale.create(locale)).getWeekendDays().slice();\n  }\n\n  /**\n   * Return an array of standalone month names.\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\n   * @param {string} [length='long'] - the length of the month representation, such as \"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\"\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.numberingSystem=null] - the numbering system\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @param {string} [opts.outputCalendar='gregory'] - the calendar\n   * @example Info.months()[0] //=> 'January'\n   * @example Info.months('short')[0] //=> 'Jan'\n   * @example Info.months('numeric')[0] //=> '1'\n   * @example Info.months('short', { locale: 'fr-CA' } )[0] //=> 'janv.'\n   * @example Info.months('numeric', { locale: 'ar' })[0] //=> '١'\n   * @example Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I'\n   * @return {Array}\n   */\n  static months(\n    length = \"long\",\n    { locale = null, numberingSystem = null, locObj = null, outputCalendar = \"gregory\" } = {}\n  ) {\n    return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length);\n  }\n\n  /**\n   * Return an array of format month names.\n   * Format months differ from standalone months in that they're meant to appear next to the day of the month. In some languages, that\n   * changes the string.\n   * See {@link Info#months}\n   * @param {string} [length='long'] - the length of the month representation, such as \"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\"\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.numberingSystem=null] - the numbering system\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @param {string} [opts.outputCalendar='gregory'] - the calendar\n   * @return {Array}\n   */\n  static monthsFormat(\n    length = \"long\",\n    { locale = null, numberingSystem = null, locObj = null, outputCalendar = \"gregory\" } = {}\n  ) {\n    return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length, true);\n  }\n\n  /**\n   * Return an array of standalone week names.\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\n   * @param {string} [length='long'] - the length of the weekday representation, such as \"narrow\", \"short\", \"long\".\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @param {string} [opts.numberingSystem=null] - the numbering system\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @example Info.weekdays()[0] //=> 'Monday'\n   * @example Info.weekdays('short')[0] //=> 'Mon'\n   * @example Info.weekdays('short', { locale: 'fr-CA' })[0] //=> 'lun.'\n   * @example Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين'\n   * @return {Array}\n   */\n  static weekdays(length = \"long\", { locale = null, numberingSystem = null, locObj = null } = {}) {\n    return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length);\n  }\n\n  /**\n   * Return an array of format week names.\n   * Format weekdays differ from standalone weekdays in that they're meant to appear next to more date information. In some languages, that\n   * changes the string.\n   * See {@link Info#weekdays}\n   * @param {string} [length='long'] - the length of the month representation, such as \"narrow\", \"short\", \"long\".\n   * @param {Object} opts - options\n   * @param {string} [opts.locale=null] - the locale code\n   * @param {string} [opts.numberingSystem=null] - the numbering system\n   * @param {string} [opts.locObj=null] - an existing locale object to use\n   * @return {Array}\n   */\n  static weekdaysFormat(\n    length = \"long\",\n    { locale = null, numberingSystem = null, locObj = null } = {}\n  ) {\n    return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length, true);\n  }\n\n  /**\n   * Return an array of meridiems.\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @example Info.meridiems() //=> [ 'AM', 'PM' ]\n   * @example Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ]\n   * @return {Array}\n   */\n  static meridiems({ locale = null } = {}) {\n    return Locale.create(locale).meridiems();\n  }\n\n  /**\n   * Return an array of eras, such as ['BC', 'AD']. The locale can be specified, but the calendar system is always Gregorian.\n   * @param {string} [length='short'] - the length of the era representation, such as \"short\" or \"long\".\n   * @param {Object} opts - options\n   * @param {string} [opts.locale] - the locale code\n   * @example Info.eras() //=> [ 'BC', 'AD' ]\n   * @example Info.eras('long') //=> [ 'Before Christ', 'Anno Domini' ]\n   * @example Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ]\n   * @return {Array}\n   */\n  static eras(length = \"short\", { locale = null } = {}) {\n    return Locale.create(locale, null, \"gregory\").eras(length);\n  }\n\n  /**\n   * Return the set of available features in this environment.\n   * Some features of Luxon are not available in all environments. For example, on older browsers, relative time formatting support is not available. Use this function to figure out if that's the case.\n   * Keys:\n   * * `relative`: whether this environment supports relative time formatting\n   * * `localeWeek`: whether this environment supports different weekdays for the start of the week based on the locale\n   * @example Info.features() //=> { relative: false, localeWeek: true }\n   * @return {Object}\n   */\n  static features() {\n    return { relative: hasRelative(), localeWeek: hasLocaleWeekInfo() };\n  }\n}\n","import SystemZone from \"./zones/systemZone.js\";\nimport IANAZone from \"./zones/IANAZone.js\";\nimport Locale from \"./impl/locale.js\";\nimport DateTime from \"./datetime.js\";\n\nimport { normalizeZone } from \"./impl/zoneUtil.js\";\nimport { validateWeekSettings } from \"./impl/util.js\";\nimport { resetDigitRegexCache } from \"./impl/digits.js\";\n\nlet now = () => Date.now(),\n  defaultZone = \"system\",\n  defaultLocale = null,\n  defaultNumberingSystem = null,\n  defaultOutputCalendar = null,\n  twoDigitCutoffYear = 60,\n  throwOnInvalid,\n  defaultWeekSettings = null;\n\n/**\n * Settings contains static getters and setters that control Luxon's overall behavior. Luxon is a simple library with few options, but the ones it does have live here.\n */\nexport default class Settings {\n  /**\n   * Get the callback for returning the current timestamp.\n   * @type {function}\n   */\n  static get now() {\n    return now;\n  }\n\n  /**\n   * Set the callback for returning the current timestamp.\n   * The function should return a number, which will be interpreted as an Epoch millisecond count\n   * @type {function}\n   * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future\n   * @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time\n   */\n  static set now(n) {\n    now = n;\n  }\n\n  /**\n   * Set the default time zone to create DateTimes in. Does not affect existing instances.\n   * Use the value \"system\" to reset this value to the system's time zone.\n   * @type {string}\n   */\n  static set defaultZone(zone) {\n    defaultZone = zone;\n  }\n\n  /**\n   * Get the default time zone object currently used to create DateTimes. Does not affect existing instances.\n   * The default value is the system's time zone (the one set on the machine that runs this code).\n   * @type {Zone}\n   */\n  static get defaultZone() {\n    return normalizeZone(defaultZone, SystemZone.instance);\n  }\n\n  /**\n   * Get the default locale to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static get defaultLocale() {\n    return defaultLocale;\n  }\n\n  /**\n   * Set the default locale to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static set defaultLocale(locale) {\n    defaultLocale = locale;\n  }\n\n  /**\n   * Get the default numbering system to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static get defaultNumberingSystem() {\n    return defaultNumberingSystem;\n  }\n\n  /**\n   * Set the default numbering system to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static set defaultNumberingSystem(numberingSystem) {\n    defaultNumberingSystem = numberingSystem;\n  }\n\n  /**\n   * Get the default output calendar to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static get defaultOutputCalendar() {\n    return defaultOutputCalendar;\n  }\n\n  /**\n   * Set the default output calendar to create DateTimes with. Does not affect existing instances.\n   * @type {string}\n   */\n  static set defaultOutputCalendar(outputCalendar) {\n    defaultOutputCalendar = outputCalendar;\n  }\n\n  /**\n   * @typedef {Object} WeekSettings\n   * @property {number} firstDay\n   * @property {number} minimalDays\n   * @property {number[]} weekend\n   */\n\n  /**\n   * @return {WeekSettings|null}\n   */\n  static get defaultWeekSettings() {\n    return defaultWeekSettings;\n  }\n\n  /**\n   * Allows overriding the default locale week settings, i.e. the start of the week, the weekend and\n   * how many days are required in the first week of a year.\n   * Does not affect existing instances.\n   *\n   * @param {WeekSettings|null} weekSettings\n   */\n  static set defaultWeekSettings(weekSettings) {\n    defaultWeekSettings = validateWeekSettings(weekSettings);\n  }\n\n  /**\n   * Get the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.\n   * @type {number}\n   */\n  static get twoDigitCutoffYear() {\n    return twoDigitCutoffYear;\n  }\n\n  /**\n   * Set the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.\n   * @type {number}\n   * @example Settings.twoDigitCutoffYear = 0 // all 'yy' are interpreted as 20th century\n   * @example Settings.twoDigitCutoffYear = 99 // all 'yy' are interpreted as 21st century\n   * @example Settings.twoDigitCutoffYear = 50 // '49' -> 2049; '50' -> 1950\n   * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50\n   * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50\n   */\n  static set twoDigitCutoffYear(cutoffYear) {\n    twoDigitCutoffYear = cutoffYear % 100;\n  }\n\n  /**\n   * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals\n   * @type {boolean}\n   */\n  static get throwOnInvalid() {\n    return throwOnInvalid;\n  }\n\n  /**\n   * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals\n   * @type {boolean}\n   */\n  static set throwOnInvalid(t) {\n    throwOnInvalid = t;\n  }\n\n  /**\n   * Reset Luxon's global caches. Should only be necessary in testing scenarios.\n   * @return {void}\n   */\n  static resetCaches() {\n    Locale.resetCache();\n    IANAZone.resetCache();\n    DateTime.resetCache();\n    resetDigitRegexCache();\n  }\n}\n","import Zone from \"../zone.js\";\n\n/**\n * A zone that failed to parse. You should never need to instantiate this.\n * @implements {Zone}\n */\nexport default class InvalidZone extends Zone {\n  constructor(zoneName) {\n    super();\n    /**  @private */\n    this.zoneName = zoneName;\n  }\n\n  /** @override **/\n  get type() {\n    return \"invalid\";\n  }\n\n  /** @override **/\n  get name() {\n    return this.zoneName;\n  }\n\n  /** @override **/\n  get isUniversal() {\n    return false;\n  }\n\n  /** @override **/\n  offsetName() {\n    return null;\n  }\n\n  /** @override **/\n  formatOffset() {\n    return \"\";\n  }\n\n  /** @override **/\n  offset() {\n    return NaN;\n  }\n\n  /** @override **/\n  equals() {\n    return false;\n  }\n\n  /** @override **/\n  get isValid() {\n    return false;\n  }\n}\n","import { formatOffset, parseZoneInfo } from \"../impl/util.js\";\nimport Zone from \"../zone.js\";\n\nlet singleton = null;\n\n/**\n * Represents the local zone for this JavaScript environment.\n * @implements {Zone}\n */\nexport default class SystemZone extends Zone {\n  /**\n   * Get a singleton instance of the local zone\n   * @return {SystemZone}\n   */\n  static get instance() {\n    if (singleton === null) {\n      singleton = new SystemZone();\n    }\n    return singleton;\n  }\n\n  /** @override **/\n  get type() {\n    return \"system\";\n  }\n\n  /** @override **/\n  get name() {\n    return new Intl.DateTimeFormat().resolvedOptions().timeZone;\n  }\n\n  /** @override **/\n  get isUniversal() {\n    return false;\n  }\n\n  /** @override **/\n  offsetName(ts, { format, locale }) {\n    return parseZoneInfo(ts, format, locale);\n  }\n\n  /** @override **/\n  formatOffset(ts, format) {\n    return formatOffset(this.offset(ts), format);\n  }\n\n  /** @override **/\n  offset(ts) {\n    return -new Date(ts).getTimezoneOffset();\n  }\n\n  /** @override **/\n  equals(otherZone) {\n    return otherZone.type === \"system\";\n  }\n\n  /** @override **/\n  get isValid() {\n    return true;\n  }\n}\n","import DateTime, { friendlyDateTime } from \"./datetime.js\";\nimport Duration from \"./duration.js\";\nimport Settings from \"./settings.js\";\nimport { InvalidArgumentError, InvalidIntervalError } from \"./errors.js\";\nimport Invalid from \"./impl/invalid.js\";\nimport Formatter from \"./impl/formatter.js\";\nimport * as Formats from \"./impl/formats.js\";\n\nconst INVALID = \"Invalid Interval\";\n\n// checks if the start is equal to or before the end\nfunction validateStartEnd(start, end) {\n  if (!start || !start.isValid) {\n    return Interval.invalid(\"missing or invalid start\");\n  } else if (!end || !end.isValid) {\n    return Interval.invalid(\"missing or invalid end\");\n  } else if (end < start) {\n    return Interval.invalid(\n      \"end before start\",\n      `The end of an interval must be after its start, but you had start=${start.toISO()} and end=${end.toISO()}`\n    );\n  } else {\n    return null;\n  }\n}\n\n/**\n * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.\n *\n * Here is a brief overview of the most commonly used methods and getters in Interval:\n *\n * * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}.\n * * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end.\n * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.\n * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.\n * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}\n * * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toLocaleString}, {@link Interval#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.\n */\nexport default class Interval {\n  /**\n   * @private\n   */\n  constructor(config) {\n    /**\n     * @access private\n     */\n    this.s = config.start;\n    /**\n     * @access private\n     */\n    this.e = config.end;\n    /**\n     * @access private\n     */\n    this.invalid = config.invalid || null;\n    /**\n     * @access private\n     */\n    this.isLuxonInterval = true;\n  }\n\n  /**\n   * Create an invalid Interval.\n   * @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent\n   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information\n   * @return {Interval}\n   */\n  static invalid(reason, explanation = null) {\n    if (!reason) {\n      throw new InvalidArgumentError(\"need to specify a reason the Interval is invalid\");\n    }\n\n    const invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);\n\n    if (Settings.throwOnInvalid) {\n      throw new InvalidIntervalError(invalid);\n    } else {\n      return new Interval({ invalid });\n    }\n  }\n\n  /**\n   * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.\n   * @param {DateTime|Date|Object} start\n   * @param {DateTime|Date|Object} end\n   * @return {Interval}\n   */\n  static fromDateTimes(start, end) {\n    const builtStart = friendlyDateTime(start),\n      builtEnd = friendlyDateTime(end);\n\n    const validateError = validateStartEnd(builtStart, builtEnd);\n\n    if (validateError == null) {\n      return new Interval({\n        start: builtStart,\n        end: builtEnd,\n      });\n    } else {\n      return validateError;\n    }\n  }\n\n  /**\n   * Create an Interval from a start DateTime and a Duration to extend to.\n   * @param {DateTime|Date|Object} start\n   * @param {Duration|Object|number} duration - the length of the Interval.\n   * @return {Interval}\n   */\n  static after(start, duration) {\n    const dur = Duration.fromDurationLike(duration),\n      dt = friendlyDateTime(start);\n    return Interval.fromDateTimes(dt, dt.plus(dur));\n  }\n\n  /**\n   * Create an Interval from an end DateTime and a Duration to extend backwards to.\n   * @param {DateTime|Date|Object} end\n   * @param {Duration|Object|number} duration - the length of the Interval.\n   * @return {Interval}\n   */\n  static before(end, duration) {\n    const dur = Duration.fromDurationLike(duration),\n      dt = friendlyDateTime(end);\n    return Interval.fromDateTimes(dt.minus(dur), dt);\n  }\n\n  /**\n   * Create an Interval from an ISO 8601 string.\n   * Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.\n   * @param {string} text - the ISO string to parse\n   * @param {Object} [opts] - options to pass {@link DateTime#fromISO} and optionally {@link Duration#fromISO}\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @return {Interval}\n   */\n  static fromISO(text, opts) {\n    const [s, e] = (text || \"\").split(\"/\", 2);\n    if (s && e) {\n      let start, startIsValid;\n      try {\n        start = DateTime.fromISO(s, opts);\n        startIsValid = start.isValid;\n      } catch (e) {\n        startIsValid = false;\n      }\n\n      let end, endIsValid;\n      try {\n        end = DateTime.fromISO(e, opts);\n        endIsValid = end.isValid;\n      } catch (e) {\n        endIsValid = false;\n      }\n\n      if (startIsValid && endIsValid) {\n        return Interval.fromDateTimes(start, end);\n      }\n\n      if (startIsValid) {\n        const dur = Duration.fromISO(e, opts);\n        if (dur.isValid) {\n          return Interval.after(start, dur);\n        }\n      } else if (endIsValid) {\n        const dur = Duration.fromISO(s, opts);\n        if (dur.isValid) {\n          return Interval.before(end, dur);\n        }\n      }\n    }\n    return Interval.invalid(\"unparsable\", `the input \"${text}\" can't be parsed as ISO 8601`);\n  }\n\n  /**\n   * Check if an object is an Interval. Works across context boundaries\n   * @param {object} o\n   * @return {boolean}\n   */\n  static isInterval(o) {\n    return (o && o.isLuxonInterval) || false;\n  }\n\n  /**\n   * Returns the start of the Interval\n   * @type {DateTime}\n   */\n  get start() {\n    return this.isValid ? this.s : null;\n  }\n\n  /**\n   * Returns the end of the Interval\n   * @type {DateTime}\n   */\n  get end() {\n    return this.isValid ? this.e : null;\n  }\n\n  /**\n   * Returns the last DateTime included in the interval (since end is not part of the interval)\n   * @type {DateTime}\n   */\n  get lastDateTime() {\n    return this.isValid ? (this.e ? this.e.minus(1) : null) : null;\n  }\n\n  /**\n   * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.\n   * @type {boolean}\n   */\n  get isValid() {\n    return this.invalidReason === null;\n  }\n\n  /**\n   * Returns an error code if this Interval is invalid, or null if the Interval is valid\n   * @type {string}\n   */\n  get invalidReason() {\n    return this.invalid ? this.invalid.reason : null;\n  }\n\n  /**\n   * Returns an explanation of why this Interval became invalid, or null if the Interval is valid\n   * @type {string}\n   */\n  get invalidExplanation() {\n    return this.invalid ? this.invalid.explanation : null;\n  }\n\n  /**\n   * Returns the length of the Interval in the specified unit.\n   * @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.\n   * @return {number}\n   */\n  length(unit = \"milliseconds\") {\n    return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN;\n  }\n\n  /**\n   * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.\n   * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'\n   * asks 'what dates are included in this interval?', not 'how many days long is this interval?'\n   * @param {string} [unit='milliseconds'] - the unit of time to count.\n   * @param {Object} opts - options\n   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; this operation will always use the locale of the start DateTime\n   * @return {number}\n   */\n  count(unit = \"milliseconds\", opts) {\n    if (!this.isValid) return NaN;\n    const start = this.start.startOf(unit, opts);\n    let end;\n    if (opts?.useLocaleWeeks) {\n      end = this.end.reconfigure({ locale: start.locale });\n    } else {\n      end = this.end;\n    }\n    end = end.startOf(unit, opts);\n    return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());\n  }\n\n  /**\n   * Returns whether this Interval's start and end are both in the same unit of time\n   * @param {string} unit - the unit of time to check sameness on\n   * @return {boolean}\n   */\n  hasSame(unit) {\n    return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;\n  }\n\n  /**\n   * Return whether this Interval has the same start and end DateTimes.\n   * @return {boolean}\n   */\n  isEmpty() {\n    return this.s.valueOf() === this.e.valueOf();\n  }\n\n  /**\n   * Return whether this Interval's start is after the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  isAfter(dateTime) {\n    if (!this.isValid) return false;\n    return this.s > dateTime;\n  }\n\n  /**\n   * Return whether this Interval's end is before the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  isBefore(dateTime) {\n    if (!this.isValid) return false;\n    return this.e <= dateTime;\n  }\n\n  /**\n   * Return whether this Interval contains the specified DateTime.\n   * @param {DateTime} dateTime\n   * @return {boolean}\n   */\n  contains(dateTime) {\n    if (!this.isValid) return false;\n    return this.s <= dateTime && this.e > dateTime;\n  }\n\n  /**\n   * \"Sets\" the start and/or end dates. Returns a newly-constructed Interval.\n   * @param {Object} values - the values to set\n   * @param {DateTime} values.start - the starting DateTime\n   * @param {DateTime} values.end - the ending DateTime\n   * @return {Interval}\n   */\n  set({ start, end } = {}) {\n    if (!this.isValid) return this;\n    return Interval.fromDateTimes(start || this.s, end || this.e);\n  }\n\n  /**\n   * Split this Interval at each of the specified DateTimes\n   * @param {...DateTime} dateTimes - the unit of time to count.\n   * @return {Array}\n   */\n  splitAt(...dateTimes) {\n    if (!this.isValid) return [];\n    const sorted = dateTimes\n        .map(friendlyDateTime)\n        .filter((d) => this.contains(d))\n        .sort((a, b) => a.toMillis() - b.toMillis()),\n      results = [];\n    let { s } = this,\n      i = 0;\n\n    while (s < this.e) {\n      const added = sorted[i] || this.e,\n        next = +added > +this.e ? this.e : added;\n      results.push(Interval.fromDateTimes(s, next));\n      s = next;\n      i += 1;\n    }\n\n    return results;\n  }\n\n  /**\n   * Split this Interval into smaller Intervals, each of the specified length.\n   * Left over time is grouped into a smaller interval\n   * @param {Duration|Object|number} duration - The length of each resulting interval.\n   * @return {Array}\n   */\n  splitBy(duration) {\n    const dur = Duration.fromDurationLike(duration);\n\n    if (!this.isValid || !dur.isValid || dur.as(\"milliseconds\") === 0) {\n      return [];\n    }\n\n    let { s } = this,\n      idx = 1,\n      next;\n\n    const results = [];\n    while (s < this.e) {\n      const added = this.start.plus(dur.mapUnits((x) => x * idx));\n      next = +added > +this.e ? this.e : added;\n      results.push(Interval.fromDateTimes(s, next));\n      s = next;\n      idx += 1;\n    }\n\n    return results;\n  }\n\n  /**\n   * Split this Interval into the specified number of smaller intervals.\n   * @param {number} numberOfParts - The number of Intervals to divide the Interval into.\n   * @return {Array}\n   */\n  divideEqually(numberOfParts) {\n    if (!this.isValid) return [];\n    return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts);\n  }\n\n  /**\n   * Return whether this Interval overlaps with the specified Interval\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  overlaps(other) {\n    return this.e > other.s && this.s < other.e;\n  }\n\n  /**\n   * Return whether this Interval's end is adjacent to the specified Interval's start.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  abutsStart(other) {\n    if (!this.isValid) return false;\n    return +this.e === +other.s;\n  }\n\n  /**\n   * Return whether this Interval's start is adjacent to the specified Interval's end.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  abutsEnd(other) {\n    if (!this.isValid) return false;\n    return +other.e === +this.s;\n  }\n\n  /**\n   * Returns true if this Interval fully contains the specified Interval, specifically if the intersect (of this Interval and the other Interval) is equal to the other Interval; false otherwise.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  engulfs(other) {\n    if (!this.isValid) return false;\n    return this.s <= other.s && this.e >= other.e;\n  }\n\n  /**\n   * Return whether this Interval has the same start and end as the specified Interval.\n   * @param {Interval} other\n   * @return {boolean}\n   */\n  equals(other) {\n    if (!this.isValid || !other.isValid) {\n      return false;\n    }\n\n    return this.s.equals(other.s) && this.e.equals(other.e);\n  }\n\n  /**\n   * Return an Interval representing the intersection of this Interval and the specified Interval.\n   * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.\n   * Returns null if the intersection is empty, meaning, the intervals don't intersect.\n   * @param {Interval} other\n   * @return {Interval}\n   */\n  intersection(other) {\n    if (!this.isValid) return this;\n    const s = this.s > other.s ? this.s : other.s,\n      e = this.e < other.e ? this.e : other.e;\n\n    if (s >= e) {\n      return null;\n    } else {\n      return Interval.fromDateTimes(s, e);\n    }\n  }\n\n  /**\n   * Return an Interval representing the union of this Interval and the specified Interval.\n   * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.\n   * @param {Interval} other\n   * @return {Interval}\n   */\n  union(other) {\n    if (!this.isValid) return this;\n    const s = this.s < other.s ? this.s : other.s,\n      e = this.e > other.e ? this.e : other.e;\n    return Interval.fromDateTimes(s, e);\n  }\n\n  /**\n   * Merge an array of Intervals into an equivalent minimal set of Intervals.\n   * Combines overlapping and adjacent Intervals.\n   * The resulting array will contain the Intervals in ascending order, that is, starting with the earliest Interval\n   * and ending with the latest.\n   *\n   * @param {Array} intervals\n   * @return {Array}\n   */\n  static merge(intervals) {\n    const [found, final] = intervals\n      .sort((a, b) => a.s - b.s)\n      .reduce(\n        ([sofar, current], item) => {\n          if (!current) {\n            return [sofar, item];\n          } else if (current.overlaps(item) || current.abutsStart(item)) {\n            return [sofar, current.union(item)];\n          } else {\n            return [sofar.concat([current]), item];\n          }\n        },\n        [[], null]\n      );\n    if (final) {\n      found.push(final);\n    }\n    return found;\n  }\n\n  /**\n   * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.\n   * @param {Array} intervals\n   * @return {Array}\n   */\n  static xor(intervals) {\n    let start = null,\n      currentCount = 0;\n    const results = [],\n      ends = intervals.map((i) => [\n        { time: i.s, type: \"s\" },\n        { time: i.e, type: \"e\" },\n      ]),\n      flattened = Array.prototype.concat(...ends),\n      arr = flattened.sort((a, b) => a.time - b.time);\n\n    for (const i of arr) {\n      currentCount += i.type === \"s\" ? 1 : -1;\n\n      if (currentCount === 1) {\n        start = i.time;\n      } else {\n        if (start && +start !== +i.time) {\n          results.push(Interval.fromDateTimes(start, i.time));\n        }\n\n        start = null;\n      }\n    }\n\n    return Interval.merge(results);\n  }\n\n  /**\n   * Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.\n   * @param {...Interval} intervals\n   * @return {Array}\n   */\n  difference(...intervals) {\n    return Interval.xor([this].concat(intervals))\n      .map((i) => this.intersection(i))\n      .filter((i) => i && !i.isEmpty());\n  }\n\n  /**\n   * Returns a string representation of this Interval appropriate for debugging.\n   * @return {string}\n   */\n  toString() {\n    if (!this.isValid) return INVALID;\n    return `[${this.s.toISO()} – ${this.e.toISO()})`;\n  }\n\n  /**\n   * Returns a string representation of this Interval appropriate for the REPL.\n   * @return {string}\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")]() {\n    if (this.isValid) {\n      return `Interval { start: ${this.s.toISO()}, end: ${this.e.toISO()} }`;\n    } else {\n      return `Interval { Invalid, reason: ${this.invalidReason} }`;\n    }\n  }\n\n  /**\n   * Returns a localized string representing this Interval. Accepts the same options as the\n   * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as\n   * {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method\n   * is browser-specific, but in general it will return an appropriate representation of the\n   * Interval in the assigned locale. Defaults to the system's locale if no locale has been\n   * specified.\n   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\n   * @param {Object} [formatOpts=DateTime.DATE_SHORT] - Either a DateTime preset or\n   * Intl.DateTimeFormat constructor options.\n   * @param {Object} opts - Options to override the configuration of the start DateTime.\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022\n   * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022\n   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM\n   * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> Mon, Nov 07, 6:00 – 8:00 p\n   * @return {string}\n   */\n  toLocaleString(formatOpts = Formats.DATE_SHORT, opts = {}) {\n    return this.isValid\n      ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this)\n      : INVALID;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of this Interval.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @param {Object} opts - The same options as {@link DateTime#toISO}\n   * @return {string}\n   */\n  toISO(opts) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISO(opts)}/${this.e.toISO(opts)}`;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of date of this Interval.\n   * The time components are ignored.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @return {string}\n   */\n  toISODate() {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISODate()}/${this.e.toISODate()}`;\n  }\n\n  /**\n   * Returns an ISO 8601-compliant string representation of time of this Interval.\n   * The date components are ignored.\n   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals\n   * @param {Object} opts - The same options as {@link DateTime#toISO}\n   * @return {string}\n   */\n  toISOTime(opts) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toISOTime(opts)}/${this.e.toISOTime(opts)}`;\n  }\n\n  /**\n   * Returns a string representation of this Interval formatted according to the specified format\n   * string. **You may not want this.** See {@link Interval#toLocaleString} for a more flexible\n   * formatting tool.\n   * @param {string} dateFormat - The format string. This string formats the start and end time.\n   * See {@link DateTime#toFormat} for details.\n   * @param {Object} opts - Options.\n   * @param {string} [opts.separator =  ' – '] - A separator to place between the start and end\n   * representations.\n   * @return {string}\n   */\n  toFormat(dateFormat, { separator = \" – \" } = {}) {\n    if (!this.isValid) return INVALID;\n    return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`;\n  }\n\n  /**\n   * Return a Duration representing the time spanned by this interval.\n   * @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.\n   * @param {Object} opts - options that affect the creation of the Duration\n   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }\n   * @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }\n   * @return {Duration}\n   */\n  toDuration(unit, opts) {\n    if (!this.isValid) {\n      return Duration.invalid(this.invalidReason);\n    }\n    return this.e.diff(this.s, unit, opts);\n  }\n\n  /**\n   * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes\n   * @param {function} mapFn\n   * @return {Interval}\n   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())\n   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))\n   */\n  mapEndpoints(mapFn) {\n    return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));\n  }\n}\n","import { ZoneIsAbstractError } from \"./errors.js\";\n\n/**\n * @interface\n */\nexport default class Zone {\n  /**\n   * The type of zone\n   * @abstract\n   * @type {string}\n   */\n  get type() {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * The name of this zone.\n   * @abstract\n   * @type {string}\n   */\n  get name() {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * The IANA name of this zone.\n   * Defaults to `name` if not overwritten by a subclass.\n   * @abstract\n   * @type {string}\n   */\n  get ianaName() {\n    return this.name;\n  }\n\n  /**\n   * Returns whether the offset is known to be fixed for the whole year.\n   * @abstract\n   * @type {boolean}\n   */\n  get isUniversal() {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * Returns the offset's common name (such as EST) at the specified timestamp\n   * @abstract\n   * @param {number} ts - Epoch milliseconds for which to get the name\n   * @param {Object} opts - Options to affect the format\n   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.\n   * @param {string} opts.locale - What locale to return the offset name in.\n   * @return {string}\n   */\n  offsetName(ts, opts) {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * Returns the offset's value as a string\n   * @abstract\n   * @param {number} ts - Epoch milliseconds for which to get the offset\n   * @param {string} format - What style of offset to return.\n   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively\n   * @return {string}\n   */\n  formatOffset(ts, format) {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * Return the offset in minutes for this zone at the specified timestamp.\n   * @abstract\n   * @param {number} ts - Epoch milliseconds for which to compute the offset\n   * @return {number}\n   */\n  offset(ts) {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * Return whether this Zone is equal to another zone\n   * @abstract\n   * @param {Zone} otherZone - the zone to compare\n   * @return {boolean}\n   */\n  equals(otherZone) {\n    throw new ZoneIsAbstractError();\n  }\n\n  /**\n   * Return whether this Zone is valid.\n   * @abstract\n   * @type {boolean}\n   */\n  get isValid() {\n    throw new ZoneIsAbstractError();\n  }\n}\n","import { formatOffset, signedOffset } from \"../impl/util.js\";\nimport Zone from \"../zone.js\";\n\nlet singleton = null;\n\n/**\n * A zone with a fixed offset (meaning no DST)\n * @implements {Zone}\n */\nexport default class FixedOffsetZone extends Zone {\n  /**\n   * Get a singleton instance of UTC\n   * @return {FixedOffsetZone}\n   */\n  static get utcInstance() {\n    if (singleton === null) {\n      singleton = new FixedOffsetZone(0);\n    }\n    return singleton;\n  }\n\n  /**\n   * Get an instance with a specified offset\n   * @param {number} offset - The offset in minutes\n   * @return {FixedOffsetZone}\n   */\n  static instance(offset) {\n    return offset === 0 ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset);\n  }\n\n  /**\n   * Get an instance of FixedOffsetZone from a UTC offset string, like \"UTC+6\"\n   * @param {string} s - The offset string to parse\n   * @example FixedOffsetZone.parseSpecifier(\"UTC+6\")\n   * @example FixedOffsetZone.parseSpecifier(\"UTC+06\")\n   * @example FixedOffsetZone.parseSpecifier(\"UTC-6:00\")\n   * @return {FixedOffsetZone}\n   */\n  static parseSpecifier(s) {\n    if (s) {\n      const r = s.match(/^utc(?:([+-]\\d{1,2})(?::(\\d{2}))?)?$/i);\n      if (r) {\n        return new FixedOffsetZone(signedOffset(r[1], r[2]));\n      }\n    }\n    return null;\n  }\n\n  constructor(offset) {\n    super();\n    /** @private **/\n    this.fixed = offset;\n  }\n\n  /**\n   * The type of zone. `fixed` for all instances of `FixedOffsetZone`.\n   * @override\n   * @type {string}\n   */\n  get type() {\n    return \"fixed\";\n  }\n\n  /**\n   * The name of this zone.\n   * All fixed zones' names always start with \"UTC\" (plus optional offset)\n   * @override\n   * @type {string}\n   */\n  get name() {\n    return this.fixed === 0 ? \"UTC\" : `UTC${formatOffset(this.fixed, \"narrow\")}`;\n  }\n\n  /**\n   * The IANA name of this zone, i.e. `Etc/UTC` or `Etc/GMT+/-nn`\n   *\n   * @override\n   * @type {string}\n   */\n  get ianaName() {\n    if (this.fixed === 0) {\n      return \"Etc/UTC\";\n    } else {\n      return `Etc/GMT${formatOffset(-this.fixed, \"narrow\")}`;\n    }\n  }\n\n  /**\n   * Returns the offset's common name at the specified timestamp.\n   *\n   * For fixed offset zones this equals to the zone name.\n   * @override\n   */\n  offsetName() {\n    return this.name;\n  }\n\n  /**\n   * Returns the offset's value as a string\n   * @override\n   * @param {number} ts - Epoch milliseconds for which to get the offset\n   * @param {string} format - What style of offset to return.\n   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively\n   * @return {string}\n   */\n  formatOffset(ts, format) {\n    return formatOffset(this.fixed, format);\n  }\n\n  /**\n   * Returns whether the offset is known to be fixed for the whole year:\n   * Always returns true for all fixed offset zones.\n   * @override\n   * @type {boolean}\n   */\n  get isUniversal() {\n    return true;\n  }\n\n  /**\n   * Return the offset in minutes for this zone at the specified timestamp.\n   *\n   * For fixed offset zones, this is constant and does not depend on a timestamp.\n   * @override\n   * @return {number}\n   */\n  offset() {\n    return this.fixed;\n  }\n\n  /**\n   * Return whether this Zone is equal to another zone (i.e. also fixed and same offset)\n   * @override\n   * @param {Zone} otherZone - the zone to compare\n   * @return {boolean}\n   */\n  equals(otherZone) {\n    return otherZone.type === \"fixed\" && otherZone.fixed === this.fixed;\n  }\n\n  /**\n   * Return whether this Zone is valid:\n   * All fixed offset zones are valid.\n   * @override\n   * @type {boolean}\n   */\n  get isValid() {\n    return true;\n  }\n}\n"],"names":["dtfCache","Map","typeToPos","year","month","day","era","hour","minute","second","ianaZoneCache","IANAZone","create","name","zone","get","undefined","set","resetCache","clear","isValidSpecifier","s","this","isValidZone","Intl","DateTimeFormat","timeZone","format","e","constructor","super","zoneName","valid","type","isUniversal","offsetName","ts","locale","formatOffset","offset","NaN","date","Date","isNaN","dtf","hour12","makeDTF","adOrBc","formatToParts","formatted","filled","i","length","value","pos","parseInt","partsOffset","replace","parsed","exec","fMonth","fDay","fYear","fadOrBc","fHour","fMinute","fSecond","hackyOffset","Math","abs","adjustedHour","asTS","over","millisecond","equals","otherZone","isValid","Info","hasDST","defaultZone","proto","now","setZone","isValidIANAZone","normalizeZone","input","getStartOfWeek","locObj","getMinimumDaysInFirstWeek","getMinDaysInFirstWeek","getWeekendWeekdays","getWeekendDays","slice","months","numberingSystem","outputCalendar","monthsFormat","weekdays","weekdaysFormat","meridiems","eras","features","relative","localeWeek","throwOnInvalid","defaultLocale","defaultNumberingSystem","defaultOutputCalendar","twoDigitCutoffYear","defaultWeekSettings","Settings","n","instance","weekSettings","cutoffYear","t","resetCaches","InvalidZone","singleton","SystemZone","resolvedOptions","getTimezoneOffset","INVALID","Interval","config","start","end","invalid","isLuxonInterval","reason","explanation","fromDateTimes","builtStart","builtEnd","validateError","toISO","validateStartEnd","after","duration","dur","fromDurationLike","dt","plus","before","minus","fromISO","text","opts","split","startIsValid","endIsValid","isInterval","o","lastDateTime","invalidReason","invalidExplanation","unit","toDuration","count","startOf","useLocaleWeeks","reconfigure","floor","diff","valueOf","hasSame","isEmpty","isAfter","dateTime","isBefore","contains","splitAt","dateTimes","sorted","map","filter","d","sort","a","b","toMillis","results","added","next","push","splitBy","as","idx","mapUnits","x","divideEqually","numberOfParts","overlaps","other","abutsStart","abutsEnd","engulfs","intersection","union","merge","intervals","found","final","reduce","sofar","current","item","concat","xor","currentCount","ends","time","arr","Array","prototype","difference","toString","Symbol","for","toLocaleString","formatOpts","loc","clone","formatInterval","toISODate","toISOTime","toFormat","dateFormat","separator","mapEndpoints","mapFn","Zone","ianaName","FixedOffsetZone","utcInstance","parseSpecifier","r","match","fixed"],"sourceRoot":""}