@sme.up/ketchup 9.0.0 → 9.2.0

package/dist/cjs/kup-planner.cjs.entry.js

@@ -2,10 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const index = require('./index-c3d10561.js');
-const kupManager$1 = require('./kup-manager-130bbd9d.js');
+const index = require('./index-d8e5eb5f.js');
+const kupManager$1 = require('./kup-manager-7334c396.js');
 const GenericVariables = require('./GenericVariables-1d52ba57.js');
-const fTextField = require('./f-text-field-bbcd2143.js');
+const fTextField = require('./f-text-field-c74856ff.js');
 const fTextFieldMdc = require('./f-text-field-mdc-4fda9705.js');
 require('./component-cb3b32f5.js');
 
@@ -1420,6 +1420,17 @@ function systemLocale() {
     return sysLocaleCache;
   }
 }
+var weekInfoCache = {};
+function getCachedWeekInfo(locString) {
+  var data = weekInfoCache[locString];
+  if (!data) {
+    var locale = new Intl.Locale(locString);
+    // browsers currently implement this as a property, but spec says it should be a getter function
+    data = "getWeekInfo" in locale ? locale.getWeekInfo() : locale.weekInfo;
+    weekInfoCache[locString] = data;
+  }
+  return data;
+}
 function parseLocaleString(localeStr) {
   // I really want to avoid writing a BCP 47 parser
   // see, e.g. https://github.com/wooorm/bcp-47
@@ -1475,7 +1486,7 @@ function intlConfigString(localeStr, numberingSystem, outputCalendar) {
 function mapMonths(f) {
   var ms = [];
   for (var i = 1; i <= 12; i++) {
-    var dt = DateTime.utc(2016, i, 1);
+    var dt = DateTime.utc(2009, i, 1);
     ms.push(f(dt));
   }
   return ms;
@@ -1488,8 +1499,8 @@ function mapWeekdays(f) {
   }
   return ms;
 }
-function listStuff(loc, length, defaultOK, englishFn, intlFn) {
-  var mode = loc.listingMode(defaultOK);
+function listStuff(loc, length, englishFn, intlFn) {
+  var mode = loc.listingMode();
   if (mode === "error") {
     return null;
   } else if (mode === "en") {
@@ -1651,14 +1662,20 @@ var PolyRelFormatter = /*#__PURE__*/function () {
   };
   return PolyRelFormatter;
 }();
+var fallbackWeekSettings = {
+  firstDay: 1,
+  minimalDays: 4,
+  weekend: [6, 7]
+};
+
 /**
  * @private
  */
 var Locale = /*#__PURE__*/function () {
   Locale.fromOpts = function fromOpts(opts) {
-    return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN);
+    return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.weekSettings, opts.defaultToEN);
   };
-  Locale.create = function create(locale, numberingSystem, outputCalendar, defaultToEN) {
+  Locale.create = function create(locale, numberingSystem, outputCalendar, weekSettings, defaultToEN) {
     if (defaultToEN === void 0) {
       defaultToEN = false;
     }
@@ -1667,7 +1684,8 @@ var Locale = /*#__PURE__*/function () {
     var localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
     var numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
     var outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
-    return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
+    var weekSettingsR = validateWeekSettings(weekSettings) || Settings.defaultWeekSettings;
+    return new Locale(localeR, numberingSystemR, outputCalendarR, weekSettingsR, specifiedLocale);
   };
   Locale.resetCache = function resetCache() {
     sysLocaleCache = null;
@@ -1679,10 +1697,11 @@ var Locale = /*#__PURE__*/function () {
     var _ref2 = _temp === void 0 ? {} : _temp,
       locale = _ref2.locale,
       numberingSystem = _ref2.numberingSystem,
-      outputCalendar = _ref2.outputCalendar;
-    return Locale.create(locale, numberingSystem, outputCalendar);
+      outputCalendar = _ref2.outputCalendar,
+      weekSettings = _ref2.weekSettings;
+    return Locale.create(locale, numberingSystem, outputCalendar, weekSettings);
   };
-  function Locale(locale, numbering, outputCalendar, specifiedLocale) {
+  function Locale(locale, numbering, outputCalendar, weekSettings, specifiedLocale) {
     var _parseLocaleString = parseLocaleString(locale),
       parsedLocale = _parseLocaleString[0],
       parsedNumberingSystem = _parseLocaleString[1],
@@ -1690,6 +1709,7 @@ var Locale = /*#__PURE__*/function () {
     this.locale = parsedLocale;
     this.numberingSystem = numbering || parsedNumberingSystem || null;
     this.outputCalendar = outputCalendar || parsedOutputCalendar || null;
+    this.weekSettings = weekSettings;
     this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar);
     this.weekdaysCache = {
       format: {},
@@ -1714,7 +1734,7 @@ var Locale = /*#__PURE__*/function () {
     if (!alts || Object.getOwnPropertyNames(alts).length === 0) {
       return this;
     } else {
-      return Locale.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, alts.defaultToEN || false);
+      return Locale.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, validateWeekSettings(alts.weekSettings) || this.weekSettings, alts.defaultToEN || false);
     }
   };
   _proto4.redefaultToEN = function redefaultToEN(alts) {
@@ -1733,15 +1753,12 @@ var Locale = /*#__PURE__*/function () {
       defaultToEN: false
     }));
   };
-  _proto4.months = function months$1(length, format, defaultOK) {
+  _proto4.months = function months$1(length, format) {
     var _this2 = this;
     if (format === void 0) {
       format = false;
     }
-    if (defaultOK === void 0) {
-      defaultOK = true;
-    }
-    return listStuff(this, length, defaultOK, months, function () {
+    return listStuff(this, length, months, function () {
       var intl = format ? {
           month: length,
           day: "numeric"
@@ -1757,15 +1774,12 @@ var Locale = /*#__PURE__*/function () {
       return _this2.monthsCache[formatStr][length];
     });
   };
-  _proto4.weekdays = function weekdays$1(length, format, defaultOK) {
+  _proto4.weekdays = function weekdays$1(length, format) {
     var _this3 = this;
     if (format === void 0) {
       format = false;
     }
-    if (defaultOK === void 0) {
-      defaultOK = true;
-    }
-    return listStuff(this, length, defaultOK, weekdays, function () {
+    return listStuff(this, length, weekdays, function () {
       var intl = format ? {
           weekday: length,
           year: "numeric",
@@ -1783,12 +1797,9 @@ var Locale = /*#__PURE__*/function () {
       return _this3.weekdaysCache[formatStr][length];
     });
   };
-  _proto4.meridiems = function meridiems$1(defaultOK) {
+  _proto4.meridiems = function meridiems$1() {
     var _this4 = this;
-    if (defaultOK === void 0) {
-      defaultOK = true;
-    }
-    return listStuff(this, undefined, defaultOK, function () {
+    return listStuff(this, undefined, function () {
       return meridiems;
     }, function () {
       // In theory there could be aribitrary day periods. We're gonna assume there are exactly two
@@ -1805,12 +1816,9 @@ var Locale = /*#__PURE__*/function () {
       return _this4.meridiemCache;
     });
   };
-  _proto4.eras = function eras$1(length, defaultOK) {
+  _proto4.eras = function eras$1(length) {
     var _this5 = this;
-    if (defaultOK === void 0) {
-      defaultOK = true;
-    }
-    return listStuff(this, length, defaultOK, eras, function () {
+    return listStuff(this, length, eras, function () {
       var intl = {
         era: length
       };
@@ -1862,6 +1870,24 @@ var Locale = /*#__PURE__*/function () {
   _proto4.isEnglish = function isEnglish() {
     return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us");
   };
+  _proto4.getWeekSettings = function getWeekSettings() {
+    if (this.weekSettings) {
+      return this.weekSettings;
+    } else if (!hasLocaleWeekInfo()) {
+      return fallbackWeekSettings;
+    } else {
+      return getCachedWeekInfo(this.locale);
+    }
+  };
+  _proto4.getStartOfWeek = function getStartOfWeek() {
+    return this.getWeekSettings().firstDay;
+  };
+  _proto4.getMinDaysInFirstWeek = function getMinDaysInFirstWeek() {
+    return this.getWeekSettings().minimalDays;
+  };
+  _proto4.getWeekendDays = function getWeekendDays() {
+    return this.getWeekSettings().weekend;
+  };
   _proto4.equals = function equals(other) {
     return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
   };
@@ -2069,7 +2095,7 @@ function normalizeZone(input, defaultZone) {
     if (lowered === "default") return defaultZone;else if (lowered === "local" || lowered === "system") return SystemZone.instance;else if (lowered === "utc" || lowered === "gmt") return FixedOffsetZone.utcInstance;else return FixedOffsetZone.parseSpecifier(lowered) || IANAZone.create(input);
   } else if (isNumber(input)) {
     return FixedOffsetZone.instance(input);
-  } else if (typeof input === "object" && input.offset && typeof input.offset === "number") {
+  } else if (typeof input === "object" && "offset" in input && typeof input.offset === "function") {
     // This is dumb, but the instanceof check above doesn't seem to really work
     // so we're duck checking it
     return input;
@@ -2086,7 +2112,8 @@ var now = function now() {
   defaultNumberingSystem = null,
   defaultOutputCalendar = null,
   twoDigitCutoffYear = 60,
-  throwOnInvalid;
+  throwOnInvalid,
+  defaultWeekSettings = null;
 
 /**
  * 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.
@@ -2197,6 +2224,33 @@ var Settings = /*#__PURE__*/function () {
       defaultOutputCalendar = outputCalendar;
     }
 
+    /**
+     * @typedef {Object} WeekSettings
+     * @property {number} firstDay
+     * @property {number} minimalDays
+     * @property {number[]} weekend
+     */
+
+    /**
+     * @return {WeekSettings|null}
+     */
+  }, {
+    key: "defaultWeekSettings",
+    get: function get() {
+      return defaultWeekSettings;
+    }
+
+    /**
+     * Allows overriding the default locale week settings, i.e. the start of the week, the weekend and
+     * how many days are required in the first week of a year.
+     * Does not affect existing instances.
+     *
+     * @param {WeekSettings|null} weekSettings
+     */,
+    set: function set(weekSettings) {
+      defaultWeekSettings = validateWeekSettings(weekSettings);
+    }
+
     /**
      * Get the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
      * @type {number}
@@ -2210,10 +2264,10 @@ var Settings = /*#__PURE__*/function () {
     /**
      * Set the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
      * @type {number}
-     * @example Settings.twoDigitCutoffYear = 0 // cut-off year is 0, so all 'yy' are interpretted as current century
+     * @example Settings.twoDigitCutoffYear = 0 // cut-off year is 0, so all 'yy' are interpreted as current century
      * @example Settings.twoDigitCutoffYear = 50 // '49' -> 1949; '50' -> 2050
-     * @example Settings.twoDigitCutoffYear = 1950 // interpretted as 50
-     * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpretted as 50
+     * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50
+     * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50
      */,
     set: function set(cutoffYear) {
       twoDigitCutoffYear = cutoffYear % 100;
@@ -2240,6 +2294,230 @@ var Settings = /*#__PURE__*/function () {
   return Settings;
 }();
 
+var Invalid = /*#__PURE__*/function () {
+  function Invalid(reason, explanation) {
+    this.reason = reason;
+    this.explanation = explanation;
+  }
+  var _proto = Invalid.prototype;
+  _proto.toMessage = function toMessage() {
+    if (this.explanation) {
+      return this.reason + ": " + this.explanation;
+    } else {
+      return this.reason;
+    }
+  };
+  return Invalid;
+}();
+
+var nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
+  leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
+function unitOutOfRange(unit, value) {
+  return new Invalid("unit out of range", "you specified " + value + " (of type " + typeof value + ") as a " + unit + ", which is invalid");
+}
+function dayOfWeek(year, month, day) {
+  var d = new Date(Date.UTC(year, month - 1, day));
+  if (year < 100 && year >= 0) {
+    d.setUTCFullYear(d.getUTCFullYear() - 1900);
+  }
+  var js = d.getUTCDay();
+  return js === 0 ? 7 : js;
+}
+function computeOrdinal(year, month, day) {
+  return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
+}
+function uncomputeOrdinal(year, ordinal) {
+  var table = isLeapYear(year) ? leapLadder : nonLeapLadder,
+    month0 = table.findIndex(function (i) {
+      return i < ordinal;
+    }),
+    day = ordinal - table[month0];
+  return {
+    month: month0 + 1,
+    day: day
+  };
+}
+function isoWeekdayToLocal(isoWeekday, startOfWeek) {
+  return (isoWeekday - startOfWeek + 7) % 7 + 1;
+}
+
+/**
+ * @private
+ */
+
+function gregorianToWeek(gregObj, minDaysInFirstWeek, startOfWeek) {
+  if (minDaysInFirstWeek === void 0) {
+    minDaysInFirstWeek = 4;
+  }
+  if (startOfWeek === void 0) {
+    startOfWeek = 1;
+  }
+  var year = gregObj.year,
+    month = gregObj.month,
+    day = gregObj.day,
+    ordinal = computeOrdinal(year, month, day),
+    weekday = isoWeekdayToLocal(dayOfWeek(year, month, day), startOfWeek);
+  var weekNumber = Math.floor((ordinal - weekday + 14 - minDaysInFirstWeek) / 7),
+    weekYear;
+  if (weekNumber < 1) {
+    weekYear = year - 1;
+    weekNumber = weeksInWeekYear(weekYear, minDaysInFirstWeek, startOfWeek);
+  } else if (weekNumber > weeksInWeekYear(year, minDaysInFirstWeek, startOfWeek)) {
+    weekYear = year + 1;
+    weekNumber = 1;
+  } else {
+    weekYear = year;
+  }
+  return _extends({
+    weekYear: weekYear,
+    weekNumber: weekNumber,
+    weekday: weekday
+  }, timeObject(gregObj));
+}
+function weekToGregorian(weekData, minDaysInFirstWeek, startOfWeek) {
+  if (minDaysInFirstWeek === void 0) {
+    minDaysInFirstWeek = 4;
+  }
+  if (startOfWeek === void 0) {
+    startOfWeek = 1;
+  }
+  var weekYear = weekData.weekYear,
+    weekNumber = weekData.weekNumber,
+    weekday = weekData.weekday,
+    weekdayOfJan4 = isoWeekdayToLocal(dayOfWeek(weekYear, 1, minDaysInFirstWeek), startOfWeek),
+    yearInDays = daysInYear(weekYear);
+  var ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 7 + minDaysInFirstWeek,
+    year;
+  if (ordinal < 1) {
+    year = weekYear - 1;
+    ordinal += daysInYear(year);
+  } else if (ordinal > yearInDays) {
+    year = weekYear + 1;
+    ordinal -= daysInYear(weekYear);
+  } else {
+    year = weekYear;
+  }
+  var _uncomputeOrdinal = uncomputeOrdinal(year, ordinal),
+    month = _uncomputeOrdinal.month,
+    day = _uncomputeOrdinal.day;
+  return _extends({
+    year: year,
+    month: month,
+    day: day
+  }, timeObject(weekData));
+}
+function gregorianToOrdinal(gregData) {
+  var year = gregData.year,
+    month = gregData.month,
+    day = gregData.day;
+  var ordinal = computeOrdinal(year, month, day);
+  return _extends({
+    year: year,
+    ordinal: ordinal
+  }, timeObject(gregData));
+}
+function ordinalToGregorian(ordinalData) {
+  var year = ordinalData.year,
+    ordinal = ordinalData.ordinal;
+  var _uncomputeOrdinal2 = uncomputeOrdinal(year, ordinal),
+    month = _uncomputeOrdinal2.month,
+    day = _uncomputeOrdinal2.day;
+  return _extends({
+    year: year,
+    month: month,
+    day: day
+  }, timeObject(ordinalData));
+}
+
+/**
+ * Check if local week units like localWeekday are used in obj.
+ * If so, validates that they are not mixed with ISO week units and then copies them to the normal week unit properties.
+ * Modifies obj in-place!
+ * @param obj the object values
+ */
+function usesLocalWeekValues(obj, loc) {
+  var hasLocaleWeekData = !isUndefined(obj.localWeekday) || !isUndefined(obj.localWeekNumber) || !isUndefined(obj.localWeekYear);
+  if (hasLocaleWeekData) {
+    var hasIsoWeekData = !isUndefined(obj.weekday) || !isUndefined(obj.weekNumber) || !isUndefined(obj.weekYear);
+    if (hasIsoWeekData) {
+      throw new ConflictingSpecificationError("Cannot mix locale-based week fields with ISO-based week fields");
+    }
+    if (!isUndefined(obj.localWeekday)) obj.weekday = obj.localWeekday;
+    if (!isUndefined(obj.localWeekNumber)) obj.weekNumber = obj.localWeekNumber;
+    if (!isUndefined(obj.localWeekYear)) obj.weekYear = obj.localWeekYear;
+    delete obj.localWeekday;
+    delete obj.localWeekNumber;
+    delete obj.localWeekYear;
+    return {
+      minDaysInFirstWeek: loc.getMinDaysInFirstWeek(),
+      startOfWeek: loc.getStartOfWeek()
+    };
+  } else {
+    return {
+      minDaysInFirstWeek: 4,
+      startOfWeek: 1
+    };
+  }
+}
+function hasInvalidWeekData(obj, minDaysInFirstWeek, startOfWeek) {
+  if (minDaysInFirstWeek === void 0) {
+    minDaysInFirstWeek = 4;
+  }
+  if (startOfWeek === void 0) {
+    startOfWeek = 1;
+  }
+  var validYear = isInteger(obj.weekYear),
+    validWeek = integerBetween(obj.weekNumber, 1, weeksInWeekYear(obj.weekYear, minDaysInFirstWeek, startOfWeek)),
+    validWeekday = integerBetween(obj.weekday, 1, 7);
+  if (!validYear) {
+    return unitOutOfRange("weekYear", obj.weekYear);
+  } else if (!validWeek) {
+    return unitOutOfRange("week", obj.weekNumber);
+  } else if (!validWeekday) {
+    return unitOutOfRange("weekday", obj.weekday);
+  } else return false;
+}
+function hasInvalidOrdinalData(obj) {
+  var validYear = isInteger(obj.year),
+    validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year));
+  if (!validYear) {
+    return unitOutOfRange("year", obj.year);
+  } else if (!validOrdinal) {
+    return unitOutOfRange("ordinal", obj.ordinal);
+  } else return false;
+}
+function hasInvalidGregorianData(obj) {
+  var validYear = isInteger(obj.year),
+    validMonth = integerBetween(obj.month, 1, 12),
+    validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month));
+  if (!validYear) {
+    return unitOutOfRange("year", obj.year);
+  } else if (!validMonth) {
+    return unitOutOfRange("month", obj.month);
+  } else if (!validDay) {
+    return unitOutOfRange("day", obj.day);
+  } else return false;
+}
+function hasInvalidTimeData(obj) {
+  var hour = obj.hour,
+    minute = obj.minute,
+    second = obj.second,
+    millisecond = obj.millisecond;
+  var validHour = integerBetween(hour, 0, 23) || hour === 24 && minute === 0 && second === 0 && millisecond === 0,
+    validMinute = integerBetween(minute, 0, 59),
+    validSecond = integerBetween(second, 0, 59),
+    validMillisecond = integerBetween(millisecond, 0, 999);
+  if (!validHour) {
+    return unitOutOfRange("hour", hour);
+  } else if (!validMinute) {
+    return unitOutOfRange("minute", minute);
+  } else if (!validSecond) {
+    return unitOutOfRange("second", second);
+  } else if (!validMillisecond) {
+    return unitOutOfRange("millisecond", millisecond);
+  } else return false;
+}
+
 /**
  * @private
  */
@@ -2271,6 +2549,13 @@ function hasRelative() {
     return false;
   }
 }
+function hasLocaleWeekInfo() {
+  try {
+    return typeof Intl !== "undefined" && !!Intl.Locale && ("weekInfo" in Intl.Locale.prototype || "getWeekInfo" in Intl.Locale.prototype);
+  } catch (e) {
+    return false;
+  }
+}
 
 // OBJECTS AND ARRAYS
 
@@ -2301,6 +2586,24 @@ function pick(obj, keys) {
 function hasOwnProperty(obj, prop) {
   return Object.prototype.hasOwnProperty.call(obj, prop);
 }
+function validateWeekSettings(settings) {
+  if (settings == null) {
+    return null;
+  } else if (typeof settings !== "object") {
+    throw new InvalidArgumentError("Week settings must be an object");
+  } else {
+    if (!integerBetween(settings.firstDay, 1, 7) || !integerBetween(settings.minimalDays, 1, 7) || !Array.isArray(settings.weekend) || settings.weekend.some(function (v) {
+      return !integerBetween(v, 1, 7);
+    })) {
+      throw new InvalidArgumentError("Invalid week settings");
+    }
+    return {
+      firstDay: settings.firstDay,
+      minimalDays: settings.minimalDays,
+      weekend: Array.from(settings.weekend)
+    };
+  }
+}
 
 // NUMBERS AND STRINGS
 
@@ -2375,7 +2678,7 @@ function daysInMonth(year, month) {
   }
 }
 
-// covert a calendar object to a local timestamp (epoch, but with the offset baked in)
+// convert a calendar object to a local timestamp (epoch, but with the offset baked in)
 function objToLocalTS(obj) {
   var d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
 
@@ -2389,11 +2692,22 @@ function objToLocalTS(obj) {
   }
   return +d;
 }
-function weeksInWeekYear(weekYear) {
-  var p1 = (weekYear + Math.floor(weekYear / 4) - Math.floor(weekYear / 100) + Math.floor(weekYear / 400)) % 7,
-    last = weekYear - 1,
-    p2 = (last + Math.floor(last / 4) - Math.floor(last / 100) + Math.floor(last / 400)) % 7;
-  return p1 === 4 || p2 === 3 ? 53 : 52;
+
+// adapted from moment.js: https://github.com/moment/moment/blob/000ac1800e620f770f4eb31b5ae908f6167b0ab2/src/lib/units/week-calendar-utils.js
+function firstWeekOffset(year, minDaysInFirstWeek, startOfWeek) {
+  var fwdlw = isoWeekdayToLocal(dayOfWeek(year, 1, minDaysInFirstWeek), startOfWeek);
+  return -fwdlw + minDaysInFirstWeek - 1;
+}
+function weeksInWeekYear(weekYear, minDaysInFirstWeek, startOfWeek) {
+  if (minDaysInFirstWeek === void 0) {
+    minDaysInFirstWeek = 4;
+  }
+  if (startOfWeek === void 0) {
+    startOfWeek = 1;
+  }
+  var weekOffset = firstWeekOffset(weekYear, minDaysInFirstWeek, startOfWeek);
+  var weekOffsetNext = firstWeekOffset(weekYear + 1, minDaysInFirstWeek, startOfWeek);
+  return (daysInYear(weekYear) - weekOffset + weekOffsetNext) / 7;
 }
 function untruncateYear(year) {
   if (year > 99) {
@@ -2688,33 +3002,24 @@ var Formatter = /*#__PURE__*/function () {
     var df = this.systemLoc.dtFormatter(dt, _extends({}, this.opts, opts));
     return df.format();
   };
-  _proto.formatDateTime = function formatDateTime(dt, opts) {
+  _proto.dtFormatter = function dtFormatter(dt, opts) {
     if (opts === void 0) {
       opts = {};
     }
-    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
-    return df.format();
+    return this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
+  };
+  _proto.formatDateTime = function formatDateTime(dt, opts) {
+    return this.dtFormatter(dt, opts).format();
   };
   _proto.formatDateTimeParts = function formatDateTimeParts(dt, opts) {
-    if (opts === void 0) {
-      opts = {};
-    }
-    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
-    return df.formatToParts();
+    return this.dtFormatter(dt, opts).formatToParts();
   };
   _proto.formatInterval = function formatInterval(interval, opts) {
-    if (opts === void 0) {
-      opts = {};
-    }
-    var df = this.loc.dtFormatter(interval.start, _extends({}, this.opts, opts));
+    var df = this.dtFormatter(interval.start, opts);
     return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate());
   };
   _proto.resolvedOptions = function resolvedOptions(dt, opts) {
-    if (opts === void 0) {
-      opts = {};
-    }
-    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
-    return df.resolvedOptions();
+    return this.dtFormatter(dt, opts).resolvedOptions();
   };
   _proto.num = function num(n, p) {
     if (p === void 0) {
@@ -2780,7 +3085,7 @@ var Formatter = /*#__PURE__*/function () {
         }, "era");
       },
       tokenToString = function tokenToString(token) {
-        // Where possible: http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles
+        // Where possible: https://cldr.unicode.org/translation/date-time/date-time-symbols
         switch (token) {
           // ms
           case "S":
@@ -2966,6 +3271,14 @@ var Formatter = /*#__PURE__*/function () {
             return _this.num(dt.weekNumber);
           case "WW":
             return _this.num(dt.weekNumber, 2);
+          case "n":
+            return _this.num(dt.localWeekNumber);
+          case "nn":
+            return _this.num(dt.localWeekNumber, 2);
+          case "ii":
+            return _this.num(dt.localWeekYear.toString().slice(-2), 2);
+          case "iiii":
+            return _this.num(dt.localWeekYear, 4);
           case "o":
             return _this.num(dt.ordinal);
           case "ooo":
@@ -3034,22 +3347,6 @@ var Formatter = /*#__PURE__*/function () {
   return Formatter;
 }();
 
-var Invalid = /*#__PURE__*/function () {
-  function Invalid(reason, explanation) {
-    this.reason = reason;
-    this.explanation = explanation;
-  }
-  var _proto = Invalid.prototype;
-  _proto.toMessage = function toMessage() {
-    if (this.explanation) {
-      return this.reason + ": " + this.explanation;
-    } else {
-      return this.reason;
-    }
-  };
-  return Invalid;
-}();
-
 /*
  * This file handles parsing for well-specified formats. Here's how it works:
  * Two things go into parsing: a regex to match with and an extractor to take apart the groups in the match.
@@ -3433,27 +3730,62 @@ function clone$1(dur, alts, clear) {
   };
   return new Duration(conf);
 }
-function antiTrunc(n) {
-  return n < 0 ? Math.floor(n) : Math.ceil(n);
-}
-
-// NB: mutates parameters
-function convert(matrix, fromMap, fromUnit, toMap, toUnit) {
-  var conv = matrix[toUnit][fromUnit],
-    raw = fromMap[fromUnit] / conv,
-    sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]),
-    // ok, so this is wild, but see the matrix in the tests
-    added = !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw);
-  toMap[toUnit] += added;
-  fromMap[fromUnit] -= added * conv;
+function durationToMillis(matrix, vals) {
+  var _vals$milliseconds;
+  var sum = (_vals$milliseconds = vals.milliseconds) != null ? _vals$milliseconds : 0;
+  for (var _iterator = _createForOfIteratorHelperLoose(reverseUnits.slice(1)), _step; !(_step = _iterator()).done;) {
+    var unit = _step.value;
+    if (vals[unit]) {
+      sum += vals[unit] * matrix[unit]["milliseconds"];
+    }
+  }
+  return sum;
 }
 
 // NB: mutates parameters
 function normalizeValues(matrix, vals) {
-  reverseUnits.reduce(function (previous, current) {
+  // the logic below assumes the overall value of the duration is positive
+  // if this is not the case, factor is used to make it so
+  var factor = durationToMillis(matrix, vals) < 0 ? -1 : 1;
+  orderedUnits$1.reduceRight(function (previous, current) {
     if (!isUndefined(vals[current])) {
       if (previous) {
-        convert(matrix, vals, previous, vals, current);
+        var previousVal = vals[previous] * factor;
+        var conv = matrix[current][previous];
+
+        // if (previousVal < 0):
+        // lower order unit is negative (e.g. { years: 2, days: -2 })
+        // normalize this by reducing the higher order unit by the appropriate amount
+        // and increasing the lower order unit
+        // this can never make the higher order unit negative, because this function only operates
+        // on positive durations, so the amount of time represented by the lower order unit cannot
+        // be larger than the higher order unit
+        // else:
+        // lower order unit is positive (e.g. { years: 2, days: 450 } or { years: -2, days: 450 })
+        // in this case we attempt to convert as much as possible from the lower order unit into
+        // the higher order one
+        //
+        // Math.floor takes care of both of these cases, rounding away from 0
+        // if previousVal < 0 it makes the absolute value larger
+        // if previousVal >= it makes the absolute value smaller
+        var rollUp = Math.floor(previousVal / conv);
+        vals[current] += rollUp * factor;
+        vals[previous] -= rollUp * conv * factor;
+      }
+      return current;
+    } else {
+      return previous;
+    }
+  }, null);
+
+  // try to convert any decimals into smaller units if possible
+  // for example for { years: 2.5, days: 0, seconds: 0 } we want to get { years: 2, days: 182, hours: 12 }
+  orderedUnits$1.reduce(function (previous, current) {
+    if (!isUndefined(vals[current])) {
+      if (previous) {
+        var fraction = vals[previous] % 1;
+        vals[previous] -= fraction;
+        vals[current] += fraction * matrix[previous][current];
       }
       return current;
     } else {
@@ -3489,7 +3821,7 @@ function removeZeroes(vals) {
  *
  * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation.
  */
-var Duration = /*#__PURE__*/function () {
+var Duration = /*#__PURE__*/function (_Symbol$for) {
   /**
    * @private
    */
@@ -3748,9 +4080,10 @@ var Duration = /*#__PURE__*/function () {
 
   /**
    * Returns a string representation of a Duration with all units included.
-   * To modify its behavior use the `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant.
-   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
-   * @param opts - On option object to override the formatting. Accepts the same keys as the options parameter of the native `Int.NumberFormat` constructor, as well as `listStyle`.
+   * To modify its behavior, use `listStyle` and any Intl.NumberFormat option, though `unitDisplay` is especially relevant.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
+   * @param {Object} opts - Formatting options. Accepts the same keys as the options parameter of the native `Intl.NumberFormat` constructor, as well as `listStyle`.
+   * @param {string} [opts.listStyle='narrow'] - How to format the merged list. Corresponds to the `style` property of the options parameter of the native `Intl.ListFormat` constructor.
    * @example
    * ```js
    * var dur = Duration.fromObject({ days: 1, hours: 5, minutes: 6 })
@@ -3764,6 +4097,7 @@ var Duration = /*#__PURE__*/function () {
     if (opts === void 0) {
       opts = {};
     }
+    if (!this.isValid) return INVALID$2;
     var l = orderedUnits$1.map(function (unit) {
       var val = _this.values[unit];
       if (isUndefined(val)) {
@@ -3851,20 +4185,13 @@ var Duration = /*#__PURE__*/function () {
       suppressSeconds: false,
       includePrefix: false,
       format: "extended"
-    }, opts);
-    var value = this.shiftTo("hours", "minutes", "seconds", "milliseconds");
-    var fmt = opts.format === "basic" ? "hhmm" : "hh:mm";
-    if (!opts.suppressSeconds || value.seconds !== 0 || value.milliseconds !== 0) {
-      fmt += opts.format === "basic" ? "ss" : ":ss";
-      if (!opts.suppressMilliseconds || value.milliseconds !== 0) {
-        fmt += ".SSS";
-      }
-    }
-    var str = value.toFormat(fmt);
-    if (opts.includePrefix) {
-      str = "T" + str;
-    }
-    return str;
+    }, opts, {
+      includeOffset: false
+    });
+    var dateTime = DateTime.fromMillis(millis, {
+      zone: "UTC"
+    });
+    return dateTime.toISOTime(opts);
   }
 
   /**
@@ -3883,12 +4210,25 @@ var Duration = /*#__PURE__*/function () {
     return this.toISO();
   }
 
+  /**
+   * Returns a string representation of this Duration appropriate for the REPL.
+   * @return {string}
+   */;
+  _proto[_Symbol$for] = function () {
+    if (this.isValid) {
+      return "Duration { values: " + JSON.stringify(this.values) + " }";
+    } else {
+      return "Duration { Invalid, reason: " + this.invalidReason + " }";
+    }
+  }
+
   /**
    * Returns an milliseconds value of this Duration.
    * @return {number}
    */;
   _proto.toMillis = function toMillis() {
-    return this.as("milliseconds");
+    if (!this.isValid) return NaN;
+    return durationToMillis(this.matrix, this.values);
   }
 
   /**
@@ -4013,8 +4353,17 @@ var Duration = /*#__PURE__*/function () {
 
   /**
    * Reduce this Duration to its canonical representation in its current units.
+   * Assuming the overall value of the Duration is positive, this means:
+   * - excessive values for lower-order units are converted to higher-order units (if possible, see first and second example)
+   * - negative lower-order units are converted to higher order units (there must be such a higher order unit, otherwise
+   *   the overall value would be negative, see third example)
+   * - fractional values for higher-order units are converted to lower-order units (if possible, see fourth example)
+   *
+   * If the overall value is negative, the result of this method is equivalent to `this.negate().normalize().negate()`.
    * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
+   * @example Duration.fromObject({ days: 5000 }).normalize().toObject() //=> { days: 5000 }
    * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
+   * @example Duration.fromObject({ years: 2.5, days: 0, hours: 0 }).normalize().toObject() //=> { years: 2, days: 182, hours: 12 }
    * @return {Duration}
    */;
   _proto.normalize = function normalize() {
@@ -4075,16 +4424,13 @@ var Duration = /*#__PURE__*/function () {
         if (isNumber(vals[k])) {
           own += vals[k];
         }
+
+        // only keep the integer part for now in the hopes of putting any decimal part
+        // into a smaller unit later
         var i = Math.trunc(own);
         built[k] = i;
         accumulated[k] = (own * 1000 - i * 1000) / 1000;
 
-        // plus anything further down the chain that should be rolled up in to this
-        for (var down in vals) {
-          if (orderedUnits$1.indexOf(down) > orderedUnits$1.indexOf(k)) {
-            convert(this.matrix, vals, down, built, k);
-          }
-        }
         // otherwise, keep it in the wings to boil it later
       } else if (isNumber(vals[k])) {
         accumulated[k] = vals[k];
@@ -4098,9 +4444,10 @@ var Duration = /*#__PURE__*/function () {
         built[lastUnit] += key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key];
       }
     }
+    normalizeValues(this.matrix, built);
     return clone$1(this, {
       values: built
-    }, true).normalize();
+    }, true);
   }
 
   /**
@@ -4294,7 +4641,7 @@ var Duration = /*#__PURE__*/function () {
     }
   }]);
   return Duration;
-}();
+}(Symbol.for("nodejs.util.inspect.custom"));
 
 var INVALID$1 = "Invalid Interval";
 
@@ -4323,7 +4670,7 @@ function validateStartEnd(start, end) {
  * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}
  * * **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}.
  */
-var Interval = /*#__PURE__*/function () {
+var Interval = /*#__PURE__*/function (_Symbol$for) {
   /**
    * @private
    */
@@ -4489,15 +4836,25 @@ var Interval = /*#__PURE__*/function () {
    * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'
    * asks 'what dates are included in this interval?', not 'how many days long is this interval?'
    * @param {string} [unit='milliseconds'] - the unit of time to count.
+   * @param {Object} opts - options
+   * @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
    * @return {number}
    */;
-  _proto.count = function count(unit) {
+  _proto.count = function count(unit, opts) {
     if (unit === void 0) {
       unit = "milliseconds";
     }
     if (!this.isValid) return NaN;
-    var start = this.start.startOf(unit),
-      end = this.end.startOf(unit);
+    var start = this.start.startOf(unit, opts);
+    var end;
+    if (opts != null && opts.useLocaleWeeks) {
+      end = this.end.reconfigure({
+        locale: start.locale
+      });
+    } else {
+      end = this.end;
+    }
+    end = end.startOf(unit, opts);
     return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());
   }
 
@@ -4576,7 +4933,9 @@ var Interval = /*#__PURE__*/function () {
     }
     var sorted = dateTimes.map(friendlyDateTime).filter(function (d) {
         return _this.contains(d);
-      }).sort(),
+      }).sort(function (a, b) {
+        return a.toMillis() - b.toMillis();
+      }),
       results = [];
     var s = this.s,
       i = 0;
@@ -4801,6 +5160,18 @@ var Interval = /*#__PURE__*/function () {
     return "[" + this.s.toISO() + " \u2013 " + this.e.toISO() + ")";
   }
 
+  /**
+   * Returns a string representation of this Interval appropriate for the REPL.
+   * @return {string}
+   */;
+  _proto[_Symbol$for] = function () {
+    if (this.isValid) {
+      return "Interval { start: " + this.s.toISO() + ", end: " + this.e.toISO() + " }";
+    } else {
+      return "Interval { Invalid, reason: " + this.invalidReason + " }";
+    }
+  }
+
   /**
    * Returns a localized string representing this Interval. Accepts the same options as the
    * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as
@@ -4958,7 +5329,7 @@ var Interval = /*#__PURE__*/function () {
     }
   }]);
   return Interval;
-}();
+}(Symbol.for("nodejs.util.inspect.custom"));
 
 /**
  * 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.
@@ -5009,6 +5380,56 @@ var Info = /*#__PURE__*/function () {
     return normalizeZone(input, Settings.defaultZone);
   }
 
+  /**
+   * Get the weekday on which the week starts according to the given locale.
+   * @param {Object} opts - options
+   * @param {string} [opts.locale] - the locale code
+   * @param {string} [opts.locObj=null] - an existing locale object to use
+   * @returns {number} the start of the week, 1 for Monday through 7 for Sunday
+   */;
+  Info.getStartOfWeek = function getStartOfWeek(_temp) {
+    var _ref = _temp === void 0 ? {} : _temp,
+      _ref$locale = _ref.locale,
+      locale = _ref$locale === void 0 ? null : _ref$locale,
+      _ref$locObj = _ref.locObj,
+      locObj = _ref$locObj === void 0 ? null : _ref$locObj;
+    return (locObj || Locale.create(locale)).getStartOfWeek();
+  }
+
+  /**
+   * Get the minimum number of days necessary in a week before it is considered part of the next year according
+   * to the given locale.
+   * @param {Object} opts - options
+   * @param {string} [opts.locale] - the locale code
+   * @param {string} [opts.locObj=null] - an existing locale object to use
+   * @returns {number}
+   */;
+  Info.getMinimumDaysInFirstWeek = function getMinimumDaysInFirstWeek(_temp2) {
+    var _ref2 = _temp2 === void 0 ? {} : _temp2,
+      _ref2$locale = _ref2.locale,
+      locale = _ref2$locale === void 0 ? null : _ref2$locale,
+      _ref2$locObj = _ref2.locObj,
+      locObj = _ref2$locObj === void 0 ? null : _ref2$locObj;
+    return (locObj || Locale.create(locale)).getMinDaysInFirstWeek();
+  }
+
+  /**
+   * Get the weekdays, which are considered the weekend according to the given locale
+   * @param {Object} opts - options
+   * @param {string} [opts.locale] - the locale code
+   * @param {string} [opts.locObj=null] - an existing locale object to use
+   * @returns {number[]} an array of weekdays, 1 for Monday through 7 for Sunday
+   */;
+  Info.getWeekendWeekdays = function getWeekendWeekdays(_temp3) {
+    var _ref3 = _temp3 === void 0 ? {} : _temp3,
+      _ref3$locale = _ref3.locale,
+      locale = _ref3$locale === void 0 ? null : _ref3$locale,
+      _ref3$locObj = _ref3.locObj,
+      locObj = _ref3$locObj === void 0 ? null : _ref3$locObj;
+    // copy the array, because we cache it internally
+    return (locObj || Locale.create(locale)).getWeekendDays().slice();
+  }
+
   /**
    * Return an array of standalone month names.
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
@@ -5026,19 +5447,19 @@ var Info = /*#__PURE__*/function () {
    * @example Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I'
    * @return {Array}
    */;
-  Info.months = function months(length, _temp) {
+  Info.months = function months(length, _temp4) {
     if (length === void 0) {
       length = "long";
     }
-    var _ref = _temp === void 0 ? {} : _temp,
-      _ref$locale = _ref.locale,
-      locale = _ref$locale === void 0 ? null : _ref$locale,
-      _ref$numberingSystem = _ref.numberingSystem,
-      numberingSystem = _ref$numberingSystem === void 0 ? null : _ref$numberingSystem,
-      _ref$locObj = _ref.locObj,
-      locObj = _ref$locObj === void 0 ? null : _ref$locObj,
-      _ref$outputCalendar = _ref.outputCalendar,
-      outputCalendar = _ref$outputCalendar === void 0 ? "gregory" : _ref$outputCalendar;
+    var _ref4 = _temp4 === void 0 ? {} : _temp4,
+      _ref4$locale = _ref4.locale,
+      locale = _ref4$locale === void 0 ? null : _ref4$locale,
+      _ref4$numberingSystem = _ref4.numberingSystem,
+      numberingSystem = _ref4$numberingSystem === void 0 ? null : _ref4$numberingSystem,
+      _ref4$locObj = _ref4.locObj,
+      locObj = _ref4$locObj === void 0 ? null : _ref4$locObj,
+      _ref4$outputCalendar = _ref4.outputCalendar,
+      outputCalendar = _ref4$outputCalendar === void 0 ? "gregory" : _ref4$outputCalendar;
     return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length);
   }
 
@@ -5055,19 +5476,19 @@ var Info = /*#__PURE__*/function () {
    * @param {string} [opts.outputCalendar='gregory'] - the calendar
    * @return {Array}
    */;
-  Info.monthsFormat = function monthsFormat(length, _temp2) {
+  Info.monthsFormat = function monthsFormat(length, _temp5) {
     if (length === void 0) {
       length = "long";
     }
-    var _ref2 = _temp2 === void 0 ? {} : _temp2,
-      _ref2$locale = _ref2.locale,
-      locale = _ref2$locale === void 0 ? null : _ref2$locale,
-      _ref2$numberingSystem = _ref2.numberingSystem,
-      numberingSystem = _ref2$numberingSystem === void 0 ? null : _ref2$numberingSystem,
-      _ref2$locObj = _ref2.locObj,
-      locObj = _ref2$locObj === void 0 ? null : _ref2$locObj,
-      _ref2$outputCalendar = _ref2.outputCalendar,
-      outputCalendar = _ref2$outputCalendar === void 0 ? "gregory" : _ref2$outputCalendar;
+    var _ref5 = _temp5 === void 0 ? {} : _temp5,
+      _ref5$locale = _ref5.locale,
+      locale = _ref5$locale === void 0 ? null : _ref5$locale,
+      _ref5$numberingSystem = _ref5.numberingSystem,
+      numberingSystem = _ref5$numberingSystem === void 0 ? null : _ref5$numberingSystem,
+      _ref5$locObj = _ref5.locObj,
+      locObj = _ref5$locObj === void 0 ? null : _ref5$locObj,
+      _ref5$outputCalendar = _ref5.outputCalendar,
+      outputCalendar = _ref5$outputCalendar === void 0 ? "gregory" : _ref5$outputCalendar;
     return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length, true);
   }
 
@@ -5085,17 +5506,17 @@ var Info = /*#__PURE__*/function () {
    * @example Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين'
    * @return {Array}
    */;
-  Info.weekdays = function weekdays(length, _temp3) {
+  Info.weekdays = function weekdays(length, _temp6) {
     if (length === void 0) {
       length = "long";
     }
-    var _ref3 = _temp3 === void 0 ? {} : _temp3,
-      _ref3$locale = _ref3.locale,
-      locale = _ref3$locale === void 0 ? null : _ref3$locale,
-      _ref3$numberingSystem = _ref3.numberingSystem,
-      numberingSystem = _ref3$numberingSystem === void 0 ? null : _ref3$numberingSystem,
-      _ref3$locObj = _ref3.locObj,
-      locObj = _ref3$locObj === void 0 ? null : _ref3$locObj;
+    var _ref6 = _temp6 === void 0 ? {} : _temp6,
+      _ref6$locale = _ref6.locale,
+      locale = _ref6$locale === void 0 ? null : _ref6$locale,
+      _ref6$numberingSystem = _ref6.numberingSystem,
+      numberingSystem = _ref6$numberingSystem === void 0 ? null : _ref6$numberingSystem,
+      _ref6$locObj = _ref6.locObj,
+      locObj = _ref6$locObj === void 0 ? null : _ref6$locObj;
     return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length);
   }
 
@@ -5111,17 +5532,17 @@ var Info = /*#__PURE__*/function () {
    * @param {string} [opts.locObj=null] - an existing locale object to use
    * @return {Array}
    */;
-  Info.weekdaysFormat = function weekdaysFormat(length, _temp4) {
+  Info.weekdaysFormat = function weekdaysFormat(length, _temp7) {
     if (length === void 0) {
       length = "long";
     }
-    var _ref4 = _temp4 === void 0 ? {} : _temp4,
-      _ref4$locale = _ref4.locale,
-      locale = _ref4$locale === void 0 ? null : _ref4$locale,
-      _ref4$numberingSystem = _ref4.numberingSystem,
-      numberingSystem = _ref4$numberingSystem === void 0 ? null : _ref4$numberingSystem,
-      _ref4$locObj = _ref4.locObj,
-      locObj = _ref4$locObj === void 0 ? null : _ref4$locObj;
+    var _ref7 = _temp7 === void 0 ? {} : _temp7,
+      _ref7$locale = _ref7.locale,
+      locale = _ref7$locale === void 0 ? null : _ref7$locale,
+      _ref7$numberingSystem = _ref7.numberingSystem,
+      numberingSystem = _ref7$numberingSystem === void 0 ? null : _ref7$numberingSystem,
+      _ref7$locObj = _ref7.locObj,
+      locObj = _ref7$locObj === void 0 ? null : _ref7$locObj;
     return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length, true);
   }
 
@@ -5133,10 +5554,10 @@ var Info = /*#__PURE__*/function () {
    * @example Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ]
    * @return {Array}
    */;
-  Info.meridiems = function meridiems(_temp5) {
-    var _ref5 = _temp5 === void 0 ? {} : _temp5,
-      _ref5$locale = _ref5.locale,
-      locale = _ref5$locale === void 0 ? null : _ref5$locale;
+  Info.meridiems = function meridiems(_temp8) {
+    var _ref8 = _temp8 === void 0 ? {} : _temp8,
+      _ref8$locale = _ref8.locale,
+      locale = _ref8$locale === void 0 ? null : _ref8$locale;
     return Locale.create(locale).meridiems();
   }
 
@@ -5150,13 +5571,13 @@ var Info = /*#__PURE__*/function () {
    * @example Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ]
    * @return {Array}
    */;
-  Info.eras = function eras(length, _temp6) {
+  Info.eras = function eras(length, _temp9) {
     if (length === void 0) {
       length = "short";
     }
-    var _ref6 = _temp6 === void 0 ? {} : _temp6,
-      _ref6$locale = _ref6.locale,
-      locale = _ref6$locale === void 0 ? null : _ref6$locale;
+    var _ref9 = _temp9 === void 0 ? {} : _temp9,
+      _ref9$locale = _ref9.locale,
+      locale = _ref9$locale === void 0 ? null : _ref9$locale;
     return Locale.create(locale, null, "gregory").eras(length);
   }
 
@@ -5165,12 +5586,14 @@ var Info = /*#__PURE__*/function () {
    * 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.
    * Keys:
    * * `relative`: whether this environment supports relative time formatting
-   * @example Info.features() //=> { relative: false }
+   * * `localeWeek`: whether this environment supports different weekdays for the start of the week based on the locale
+   * @example Info.features() //=> { relative: false, localeWeek: true }
    * @return {Object}
    */;
   Info.features = function features() {
     return {
-      relative: hasRelative()
+      relative: hasRelative(),
+      localeWeek: hasLocaleWeekInfo()
     };
   };
   return Info;
@@ -5199,6 +5622,15 @@ function highOrderDiffs(cursor, later, units) {
   var results = {};
   var earlier = cursor;
   var lowestOrder, highWater;
+
+  /* This loop tries to diff using larger units first.
+     If we overshoot, we backtrack and try the next smaller unit.
+     "cursor" starts out at the earlier timestamp and moves closer and closer to "later"
+     as we use smaller and smaller units.
+     highWater keeps track of where we would be if we added one more of the smallest unit,
+     this is used later to potentially convert any difference smaller than the smallest higher order unit
+     into a fraction of that smallest higher order unit
+  */
   for (var _i = 0, _differs = differs; _i < _differs.length; _i++) {
     var _differs$_i = _differs[_i],
       unit = _differs$_i[0],
@@ -5208,8 +5640,20 @@ function highOrderDiffs(cursor, later, units) {
       results[unit] = differ(cursor, later);
       highWater = earlier.plus(results);
       if (highWater > later) {
+        // we overshot the end point, backtrack cursor by 1
         results[unit]--;
         cursor = earlier.plus(results);
+
+        // if we are still overshooting now, we need to backtrack again
+        // this happens in certain situations when diffing times in different zones,
+        // because this calculation ignores time zones
+        if (cursor > later) {
+          // keep the "overshot by 1" around as highWater
+          highWater = cursor;
+          // backtrack cursor by 1
+          results[unit]--;
+          cursor = earlier.plus(results);
+        }
       } else {
         cursor = highWater;
       }
@@ -5388,6 +5832,11 @@ function simple(regex) {
 function escapeToken(value) {
   return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
 }
+
+/**
+ * @param token
+ * @param {Locale} loc
+ */
 function unitForToken(token, loc) {
   var one = digitRegex(loc),
     two = digitRegex(loc, "{2}"),
@@ -5417,9 +5866,9 @@ function unitForToken(token, loc) {
       switch (t.val) {
         // era
         case "G":
-          return oneOf(loc.eras("short", false), 0);
+          return oneOf(loc.eras("short"), 0);
         case "GG":
-          return oneOf(loc.eras("long", false), 0);
+          return oneOf(loc.eras("long"), 0);
         // years
         case "y":
           return intUnit(oneToSix);
@@ -5437,17 +5886,17 @@ function unitForToken(token, loc) {
         case "MM":
           return intUnit(two);
         case "MMM":
-          return oneOf(loc.months("short", true, false), 1);
+          return oneOf(loc.months("short", true), 1);
         case "MMMM":
-          return oneOf(loc.months("long", true, false), 1);
+          return oneOf(loc.months("long", true), 1);
         case "L":
           return intUnit(oneOrTwo);
         case "LL":
           return intUnit(two);
         case "LLL":
-          return oneOf(loc.months("short", false, false), 1);
+          return oneOf(loc.months("short", false), 1);
         case "LLLL":
-          return oneOf(loc.months("long", false, false), 1);
+          return oneOf(loc.months("long", false), 1);
         // dates
         case "d":
           return intUnit(oneOrTwo);
@@ -5507,13 +5956,13 @@ function unitForToken(token, loc) {
         case "c":
           return intUnit(one);
         case "EEE":
-          return oneOf(loc.weekdays("short", false, false), 1);
+          return oneOf(loc.weekdays("short", false), 1);
         case "EEEE":
-          return oneOf(loc.weekdays("long", false, false), 1);
+          return oneOf(loc.weekdays("long", false), 1);
         case "ccc":
-          return oneOf(loc.weekdays("short", true, false), 1);
+          return oneOf(loc.weekdays("short", true), 1);
         case "cccc":
-          return oneOf(loc.weekdays("long", true, false), 1);
+          return oneOf(loc.weekdays("long", true), 1);
         // offset/zone
         case "Z":
         case "ZZ":
@@ -5559,10 +6008,14 @@ var partTypeStyleToTokenVal = {
   },
   dayperiod: "a",
   dayPeriod: "a",
-  hour: {
+  hour12: {
     numeric: "h",
     "2-digit": "hh"
   },
+  hour24: {
+    numeric: "H",
+    "2-digit": "HH"
+  },
   minute: {
     numeric: "m",
     "2-digit": "mm"
@@ -5576,7 +6029,7 @@ var partTypeStyleToTokenVal = {
     short: "ZZZ"
   }
 };
-function tokenForPart(part, formatOpts) {
+function tokenForPart(part, formatOpts, resolvedOpts) {
   var type = part.type,
     value = part.value;
   if (type === "literal") {
@@ -5587,7 +6040,27 @@ function tokenForPart(part, formatOpts) {
     };
   }
   var style = formatOpts[type];
-  var val = partTypeStyleToTokenVal[type];
+
+  // The user might have explicitly specified hour12 or hourCycle
+  // if so, respect their decision
+  // if not, refer back to the resolvedOpts, which are based on the locale
+  var actualType = type;
+  if (type === "hour") {
+    if (formatOpts.hour12 != null) {
+      actualType = formatOpts.hour12 ? "hour12" : "hour24";
+    } else if (formatOpts.hourCycle != null) {
+      if (formatOpts.hourCycle === "h11" || formatOpts.hourCycle === "h12") {
+        actualType = "hour12";
+      } else {
+        actualType = "hour24";
+      }
+    } else {
+      // tokens only differentiate between 24 hours or not,
+      // so we do not need to check hourCycle here, which is less supported anyways
+      actualType = resolvedOpts.hour12 ? "hour12" : "hour24";
+    }
+  }
+  var val = partTypeStyleToTokenVal[actualType];
   if (typeof val === "object") {
     val = val[style];
   }
@@ -5780,168 +6253,14 @@ function formatOptsToTokens(formatOpts, locale) {
     return null;
   }
   var formatter = Formatter.create(locale, formatOpts);
-  var parts = formatter.formatDateTimeParts(getDummyDateTime());
+  var df = formatter.dtFormatter(getDummyDateTime());
+  var parts = df.formatToParts();
+  var resolvedOpts = df.resolvedOptions();
   return parts.map(function (p) {
-    return tokenForPart(p, formatOpts);
+    return tokenForPart(p, formatOpts, resolvedOpts);
   });
 }
 
-var nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
-  leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
-function unitOutOfRange(unit, value) {
-  return new Invalid("unit out of range", "you specified " + value + " (of type " + typeof value + ") as a " + unit + ", which is invalid");
-}
-function dayOfWeek(year, month, day) {
-  var d = new Date(Date.UTC(year, month - 1, day));
-  if (year < 100 && year >= 0) {
-    d.setUTCFullYear(d.getUTCFullYear() - 1900);
-  }
-  var js = d.getUTCDay();
-  return js === 0 ? 7 : js;
-}
-function computeOrdinal(year, month, day) {
-  return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
-}
-function uncomputeOrdinal(year, ordinal) {
-  var table = isLeapYear(year) ? leapLadder : nonLeapLadder,
-    month0 = table.findIndex(function (i) {
-      return i < ordinal;
-    }),
-    day = ordinal - table[month0];
-  return {
-    month: month0 + 1,
-    day: day
-  };
-}
-
-/**
- * @private
- */
-
-function gregorianToWeek(gregObj) {
-  var year = gregObj.year,
-    month = gregObj.month,
-    day = gregObj.day,
-    ordinal = computeOrdinal(year, month, day),
-    weekday = dayOfWeek(year, month, day);
-  var weekNumber = Math.floor((ordinal - weekday + 10) / 7),
-    weekYear;
-  if (weekNumber < 1) {
-    weekYear = year - 1;
-    weekNumber = weeksInWeekYear(weekYear);
-  } else if (weekNumber > weeksInWeekYear(year)) {
-    weekYear = year + 1;
-    weekNumber = 1;
-  } else {
-    weekYear = year;
-  }
-  return _extends({
-    weekYear: weekYear,
-    weekNumber: weekNumber,
-    weekday: weekday
-  }, timeObject(gregObj));
-}
-function weekToGregorian(weekData) {
-  var weekYear = weekData.weekYear,
-    weekNumber = weekData.weekNumber,
-    weekday = weekData.weekday,
-    weekdayOfJan4 = dayOfWeek(weekYear, 1, 4),
-    yearInDays = daysInYear(weekYear);
-  var ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 3,
-    year;
-  if (ordinal < 1) {
-    year = weekYear - 1;
-    ordinal += daysInYear(year);
-  } else if (ordinal > yearInDays) {
-    year = weekYear + 1;
-    ordinal -= daysInYear(weekYear);
-  } else {
-    year = weekYear;
-  }
-  var _uncomputeOrdinal = uncomputeOrdinal(year, ordinal),
-    month = _uncomputeOrdinal.month,
-    day = _uncomputeOrdinal.day;
-  return _extends({
-    year: year,
-    month: month,
-    day: day
-  }, timeObject(weekData));
-}
-function gregorianToOrdinal(gregData) {
-  var year = gregData.year,
-    month = gregData.month,
-    day = gregData.day;
-  var ordinal = computeOrdinal(year, month, day);
-  return _extends({
-    year: year,
-    ordinal: ordinal
-  }, timeObject(gregData));
-}
-function ordinalToGregorian(ordinalData) {
-  var year = ordinalData.year,
-    ordinal = ordinalData.ordinal;
-  var _uncomputeOrdinal2 = uncomputeOrdinal(year, ordinal),
-    month = _uncomputeOrdinal2.month,
-    day = _uncomputeOrdinal2.day;
-  return _extends({
-    year: year,
-    month: month,
-    day: day
-  }, timeObject(ordinalData));
-}
-function hasInvalidWeekData(obj) {
-  var validYear = isInteger(obj.weekYear),
-    validWeek = integerBetween(obj.weekNumber, 1, weeksInWeekYear(obj.weekYear)),
-    validWeekday = integerBetween(obj.weekday, 1, 7);
-  if (!validYear) {
-    return unitOutOfRange("weekYear", obj.weekYear);
-  } else if (!validWeek) {
-    return unitOutOfRange("week", obj.week);
-  } else if (!validWeekday) {
-    return unitOutOfRange("weekday", obj.weekday);
-  } else return false;
-}
-function hasInvalidOrdinalData(obj) {
-  var validYear = isInteger(obj.year),
-    validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year));
-  if (!validYear) {
-    return unitOutOfRange("year", obj.year);
-  } else if (!validOrdinal) {
-    return unitOutOfRange("ordinal", obj.ordinal);
-  } else return false;
-}
-function hasInvalidGregorianData(obj) {
-  var validYear = isInteger(obj.year),
-    validMonth = integerBetween(obj.month, 1, 12),
-    validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month));
-  if (!validYear) {
-    return unitOutOfRange("year", obj.year);
-  } else if (!validMonth) {
-    return unitOutOfRange("month", obj.month);
-  } else if (!validDay) {
-    return unitOutOfRange("day", obj.day);
-  } else return false;
-}
-function hasInvalidTimeData(obj) {
-  var hour = obj.hour,
-    minute = obj.minute,
-    second = obj.second,
-    millisecond = obj.millisecond;
-  var validHour = integerBetween(hour, 0, 23) || hour === 24 && minute === 0 && second === 0 && millisecond === 0,
-    validMinute = integerBetween(minute, 0, 59),
-    validSecond = integerBetween(second, 0, 59),
-    validMillisecond = integerBetween(millisecond, 0, 999);
-  if (!validHour) {
-    return unitOutOfRange("hour", hour);
-  } else if (!validMinute) {
-    return unitOutOfRange("minute", minute);
-  } else if (!validSecond) {
-    return unitOutOfRange("second", second);
-  } else if (!validMillisecond) {
-    return unitOutOfRange("millisecond", millisecond);
-  } else return false;
-}
-
 var INVALID = "Invalid DateTime";
 var MAX_DATE = 8.64e15;
 function unsupportedZone(zone) {
@@ -5949,6 +6268,9 @@ function unsupportedZone(zone) {
 }
 
 // we cache week data on the DT object and this intermediates the cache
+/**
+ * @param {DateTime} dt
+ */
 function possiblyCachedWeekData(dt) {
   if (dt.weekData === null) {
     dt.weekData = gregorianToWeek(dt.c);
@@ -5956,6 +6278,16 @@ function possiblyCachedWeekData(dt) {
   return dt.weekData;
 }
 
+/**
+ * @param {DateTime} dt
+ */
+function possiblyCachedLocalWeekData(dt) {
+  if (dt.localWeekData === null) {
+    dt.localWeekData = gregorianToWeek(dt.c, dt.loc.getMinDaysInFirstWeek(), dt.loc.getStartOfWeek());
+  }
+  return dt.localWeekData;
+}
+
 // clone really means, "make a new object with these modifications". all "setters" really use this
 // to create a new object while only changing some of the properties
 function clone(inst, alts) {
@@ -6104,13 +6436,13 @@ function _toISOTime(o, extended, suppressSeconds, suppressMilliseconds, includeO
   if (extended) {
     c += ":";
     c += padStart(o.c.minute);
-    if (o.c.second !== 0 || !suppressSeconds) {
+    if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
       c += ":";
     }
   } else {
     c += padStart(o.c.minute);
   }
-  if (o.c.second !== 0 || !suppressSeconds) {
+  if (o.c.millisecond !== 0 || o.c.second !== 0 || !suppressSeconds) {
     c += padStart(o.c.second);
     if (o.c.millisecond !== 0 || !suppressMilliseconds) {
       c += ".";
@@ -6199,6 +6531,21 @@ function normalizeUnit(unit) {
   if (!normalized) throw new InvalidUnitError(unit);
   return normalized;
 }
+function normalizeUnitWithLocalWeeks(unit) {
+  switch (unit.toLowerCase()) {
+    case "localweekday":
+    case "localweekdays":
+      return "localWeekday";
+    case "localweeknumber":
+    case "localweeknumbers":
+      return "localWeekNumber";
+    case "localweekyear":
+    case "localweekyears":
+      return "localWeekYear";
+    default:
+      return normalizeUnit(unit);
+  }
+}
 
 // this is a dumbed down version of fromObject() that runs about 60% faster
 // but doesn't do any validation, makes a bunch of assumptions about what units
@@ -6295,7 +6642,7 @@ function lastOpts(argList) {
  *
  * There's plenty others documented below. In addition, for more information on subtler topics like internationalization, time zones, alternative calendars, validity, and so on, see the external documentation.
  */
-var DateTime = /*#__PURE__*/function () {
+var DateTime = /*#__PURE__*/function (_Symbol$for) {
   /**
    * @access private
    */
@@ -6339,6 +6686,10 @@ var DateTime = /*#__PURE__*/function () {
      * @access private
      */
     this.weekData = null;
+    /**
+     * @access private
+     */
+    this.localWeekData = null;
     /**
      * @access private
      */
@@ -6545,13 +6896,16 @@ var DateTime = /*#__PURE__*/function () {
    * @param {number} obj.weekYear - an ISO week year
    * @param {number} obj.weekNumber - an ISO week number, between 1 and 52 or 53, depending on the year
    * @param {number} obj.weekday - an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday
+   * @param {number} obj.localWeekYear - a week year, according to the locale
+   * @param {number} obj.localWeekNumber - a week number, between 1 and 52 or 53, depending on the year, according to the locale
+   * @param {number} obj.localWeekday - a weekday, 1-7, where 1 is the first and 7 is the last day of the week, according to the locale
    * @param {number} obj.hour - hour of the day, 0-23
    * @param {number} obj.minute - minute of the hour, 0-59
    * @param {number} obj.second - second of the minute, 0-59
    * @param {number} obj.millisecond - millisecond of the second, 0-999
    * @param {Object} opts - options for creating this DateTime
    * @param {string|Zone} [opts.zone='local'] - interpret the numbers in the context of a particular zone. Can take any value taken as the first argument to setZone()
-   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
+   * @param {string} [opts.locale='system\'s locale'] - a locale to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
    * @example DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25'
@@ -6561,6 +6915,7 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'local' })
    * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'America/New_York' })
    * @example DateTime.fromObject({ weekYear: 2016, weekNumber: 2, weekday: 3 }).toISODate() //=> '2016-01-13'
+   * @example DateTime.fromObject({ localWeekYear: 2022, localWeekNumber: 1, localWeekday: 1 }, { locale: "en-US" }).toISODate() //=> '2021-12-26'
    * @return {DateTime}
    */;
   DateTime.fromObject = function fromObject(obj, opts) {
@@ -6572,15 +6927,18 @@ var DateTime = /*#__PURE__*/function () {
     if (!zoneToUse.isValid) {
       return DateTime.invalid(unsupportedZone(zoneToUse));
     }
+    var loc = Locale.fromObject(opts);
+    var normalized = normalizeObject(obj, normalizeUnitWithLocalWeeks);
+    var _usesLocalWeekValues = usesLocalWeekValues(normalized, loc),
+      minDaysInFirstWeek = _usesLocalWeekValues.minDaysInFirstWeek,
+      startOfWeek = _usesLocalWeekValues.startOfWeek;
     var tsNow = Settings.now(),
       offsetProvis = !isUndefined(opts.specificOffset) ? opts.specificOffset : zoneToUse.offset(tsNow),
-      normalized = normalizeObject(obj, normalizeUnit),
       containsOrdinal = !isUndefined(normalized.ordinal),
       containsGregorYear = !isUndefined(normalized.year),
       containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day),
       containsGregor = containsGregorYear || containsGregorMD,
-      definiteWeekDef = normalized.weekYear || normalized.weekNumber,
-      loc = Locale.fromObject(opts);
+      definiteWeekDef = normalized.weekYear || normalized.weekNumber;
 
     // cases:
     // just a weekday -> this week's instance of that weekday, no worries
@@ -6603,7 +6961,7 @@ var DateTime = /*#__PURE__*/function () {
     if (useWeekData) {
       units = orderedWeekUnits;
       defaultValues = defaultWeekUnitValues;
-      objNow = gregorianToWeek(objNow);
+      objNow = gregorianToWeek(objNow, minDaysInFirstWeek, startOfWeek);
     } else if (containsOrdinal) {
       units = orderedOrdinalUnits;
       defaultValues = defaultOrdinalUnitValues;
@@ -6628,14 +6986,14 @@ var DateTime = /*#__PURE__*/function () {
     }
 
     // make sure the values we have are in range
-    var higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized),
+    var higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized),
       invalid = higherOrderInvalid || hasInvalidTimeData(normalized);
     if (invalid) {
       return DateTime.invalid(invalid);
     }
 
     // compute the actual time
-    var gregorian = useWeekData ? weekToGregorian(normalized) : containsOrdinal ? ordinalToGregorian(normalized) : normalized,
+    var gregorian = useWeekData ? weekToGregorian(normalized, minDaysInFirstWeek, startOfWeek) : containsOrdinal ? ordinalToGregorian(normalized) : normalized,
       _objToTS2 = objToTS(gregorian, offsetProvis, zoneToUse),
       tsFinal = _objToTS2[0],
       offsetFinal = _objToTS2[1],
@@ -6812,7 +7170,7 @@ var DateTime = /*#__PURE__*/function () {
 
   /**
    * Create an invalid DateTime.
-   * @param {DateTime} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent
+   * @param {string} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent.
    * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
    * @return {DateTime}
    */;
@@ -6895,6 +7253,47 @@ var DateTime = /*#__PURE__*/function () {
    * * The DateTime was created by an operation on another invalid date
    * @type {boolean}
    */;
+  /**
+   * Get those DateTimes which have the same local time as this DateTime, but a different offset from UTC
+   * in this DateTime's zone. During DST changes local time can be ambiguous, for example
+   * `2023-10-29T02:30:00` in `Europe/Berlin` can have offset `+01:00` or `+02:00`.
+   * This method will return both possible DateTimes if this DateTime's local time is ambiguous.
+   * @returns {DateTime[]}
+   */
+  _proto.getPossibleOffsets = function getPossibleOffsets() {
+    if (!this.isValid || this.isOffsetFixed) {
+      return [this];
+    }
+    var dayMs = 86400000;
+    var minuteMs = 60000;
+    var localTS = objToLocalTS(this.c);
+    var oEarlier = this.zone.offset(localTS - dayMs);
+    var oLater = this.zone.offset(localTS + dayMs);
+    var o1 = this.zone.offset(localTS - oEarlier * minuteMs);
+    var o2 = this.zone.offset(localTS - oLater * minuteMs);
+    if (o1 === o2) {
+      return [this];
+    }
+    var ts1 = localTS - o1 * minuteMs;
+    var ts2 = localTS - o2 * minuteMs;
+    var c1 = tsToObj(ts1, o1);
+    var c2 = tsToObj(ts2, o2);
+    if (c1.hour === c2.hour && c1.minute === c2.minute && c1.second === c2.second && c1.millisecond === c2.millisecond) {
+      return [clone(this, {
+        ts: ts1
+      }), clone(this, {
+        ts: ts2
+      })];
+    }
+    return [this];
+  }
+
+  /**
+   * Returns true if this DateTime is in a leap year, false otherwise
+   * @example DateTime.local(2016).isInLeapYear //=> true
+   * @example DateTime.local(2013).isInLeapYear //=> false
+   * @type {boolean}
+   */;
   /**
    * Returns the resolved Intl options for this DateTime.
    * This is useful in understanding the behavior of formatting methods
@@ -7017,6 +7416,9 @@ var DateTime = /*#__PURE__*/function () {
   /**
    * "Set" the values of specified units. Returns a newly-constructed DateTime.
    * You can only set units with this method; for "setting" metadata, see {@link DateTime#reconfigure} and {@link DateTime#setZone}.
+   *
+   * This method also supports setting locale-based week units, i.e. `localWeekday`, `localWeekNumber` and `localWeekYear`.
+   * They cannot be mixed with ISO-week units like `weekday`.
    * @param {Object} values - a mapping of units to numbers
    * @example dt.set({ year: 2017 })
    * @example dt.set({ hour: 8, minute: 30 })
@@ -7026,8 +7428,11 @@ var DateTime = /*#__PURE__*/function () {
    */;
   _proto.set = function set(values) {
     if (!this.isValid) return this;
-    var normalized = normalizeObject(values, normalizeUnit),
-      settingWeekStuff = !isUndefined(normalized.weekYear) || !isUndefined(normalized.weekNumber) || !isUndefined(normalized.weekday),
+    var normalized = normalizeObject(values, normalizeUnitWithLocalWeeks);
+    var _usesLocalWeekValues2 = usesLocalWeekValues(normalized, this.loc),
+      minDaysInFirstWeek = _usesLocalWeekValues2.minDaysInFirstWeek,
+      startOfWeek = _usesLocalWeekValues2.startOfWeek;
+    var settingWeekStuff = !isUndefined(normalized.weekYear) || !isUndefined(normalized.weekNumber) || !isUndefined(normalized.weekday),
       containsOrdinal = !isUndefined(normalized.ordinal),
       containsGregorYear = !isUndefined(normalized.year),
       containsGregorMD = !isUndefined(normalized.month) || !isUndefined(normalized.day),
@@ -7041,7 +7446,7 @@ var DateTime = /*#__PURE__*/function () {
     }
     var mixed;
     if (settingWeekStuff) {
-      mixed = weekToGregorian(_extends({}, gregorianToWeek(this.c), normalized));
+      mixed = weekToGregorian(_extends({}, gregorianToWeek(this.c, minDaysInFirstWeek, startOfWeek), normalized), minDaysInFirstWeek, startOfWeek);
     } else if (!isUndefined(normalized.ordinal)) {
       mixed = ordinalToGregorian(_extends({}, gregorianToOrdinal(this.c), normalized));
     } else {
@@ -7096,6 +7501,8 @@ var DateTime = /*#__PURE__*/function () {
   /**
    * "Set" this DateTime to the beginning of a unit of time.
    * @param {string} unit - The unit to go to the beginning of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
+   * @param {Object} opts - options
+   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week
    * @example DateTime.local(2014, 3, 3).startOf('month').toISODate(); //=> '2014-03-01'
    * @example DateTime.local(2014, 3, 3).startOf('year').toISODate(); //=> '2014-01-01'
    * @example DateTime.local(2014, 3, 3).startOf('week').toISODate(); //=> '2014-03-03', weeks always start on Mondays
@@ -7103,7 +7510,10 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.local(2014, 3, 3, 5, 30).startOf('hour').toISOTime(); //=> '05:00:00.000-05:00'
    * @return {DateTime}
    */;
-  _proto.startOf = function startOf(unit) {
+  _proto.startOf = function startOf(unit, _temp3) {
+    var _ref4 = _temp3 === void 0 ? {} : _temp3,
+      _ref4$useLocaleWeeks = _ref4.useLocaleWeeks,
+      useLocaleWeeks = _ref4$useLocaleWeeks === void 0 ? false : _ref4$useLocaleWeeks;
     if (!this.isValid) return this;
     var o = {},
       normalizedUnit = Duration.normalizeUnit(unit);
@@ -7132,7 +7542,16 @@ var DateTime = /*#__PURE__*/function () {
     }
 
     if (normalizedUnit === "weeks") {
-      o.weekday = 1;
+      if (useLocaleWeeks) {
+        var startOfWeek = this.loc.getStartOfWeek();
+        var weekday = this.weekday;
+        if (weekday < startOfWeek) {
+          o.weekNumber = this.weekNumber - 1;
+        }
+        o.weekday = startOfWeek;
+      } else {
+        o.weekday = 1;
+      }
     }
     if (normalizedUnit === "quarters") {
       var q = Math.ceil(this.month / 3);
@@ -7144,6 +7563,8 @@ var DateTime = /*#__PURE__*/function () {
   /**
    * "Set" this DateTime to the end (meaning the last millisecond) of a unit of time
    * @param {string} unit - The unit to go to the end of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
+   * @param {Object} opts - options
+   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week
    * @example DateTime.local(2014, 3, 3).endOf('month').toISO(); //=> '2014-03-31T23:59:59.999-05:00'
    * @example DateTime.local(2014, 3, 3).endOf('year').toISO(); //=> '2014-12-31T23:59:59.999-05:00'
    * @example DateTime.local(2014, 3, 3).endOf('week').toISO(); // => '2014-03-09T23:59:59.999-05:00', weeks start on Mondays
@@ -7151,9 +7572,9 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.local(2014, 3, 3, 5, 30).endOf('hour').toISO(); //=> '2014-03-03T05:59:59.999-05:00'
    * @return {DateTime}
    */;
-  _proto.endOf = function endOf(unit) {
+  _proto.endOf = function endOf(unit, opts) {
     var _this$plus;
-    return this.isValid ? this.plus((_this$plus = {}, _this$plus[unit] = 1, _this$plus)).startOf(unit).minus(1) : this;
+    return this.isValid ? this.plus((_this$plus = {}, _this$plus[unit] = 1, _this$plus)).startOf(unit, opts).minus(1) : this;
   }
 
   // OUTPUT
@@ -7240,18 +7661,18 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
    * @return {string}
    */;
-  _proto.toISO = function toISO(_temp3) {
-    var _ref4 = _temp3 === void 0 ? {} : _temp3,
-      _ref4$format = _ref4.format,
-      format = _ref4$format === void 0 ? "extended" : _ref4$format,
-      _ref4$suppressSeconds = _ref4.suppressSeconds,
-      suppressSeconds = _ref4$suppressSeconds === void 0 ? false : _ref4$suppressSeconds,
-      _ref4$suppressMillise = _ref4.suppressMilliseconds,
-      suppressMilliseconds = _ref4$suppressMillise === void 0 ? false : _ref4$suppressMillise,
-      _ref4$includeOffset = _ref4.includeOffset,
-      includeOffset = _ref4$includeOffset === void 0 ? true : _ref4$includeOffset,
-      _ref4$extendedZone = _ref4.extendedZone,
-      extendedZone = _ref4$extendedZone === void 0 ? false : _ref4$extendedZone;
+  _proto.toISO = function toISO(_temp4) {
+    var _ref5 = _temp4 === void 0 ? {} : _temp4,
+      _ref5$format = _ref5.format,
+      format = _ref5$format === void 0 ? "extended" : _ref5$format,
+      _ref5$suppressSeconds = _ref5.suppressSeconds,
+      suppressSeconds = _ref5$suppressSeconds === void 0 ? false : _ref5$suppressSeconds,
+      _ref5$suppressMillise = _ref5.suppressMilliseconds,
+      suppressMilliseconds = _ref5$suppressMillise === void 0 ? false : _ref5$suppressMillise,
+      _ref5$includeOffset = _ref5.includeOffset,
+      includeOffset = _ref5$includeOffset === void 0 ? true : _ref5$includeOffset,
+      _ref5$extendedZone = _ref5.extendedZone,
+      extendedZone = _ref5$extendedZone === void 0 ? false : _ref5$extendedZone;
     if (!this.isValid) {
       return null;
     }
@@ -7270,10 +7691,10 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
    * @return {string}
    */;
-  _proto.toISODate = function toISODate(_temp4) {
-    var _ref5 = _temp4 === void 0 ? {} : _temp4,
-      _ref5$format = _ref5.format,
-      format = _ref5$format === void 0 ? "extended" : _ref5$format;
+  _proto.toISODate = function toISODate(_temp5) {
+    var _ref6 = _temp5 === void 0 ? {} : _temp5,
+      _ref6$format = _ref6.format,
+      format = _ref6$format === void 0 ? "extended" : _ref6$format;
     if (!this.isValid) {
       return null;
     }
@@ -7304,20 +7725,20 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ includePrefix: true }) //=> 'T07:34:19.361Z'
    * @return {string}
    */;
-  _proto.toISOTime = function toISOTime(_temp5) {
-    var _ref6 = _temp5 === void 0 ? {} : _temp5,
-      _ref6$suppressMillise = _ref6.suppressMilliseconds,
-      suppressMilliseconds = _ref6$suppressMillise === void 0 ? false : _ref6$suppressMillise,
-      _ref6$suppressSeconds = _ref6.suppressSeconds,
-      suppressSeconds = _ref6$suppressSeconds === void 0 ? false : _ref6$suppressSeconds,
-      _ref6$includeOffset = _ref6.includeOffset,
-      includeOffset = _ref6$includeOffset === void 0 ? true : _ref6$includeOffset,
-      _ref6$includePrefix = _ref6.includePrefix,
-      includePrefix = _ref6$includePrefix === void 0 ? false : _ref6$includePrefix,
-      _ref6$extendedZone = _ref6.extendedZone,
-      extendedZone = _ref6$extendedZone === void 0 ? false : _ref6$extendedZone,
-      _ref6$format = _ref6.format,
-      format = _ref6$format === void 0 ? "extended" : _ref6$format;
+  _proto.toISOTime = function toISOTime(_temp6) {
+    var _ref7 = _temp6 === void 0 ? {} : _temp6,
+      _ref7$suppressMillise = _ref7.suppressMilliseconds,
+      suppressMilliseconds = _ref7$suppressMillise === void 0 ? false : _ref7$suppressMillise,
+      _ref7$suppressSeconds = _ref7.suppressSeconds,
+      suppressSeconds = _ref7$suppressSeconds === void 0 ? false : _ref7$suppressSeconds,
+      _ref7$includeOffset = _ref7.includeOffset,
+      includeOffset = _ref7$includeOffset === void 0 ? true : _ref7$includeOffset,
+      _ref7$includePrefix = _ref7.includePrefix,
+      includePrefix = _ref7$includePrefix === void 0 ? false : _ref7$includePrefix,
+      _ref7$extendedZone = _ref7.extendedZone,
+      extendedZone = _ref7$extendedZone === void 0 ? false : _ref7$extendedZone,
+      _ref7$format = _ref7.format,
+      format = _ref7$format === void 0 ? "extended" : _ref7$format;
     if (!this.isValid) {
       return null;
     }
@@ -7371,14 +7792,14 @@ var DateTime = /*#__PURE__*/function () {
    * @example DateTime.now().toSQL({ includeZone: false }) //=> '05:15:16.345 America/New_York'
    * @return {string}
    */;
-  _proto.toSQLTime = function toSQLTime(_temp6) {
-    var _ref7 = _temp6 === void 0 ? {} : _temp6,
-      _ref7$includeOffset = _ref7.includeOffset,
-      includeOffset = _ref7$includeOffset === void 0 ? true : _ref7$includeOffset,
-      _ref7$includeZone = _ref7.includeZone,
-      includeZone = _ref7$includeZone === void 0 ? false : _ref7$includeZone,
-      _ref7$includeOffsetSp = _ref7.includeOffsetSpace,
-      includeOffsetSpace = _ref7$includeOffsetSp === void 0 ? true : _ref7$includeOffsetSp;
+  _proto.toSQLTime = function toSQLTime(_temp7) {
+    var _ref8 = _temp7 === void 0 ? {} : _temp7,
+      _ref8$includeOffset = _ref8.includeOffset,
+      includeOffset = _ref8$includeOffset === void 0 ? true : _ref8$includeOffset,
+      _ref8$includeZone = _ref8.includeZone,
+      includeZone = _ref8$includeZone === void 0 ? false : _ref8$includeZone,
+      _ref8$includeOffsetSp = _ref8.includeOffsetSpace,
+      includeOffsetSpace = _ref8$includeOffsetSp === void 0 ? true : _ref8$includeOffsetSp;
     var fmt = "HH:mm:ss.SSS";
     if (includeZone || includeOffset) {
       if (includeOffsetSpace) {
@@ -7423,6 +7844,18 @@ var DateTime = /*#__PURE__*/function () {
     return this.isValid ? this.toISO() : INVALID;
   }
 
+  /**
+   * Returns a string representation of this DateTime appropriate for the REPL.
+   * @return {string}
+   */;
+  _proto[_Symbol$for] = function () {
+    if (this.isValid) {
+      return "DateTime { ts: " + this.toISO() + ", zone: " + this.zone.name + ", locale: " + this.locale + " }";
+    } else {
+      return "DateTime { Invalid, reason: " + this.invalidReason + " }";
+    }
+  }
+
   /**
    * Returns the epoch milliseconds of this DateTime. Alias of {@link DateTime#toMillis}
    * @return {number}
@@ -7572,16 +8005,18 @@ var DateTime = /*#__PURE__*/function () {
    * Note that time zones are **ignored** in this comparison, which compares the **local** calendar time. Use {@link DateTime#setZone} to convert one of the dates if needed.
    * @param {DateTime} otherDateTime - the other DateTime
    * @param {string} unit - the unit of time to check sameness on
+   * @param {Object} opts - options
+   * @param {boolean} [opts.useLocaleWeeks=false] - If true, use weeks based on the locale, i.e. use the locale-dependent start of the week; only the locale of this DateTime is used
    * @example DateTime.now().hasSame(otherDT, 'day'); //~> true if otherDT is in the same current calendar day
    * @return {boolean}
    */;
-  _proto.hasSame = function hasSame(otherDateTime, unit) {
+  _proto.hasSame = function hasSame(otherDateTime, unit, opts) {
     if (!this.isValid) return false;
     var inputMs = otherDateTime.valueOf();
     var adjustedToZone = this.setZone(otherDateTime.zone, {
       keepLocalTime: true
     });
-    return adjustedToZone.startOf(unit) <= inputMs && inputMs <= adjustedToZone.endOf(unit);
+    return adjustedToZone.startOf(unit, opts) <= inputMs && inputMs <= adjustedToZone.endOf(unit, opts);
   }
 
   /**
@@ -7942,6 +8377,51 @@ var DateTime = /*#__PURE__*/function () {
       return this.isValid ? possiblyCachedWeekData(this).weekday : NaN;
     }
 
+    /**
+     * Returns true if this date is on a weekend according to the locale, false otherwise
+     * @returns {boolean}
+     */
+  }, {
+    key: "isWeekend",
+    get: function get() {
+      return this.isValid && this.loc.getWeekendDays().includes(this.weekday);
+    }
+
+    /**
+     * Get the day of the week according to the locale.
+     * 1 is the first day of the week and 7 is the last day of the week.
+     * If the locale assigns Sunday as the first day of the week, then a date which is a Sunday will return 1,
+     * @returns {number}
+     */
+  }, {
+    key: "localWeekday",
+    get: function get() {
+      return this.isValid ? possiblyCachedLocalWeekData(this).weekday : NaN;
+    }
+
+    /**
+     * Get the week number of the week year according to the locale. Different locales assign week numbers differently,
+     * because the week can start on different days of the week (see localWeekday) and because a different number of days
+     * is required for a week to count as the first week of a year.
+     * @returns {number}
+     */
+  }, {
+    key: "localWeekNumber",
+    get: function get() {
+      return this.isValid ? possiblyCachedLocalWeekData(this).weekNumber : NaN;
+    }
+
+    /**
+     * Get the week year according to the locale. Different locales assign week numbers (and therefor week years)
+     * differently, see localWeekNumber.
+     * @returns {number}
+     */
+  }, {
+    key: "localWeekYear",
+    get: function get() {
+      return this.isValid ? possiblyCachedLocalWeekData(this).weekYear : NaN;
+    }
+
     /**
      * Get the ordinal (meaning the day of the year)
      * @example DateTime.local(2017, 5, 25).ordinal //=> 145
@@ -8085,13 +8565,6 @@ var DateTime = /*#__PURE__*/function () {
         }).offset;
       }
     }
-
-    /**
-     * Returns true if this DateTime is in a leap year, false otherwise
-     * @example DateTime.local(2016).isInLeapYear //=> true
-     * @example DateTime.local(2013).isInLeapYear //=> false
-     * @type {boolean}
-     */
   }, {
     key: "isInLeapYear",
     get: function get() {
@@ -8134,6 +8607,18 @@ var DateTime = /*#__PURE__*/function () {
     get: function get() {
       return this.isValid ? weeksInWeekYear(this.weekYear) : NaN;
     }
+
+    /**
+     * Returns the number of weeks in this DateTime's local week year
+     * @example DateTime.local(2020, 6, {locale: 'en-US'}).weeksInLocalWeekYear //=> 52
+     * @example DateTime.local(2020, 6, {locale: 'de-DE'}).weeksInLocalWeekYear //=> 53
+     * @type {number}
+     */
+  }, {
+    key: "weeksInLocalWeekYear",
+    get: function get() {
+      return this.isValid ? weeksInWeekYear(this.localWeekYear, this.loc.getMinDaysInFirstWeek(), this.loc.getStartOfWeek()) : NaN;
+    }
   }], [{
     key: "DATE_SHORT",
     get: function get() {
@@ -8351,7 +8836,7 @@ var DateTime = /*#__PURE__*/function () {
     }
   }]);
   return DateTime;
-}();
+}(Symbol.for("nodejs.util.inspect.custom"));
 function friendlyDateTime(dateTimeish) {
   if (DateTime.isDateTime(dateTimeish)) {
     return dateTimeish;
@@ -8364,7 +8849,7 @@ function friendlyDateTime(dateTimeish) {
   }
 }
 
-var VERSION = "3.3.0";
+var VERSION = "3.4.4";
 
 exports.DateTime = DateTime;
 exports.Duration = Duration;