@js-joda/locale 4.2.1 → 4.6.0

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

@@ -0,0 +1,1823 @@
+//! @version @js-joda/locale - 4.5.0
+//! @copyright (c) 2015-present, Philipp Thürwächter, Pattrick Hüper & js-joda contributors
+//! @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+//! @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+
+import { IllegalArgumentException, DateTimeFormatterBuilder, SignStyle, TextStyle, ChronoField, IsoFields, _, TemporalQueries, ZoneOffset, ZoneRulesProvider, ZoneId, ValueRange, DayOfWeek, ChronoUnit, IllegalStateException, LocalDate, Year, ResolverStyle, DateTimeException, IsoChronology, TemporalField, DateTimeFormatter, use } from '@js-joda/core';
+import cldrData from 'cldr-data';
+import Cldr from 'cldrjs';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+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) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  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;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+
+  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 TextPrinterParser = function () {
+  function TextPrinterParser(field, textStyle, provider) {
+    this._field = field;
+    this._textStyle = textStyle;
+    this._provider = provider;
+  }
+
+  var _proto = TextPrinterParser.prototype;
+
+  _proto.field = function field() {
+    return this._field;
+  };
+
+  _proto.textStyle = function textStyle() {
+    return this._textStyle;
+  };
+
+  _proto.provider = function provider() {
+    return this._provider;
+  };
+
+  _proto.print = function print(context, buf) {
+    var value = context.getValue(this._field);
+
+    if (value === null) {
+      return false;
+    }
+
+    var text = this._provider.getText(this._field, value, this._textStyle, context.locale());
+
+    if (text === null) {
+      return this._numberPrinterParser().print(context, buf);
+    }
+
+    buf.append(text);
+    return true;
+  };
+
+  _proto.parse = function parse(context, parseText, position) {
+    var length = parseText.length;
+
+    if (position < 0 || position > length) {
+      throw new IllegalArgumentException("The position is invalid: " + position);
+    }
+
+    var style = context.isStrict() ? this._textStyle : null;
+
+    var it = this._provider.getTextIterator(this._field, style, context.locale());
+
+    if (it != null) {
+      for (var _iterator = _createForOfIteratorHelperLoose(it), _step; !(_step = _iterator()).done;) {
+        var entry = _step.value;
+        var itText = entry.key;
+
+        if (context.subSequenceEquals(itText, 0, parseText, position, itText.length)) {
+          return context.setParsedField(this._field, entry.value, position, position + itText.length);
+        }
+      }
+
+      if (context.isStrict()) {
+        return ~position;
+      }
+    }
+
+    return this._numberPrinterParser().parse(context, parseText, position);
+  };
+
+  _proto._numberPrinterParser = function _numberPrinterParser() {
+    if (this._currentNumberPrinterParser == null) {
+      this._currentNumberPrinterParser = new DateTimeFormatterBuilder.NumberPrinterParser(this._field, 1, 19, SignStyle.NORMAL);
+    }
+
+    return this._currentNumberPrinterParser;
+  };
+
+  _proto.toString = function toString() {
+    if (this._textStyle === TextStyle.FULL) {
+      return "Text(" + this._field + ")";
+    }
+
+    return "Text(" + this._field + "," + this._textStyle + ")";
+  };
+
+  return TextPrinterParser;
+}();
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+var createEntry = function createEntry(text, field) {
+  return {
+    key: text,
+    value: field,
+    toString: function toString() {
+      return text + "->" + field;
+    }
+  };
+};
+
+var _comparator = function _comparator(obj1, obj2) {
+  return obj2.key.length - obj1.key.length;
+};
+
+var LocaleStore = function () {
+  function LocaleStore(valueTextMap) {
+    this._valueTextMap = valueTextMap;
+    var map = {};
+    var allList = [];
+    Object.keys(valueTextMap).forEach(function (style) {
+      var reverse = {};
+      var list = [];
+      Object.keys(valueTextMap[style]).forEach(function (key) {
+        var value = valueTextMap[style][key];
+
+        if (reverse[value] === undefined) {
+          reverse[value] = createEntry(value, parseInt(key));
+          list.push(reverse[value]);
+        }
+      });
+      list.sort(_comparator);
+      map[style] = list;
+      allList = allList.concat(list);
+      map[null] = allList;
+    });
+    allList.sort(_comparator);
+    this._parsable = map;
+  }
+
+  var _proto = LocaleStore.prototype;
+
+  _proto.getText = function getText(value, style) {
+    var map = this._valueTextMap[style];
+    return map != null ? map[value] : null;
+  };
+
+  _proto.getTextIterator = function getTextIterator(style) {
+    var list = this._parsable[style];
+    return list != null ? list[Symbol.iterator]() : null;
+  };
+
+  return LocaleStore;
+}();
+
+/*
+* @copyright (c) 2020, Philipp Thuerwaechter & Pattrick Hueper
+* @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+*/
+var cldrDataLoaded = new Set();
+var loadCldrData = function loadCldrData(path) {
+  if (!cldrDataLoaded.has(path)) {
+    Cldr.load(cldrData(path));
+    cldrDataLoaded.add(path);
+  }
+};
+var localeToCldrInstanceCache = {};
+var getOrCreateCldrInstance = function getOrCreateCldrInstance(locale) {
+  if (localeToCldrInstanceCache[locale] == null) {
+    localeToCldrInstanceCache[locale] = new Cldr(locale);
+  }
+
+  return localeToCldrInstanceCache[locale];
+};
+var localeToMapZonesCache = {};
+var getOrCreateMapZones = function getOrCreateMapZones(cldr) {
+  if (localeToMapZonesCache[cldr.locale] == null) {
+    var mapZones = {};
+    cldr.get('supplemental/metaZones/metazones').forEach(function (metaZone) {
+      if (metaZone.mapZone) {
+        if (!mapZones[metaZone.mapZone._other]) {
+          mapZones[metaZone.mapZone._other] = {};
+        }
+
+        mapZones[metaZone.mapZone._other][metaZone.mapZone._territory] = metaZone.mapZone._type;
+      }
+    });
+    localeToMapZonesCache[cldr.locale] = mapZones;
+  }
+
+  return localeToMapZonesCache[cldr.locale];
+};
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+
+var CldrDateTimeTextProvider = function () {
+  function CldrDateTimeTextProvider() {
+    this._cache = {};
+    loadCldrData('supplemental/likelySubtags.json');
+  }
+
+  var _proto = CldrDateTimeTextProvider.prototype;
+
+  _proto.getAvailableLocales = function getAvailableLocales() {
+    return cldrData('availableLocales.json').availableLocales;
+  };
+
+  _proto.getText = function getText(field, value, style, locale) {
+    var store = this._findStore(field, locale);
+
+    if (store instanceof LocaleStore) {
+      return store.getText(value, style);
+    }
+
+    return null;
+  };
+
+  _proto.getTextIterator = function getTextIterator(field, style, locale) {
+    var store = this._findStore(field, locale);
+
+    if (store instanceof LocaleStore) {
+      return store.getTextIterator(style);
+    }
+
+    return null;
+  };
+
+  _proto._findStore = function _findStore(field, locale) {
+    var key = createEntry(field, locale);
+    var store = this._cache[key];
+
+    if (store === undefined) {
+      store = this._createStore(field, locale);
+      this._cache[key] = store;
+    }
+
+    return store;
+  };
+
+  _proto._createStore = function _createStore(field, locale) {
+    loadCldrData("main/" + locale.localeString() + "/ca-gregorian.json");
+    var cldr = getOrCreateCldrInstance(locale.localeString());
+
+    if (field === ChronoField.MONTH_OF_YEAR) {
+      var monthsData = cldr.main('dates/calendars/gregorian/months/format');
+      var styleMap = {};
+      var data = {};
+      data[1] = monthsData.wide[1];
+      data[2] = monthsData.wide[2];
+      data[3] = monthsData.wide[3];
+      data[4] = monthsData.wide[4];
+      data[5] = monthsData.wide[5];
+      data[6] = monthsData.wide[6];
+      data[7] = monthsData.wide[7];
+      data[8] = monthsData.wide[8];
+      data[9] = monthsData.wide[9];
+      data[10] = monthsData.wide[10];
+      data[11] = monthsData.wide[11];
+      data[12] = monthsData.wide[12];
+      styleMap[TextStyle.FULL] = data;
+      data = {};
+      data[1] = monthsData.narrow[1];
+      data[2] = monthsData.narrow[2];
+      data[3] = monthsData.narrow[3];
+      data[4] = monthsData.narrow[4];
+      data[5] = monthsData.narrow[5];
+      data[6] = monthsData.narrow[6];
+      data[7] = monthsData.narrow[7];
+      data[8] = monthsData.narrow[8];
+      data[9] = monthsData.narrow[9];
+      data[10] = monthsData.narrow[10];
+      data[11] = monthsData.narrow[11];
+      data[12] = monthsData.narrow[12];
+      styleMap[TextStyle.NARROW] = data;
+      data = {};
+      data[1] = monthsData.abbreviated[1];
+      data[2] = monthsData.abbreviated[2];
+      data[3] = monthsData.abbreviated[3];
+      data[4] = monthsData.abbreviated[4];
+      data[5] = monthsData.abbreviated[5];
+      data[6] = monthsData.abbreviated[6];
+      data[7] = monthsData.abbreviated[7];
+      data[8] = monthsData.abbreviated[8];
+      data[9] = monthsData.abbreviated[9];
+      data[10] = monthsData.abbreviated[10];
+      data[11] = monthsData.abbreviated[11];
+      data[12] = monthsData.abbreviated[12];
+      styleMap[TextStyle.SHORT] = data;
+      return this._createLocaleStore(styleMap);
+    }
+
+    if (field === ChronoField.DAY_OF_WEEK) {
+      var daysData = cldr.main('dates/calendars/gregorian/days/format');
+      var _styleMap = {};
+      var _data = {};
+      _data[1] = daysData.wide.mon;
+      _data[2] = daysData.wide.tue;
+      _data[3] = daysData.wide.wed;
+      _data[4] = daysData.wide.thu;
+      _data[5] = daysData.wide.fri;
+      _data[6] = daysData.wide.sat;
+      _data[7] = daysData.wide.sun;
+      _styleMap[TextStyle.FULL] = _data;
+      _data = {};
+      _data[1] = daysData.narrow.mon;
+      _data[2] = daysData.narrow.tue;
+      _data[3] = daysData.narrow.wed;
+      _data[4] = daysData.narrow.thu;
+      _data[5] = daysData.narrow.fri;
+      _data[6] = daysData.narrow.sat;
+      _data[7] = daysData.narrow.sun;
+      _styleMap[TextStyle.NARROW] = _data;
+      _data = {};
+      _data[1] = daysData.abbreviated.mon;
+      _data[2] = daysData.abbreviated.tue;
+      _data[3] = daysData.abbreviated.wed;
+      _data[4] = daysData.abbreviated.thu;
+      _data[5] = daysData.abbreviated.fri;
+      _data[6] = daysData.abbreviated.sat;
+      _data[7] = daysData.abbreviated.sun;
+      _styleMap[TextStyle.SHORT] = _data;
+      return this._createLocaleStore(_styleMap);
+    }
+
+    if (field === ChronoField.AMPM_OF_DAY) {
+      var dayPeriodsData = cldr.main('dates/calendars/gregorian/dayPeriods/format');
+      var _styleMap2 = {};
+      var _data2 = {};
+      _data2[0] = dayPeriodsData.wide.am;
+      _data2[1] = dayPeriodsData.wide.pm;
+      _styleMap2[TextStyle.FULL] = _data2;
+      _data2 = {};
+      _data2[0] = dayPeriodsData.narrow.am;
+      _data2[1] = dayPeriodsData.narrow.pm;
+      _styleMap2[TextStyle.NARROW] = _data2;
+      _data2 = {};
+      _data2[0] = dayPeriodsData.abbreviated.am;
+      _data2[1] = dayPeriodsData.abbreviated.pm;
+      _styleMap2[TextStyle.SHORT] = _data2;
+      return this._createLocaleStore(_styleMap2);
+    }
+
+    if (field === ChronoField.ERA) {
+      var erasData = cldr.main('dates/calendars/gregorian/eras');
+      var _styleMap3 = {};
+      var _data3 = {};
+      _data3[0] = erasData.eraNames['0'];
+      _data3[1] = erasData.eraNames['1'];
+      _styleMap3[TextStyle.FULL] = _data3;
+      _data3 = {};
+      _data3[0] = erasData.eraNarrow['0'];
+      _data3[1] = erasData.eraNarrow['1'];
+      _styleMap3[TextStyle.NARROW] = _data3;
+      _data3 = {};
+      _data3[0] = erasData.eraAbbr['0'];
+      _data3[1] = erasData.eraAbbr['1'];
+      _styleMap3[TextStyle.SHORT] = _data3;
+      return this._createLocaleStore(_styleMap3);
+    }
+
+    if (field === IsoFields.QUARTER_OF_YEAR) {
+      var quartersData = cldr.main('dates/calendars/gregorian/quarters/format');
+      var _styleMap4 = {};
+      var _data4 = {};
+      _data4[1] = quartersData.wide['1'];
+      _data4[2] = quartersData.wide['2'];
+      _data4[3] = quartersData.wide['3'];
+      _data4[4] = quartersData.wide['4'];
+      _styleMap4[TextStyle.FULL] = _data4;
+      _data4 = {};
+      _data4[1] = quartersData.narrow['1'];
+      _data4[2] = quartersData.narrow['2'];
+      _data4[3] = quartersData.narrow['3'];
+      _data4[4] = quartersData.narrow['4'];
+      _styleMap4[TextStyle.NARROW] = _data4;
+      _data4 = {};
+      _data4[1] = quartersData.abbreviated['1'];
+      _data4[2] = quartersData.abbreviated['2'];
+      _data4[3] = quartersData.abbreviated['3'];
+      _data4[4] = quartersData.abbreviated['4'];
+      _styleMap4[TextStyle.SHORT] = _data4;
+      return this._createLocaleStore(_styleMap4);
+    }
+
+    return null;
+  };
+
+  _proto._createLocaleStore = function _createLocaleStore(valueTextMap) {
+    valueTextMap[TextStyle.FULL_STANDALONE] = valueTextMap[TextStyle.FULL];
+    valueTextMap[TextStyle.SHORT_STANDALONE] = valueTextMap[TextStyle.SHORT];
+
+    if (Object.keys(valueTextMap).indexOf(TextStyle.NARROW) > -1 && Object.keys(valueTextMap).indexOf(TextStyle.NARROW_STANDALONE) === -1) {
+      valueTextMap[TextStyle.NARROW_STANDALONE] = valueTextMap[TextStyle.NARROW];
+    }
+
+    return new LocaleStore(valueTextMap);
+  };
+
+  return CldrDateTimeTextProvider;
+}();
+
+var _jodaInternal$assert$2 = _.assert,
+    requireNonNull$3 = _jodaInternal$assert$2.requireNonNull,
+    requireInstance$2 = _jodaInternal$assert$2.requireInstance;
+
+var LENGTH_COMPARATOR = function LENGTH_COMPARATOR(str1, str2) {
+  var cmp = str2.length - str1.length;
+
+  if (cmp === 0) {
+    cmp = str1.localeCompare(str2);
+  }
+
+  return cmp;
+};
+
+var resolveZoneIdTextCache = {};
+
+var CldrZoneTextPrinterParser = function () {
+  function CldrZoneTextPrinterParser(textStyle) {
+    requireNonNull$3(textStyle, 'textStyle');
+    requireInstance$2(textStyle, TextStyle, 'textStyle');
+    this._textStyle = textStyle;
+    this._zoneIdsLocales = {};
+    loadCldrData('supplemental/likelySubtags.json');
+    loadCldrData('supplemental/metaZones.json');
+  }
+
+  var _proto = CldrZoneTextPrinterParser.prototype;
+
+  _proto._cachedResolveZoneIdText = function _cachedResolveZoneIdText(cldr, zoneId, style, type) {
+    if (resolveZoneIdTextCache[cldr.locale] == null) {
+      resolveZoneIdTextCache[cldr.locale] = {};
+    }
+
+    var zoneIdToStyle = resolveZoneIdTextCache[cldr.locale];
+
+    if (zoneIdToStyle[zoneId] == null) {
+      zoneIdToStyle[zoneId] = {};
+    }
+
+    var styleToType = zoneIdToStyle[zoneId];
+
+    if (styleToType[style] == null) {
+      styleToType[style] = {};
+    }
+
+    var typeToResolvedZoneIdText = styleToType[style];
+
+    if (typeToResolvedZoneIdText[type] == null) {
+      typeToResolvedZoneIdText[type] = this._resolveZoneIdText(cldr, zoneId, style, type);
+    }
+
+    return typeToResolvedZoneIdText[type];
+  };
+
+  _proto._resolveZoneIdText = function _resolveZoneIdText(cldr, zoneId, style, type) {
+    var zoneData = cldr.main("dates/timeZoneNames/zone/" + zoneId + "/" + style + "/" + type);
+
+    if (zoneData) {
+      return zoneData;
+    } else {
+      var metazoneInfo = cldr.get("supplemental/metaZones/metazoneInfo/timezone/" + zoneId);
+
+      if (metazoneInfo) {
+        var metazone = metazoneInfo[metazoneInfo.length - 1]['usesMetazone']['_mzone'];
+        var metaZoneData = cldr.main("dates/timeZoneNames/metazone/" + metazone + "/" + style + "/" + type);
+
+        if (metaZoneData) {
+          return metaZoneData;
+        } else {
+          metaZoneData = cldr.main("dates/timeZoneNames/metazone/" + metazone + "/" + style + "/generic");
+
+          if (!metaZoneData) {
+            metaZoneData = cldr.main("dates/timeZoneNames/metazone/" + metazone + "/" + style + "/standard");
+          }
+
+          if (metaZoneData) {
+            return metaZoneData;
+          } else {
+            var mapZones = getOrCreateMapZones(cldr);
+            var preferredZone = mapZones[metazone][cldr.attributes.territory];
+
+            if (preferredZone) {
+              if (preferredZone !== zoneId) {
+                return this._cachedResolveZoneIdText(cldr, preferredZone, style, type);
+              }
+            } else {
+              var goldenZone = mapZones[metazone]['001'];
+
+              if (goldenZone !== zoneId) {
+                return this._cachedResolveZoneIdText(cldr, goldenZone, style, type);
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  _proto.print = function print(context, buf) {
+    var zone = context.getValueQuery(TemporalQueries.zoneId());
+
+    if (zone == null) {
+      return false;
+    }
+
+    if (zone.normalized() instanceof ZoneOffset) {
+      buf.append(zone.id());
+      return true;
+    }
+    var tzType = 'generic';
+    var tzstyle = this._textStyle.asNormal() === TextStyle.FULL ? 'long' : 'short';
+    loadCldrData("main/" + context.locale().localeString() + "/timeZoneNames.json");
+    var cldr = getOrCreateCldrInstance(context.locale().localeString());
+
+    var text = this._cachedResolveZoneIdText(cldr, zone.id(), tzstyle, tzType);
+
+    if (text) {
+      buf.append(text);
+    } else {
+      buf.append(zone.id());
+    }
+
+    return true;
+  };
+
+  _proto._resolveZoneIds = function _resolveZoneIds(localString) {
+    if (this._zoneIdsLocales[localString] != null) {
+      return this._zoneIdsLocales[localString];
+    }
+
+    var ids = {};
+    loadCldrData("main/" + localString + "/timeZoneNames.json");
+    var cldr = getOrCreateCldrInstance(localString);
+
+    for (var _iterator = _createForOfIteratorHelperLoose(ZoneRulesProvider.getAvailableZoneIds()), _step; !(_step = _iterator()).done;) {
+      var id = _step.value;
+      ids[id] = id;
+      var tzstyle = this._textStyle.asNormal() === TextStyle.FULL ? 'long' : 'short';
+
+      var genericText = this._cachedResolveZoneIdText(cldr, id, tzstyle, 'generic');
+
+      if (genericText) {
+        ids[genericText] = id;
+      }
+
+      var standardText = this._cachedResolveZoneIdText(cldr, id, tzstyle, 'standard');
+
+      if (standardText) {
+        ids[standardText] = id;
+      }
+
+      var daylightText = this._cachedResolveZoneIdText(cldr, id, tzstyle, 'daylight');
+
+      if (daylightText) {
+        ids[daylightText] = id;
+      }
+    }
+
+    var sortedKeys = Object.keys(ids).sort(LENGTH_COMPARATOR);
+    this._zoneIdsLocales[localString] = {
+      ids: ids,
+      sortedKeys: sortedKeys
+    };
+    return this._zoneIdsLocales[localString];
+  };
+
+  _proto.parse = function parse(context, text, position) {
+    for (var _i = 0, _arr = ['UTC', 'GMT']; _i < _arr.length; _i++) {
+      var name = _arr[_i];
+
+      if (context.subSequenceEquals(text, position, name, 0, name.length)) {
+        context.setParsedZone(ZoneId.of(name));
+        return position + name.length;
+      }
+    }
+
+    var _this$_resolveZoneIds = this._resolveZoneIds(context.locale().localeString()),
+        ids = _this$_resolveZoneIds.ids,
+        sortedKeys = _this$_resolveZoneIds.sortedKeys;
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(sortedKeys), _step2; !(_step2 = _iterator2()).done;) {
+      var _name = _step2.value;
+
+      if (context.subSequenceEquals(text, position, _name, 0, _name.length)) {
+        context.setParsedZone(ZoneId.of(ids[_name]));
+        return position + _name.length;
+      }
+    }
+
+    return ~position;
+  };
+
+  _proto.toString = function toString() {
+    return "ZoneText(" + this._textStyle + ")";
+  };
+
+  return CldrZoneTextPrinterParser;
+}();
+
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+var MathUtil$1 = _.MathUtil;
+
+var LocalizedOffsetPrinterParser = function () {
+  function LocalizedOffsetPrinterParser(textStyle) {
+    this._textStyle = textStyle;
+  }
+
+  var _proto = LocalizedOffsetPrinterParser.prototype;
+
+  _proto.textStyle = function textStyle() {
+    return this._textStyle;
+  };
+
+  _proto.print = function print(context, buf) {
+    var offsetSecs = context.getValue(ChronoField.OFFSET_SECONDS);
+
+    if (offsetSecs == null) {
+      return false;
+    }
+
+    buf.append('GMT');
+
+    if (this._textStyle === TextStyle.FULL) {
+      return new DateTimeFormatterBuilder.OffsetIdPrinterParser('', '+HH:MM:ss').print(context, buf);
+    }
+
+    var totalSecs = MathUtil$1.safeToInt(offsetSecs);
+
+    if (totalSecs !== 0) {
+      var absHours = Math.abs(MathUtil$1.intMod(MathUtil$1.intDiv(totalSecs, 3600), 100));
+      var absMinutes = Math.abs(MathUtil$1.intMod(MathUtil$1.intDiv(totalSecs, 60), 60));
+      var absSeconds = Math.abs(MathUtil$1.intMod(totalSecs, 60));
+      buf.append(totalSecs < 0 ? '-' : '+').append(absHours);
+
+      if (absMinutes > 0 || absSeconds > 0) {
+        buf.append(':').append(MathUtil$1.intDiv(absMinutes, 10)).append(MathUtil$1.intMod(absMinutes, 10));
+
+        if (absSeconds > 0) {
+          buf.append(':').append(MathUtil$1.intDiv(absSeconds, 10)).append(MathUtil$1.intMod(absSeconds, 10));
+        }
+      }
+    }
+
+    return true;
+  };
+
+  _proto.parse = function parse(context, text, position) {
+    if (context.subSequenceEquals(text, position, 'GMT', 0, 3) === false) {
+      return ~position;
+    }
+
+    position += 3;
+
+    if (this._textStyle === TextStyle.FULL) {
+      return new DateTimeFormatterBuilder.OffsetIdPrinterParser('', '+HH:MM:ss').parse(context, text, position);
+    }
+
+    var end = text.length;
+
+    if (position === end) {
+      return context.setParsedField(ChronoField.OFFSET_SECONDS, 0, position, position);
+    }
+
+    var sign = text.charAt(position);
+
+    if (sign !== '+' && sign !== '-') {
+      return context.setParsedField(ChronoField.OFFSET_SECONDS, 0, position, position);
+    }
+
+    var negative = sign === '-' ? -1 : 1;
+
+    if (position === end) {
+      return ~position;
+    }
+
+    position++;
+    var ch = text.charAt(position);
+
+    if (ch < '0' || ch > '9') {
+      return ~position;
+    }
+
+    position++;
+    var hour = MathUtil$1.parseInt(ch);
+
+    if (position !== end) {
+      ch = text.charAt(position);
+
+      if (ch >= '0' && ch <= '9') {
+        hour = hour * 10 + MathUtil$1.parseInt(ch);
+
+        if (hour > 23) {
+          return ~position;
+        }
+
+        position++;
+      }
+    }
+
+    if (position === end || text.charAt(position) !== ':') {
+      var _offset = negative * 3600 * hour;
+
+      return context.setParsedField(ChronoField.OFFSET_SECONDS, _offset, position, position);
+    }
+
+    position++;
+
+    if (position > end - 2) {
+      return ~position;
+    }
+
+    ch = text.charAt(position);
+
+    if (ch < '0' || ch > '9') {
+      return ~position;
+    }
+
+    position++;
+    var min = MathUtil$1.parseInt(ch);
+    ch = text.charAt(position);
+
+    if (ch < '0' || ch > '9') {
+      return ~position;
+    }
+
+    position++;
+    min = min * 10 + MathUtil$1.parseInt(ch);
+
+    if (min > 59) {
+      return ~position;
+    }
+
+    if (position === end || text.charAt(position) !== ':') {
+      var _offset2 = negative * (3600 * hour + 60 * min);
+
+      return context.setParsedField(ChronoField.OFFSET_SECONDS, _offset2, position, position);
+    }
+
+    position++;
+
+    if (position > end - 2) {
+      return ~position;
+    }
+
+    ch = text.charAt(position);
+
+    if (ch < '0' || ch > '9') {
+      return ~position;
+    }
+
+    position++;
+    var sec = MathUtil$1.parseInt(ch);
+    ch = text.charAt(position);
+
+    if (ch < '0' || ch > '9') {
+      return ~position;
+    }
+
+    position++;
+    sec = sec * 10 + MathUtil$1.parseInt(ch);
+
+    if (sec > 59) {
+      return ~position;
+    }
+
+    var offset = negative * (3600 * hour + 60 * min + sec);
+    return context.setParsedField(ChronoField.OFFSET_SECONDS, offset, position, position);
+  };
+
+  _proto.toString = function toString() {
+    return "LocalizedOffset(" + this._textStyle + ")";
+  };
+
+  return LocalizedOffsetPrinterParser;
+}();
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+var MathUtil = _.MathUtil,
+    _jodaInternal$assert$1 = _.assert,
+    requireNonNull$2 = _jodaInternal$assert$1.requireNonNull,
+    requireInstance$1 = _jodaInternal$assert$1.requireInstance;
+var DAY_OF_WEEK_RANGE = ValueRange.of(1, 7);
+var WEEK_OF_MONTH_RANGE = ValueRange.of(0, 1, 4, 6);
+var WEEK_OF_YEAR_RANGE = ValueRange.of(0, 1, 52, 54);
+var WEEK_OF_WEEK_BASED_YEAR_RANGE = ValueRange.of(1, 52, 53);
+var WEEK_BASED_YEAR_RANGE = ChronoField.YEAR.range();
+var _weekDayMap = {
+  'mon': DayOfWeek.MONDAY,
+  'tue': DayOfWeek.TUESDAY,
+  'wed': DayOfWeek.WEDNESDAY,
+  'thu': DayOfWeek.THURSDAY,
+  'fri': DayOfWeek.FRIDAY,
+  'sat': DayOfWeek.SATURDAY,
+  'sun': DayOfWeek.SUNDAY
+};
+var ComputedDayOfField = function () {
+  ComputedDayOfField.ofDayOfWeekField = function ofDayOfWeekField(weekDef) {
+    return new ComputedDayOfField('DayOfWeek', weekDef, ChronoUnit.DAYS, ChronoUnit.WEEKS, DAY_OF_WEEK_RANGE);
+  };
+
+  ComputedDayOfField.ofWeekOfMonthField = function ofWeekOfMonthField(weekDef) {
+    return new ComputedDayOfField('WeekOfMonth', weekDef, ChronoUnit.WEEKS, ChronoUnit.MONTHS, WEEK_OF_MONTH_RANGE);
+  };
+
+  ComputedDayOfField.ofWeekOfYearField = function ofWeekOfYearField(weekDef) {
+    return new ComputedDayOfField('WeekOfYear', weekDef, ChronoUnit.WEEKS, ChronoUnit.YEARS, WEEK_OF_YEAR_RANGE);
+  };
+
+  ComputedDayOfField.ofWeekOfWeekBasedYearField = function ofWeekOfWeekBasedYearField(weekDef) {
+    return new ComputedDayOfField('WeekOfWeekBasedYear', weekDef, ChronoUnit.WEEKS, IsoFields.WEEK_BASED_YEARS, WEEK_OF_WEEK_BASED_YEAR_RANGE);
+  };
+
+  ComputedDayOfField.ofWeekBasedYearField = function ofWeekBasedYearField(weekDef) {
+    return new ComputedDayOfField('WeekBasedYear', weekDef, IsoFields.WEEK_BASED_YEARS, ChronoUnit.FOREVER, WEEK_BASED_YEAR_RANGE);
+  };
+
+  function ComputedDayOfField(name, weekDef, baseUnit, rangeUnit, range) {
+    this._name = name;
+    this._weekDef = weekDef;
+    this._baseUnit = baseUnit;
+    this._rangeUnit = rangeUnit;
+    this._range = range;
+  }
+
+  var _proto = ComputedDayOfField.prototype;
+
+  _proto.getFrom = function getFrom(temporal) {
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    var dow = this._localizedDayOfWeek(temporal, sow);
+
+    if (this._rangeUnit === ChronoUnit.WEEKS) {
+      return dow;
+    } else if (this._rangeUnit === ChronoUnit.MONTHS) {
+      return this._localizedWeekOfMonth(temporal, dow);
+    } else if (this._rangeUnit === ChronoUnit.YEARS) {
+      return this._localizedWeekOfYear(temporal, dow);
+    } else if (this._rangeUnit === IsoFields.WEEK_BASED_YEARS) {
+      return this._localizedWOWBY(temporal);
+    } else if (this._rangeUnit === ChronoUnit.FOREVER) {
+      return this._localizedWBY(temporal);
+    } else {
+      throw new IllegalStateException('unreachable');
+    }
+  };
+
+  _proto._localizedDayOfWeek = function _localizedDayOfWeek(temporal, sow) {
+    var isoDow = temporal.get(ChronoField.DAY_OF_WEEK);
+    return MathUtil.floorMod(isoDow - sow, 7) + 1;
+  };
+
+  _proto._localizedWeekOfMonth = function _localizedWeekOfMonth(temporal, dow) {
+    var dom = temporal.get(ChronoField.DAY_OF_MONTH);
+
+    var offset = this._startOfWeekOffset(dom, dow);
+
+    return ComputedDayOfField._computeWeek(offset, dom);
+  };
+
+  _proto._localizedWeekOfYear = function _localizedWeekOfYear(temporal, dow) {
+    var doy = temporal.get(ChronoField.DAY_OF_YEAR);
+
+    var offset = this._startOfWeekOffset(doy, dow);
+
+    return ComputedDayOfField._computeWeek(offset, doy);
+  };
+
+  _proto._localizedWOWBY = function _localizedWOWBY(temporal) {
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    var isoDow = temporal.get(ChronoField.DAY_OF_WEEK);
+    var dow = MathUtil.floorMod(isoDow - sow, 7) + 1;
+
+    var woy = this._localizedWeekOfYear(temporal, dow);
+
+    if (woy === 0) {
+      var previous = LocalDate.from(temporal).minus(1, ChronoUnit.WEEKS);
+      return this._localizedWeekOfYear(previous, dow) + 1;
+    } else if (woy >= 53) {
+      var offset = this._startOfWeekOffset(temporal.get(ChronoField.DAY_OF_YEAR), dow);
+
+      var year = temporal.get(ChronoField.YEAR);
+      var yearLen = Year.isLeap(year) ? 366 : 365;
+
+      var weekIndexOfFirstWeekNextYear = ComputedDayOfField._computeWeek(offset, yearLen + this._weekDef.minimalDaysInFirstWeek());
+
+      if (woy >= weekIndexOfFirstWeekNextYear) {
+        return woy - (weekIndexOfFirstWeekNextYear - 1);
+      }
+    }
+
+    return woy;
+  };
+
+  _proto._localizedWBY = function _localizedWBY(temporal) {
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    var isoDow = temporal.get(ChronoField.DAY_OF_WEEK);
+    var dow = MathUtil.floorMod(isoDow - sow, 7) + 1;
+    var year = temporal.get(ChronoField.YEAR);
+
+    var woy = this._localizedWeekOfYear(temporal, dow);
+
+    if (woy === 0) {
+      return year - 1;
+    } else if (woy < 53) {
+      return year;
+    }
+
+    var offset = this._startOfWeekOffset(temporal.get(ChronoField.DAY_OF_YEAR), dow);
+
+    var yearLen = Year.isLeap(year) ? 366 : 365;
+
+    var weekIndexOfFirstWeekNextYear = ComputedDayOfField._computeWeek(offset, yearLen + this._weekDef.minimalDaysInFirstWeek());
+
+    if (woy >= weekIndexOfFirstWeekNextYear) {
+      return year + 1;
+    }
+
+    return year;
+  };
+
+  _proto._startOfWeekOffset = function _startOfWeekOffset(day, dow) {
+    var weekStart = MathUtil.floorMod(day - dow, 7);
+    var offset = -weekStart;
+
+    if (weekStart + 1 > this._weekDef.minimalDaysInFirstWeek()) {
+      offset = 7 - weekStart;
+    }
+
+    return offset;
+  };
+
+  ComputedDayOfField._computeWeek = function _computeWeek(offset, day) {
+    return MathUtil.intDiv(7 + offset + (day - 1), 7);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal, newValue) {
+    var newVal = this._range.checkValidIntValue(newValue, this);
+
+    var currentVal = temporal.get(this);
+
+    if (newVal === currentVal) {
+      return temporal;
+    }
+
+    if (this._rangeUnit === ChronoUnit.FOREVER) {
+      var baseWowby = temporal.get(this._weekDef.weekOfWeekBasedYear());
+      var diffWeeks = MathUtil.roundDown((newValue - currentVal) * 52.1775);
+      var result = temporal.plus(diffWeeks, ChronoUnit.WEEKS);
+
+      if (result.get(this) > newVal) {
+        var newWowby = result.get(this._weekDef.weekOfWeekBasedYear());
+        result = result.minus(newWowby, ChronoUnit.WEEKS);
+      } else {
+        if (result.get(this) < newVal) {
+          result = result.plus(2, ChronoUnit.WEEKS);
+        }
+
+        var _newWowby = result.get(this._weekDef.weekOfWeekBasedYear());
+
+        result = result.plus(baseWowby - _newWowby, ChronoUnit.WEEKS);
+
+        if (result.get(this) > newVal) {
+          result = result.minus(1, ChronoUnit.WEEKS);
+        }
+      }
+
+      return result;
+    }
+
+    var delta = newVal - currentVal;
+    return temporal.plus(delta, this._baseUnit);
+  };
+
+  _proto.resolve = function resolve(fieldValues, partialTemporal, resolverStyle) {
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    if (this._rangeUnit === ChronoUnit.WEEKS) {
+      var value = fieldValues.remove(this);
+
+      var localDow = this._range.checkValidIntValue(value, this);
+
+      var _isoDow = MathUtil.floorMod(sow - 1 + (localDow - 1), 7) + 1;
+
+      fieldValues.put(ChronoField.DAY_OF_WEEK, _isoDow);
+      return null;
+    }
+
+    if (fieldValues.containsKey(ChronoField.DAY_OF_WEEK) === false) {
+      return null;
+    }
+
+    if (this._rangeUnit === ChronoUnit.FOREVER) {
+      if (fieldValues.containsKey(this._weekDef.weekOfWeekBasedYear()) === false) {
+        return null;
+      }
+
+      var _isoDow2 = ChronoField.DAY_OF_WEEK.checkValidIntValue(fieldValues.get(ChronoField.DAY_OF_WEEK));
+
+      var _dow = MathUtil.floorMod(_isoDow2 - sow, 7) + 1;
+
+      var wby = this.range().checkValidIntValue(fieldValues.get(this), this);
+      var date;
+      var days;
+
+      if (resolverStyle === ResolverStyle.LENIENT) {
+        date = LocalDate.of(wby, 1, this._weekDef.minimalDaysInFirstWeek());
+        var wowby = fieldValues.get(this._weekDef.weekOfWeekBasedYear());
+
+        var dateDow = this._localizedDayOfWeek(date, sow);
+
+        var weeks = wowby - this._localizedWeekOfYear(date, dateDow);
+
+        days = weeks * 7 + (_dow - dateDow);
+      } else {
+        date = LocalDate.of(wby, 1, this._weekDef.minimalDaysInFirstWeek());
+
+        var _wowby = this._weekDef.weekOfWeekBasedYear().range().checkValidIntValue(fieldValues.get(this._weekDef.weekOfWeekBasedYear()), this._weekDef.weekOfWeekBasedYear);
+
+        var _dateDow = this._localizedDayOfWeek(date, sow);
+
+        var _weeks = _wowby - this._localizedWeekOfYear(date, _dateDow);
+
+        days = _weeks * 7 + (_dow - _dateDow);
+      }
+
+      date = date.plus(days, ChronoUnit.DAYS);
+
+      if (resolverStyle === ResolverStyle.STRICT) {
+        if (date.getLong(this) !== fieldValues.get(this)) {
+          throw new DateTimeException('Strict mode rejected date parsed to a different year');
+        }
+      }
+
+      fieldValues.remove(this);
+      fieldValues.remove(this._weekDef.weekOfWeekBasedYear());
+      fieldValues.remove(ChronoField.DAY_OF_WEEK);
+      return date;
+    }
+
+    if (fieldValues.containsKey(ChronoField.YEAR) === false) {
+      return null;
+    }
+
+    var isoDow = ChronoField.DAY_OF_WEEK.checkValidIntValue(fieldValues.get(ChronoField.DAY_OF_WEEK));
+    var dow = MathUtil.floorMod(isoDow - sow, 7) + 1;
+    var year = ChronoField.YEAR.checkValidIntValue(fieldValues.get(ChronoField.YEAR));
+
+    if (this._rangeUnit === ChronoUnit.MONTHS) {
+      if (fieldValues.containsKey(ChronoField.MONTH_OF_YEAR) === false) {
+        return null;
+      }
+
+      var _value = fieldValues.remove(this);
+
+      var _date;
+
+      var _days;
+
+      if (resolverStyle === ResolverStyle.LENIENT) {
+        var month = fieldValues.get(ChronoField.MONTH_OF_YEAR);
+        _date = LocalDate.of(year, 1, 1);
+        _date = _date.plus(month - 1, ChronoUnit.MONTHS);
+
+        var _dateDow2 = this._localizedDayOfWeek(_date, sow);
+
+        var _weeks2 = _value - this._localizedWeekOfMonth(_date, _dateDow2);
+
+        _days = _weeks2 * 7 + (dow - _dateDow2);
+      } else {
+        var _month = ChronoField.MONTH_OF_YEAR.checkValidIntValue(fieldValues.get(ChronoField.MONTH_OF_YEAR));
+
+        _date = LocalDate.of(year, _month, 8);
+
+        var _dateDow3 = this._localizedDayOfWeek(_date, sow);
+
+        var wom = this._range.checkValidIntValue(_value, this);
+
+        var _weeks3 = wom - this._localizedWeekOfMonth(_date, _dateDow3);
+
+        _days = _weeks3 * 7 + (dow - _dateDow3);
+      }
+
+      _date = _date.plus(_days, ChronoUnit.DAYS);
+
+      if (resolverStyle === ResolverStyle.STRICT) {
+        if (_date.getLong(ChronoField.MONTH_OF_YEAR) !== fieldValues.get(ChronoField.MONTH_OF_YEAR)) {
+          throw new DateTimeException('Strict mode rejected date parsed to a different month');
+        }
+      }
+
+      fieldValues.remove(this);
+      fieldValues.remove(ChronoField.YEAR);
+      fieldValues.remove(ChronoField.MONTH_OF_YEAR);
+      fieldValues.remove(ChronoField.DAY_OF_WEEK);
+      return _date;
+    } else if (this._rangeUnit === ChronoUnit.YEARS) {
+      var _value2 = fieldValues.remove(this);
+
+      var _date2 = LocalDate.of(year, 1, 1);
+
+      var _days2;
+
+      if (resolverStyle === ResolverStyle.LENIENT) {
+        var _dateDow4 = this._localizedDayOfWeek(_date2, sow);
+
+        var _weeks4 = _value2 - this._localizedWeekOfYear(_date2, _dateDow4);
+
+        _days2 = _weeks4 * 7 + (dow - _dateDow4);
+      } else {
+        var _dateDow5 = this._localizedDayOfWeek(_date2, sow);
+
+        var woy = this._range.checkValidIntValue(_value2, this);
+
+        var _weeks5 = woy - this._localizedWeekOfYear(_date2, _dateDow5);
+
+        _days2 = _weeks5 * 7 + (dow - _dateDow5);
+      }
+
+      _date2 = _date2.plus(_days2, ChronoUnit.DAYS);
+
+      if (resolverStyle === ResolverStyle.STRICT) {
+        if (_date2.getLong(ChronoField.YEAR) !== fieldValues.get(ChronoField.YEAR)) {
+          throw new DateTimeException('Strict mode rejected date parsed to a different year');
+        }
+      }
+
+      fieldValues.remove(this);
+      fieldValues.remove(ChronoField.YEAR);
+      fieldValues.remove(ChronoField.DAY_OF_WEEK);
+      return _date2;
+    } else {
+      throw new IllegalStateException('unreachable');
+    }
+  };
+
+  _proto.name = function name() {
+    return this._name;
+  };
+
+  _proto.baseUnit = function baseUnit() {
+    return this._baseUnit;
+  };
+
+  _proto.rangeUnit = function rangeUnit() {
+    return this._rangeUnit;
+  };
+
+  _proto.range = function range() {
+    return this._range;
+  };
+
+  _proto.isDateBased = function isDateBased() {
+    return true;
+  };
+
+  _proto.isTimeBased = function isTimeBased() {
+    return false;
+  };
+
+  _proto.isSupportedBy = function isSupportedBy(temporal) {
+    if (temporal.isSupported(ChronoField.DAY_OF_WEEK)) {
+      if (this._rangeUnit === ChronoUnit.WEEKS) {
+        return true;
+      } else if (this._rangeUnit === ChronoUnit.MONTHS) {
+        return temporal.isSupported(ChronoField.DAY_OF_MONTH);
+      } else if (this._rangeUnit === ChronoUnit.YEARS) {
+        return temporal.isSupported(ChronoField.DAY_OF_YEAR);
+      } else if (this._rangeUnit === IsoFields.WEEK_BASED_YEARS) {
+        return temporal.isSupported(ChronoField.EPOCH_DAY);
+      } else if (this._rangeUnit === ChronoUnit.FOREVER) {
+        return temporal.isSupported(ChronoField.EPOCH_DAY);
+      }
+    }
+
+    return false;
+  };
+
+  _proto.rangeRefinedBy = function rangeRefinedBy(temporal) {
+    if (this._rangeUnit === ChronoUnit.WEEKS) {
+      return this._range;
+    }
+
+    var field = null;
+
+    if (this._rangeUnit === ChronoUnit.MONTHS) {
+      field = ChronoField.DAY_OF_MONTH;
+    } else if (this._rangeUnit === ChronoUnit.YEARS) {
+      field = ChronoField.DAY_OF_YEAR;
+    } else if (this._rangeUnit === IsoFields.WEEK_BASED_YEARS) {
+      return this._rangeWOWBY(temporal);
+    } else if (this._rangeUnit === ChronoUnit.FOREVER) {
+      return temporal.range(ChronoField.YEAR);
+    } else {
+      throw new IllegalStateException('unreachable');
+    }
+
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    var isoDow = temporal.get(ChronoField.DAY_OF_WEEK);
+    var dow = MathUtil.floorMod(isoDow - sow, 7) + 1;
+
+    var offset = this._startOfWeekOffset(temporal.get(field), dow);
+
+    var fieldRange = temporal.range(field);
+    return ValueRange.of(ComputedDayOfField._computeWeek(offset, fieldRange.minimum()), ComputedDayOfField._computeWeek(offset, fieldRange.maximum()));
+  };
+
+  _proto._rangeWOWBY = function _rangeWOWBY(temporal) {
+    var sow = this._weekDef.firstDayOfWeek().value();
+
+    var isoDow = temporal.get(ChronoField.DAY_OF_WEEK);
+    var dow = MathUtil.floorMod(isoDow - sow, 7) + 1;
+
+    var woy = this._localizedWeekOfYear(temporal, dow);
+
+    if (woy === 0) {
+      return this._rangeWOWBY(IsoChronology.INSTANCE.date(temporal).minus(2, ChronoUnit.WEEKS));
+    }
+
+    var offset = this._startOfWeekOffset(temporal.get(ChronoField.DAY_OF_YEAR), dow);
+
+    var year = temporal.get(ChronoField.YEAR);
+    var yearLen = Year.isLeap(year) ? 366 : 365;
+
+    var weekIndexOfFirstWeekNextYear = ComputedDayOfField._computeWeek(offset, yearLen + this._weekDef.minimalDaysInFirstWeek());
+
+    if (woy >= weekIndexOfFirstWeekNextYear) {
+      return this._rangeWOWBY(IsoChronology.INSTANCE.date(temporal).plus(2, ChronoUnit.WEEKS));
+    }
+
+    return ValueRange.of(1, weekIndexOfFirstWeekNextYear - 1);
+  };
+
+  _proto.displayName = function displayName(locale) {
+    requireNonNull$2(locale, 'locale');
+
+    if (this._rangeUnit === ChronoUnit.YEARS) {
+      return 'Week';
+    }
+
+    return this.toString();
+  };
+
+  _proto.toString = function toString() {
+    return this._name + "[" + this._weekDef.toString() + "]";
+  };
+
+  return ComputedDayOfField;
+}();
+var WeekFieldsCache = new Map();
+var WeekFields = function () {
+  WeekFields.of = function of(firstDayOrLocale, minDays) {
+    if (minDays === undefined) {
+      return WeekFields.ofLocale(firstDayOrLocale);
+    } else {
+      return WeekFields.ofFirstDayOfWeekMinDays(firstDayOrLocale, minDays);
+    }
+  };
+
+  WeekFields.ofLocale = function ofLocale(locale) {
+    requireNonNull$2(locale, 'locale');
+    Cldr.load(cldrData('supplemental/weekData.json'));
+    var cldr = new Cldr(locale.localeString());
+    var worldRegion = '001';
+    var weekData = cldr.get('supplemental/weekData');
+
+    var dow = _weekDayMap[weekData.firstDay[locale.country()]];
+
+    if (!dow) {
+      dow = _weekDayMap[weekData.firstDay[worldRegion]];
+    }
+
+    var minDays = weekData.minDays[locale.country()];
+
+    if (!minDays) {
+      minDays = weekData.minDays[worldRegion];
+    }
+
+    return WeekFields.ofFirstDayOfWeekMinDays(dow, minDays);
+  };
+
+  WeekFields.ofFirstDayOfWeekMinDays = function ofFirstDayOfWeekMinDays(firstDayOfWeek, minimalDaysInFirstWeek) {
+    requireNonNull$2(firstDayOfWeek, 'firstDayOfWeek');
+    requireInstance$1(firstDayOfWeek, DayOfWeek, 'firstDayOfWeek');
+    requireNonNull$2(minimalDaysInFirstWeek, 'minimalDaysInFirstWeek');
+    var key = firstDayOfWeek.toString() + minimalDaysInFirstWeek;
+    var rules = WeekFieldsCache.get(key);
+
+    if (rules == null) {
+      rules = new WeekFields(firstDayOfWeek, minimalDaysInFirstWeek);
+      WeekFieldsCache.set(key, rules);
+      rules = WeekFieldsCache.get(key);
+    }
+
+    return rules;
+  };
+
+  function WeekFields(firstDayOfWeek, minimalDaysInFirstWeek) {
+    requireNonNull$2(firstDayOfWeek, 'firstDayOfWeek');
+    requireInstance$1(firstDayOfWeek, DayOfWeek, 'firstDayOfWeek');
+    requireNonNull$2(minimalDaysInFirstWeek, 'minimalDaysInFirstWeek');
+
+    if (minimalDaysInFirstWeek < 1 || minimalDaysInFirstWeek > 7) {
+      throw new IllegalArgumentException('Minimal number of days is invalid');
+    }
+
+    this._firstDayOfWeek = firstDayOfWeek;
+    this._minimalDays = minimalDaysInFirstWeek;
+    this._dayOfWeek = ComputedDayOfField.ofDayOfWeekField(this);
+    this._weekOfMonth = ComputedDayOfField.ofWeekOfMonthField(this);
+    this._weekOfYear = ComputedDayOfField.ofWeekOfYearField(this);
+    this._weekOfWeekBasedYear = ComputedDayOfField.ofWeekOfWeekBasedYearField(this);
+    this._weekBasedYear = ComputedDayOfField.ofWeekBasedYearField(this);
+    Cldr.load(cldrData('supplemental/likelySubtags.json'));
+  }
+
+  var _proto2 = WeekFields.prototype;
+
+  _proto2.firstDayOfWeek = function firstDayOfWeek() {
+    return this._firstDayOfWeek;
+  };
+
+  _proto2.minimalDaysInFirstWeek = function minimalDaysInFirstWeek() {
+    return this._minimalDays;
+  };
+
+  _proto2.dayOfWeek = function dayOfWeek() {
+    return this._dayOfWeek;
+  };
+
+  _proto2.weekOfMonth = function weekOfMonth() {
+    return this._weekOfMonth;
+  };
+
+  _proto2.weekOfYear = function weekOfYear() {
+    return this._weekOfYear;
+  };
+
+  _proto2.weekOfWeekBasedYear = function weekOfWeekBasedYear() {
+    return this._weekOfWeekBasedYear;
+  };
+
+  _proto2.weekBasedYear = function weekBasedYear() {
+    return this._weekBasedYear;
+  };
+
+  _proto2.equals = function equals(other) {
+    if (this === other) {
+      return true;
+    }
+
+    if (other instanceof WeekFields) {
+      return this.hashCode() === other.hashCode();
+    }
+
+    return false;
+  };
+
+  _proto2.hashCode = function hashCode() {
+    return this._firstDayOfWeek.ordinal() * 7 + this._minimalDays;
+  };
+
+  _proto2.toString = function toString() {
+    return "WeekFields[" + this._firstDayOfWeek + "," + this._minimalDays + "]";
+  };
+
+  return WeekFields;
+}();
+function _init$2() {
+  WeekFields.ISO = WeekFields.of(DayOfWeek.MONDAY, 4);
+  WeekFields.SUNDAY_START = WeekFields.of(DayOfWeek.SUNDAY, 1);
+}
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+var StringBuilder = _.StringBuilder;
+
+var WeekFieldsPrinterParser = function () {
+  function WeekFieldsPrinterParser(letter, count) {
+    this._letter = letter;
+    this._count = count;
+  }
+
+  var _proto = WeekFieldsPrinterParser.prototype;
+
+  _proto.print = function print(context, buf) {
+    var weekFields = WeekFields.of(context.locale());
+
+    var pp = this._evaluate(weekFields);
+
+    return pp.print(context, buf);
+  };
+
+  _proto.parse = function parse(context, text, position) {
+    var weekFields = WeekFields.of(context.locale());
+
+    var pp = this._evaluate(weekFields);
+
+    return pp.parse(context, text, position);
+  };
+
+  _proto._evaluate = function _evaluate(weekFields) {
+    var pp = null;
+
+    switch (this._letter) {
+      case 'e':
+        pp = new DateTimeFormatterBuilder.NumberPrinterParser(weekFields.dayOfWeek(), this._count, 2, SignStyle.NOT_NEGATIVE);
+        break;
+
+      case 'c':
+        pp = new DateTimeFormatterBuilder.NumberPrinterParser(weekFields.dayOfWeek(), this._count, 2, SignStyle.NOT_NEGATIVE);
+        break;
+
+      case 'w':
+        pp = new DateTimeFormatterBuilder.NumberPrinterParser(weekFields.weekOfWeekBasedYear(), this._count, 2, SignStyle.NOT_NEGATIVE);
+        break;
+
+      case 'W':
+        pp = new DateTimeFormatterBuilder.NumberPrinterParser(weekFields.weekOfMonth(), 1, 2, SignStyle.NOT_NEGATIVE);
+        break;
+
+      case 'Y':
+        if (this._count === 2) {
+          pp = new DateTimeFormatterBuilder.ReducedPrinterParser(weekFields.weekBasedYear(), 2, 2, 0, DateTimeFormatterBuilder.ReducedPrinterParser.BASE_DATE);
+        } else {
+          pp = new DateTimeFormatterBuilder.NumberPrinterParser(weekFields.weekBasedYear(), this._count, 19, this._count < 4 ? SignStyle.NORMAL : SignStyle.EXCEEDS_PAD, -1);
+        }
+
+        break;
+    }
+
+    return pp;
+  };
+
+  _proto.toString = function toString() {
+    var sb = new StringBuilder(30);
+    sb.append('Localized(');
+
+    if (this._letter === 'Y') {
+      if (this._count === 1) {
+        sb.append('WeekBasedYear');
+      } else if (this._count === 2) {
+        sb.append('ReducedValue(WeekBasedYear,2,2,2000-01-01)');
+      } else {
+        sb.append('WeekBasedYear,').append(this._count).append(',').append(19).append(',').append(this._count < 4 ? SignStyle.NORMAL : SignStyle.EXCEEDS_PAD);
+      }
+    } else {
+      if (this._letter === 'c' || this._letter === 'e') {
+        sb.append('DayOfWeek');
+      } else if (this._letter === 'w') {
+        sb.append('WeekOfWeekBasedYear');
+      } else if (this._letter === 'W') {
+        sb.append('WeekOfMonth');
+      }
+
+      sb.append(',');
+      sb.append(this._count);
+    }
+
+    sb.append(')');
+    return sb.toString();
+  };
+
+  return WeekFieldsPrinterParser;
+}();
+
+var _jodaInternal$assert = _.assert,
+    requireNonNull$1 = _jodaInternal$assert.requireNonNull,
+    requireInstance = _jodaInternal$assert.requireInstance;
+
+var CldrDateTimeFormatterBuilder = function (_DateTimeFormatterBui) {
+  _inheritsLoose(CldrDateTimeFormatterBuilder, _DateTimeFormatterBui);
+
+  function CldrDateTimeFormatterBuilder() {
+    return _DateTimeFormatterBui.apply(this, arguments) || this;
+  }
+
+  var _proto = CldrDateTimeFormatterBuilder.prototype;
+
+  _proto.appendText = function appendText(field, styleOrMap) {
+    if (styleOrMap === undefined) {
+      return this.appendTextField(field);
+    } else if (styleOrMap instanceof TextStyle) {
+      return this.appendTextFieldStyle(field, styleOrMap);
+    } else {
+      return this.appendTextFieldMap(field, styleOrMap);
+    }
+  };
+
+  _proto.appendTextField = function appendTextField(field) {
+    return this.appendTextFieldStyle(field, TextStyle.FULL);
+  };
+
+  _proto.appendTextFieldStyle = function appendTextFieldStyle(field, textStyle) {
+    requireNonNull$1(field, 'field');
+    requireInstance(field, TemporalField, 'field');
+    requireNonNull$1(textStyle, 'textStyle');
+    requireInstance(textStyle, TextStyle, 'textStyle');
+
+    this._appendInternal(new TextPrinterParser(field, textStyle, new CldrDateTimeTextProvider()));
+
+    return this;
+  };
+
+  _proto.appendTextFieldMap = function appendTextFieldMap(field, textLookup) {
+    requireNonNull$1(field, 'field');
+    requireInstance(field, ChronoField, 'field');
+    requireNonNull$1(textLookup, 'textLookup');
+
+    var copy = _extends({}, textLookup);
+
+    var map = {};
+    map[TextStyle.FULL] = copy;
+    var store = new LocaleStore(map);
+    var provider = {
+      getText: function getText(field, value, style) {
+        return store.getText(value, style);
+      },
+      getTextIterator: function getTextIterator(field, style) {
+        return store.getTextIterator(style);
+      }
+    };
+
+    this._appendInternal(new TextPrinterParser(field, TextStyle.FULL, provider));
+
+    return this;
+  };
+
+  _proto.appendWeekField = function appendWeekField(field, count) {
+    requireNonNull$1(field, 'field');
+    requireNonNull$1(count, 'count');
+
+    this._appendInternal(new WeekFieldsPrinterParser(field, count));
+
+    return this;
+  };
+
+  _proto.appendZoneText = function appendZoneText(textStyle) {
+    this._appendInternal(new CldrZoneTextPrinterParser(textStyle));
+
+    return this;
+  };
+
+  _proto.appendLocalizedOffset = function appendLocalizedOffset(textStyle) {
+    requireNonNull$1(textStyle, 'textStyle');
+
+    if (textStyle !== TextStyle.FULL && textStyle !== TextStyle.SHORT) {
+      throw new IllegalArgumentException('Style must be either full or short');
+    }
+
+    this._appendInternal(new LocalizedOffsetPrinterParser(textStyle));
+
+    return this;
+  };
+
+  return CldrDateTimeFormatterBuilder;
+}(DateTimeFormatterBuilder);
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+
+var Locale = function () {
+  Locale.getAvailableLocales = function getAvailableLocales() {
+    return new CldrDateTimeTextProvider().getAvailableLocales();
+  };
+
+  function Locale(language, country, localeString) {
+    if (country === void 0) {
+      country = '';
+    }
+
+    if (localeString === void 0) {
+      localeString = '';
+    }
+
+    this._language = language;
+    this._country = country;
+    this._localeString = localeString;
+  }
+
+  var _proto = Locale.prototype;
+
+  _proto.language = function language() {
+    return this._language;
+  };
+
+  _proto.country = function country() {
+    return this._country;
+  };
+
+  _proto.localeString = function localeString() {
+    if (this._localeString.length > 0) {
+      return this._localeString;
+    }
+
+    if (this._country.length > 0) {
+      return this._language + "-" + this._country;
+    } else {
+      return this._language;
+    }
+  };
+
+  _proto.toString = function toString() {
+    return "Locale[" + this.localeString() + "]";
+  };
+
+  _proto.equals = function equals(other) {
+    if (!other) {
+      return false;
+    }
+
+    if (!(other instanceof Locale)) {
+      return false;
+    }
+
+    return this.localeString() === other.localeString();
+  };
+
+  return Locale;
+}();
+function _init$1() {
+  Locale.ENGLISH = new Locale('en');
+  Locale.US = new Locale('en', 'US', 'en');
+  Locale.UK = new Locale('en', 'GB');
+  Locale.CANADA = new Locale('en', 'CA');
+  Locale.FRENCH = new Locale('fr');
+  Locale.FRANCE = new Locale('fr', 'FR', 'fr');
+  Locale.GERMAN = new Locale('de');
+  Locale.GERMANY = new Locale('de', 'DE', 'de');
+  Locale.KOREAN = new Locale('ko');
+  Locale.JAPANESE = new Locale('ja', 'JP');
+  Locale.JAPAN = new Locale('ja', 'JP', 'ja');
+  Locale.ITALIAN = new Locale('it');
+  Locale.ITALY = new Locale('it', 'IT', 'it');
+  Locale.CHINESE = new Locale('zh');
+  Locale.ROMANIAN = new Locale('ro');
+  Locale.SWEDISH = new Locale('sv');
+  Locale.SWEDEN = new Locale('sv', 'SE', 'sv');
+  Locale.HINDI = new Locale('hi');
+  Locale.RUSSIAN = new Locale('ru');
+}
+
+var requireNonNull = _.assert.requireNonNull;
+
+var LocaleDateTimeFormatter = function (_DateTimeFormatter) {
+  _inheritsLoose(LocaleDateTimeFormatter, _DateTimeFormatter);
+
+  function LocaleDateTimeFormatter() {
+    return _DateTimeFormatter.apply(this, arguments) || this;
+  }
+
+  var _proto = LocaleDateTimeFormatter.prototype;
+
+  _proto.withLocale = function withLocale(locale) {
+    requireNonNull(locale, 'locale');
+
+    if (locale.equals(this._locale)) {
+      return this;
+    }
+
+    return new DateTimeFormatter(this._printerParser, locale, this._decimalStyle, this._resolverStyle, this._resolverFields, this._chrono, this._zone);
+  };
+
+  return LocaleDateTimeFormatter;
+}(DateTimeFormatter);
+function _init() {
+  var dow = {
+    1: 'Mon',
+    2: 'Tue',
+    3: 'Wed',
+    4: 'Thu',
+    5: 'Fri',
+    6: 'Sat',
+    7: 'Sun'
+  };
+  var moy = {
+    1: 'Jan',
+    2: 'Feb',
+    3: 'Mar',
+    4: 'Apr',
+    5: 'May',
+    6: 'Jun',
+    7: 'Jul',
+    8: 'Aug',
+    9: 'Sep',
+    10: 'Oct',
+    11: 'Nov',
+    12: 'Dec'
+  };
+  LocaleDateTimeFormatter.RFC_1123_DATE_TIME = new CldrDateTimeFormatterBuilder().parseCaseInsensitive().parseLenient().optionalStart().appendText(ChronoField.DAY_OF_WEEK, dow).appendLiteral(', ').optionalEnd().appendValue(ChronoField.DAY_OF_MONTH, 2).appendLiteral(' ').appendText(ChronoField.MONTH_OF_YEAR, moy).appendLiteral(' ').appendValue(ChronoField.YEAR, 4).appendLiteral(' ').appendValue(ChronoField.HOUR_OF_DAY, 2).appendLiteral(':').appendValue(ChronoField.MINUTE_OF_HOUR, 2).optionalStart().appendLiteral(':').appendValue(ChronoField.SECOND_OF_MINUTE, 2).optionalEnd().appendLiteral(' ').appendZoneId().toFormatter(ResolverStyle.SMART).withChronology(IsoChronology.INSTANCE);
+}
+
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+var isInit = false;
+
+function init() {
+  if (isInit) {
+    return;
+  }
+
+  isInit = true;
+  _init$1();
+  _init$2();
+  _init();
+}
+
+init();
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+function plug (jsJoda) {
+  Object.getOwnPropertyNames(CldrDateTimeFormatterBuilder.prototype).forEach(function (prop) {
+    if (prop !== 'constructor') {
+      jsJoda.DateTimeFormatterBuilder.prototype[prop] = CldrDateTimeFormatterBuilder.prototype[prop];
+    }
+  });
+  Object.getOwnPropertyNames(LocaleDateTimeFormatter.prototype).forEach(function (prop) {
+    if (prop !== 'constructor') {
+      jsJoda.DateTimeFormatter.prototype[prop] = LocaleDateTimeFormatter.prototype[prop];
+    }
+  });
+  jsJoda.DateTimeFormatter.RFC_1123_DATE_TIME = LocaleDateTimeFormatter.RFC_1123_DATE_TIME;
+}
+
+/*
+ * @copyright (c) 2017, Philipp Thuerwaechter & Pattrick Hueper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+use(plug);
+
+export { Locale };