@bpmn-io/form-js-playground 0.12.1 → 0.12.2

package/dist/form-playground.umd.js

@@ -1521,772 +1521,6 @@
     timeZoneName: l$1
   };
 
-  /*
-    This is just a junk drawer, containing anything used across multiple classes.
-    Because Luxon is small(ish), this should stay small and we won't worry about splitting
-    it up into, say, parsingUtil.js and basicUtil.js and so on. But they are divided up by feature area.
-  */
-
-  /**
-   * @private
-   */
-
-  // TYPES
-
-  function isUndefined$1(o) {
-    return typeof o === "undefined";
-  }
-  function isNumber$2(o) {
-    return typeof o === "number";
-  }
-  function isInteger(o) {
-    return typeof o === "number" && o % 1 === 0;
-  }
-  function isString$2(o) {
-    return typeof o === "string";
-  }
-  function isDate(o) {
-    return Object.prototype.toString.call(o) === "[object Date]";
-  }
-
-  // CAPABILITIES
-
-  function hasRelative() {
-    try {
-      return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  // OBJECTS AND ARRAYS
-
-  function maybeArray(thing) {
-    return Array.isArray(thing) ? thing : [thing];
-  }
-  function bestBy(arr, by, compare) {
-    if (arr.length === 0) {
-      return undefined;
-    }
-    return arr.reduce((best, next) => {
-      const pair = [by(next), next];
-      if (!best) {
-        return pair;
-      } else if (compare(best[0], pair[0]) === best[0]) {
-        return best;
-      } else {
-        return pair;
-      }
-    }, null)[1];
-  }
-  function pick(obj, keys) {
-    return keys.reduce((a, k) => {
-      a[k] = obj[k];
-      return a;
-    }, {});
-  }
-  function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-  }
-
-  // NUMBERS AND STRINGS
-
-  function integerBetween(thing, bottom, top) {
-    return isInteger(thing) && thing >= bottom && thing <= top;
-  }
-
-  // x % n but takes the sign of n instead of x
-  function floorMod(x, n) {
-    return x - n * Math.floor(x / n);
-  }
-  function padStart(input, n = 2) {
-    const isNeg = input < 0;
-    let padded;
-    if (isNeg) {
-      padded = "-" + ("" + -input).padStart(n, "0");
-    } else {
-      padded = ("" + input).padStart(n, "0");
-    }
-    return padded;
-  }
-  function parseInteger(string) {
-    if (isUndefined$1(string) || string === null || string === "") {
-      return undefined;
-    } else {
-      return parseInt(string, 10);
-    }
-  }
-  function parseFloating(string) {
-    if (isUndefined$1(string) || string === null || string === "") {
-      return undefined;
-    } else {
-      return parseFloat(string);
-    }
-  }
-  function parseMillis(fraction) {
-    // Return undefined (instead of 0) in these cases, where fraction is not set
-    if (isUndefined$1(fraction) || fraction === null || fraction === "") {
-      return undefined;
-    } else {
-      const f = parseFloat("0." + fraction) * 1000;
-      return Math.floor(f);
-    }
-  }
-  function roundTo(number, digits, towardZero = false) {
-    const factor = 10 ** digits,
-      rounder = towardZero ? Math.trunc : Math.round;
-    return rounder(number * factor) / factor;
-  }
-
-  // DATE BASICS
-
-  function isLeapYear(year) {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-  }
-  function daysInYear(year) {
-    return isLeapYear(year) ? 366 : 365;
-  }
-  function daysInMonth(year, month) {
-    const modMonth = floorMod(month - 1, 12) + 1,
-      modYear = year + (month - modMonth) / 12;
-    if (modMonth === 2) {
-      return isLeapYear(modYear) ? 29 : 28;
-    } else {
-      return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1];
-    }
-  }
-
-  // covert a calendar object to a local timestamp (epoch, but with the offset baked in)
-  function objToLocalTS(obj) {
-    let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
-
-    // for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that
-    if (obj.year < 100 && obj.year >= 0) {
-      d = new Date(d);
-      d.setUTCFullYear(d.getUTCFullYear() - 1900);
-    }
-    return +d;
-  }
-  function weeksInWeekYear(weekYear) {
-    const 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;
-  }
-  function untruncateYear(year) {
-    if (year > 99) {
-      return year;
-    } else return year > 60 ? 1900 + year : 2000 + year;
-  }
-
-  // PARSING
-
-  function parseZoneInfo(ts, offsetFormat, locale, timeZone = null) {
-    const date = new Date(ts),
-      intlOpts = {
-        hourCycle: "h23",
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit"
-      };
-    if (timeZone) {
-      intlOpts.timeZone = timeZone;
-    }
-    const modified = {
-      timeZoneName: offsetFormat,
-      ...intlOpts
-    };
-    const parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find(m => m.type.toLowerCase() === "timezonename");
-    return parsed ? parsed.value : null;
-  }
-
-  // signedOffset('-5', '30') -> -330
-  function signedOffset(offHourStr, offMinuteStr) {
-    let offHour = parseInt(offHourStr, 10);
-
-    // don't || this because we want to preserve -0
-    if (Number.isNaN(offHour)) {
-      offHour = 0;
-    }
-    const offMin = parseInt(offMinuteStr, 10) || 0,
-      offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin;
-    return offHour * 60 + offMinSigned;
-  }
-
-  // COERCION
-
-  function asNumber(value) {
-    const numericValue = Number(value);
-    if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue)) throw new InvalidArgumentError(`Invalid unit value ${value}`);
-    return numericValue;
-  }
-  function normalizeObject(obj, normalizer) {
-    const normalized = {};
-    for (const u in obj) {
-      if (hasOwnProperty(obj, u)) {
-        const v = obj[u];
-        if (v === undefined || v === null) continue;
-        normalized[normalizer(u)] = asNumber(v);
-      }
-    }
-    return normalized;
-  }
-  function formatOffset(offset, format) {
-    const hours = Math.trunc(Math.abs(offset / 60)),
-      minutes = Math.trunc(Math.abs(offset % 60)),
-      sign = offset >= 0 ? "+" : "-";
-    switch (format) {
-      case "short":
-        return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`;
-      case "narrow":
-        return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`;
-      case "techie":
-        return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`;
-      default:
-        throw new RangeError(`Value format ${format} is out of range for property format`);
-    }
-  }
-  function timeObject(obj) {
-    return pick(obj, ["hour", "minute", "second", "millisecond"]);
-  }
-  const ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
-
-  /**
-   * @private
-   */
-
-  const monthsLong = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-  const monthsShort = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-  const monthsNarrow = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
-  function months(length) {
-    switch (length) {
-      case "narrow":
-        return [...monthsNarrow];
-      case "short":
-        return [...monthsShort];
-      case "long":
-        return [...monthsLong];
-      case "numeric":
-        return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
-      case "2-digit":
-        return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];
-      default:
-        return null;
-    }
-  }
-  const weekdaysLong = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
-  const weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
-  const weekdaysNarrow = ["M", "T", "W", "T", "F", "S", "S"];
-  function weekdays(length) {
-    switch (length) {
-      case "narrow":
-        return [...weekdaysNarrow];
-      case "short":
-        return [...weekdaysShort];
-      case "long":
-        return [...weekdaysLong];
-      case "numeric":
-        return ["1", "2", "3", "4", "5", "6", "7"];
-      default:
-        return null;
-    }
-  }
-  const meridiems = ["AM", "PM"];
-  const erasLong = ["Before Christ", "Anno Domini"];
-  const erasShort = ["BC", "AD"];
-  const erasNarrow = ["B", "A"];
-  function eras(length) {
-    switch (length) {
-      case "narrow":
-        return [...erasNarrow];
-      case "short":
-        return [...erasShort];
-      case "long":
-        return [...erasLong];
-      default:
-        return null;
-    }
-  }
-  function meridiemForDateTime(dt) {
-    return meridiems[dt.hour < 12 ? 0 : 1];
-  }
-  function weekdayForDateTime(dt, length) {
-    return weekdays(length)[dt.weekday - 1];
-  }
-  function monthForDateTime(dt, length) {
-    return months(length)[dt.month - 1];
-  }
-  function eraForDateTime(dt, length) {
-    return eras(length)[dt.year < 0 ? 0 : 1];
-  }
-  function formatRelativeTime(unit, count, numeric = "always", narrow = false) {
-    const units = {
-      years: ["year", "yr."],
-      quarters: ["quarter", "qtr."],
-      months: ["month", "mo."],
-      weeks: ["week", "wk."],
-      days: ["day", "day", "days"],
-      hours: ["hour", "hr."],
-      minutes: ["minute", "min."],
-      seconds: ["second", "sec."]
-    };
-    const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1;
-    if (numeric === "auto" && lastable) {
-      const isDay = unit === "days";
-      switch (count) {
-        case 1:
-          return isDay ? "tomorrow" : `next ${units[unit][0]}`;
-        case -1:
-          return isDay ? "yesterday" : `last ${units[unit][0]}`;
-        case 0:
-          return isDay ? "today" : `this ${units[unit][0]}`;
-      }
-    }
-
-    const isInPast = Object.is(count, -0) || count < 0,
-      fmtValue = Math.abs(count),
-      singular = fmtValue === 1,
-      lilUnits = units[unit],
-      fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit;
-    return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`;
-  }
-
-  function stringifyTokens(splits, tokenToString) {
-    let s = "";
-    for (const token of splits) {
-      if (token.literal) {
-        s += token.val;
-      } else {
-        s += tokenToString(token.val);
-      }
-    }
-    return s;
-  }
-  const macroTokenToFormatOpts = {
-    D: DATE_SHORT,
-    DD: DATE_MED,
-    DDD: DATE_FULL,
-    DDDD: DATE_HUGE,
-    t: TIME_SIMPLE,
-    tt: TIME_WITH_SECONDS,
-    ttt: TIME_WITH_SHORT_OFFSET,
-    tttt: TIME_WITH_LONG_OFFSET,
-    T: TIME_24_SIMPLE,
-    TT: TIME_24_WITH_SECONDS,
-    TTT: TIME_24_WITH_SHORT_OFFSET,
-    TTTT: TIME_24_WITH_LONG_OFFSET,
-    f: DATETIME_SHORT,
-    ff: DATETIME_MED,
-    fff: DATETIME_FULL,
-    ffff: DATETIME_HUGE,
-    F: DATETIME_SHORT_WITH_SECONDS,
-    FF: DATETIME_MED_WITH_SECONDS,
-    FFF: DATETIME_FULL_WITH_SECONDS,
-    FFFF: DATETIME_HUGE_WITH_SECONDS
-  };
-
-  /**
-   * @private
-   */
-
-  class Formatter {
-    static create(locale, opts = {}) {
-      return new Formatter(locale, opts);
-    }
-    static parseFormat(fmt) {
-      let current = null,
-        currentFull = "",
-        bracketed = false;
-      const splits = [];
-      for (let i = 0; i < fmt.length; i++) {
-        const c = fmt.charAt(i);
-        if (c === "'") {
-          if (currentFull.length > 0) {
-            splits.push({
-              literal: bracketed,
-              val: currentFull
-            });
-          }
-          current = null;
-          currentFull = "";
-          bracketed = !bracketed;
-        } else if (bracketed) {
-          currentFull += c;
-        } else if (c === current) {
-          currentFull += c;
-        } else {
-          if (currentFull.length > 0) {
-            splits.push({
-              literal: false,
-              val: currentFull
-            });
-          }
-          currentFull = c;
-          current = c;
-        }
-      }
-      if (currentFull.length > 0) {
-        splits.push({
-          literal: bracketed,
-          val: currentFull
-        });
-      }
-      return splits;
-    }
-    static macroTokenToFormatOpts(token) {
-      return macroTokenToFormatOpts[token];
-    }
-    constructor(locale, formatOpts) {
-      this.opts = formatOpts;
-      this.loc = locale;
-      this.systemLoc = null;
-    }
-    formatWithSystemDefault(dt, opts) {
-      if (this.systemLoc === null) {
-        this.systemLoc = this.loc.redefaultToSystem();
-      }
-      const df = this.systemLoc.dtFormatter(dt, {
-        ...this.opts,
-        ...opts
-      });
-      return df.format();
-    }
-    formatDateTime(dt, opts = {}) {
-      const df = this.loc.dtFormatter(dt, {
-        ...this.opts,
-        ...opts
-      });
-      return df.format();
-    }
-    formatDateTimeParts(dt, opts = {}) {
-      const df = this.loc.dtFormatter(dt, {
-        ...this.opts,
-        ...opts
-      });
-      return df.formatToParts();
-    }
-    resolvedOptions(dt, opts = {}) {
-      const df = this.loc.dtFormatter(dt, {
-        ...this.opts,
-        ...opts
-      });
-      return df.resolvedOptions();
-    }
-    num(n, p = 0) {
-      // we get some perf out of doing this here, annoyingly
-      if (this.opts.forceSimple) {
-        return padStart(n, p);
-      }
-      const opts = {
-        ...this.opts
-      };
-      if (p > 0) {
-        opts.padTo = p;
-      }
-      return this.loc.numberFormatter(opts).format(n);
-    }
-    formatDateTimeFromString(dt, fmt) {
-      const knownEnglish = this.loc.listingMode() === "en",
-        useDateTimeFormatter = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory",
-        string = (opts, extract) => this.loc.extract(dt, opts, extract),
-        formatOffset = opts => {
-          if (dt.isOffsetFixed && dt.offset === 0 && opts.allowZ) {
-            return "Z";
-          }
-          return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : "";
-        },
-        meridiem = () => knownEnglish ? meridiemForDateTime(dt) : string({
-          hour: "numeric",
-          hourCycle: "h12"
-        }, "dayperiod"),
-        month = (length, standalone) => knownEnglish ? monthForDateTime(dt, length) : string(standalone ? {
-          month: length
-        } : {
-          month: length,
-          day: "numeric"
-        }, "month"),
-        weekday = (length, standalone) => knownEnglish ? weekdayForDateTime(dt, length) : string(standalone ? {
-          weekday: length
-        } : {
-          weekday: length,
-          month: "long",
-          day: "numeric"
-        }, "weekday"),
-        maybeMacro = token => {
-          const formatOpts = Formatter.macroTokenToFormatOpts(token);
-          if (formatOpts) {
-            return this.formatWithSystemDefault(dt, formatOpts);
-          } else {
-            return token;
-          }
-        },
-        era = length => knownEnglish ? eraForDateTime(dt, length) : string({
-          era: length
-        }, "era"),
-        tokenToString = token => {
-          // Where possible: http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles
-          switch (token) {
-            // ms
-            case "S":
-              return this.num(dt.millisecond);
-            case "u":
-            // falls through
-            case "SSS":
-              return this.num(dt.millisecond, 3);
-            // seconds
-            case "s":
-              return this.num(dt.second);
-            case "ss":
-              return this.num(dt.second, 2);
-            // fractional seconds
-            case "uu":
-              return this.num(Math.floor(dt.millisecond / 10), 2);
-            case "uuu":
-              return this.num(Math.floor(dt.millisecond / 100));
-            // minutes
-            case "m":
-              return this.num(dt.minute);
-            case "mm":
-              return this.num(dt.minute, 2);
-            // hours
-            case "h":
-              return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12);
-            case "hh":
-              return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2);
-            case "H":
-              return this.num(dt.hour);
-            case "HH":
-              return this.num(dt.hour, 2);
-            // offset
-            case "Z":
-              // like +6
-              return formatOffset({
-                format: "narrow",
-                allowZ: this.opts.allowZ
-              });
-            case "ZZ":
-              // like +06:00
-              return formatOffset({
-                format: "short",
-                allowZ: this.opts.allowZ
-              });
-            case "ZZZ":
-              // like +0600
-              return formatOffset({
-                format: "techie",
-                allowZ: this.opts.allowZ
-              });
-            case "ZZZZ":
-              // like EST
-              return dt.zone.offsetName(dt.ts, {
-                format: "short",
-                locale: this.loc.locale
-              });
-            case "ZZZZZ":
-              // like Eastern Standard Time
-              return dt.zone.offsetName(dt.ts, {
-                format: "long",
-                locale: this.loc.locale
-              });
-            // zone
-            case "z":
-              // like America/New_York
-              return dt.zoneName;
-            // meridiems
-            case "a":
-              return meridiem();
-            // dates
-            case "d":
-              return useDateTimeFormatter ? string({
-                day: "numeric"
-              }, "day") : this.num(dt.day);
-            case "dd":
-              return useDateTimeFormatter ? string({
-                day: "2-digit"
-              }, "day") : this.num(dt.day, 2);
-            // weekdays - standalone
-            case "c":
-              // like 1
-              return this.num(dt.weekday);
-            case "ccc":
-              // like 'Tues'
-              return weekday("short", true);
-            case "cccc":
-              // like 'Tuesday'
-              return weekday("long", true);
-            case "ccccc":
-              // like 'T'
-              return weekday("narrow", true);
-            // weekdays - format
-            case "E":
-              // like 1
-              return this.num(dt.weekday);
-            case "EEE":
-              // like 'Tues'
-              return weekday("short", false);
-            case "EEEE":
-              // like 'Tuesday'
-              return weekday("long", false);
-            case "EEEEE":
-              // like 'T'
-              return weekday("narrow", false);
-            // months - standalone
-            case "L":
-              // like 1
-              return useDateTimeFormatter ? string({
-                month: "numeric",
-                day: "numeric"
-              }, "month") : this.num(dt.month);
-            case "LL":
-              // like 01, doesn't seem to work
-              return useDateTimeFormatter ? string({
-                month: "2-digit",
-                day: "numeric"
-              }, "month") : this.num(dt.month, 2);
-            case "LLL":
-              // like Jan
-              return month("short", true);
-            case "LLLL":
-              // like January
-              return month("long", true);
-            case "LLLLL":
-              // like J
-              return month("narrow", true);
-            // months - format
-            case "M":
-              // like 1
-              return useDateTimeFormatter ? string({
-                month: "numeric"
-              }, "month") : this.num(dt.month);
-            case "MM":
-              // like 01
-              return useDateTimeFormatter ? string({
-                month: "2-digit"
-              }, "month") : this.num(dt.month, 2);
-            case "MMM":
-              // like Jan
-              return month("short", false);
-            case "MMMM":
-              // like January
-              return month("long", false);
-            case "MMMMM":
-              // like J
-              return month("narrow", false);
-            // years
-            case "y":
-              // like 2014
-              return useDateTimeFormatter ? string({
-                year: "numeric"
-              }, "year") : this.num(dt.year);
-            case "yy":
-              // like 14
-              return useDateTimeFormatter ? string({
-                year: "2-digit"
-              }, "year") : this.num(dt.year.toString().slice(-2), 2);
-            case "yyyy":
-              // like 0012
-              return useDateTimeFormatter ? string({
-                year: "numeric"
-              }, "year") : this.num(dt.year, 4);
-            case "yyyyyy":
-              // like 000012
-              return useDateTimeFormatter ? string({
-                year: "numeric"
-              }, "year") : this.num(dt.year, 6);
-            // eras
-            case "G":
-              // like AD
-              return era("short");
-            case "GG":
-              // like Anno Domini
-              return era("long");
-            case "GGGGG":
-              return era("narrow");
-            case "kk":
-              return this.num(dt.weekYear.toString().slice(-2), 2);
-            case "kkkk":
-              return this.num(dt.weekYear, 4);
-            case "W":
-              return this.num(dt.weekNumber);
-            case "WW":
-              return this.num(dt.weekNumber, 2);
-            case "o":
-              return this.num(dt.ordinal);
-            case "ooo":
-              return this.num(dt.ordinal, 3);
-            case "q":
-              // like 1
-              return this.num(dt.quarter);
-            case "qq":
-              // like 01
-              return this.num(dt.quarter, 2);
-            case "X":
-              return this.num(Math.floor(dt.ts / 1000));
-            case "x":
-              return this.num(dt.ts);
-            default:
-              return maybeMacro(token);
-          }
-        };
-      return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
-    }
-    formatDurationFromString(dur, fmt) {
-      const tokenToField = token => {
-          switch (token[0]) {
-            case "S":
-              return "millisecond";
-            case "s":
-              return "second";
-            case "m":
-              return "minute";
-            case "h":
-              return "hour";
-            case "d":
-              return "day";
-            case "w":
-              return "week";
-            case "M":
-              return "month";
-            case "y":
-              return "year";
-            default:
-              return null;
-          }
-        },
-        tokenToString = lildur => token => {
-          const mapped = tokenToField(token);
-          if (mapped) {
-            return this.num(lildur.get(mapped), token.length);
-          } else {
-            return token;
-          }
-        },
-        tokens = Formatter.parseFormat(fmt),
-        realTokens = tokens.reduce((found, {
-          literal,
-          val
-        }) => literal ? found : found.concat(val), []),
-        collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter(t => t));
-      return stringifyTokens(tokens, tokenToString(collapsed));
-    }
-  }
-
-  class Invalid {
-    constructor(reason, explanation) {
-      this.reason = reason;
-      this.explanation = explanation;
-    }
-    toMessage() {
-      if (this.explanation) {
-        return `${this.reason}: ${this.explanation}`;
-      } else {
-        return this.reason;
-      }
-    }
-  }
-
   /**
    * @interface
    */
@@ -2620,6 +1854,435 @@
     }
   }
 
+  // todo - remap caching
+
+  let intlLFCache = {};
+  function getCachedLF(locString, opts = {}) {
+    const key = JSON.stringify([locString, opts]);
+    let dtf = intlLFCache[key];
+    if (!dtf) {
+      dtf = new Intl.ListFormat(locString, opts);
+      intlLFCache[key] = dtf;
+    }
+    return dtf;
+  }
+  let intlDTCache = {};
+  function getCachedDTF(locString, opts = {}) {
+    const key = JSON.stringify([locString, opts]);
+    let dtf = intlDTCache[key];
+    if (!dtf) {
+      dtf = new Intl.DateTimeFormat(locString, opts);
+      intlDTCache[key] = dtf;
+    }
+    return dtf;
+  }
+  let intlNumCache = {};
+  function getCachedINF(locString, opts = {}) {
+    const key = JSON.stringify([locString, opts]);
+    let inf = intlNumCache[key];
+    if (!inf) {
+      inf = new Intl.NumberFormat(locString, opts);
+      intlNumCache[key] = inf;
+    }
+    return inf;
+  }
+  let intlRelCache = {};
+  function getCachedRTF(locString, opts = {}) {
+    const {
+      base,
+      ...cacheKeyOpts
+    } = opts; // exclude `base` from the options
+    const key = JSON.stringify([locString, cacheKeyOpts]);
+    let inf = intlRelCache[key];
+    if (!inf) {
+      inf = new Intl.RelativeTimeFormat(locString, opts);
+      intlRelCache[key] = inf;
+    }
+    return inf;
+  }
+  let sysLocaleCache = null;
+  function systemLocale() {
+    if (sysLocaleCache) {
+      return sysLocaleCache;
+    } else {
+      sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
+      return sysLocaleCache;
+    }
+  }
+  function parseLocaleString(localeStr) {
+    // I really want to avoid writing a BCP 47 parser
+    // see, e.g. https://github.com/wooorm/bcp-47
+    // Instead, we'll do this:
+
+    // a) if the string has no -u extensions, just leave it alone
+    // b) if it does, use Intl to resolve everything
+    // c) if Intl fails, try again without the -u
+
+    // private subtags and unicode subtags have ordering requirements,
+    // and we're not properly parsing this, so just strip out the
+    // private ones if they exist.
+    const xIndex = localeStr.indexOf("-x-");
+    if (xIndex !== -1) {
+      localeStr = localeStr.substring(0, xIndex);
+    }
+    const uIndex = localeStr.indexOf("-u-");
+    if (uIndex === -1) {
+      return [localeStr];
+    } else {
+      let options;
+      let selectedStr;
+      try {
+        options = getCachedDTF(localeStr).resolvedOptions();
+        selectedStr = localeStr;
+      } catch (e) {
+        const smaller = localeStr.substring(0, uIndex);
+        options = getCachedDTF(smaller).resolvedOptions();
+        selectedStr = smaller;
+      }
+      const {
+        numberingSystem,
+        calendar
+      } = options;
+      return [selectedStr, numberingSystem, calendar];
+    }
+  }
+  function intlConfigString(localeStr, numberingSystem, outputCalendar) {
+    if (outputCalendar || numberingSystem) {
+      if (!localeStr.includes("-u-")) {
+        localeStr += "-u";
+      }
+      if (outputCalendar) {
+        localeStr += `-ca-${outputCalendar}`;
+      }
+      if (numberingSystem) {
+        localeStr += `-nu-${numberingSystem}`;
+      }
+      return localeStr;
+    } else {
+      return localeStr;
+    }
+  }
+  function mapMonths(f) {
+    const ms = [];
+    for (let i = 1; i <= 12; i++) {
+      const dt = DateTime.utc(2016, i, 1);
+      ms.push(f(dt));
+    }
+    return ms;
+  }
+  function mapWeekdays(f) {
+    const ms = [];
+    for (let i = 1; i <= 7; i++) {
+      const dt = DateTime.utc(2016, 11, 13 + i);
+      ms.push(f(dt));
+    }
+    return ms;
+  }
+  function listStuff(loc, length, defaultOK, englishFn, intlFn) {
+    const mode = loc.listingMode(defaultOK);
+    if (mode === "error") {
+      return null;
+    } else if (mode === "en") {
+      return englishFn(length);
+    } else {
+      return intlFn(length);
+    }
+  }
+  function supportsFastNumbers(loc) {
+    if (loc.numberingSystem && loc.numberingSystem !== "latn") {
+      return false;
+    } else {
+      return loc.numberingSystem === "latn" || !loc.locale || loc.locale.startsWith("en") || new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn";
+    }
+  }
+
+  /**
+   * @private
+   */
+
+  class PolyNumberFormatter {
+    constructor(intl, forceSimple, opts) {
+      this.padTo = opts.padTo || 0;
+      this.floor = opts.floor || false;
+      const {
+        padTo,
+        floor,
+        ...otherOpts
+      } = opts;
+      if (!forceSimple || Object.keys(otherOpts).length > 0) {
+        const intlOpts = {
+          useGrouping: false,
+          ...opts
+        };
+        if (opts.padTo > 0) intlOpts.minimumIntegerDigits = opts.padTo;
+        this.inf = getCachedINF(intl, intlOpts);
+      }
+    }
+    format(i) {
+      if (this.inf) {
+        const fixed = this.floor ? Math.floor(i) : i;
+        return this.inf.format(fixed);
+      } else {
+        // to match the browser's numberformatter defaults
+        const fixed = this.floor ? Math.floor(i) : roundTo(i, 3);
+        return padStart(fixed, this.padTo);
+      }
+    }
+  }
+
+  /**
+   * @private
+   */
+
+  class PolyDateFormatter {
+    constructor(dt, intl, opts) {
+      this.opts = opts;
+      let z = undefined;
+      if (dt.zone.isUniversal) {
+        // UTC-8 or Etc/UTC-8 are not part of tzdata, only Etc/GMT+8 and the like.
+        // That is why fixed-offset TZ is set to that unless it is:
+        // 1. Representing offset 0 when UTC is used to maintain previous behavior and does not become GMT.
+        // 2. Unsupported by the browser:
+        //    - some do not support Etc/
+        //    - < Etc/GMT-14, > Etc/GMT+12, and 30-minute or 45-minute offsets are not part of tzdata
+        const gmtOffset = -1 * (dt.offset / 60);
+        const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`;
+        if (dt.offset !== 0 && IANAZone.create(offsetZ).valid) {
+          z = offsetZ;
+          this.dt = dt;
+        } else {
+          // Not all fixed-offset zones like Etc/+4:30 are present in tzdata.
+          // So we have to make do. Two cases:
+          // 1. The format options tell us to show the zone. We can't do that, so the best
+          // we can do is format the date in UTC.
+          // 2. The format options don't tell us to show the zone. Then we can adjust them
+          // the time and tell the formatter to show it to us in UTC, so that the time is right
+          // and the bad zone doesn't show up.
+          z = "UTC";
+          if (opts.timeZoneName) {
+            this.dt = dt;
+          } else {
+            this.dt = dt.offset === 0 ? dt : DateTime.fromMillis(dt.ts + dt.offset * 60 * 1000);
+          }
+        }
+      } else if (dt.zone.type === "system") {
+        this.dt = dt;
+      } else {
+        this.dt = dt;
+        z = dt.zone.name;
+      }
+      const intlOpts = {
+        ...this.opts
+      };
+      intlOpts.timeZone = intlOpts.timeZone || z;
+      this.dtf = getCachedDTF(intl, intlOpts);
+    }
+    format() {
+      return this.dtf.format(this.dt.toJSDate());
+    }
+    formatToParts() {
+      return this.dtf.formatToParts(this.dt.toJSDate());
+    }
+    resolvedOptions() {
+      return this.dtf.resolvedOptions();
+    }
+  }
+
+  /**
+   * @private
+   */
+  class PolyRelFormatter {
+    constructor(intl, isEnglish, opts) {
+      this.opts = {
+        style: "long",
+        ...opts
+      };
+      if (!isEnglish && hasRelative()) {
+        this.rtf = getCachedRTF(intl, opts);
+      }
+    }
+    format(count, unit) {
+      if (this.rtf) {
+        return this.rtf.format(count, unit);
+      } else {
+        return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
+      }
+    }
+    formatToParts(count, unit) {
+      if (this.rtf) {
+        return this.rtf.formatToParts(count, unit);
+      } else {
+        return [];
+      }
+    }
+  }
+
+  /**
+   * @private
+   */
+
+  class Locale {
+    static fromOpts(opts) {
+      return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN);
+    }
+    static create(locale, numberingSystem, outputCalendar, defaultToEN = false) {
+      const specifiedLocale = locale || Settings.defaultLocale;
+      // the system locale is useful for human readable strings but annoying for parsing/formatting known formats
+      const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
+      const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
+      const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
+      return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
+    }
+    static resetCache() {
+      sysLocaleCache = null;
+      intlDTCache = {};
+      intlNumCache = {};
+      intlRelCache = {};
+    }
+    static fromObject({
+      locale,
+      numberingSystem,
+      outputCalendar
+    } = {}) {
+      return Locale.create(locale, numberingSystem, outputCalendar);
+    }
+    constructor(locale, numbering, outputCalendar, specifiedLocale) {
+      const [parsedLocale, parsedNumberingSystem, parsedOutputCalendar] = parseLocaleString(locale);
+      this.locale = parsedLocale;
+      this.numberingSystem = numbering || parsedNumberingSystem || null;
+      this.outputCalendar = outputCalendar || parsedOutputCalendar || null;
+      this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar);
+      this.weekdaysCache = {
+        format: {},
+        standalone: {}
+      };
+      this.monthsCache = {
+        format: {},
+        standalone: {}
+      };
+      this.meridiemCache = null;
+      this.eraCache = {};
+      this.specifiedLocale = specifiedLocale;
+      this.fastNumbersCached = null;
+    }
+    get fastNumbers() {
+      if (this.fastNumbersCached == null) {
+        this.fastNumbersCached = supportsFastNumbers(this);
+      }
+      return this.fastNumbersCached;
+    }
+    listingMode() {
+      const isActuallyEn = this.isEnglish();
+      const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
+      return isActuallyEn && hasNoWeirdness ? "en" : "intl";
+    }
+    clone(alts) {
+      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);
+      }
+    }
+    redefaultToEN(alts = {}) {
+      return this.clone({
+        ...alts,
+        defaultToEN: true
+      });
+    }
+    redefaultToSystem(alts = {}) {
+      return this.clone({
+        ...alts,
+        defaultToEN: false
+      });
+    }
+    months(length, format = false, defaultOK = true) {
+      return listStuff(this, length, defaultOK, months, () => {
+        const intl = format ? {
+            month: length,
+            day: "numeric"
+          } : {
+            month: length
+          },
+          formatStr = format ? "format" : "standalone";
+        if (!this.monthsCache[formatStr][length]) {
+          this.monthsCache[formatStr][length] = mapMonths(dt => this.extract(dt, intl, "month"));
+        }
+        return this.monthsCache[formatStr][length];
+      });
+    }
+    weekdays(length, format = false, defaultOK = true) {
+      return listStuff(this, length, defaultOK, weekdays, () => {
+        const intl = format ? {
+            weekday: length,
+            year: "numeric",
+            month: "long",
+            day: "numeric"
+          } : {
+            weekday: length
+          },
+          formatStr = format ? "format" : "standalone";
+        if (!this.weekdaysCache[formatStr][length]) {
+          this.weekdaysCache[formatStr][length] = mapWeekdays(dt => this.extract(dt, intl, "weekday"));
+        }
+        return this.weekdaysCache[formatStr][length];
+      });
+    }
+    meridiems(defaultOK = true) {
+      return listStuff(this, undefined, defaultOK, () => meridiems, () => {
+        // In theory there could be aribitrary day periods. We're gonna assume there are exactly two
+        // for AM and PM. This is probably wrong, but it's makes parsing way easier.
+        if (!this.meridiemCache) {
+          const intl = {
+            hour: "numeric",
+            hourCycle: "h12"
+          };
+          this.meridiemCache = [DateTime.utc(2016, 11, 13, 9), DateTime.utc(2016, 11, 13, 19)].map(dt => this.extract(dt, intl, "dayperiod"));
+        }
+        return this.meridiemCache;
+      });
+    }
+    eras(length, defaultOK = true) {
+      return listStuff(this, length, defaultOK, eras, () => {
+        const intl = {
+          era: length
+        };
+
+        // This is problematic. Different calendars are going to define eras totally differently. What I need is the minimum set of dates
+        // to definitely enumerate them.
+        if (!this.eraCache[length]) {
+          this.eraCache[length] = [DateTime.utc(-40, 1, 1), DateTime.utc(2017, 1, 1)].map(dt => this.extract(dt, intl, "era"));
+        }
+        return this.eraCache[length];
+      });
+    }
+    extract(dt, intlOpts, field) {
+      const df = this.dtFormatter(dt, intlOpts),
+        results = df.formatToParts(),
+        matching = results.find(m => m.type.toLowerCase() === field);
+      return matching ? matching.value : null;
+    }
+    numberFormatter(opts = {}) {
+      // this forcesimple option is never used (the only caller short-circuits on it, but it seems safer to leave)
+      // (in contrast, the rest of the condition is used heavily)
+      return new PolyNumberFormatter(this.intl, opts.forceSimple || this.fastNumbers, opts);
+    }
+    dtFormatter(dt, intlOpts = {}) {
+      return new PolyDateFormatter(dt, this.intl, intlOpts);
+    }
+    relFormatter(opts = {}) {
+      return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
+    }
+    listFormatter(opts = {}) {
+      return getCachedLF(this.intl, opts);
+    }
+    isEnglish() {
+      return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us");
+    }
+    equals(other) {
+      return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
+    }
+  }
+
   let singleton = null;
 
   /**
@@ -2797,6 +2460,7 @@
     defaultLocale = null,
     defaultNumberingSystem = null,
     defaultOutputCalendar = null,
+    twoDigitCutoffYear = 60,
     throwOnInvalid;
 
   /**
@@ -2888,6 +2552,26 @@
       defaultOutputCalendar = outputCalendar;
     }
 
+    /**
+     * Get the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
+     * @type {number}
+     */
+    static get twoDigitCutoffYear() {
+      return twoDigitCutoffYear;
+    }
+
+    /**
+     * 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 = 50 // '49' -> 1949; '50' -> 2050
+     * @example Settings.twoDigitCutoffYear = 1950 // interpretted as 50
+     * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpretted as 50
+     */
+    static set twoDigitCutoffYear(cutoffYear) {
+      twoDigitCutoffYear = cutoffYear % 100;
+    }
+
     /**
      * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
      * @type {boolean}
@@ -2896,441 +2580,793 @@
       return throwOnInvalid;
     }
 
-    /**
-     * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
-     * @type {boolean}
-     */
-    static set throwOnInvalid(t) {
-      throwOnInvalid = t;
-    }
+    /**
+     * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
+     * @type {boolean}
+     */
+    static set throwOnInvalid(t) {
+      throwOnInvalid = t;
+    }
+
+    /**
+     * Reset Luxon's global caches. Should only be necessary in testing scenarios.
+     * @return {void}
+     */
+    static resetCaches() {
+      Locale.resetCache();
+      IANAZone.resetCache();
+    }
+  }
+
+  /*
+    This is just a junk drawer, containing anything used across multiple classes.
+    Because Luxon is small(ish), this should stay small and we won't worry about splitting
+    it up into, say, parsingUtil.js and basicUtil.js and so on. But they are divided up by feature area.
+  */
+
+  /**
+   * @private
+   */
+
+  // TYPES
+
+  function isUndefined$1(o) {
+    return typeof o === "undefined";
+  }
+  function isNumber$2(o) {
+    return typeof o === "number";
+  }
+  function isInteger(o) {
+    return typeof o === "number" && o % 1 === 0;
+  }
+  function isString$2(o) {
+    return typeof o === "string";
+  }
+  function isDate(o) {
+    return Object.prototype.toString.call(o) === "[object Date]";
+  }
+
+  // CAPABILITIES
+
+  function hasRelative() {
+    try {
+      return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // OBJECTS AND ARRAYS
+
+  function maybeArray(thing) {
+    return Array.isArray(thing) ? thing : [thing];
+  }
+  function bestBy(arr, by, compare) {
+    if (arr.length === 0) {
+      return undefined;
+    }
+    return arr.reduce((best, next) => {
+      const pair = [by(next), next];
+      if (!best) {
+        return pair;
+      } else if (compare(best[0], pair[0]) === best[0]) {
+        return best;
+      } else {
+        return pair;
+      }
+    }, null)[1];
+  }
+  function pick(obj, keys) {
+    return keys.reduce((a, k) => {
+      a[k] = obj[k];
+      return a;
+    }, {});
+  }
+  function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+
+  // NUMBERS AND STRINGS
 
-    /**
-     * Reset Luxon's global caches. Should only be necessary in testing scenarios.
-     * @return {void}
-     */
-    static resetCaches() {
-      Locale.resetCache();
-      IANAZone.resetCache();
-    }
+  function integerBetween(thing, bottom, top) {
+    return isInteger(thing) && thing >= bottom && thing <= top;
   }
 
-  // todo - remap caching
-
-  let intlLFCache = {};
-  function getCachedLF(locString, opts = {}) {
-    const key = JSON.stringify([locString, opts]);
-    let dtf = intlLFCache[key];
-    if (!dtf) {
-      dtf = new Intl.ListFormat(locString, opts);
-      intlLFCache[key] = dtf;
-    }
-    return dtf;
+  // x % n but takes the sign of n instead of x
+  function floorMod(x, n) {
+    return x - n * Math.floor(x / n);
   }
-  let intlDTCache = {};
-  function getCachedDTF(locString, opts = {}) {
-    const key = JSON.stringify([locString, opts]);
-    let dtf = intlDTCache[key];
-    if (!dtf) {
-      dtf = new Intl.DateTimeFormat(locString, opts);
-      intlDTCache[key] = dtf;
+  function padStart(input, n = 2) {
+    const isNeg = input < 0;
+    let padded;
+    if (isNeg) {
+      padded = "-" + ("" + -input).padStart(n, "0");
+    } else {
+      padded = ("" + input).padStart(n, "0");
     }
-    return dtf;
+    return padded;
   }
-  let intlNumCache = {};
-  function getCachedINF(locString, opts = {}) {
-    const key = JSON.stringify([locString, opts]);
-    let inf = intlNumCache[key];
-    if (!inf) {
-      inf = new Intl.NumberFormat(locString, opts);
-      intlNumCache[key] = inf;
+  function parseInteger(string) {
+    if (isUndefined$1(string) || string === null || string === "") {
+      return undefined;
+    } else {
+      return parseInt(string, 10);
     }
-    return inf;
   }
-  let intlRelCache = {};
-  function getCachedRTF(locString, opts = {}) {
-    const {
-      base,
-      ...cacheKeyOpts
-    } = opts; // exclude `base` from the options
-    const key = JSON.stringify([locString, cacheKeyOpts]);
-    let inf = intlRelCache[key];
-    if (!inf) {
-      inf = new Intl.RelativeTimeFormat(locString, opts);
-      intlRelCache[key] = inf;
+  function parseFloating(string) {
+    if (isUndefined$1(string) || string === null || string === "") {
+      return undefined;
+    } else {
+      return parseFloat(string);
     }
-    return inf;
   }
-  let sysLocaleCache = null;
-  function systemLocale() {
-    if (sysLocaleCache) {
-      return sysLocaleCache;
+  function parseMillis(fraction) {
+    // Return undefined (instead of 0) in these cases, where fraction is not set
+    if (isUndefined$1(fraction) || fraction === null || fraction === "") {
+      return undefined;
     } else {
-      sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
-      return sysLocaleCache;
+      const f = parseFloat("0." + fraction) * 1000;
+      return Math.floor(f);
     }
   }
-  function parseLocaleString(localeStr) {
-    // I really want to avoid writing a BCP 47 parser
-    // see, e.g. https://github.com/wooorm/bcp-47
-    // Instead, we'll do this:
+  function roundTo(number, digits, towardZero = false) {
+    const factor = 10 ** digits,
+      rounder = towardZero ? Math.trunc : Math.round;
+    return rounder(number * factor) / factor;
+  }
 
-    // a) if the string has no -u extensions, just leave it alone
-    // b) if it does, use Intl to resolve everything
-    // c) if Intl fails, try again without the -u
+  // DATE BASICS
 
-    const uIndex = localeStr.indexOf("-u-");
-    if (uIndex === -1) {
-      return [localeStr];
-    } else {
-      let options;
-      const smaller = localeStr.substring(0, uIndex);
-      try {
-        options = getCachedDTF(localeStr).resolvedOptions();
-      } catch (e) {
-        options = getCachedDTF(smaller).resolvedOptions();
-      }
-      const {
-        numberingSystem,
-        calendar
-      } = options;
-      // return the smaller one so that we can append the calendar and numbering overrides to it
-      return [smaller, numberingSystem, calendar];
-    }
+  function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
   }
-  function intlConfigString(localeStr, numberingSystem, outputCalendar) {
-    if (outputCalendar || numberingSystem) {
-      localeStr += "-u";
-      if (outputCalendar) {
-        localeStr += `-ca-${outputCalendar}`;
-      }
-      if (numberingSystem) {
-        localeStr += `-nu-${numberingSystem}`;
-      }
-      return localeStr;
+  function daysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
+  }
+  function daysInMonth(year, month) {
+    const modMonth = floorMod(month - 1, 12) + 1,
+      modYear = year + (month - modMonth) / 12;
+    if (modMonth === 2) {
+      return isLeapYear(modYear) ? 29 : 28;
     } else {
-      return localeStr;
+      return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1];
     }
   }
-  function mapMonths(f) {
-    const ms = [];
-    for (let i = 1; i <= 12; i++) {
-      const dt = DateTime.utc(2016, i, 1);
-      ms.push(f(dt));
+
+  // covert a calendar object to a local timestamp (epoch, but with the offset baked in)
+  function objToLocalTS(obj) {
+    let d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond);
+
+    // for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that
+    if (obj.year < 100 && obj.year >= 0) {
+      d = new Date(d);
+      d.setUTCFullYear(d.getUTCFullYear() - 1900);
     }
-    return ms;
+    return +d;
   }
-  function mapWeekdays(f) {
-    const ms = [];
-    for (let i = 1; i <= 7; i++) {
-      const dt = DateTime.utc(2016, 11, 13 + i);
-      ms.push(f(dt));
-    }
-    return ms;
+  function weeksInWeekYear(weekYear) {
+    const 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;
   }
-  function listStuff(loc, length, defaultOK, englishFn, intlFn) {
-    const mode = loc.listingMode(defaultOK);
-    if (mode === "error") {
-      return null;
-    } else if (mode === "en") {
-      return englishFn(length);
-    } else {
-      return intlFn(length);
+  function untruncateYear(year) {
+    if (year > 99) {
+      return year;
+    } else return year > Settings.twoDigitCutoffYear ? 1900 + year : 2000 + year;
+  }
+
+  // PARSING
+
+  function parseZoneInfo(ts, offsetFormat, locale, timeZone = null) {
+    const date = new Date(ts),
+      intlOpts = {
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit"
+      };
+    if (timeZone) {
+      intlOpts.timeZone = timeZone;
     }
+    const modified = {
+      timeZoneName: offsetFormat,
+      ...intlOpts
+    };
+    const parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find(m => m.type.toLowerCase() === "timezonename");
+    return parsed ? parsed.value : null;
   }
-  function supportsFastNumbers(loc) {
-    if (loc.numberingSystem && loc.numberingSystem !== "latn") {
-      return false;
-    } else {
-      return loc.numberingSystem === "latn" || !loc.locale || loc.locale.startsWith("en") || new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn";
+
+  // signedOffset('-5', '30') -> -330
+  function signedOffset(offHourStr, offMinuteStr) {
+    let offHour = parseInt(offHourStr, 10);
+
+    // don't || this because we want to preserve -0
+    if (Number.isNaN(offHour)) {
+      offHour = 0;
     }
+    const offMin = parseInt(offMinuteStr, 10) || 0,
+      offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin;
+    return offHour * 60 + offMinSigned;
   }
 
-  /**
-   * @private
-   */
+  // COERCION
 
-  class PolyNumberFormatter {
-    constructor(intl, forceSimple, opts) {
-      this.padTo = opts.padTo || 0;
-      this.floor = opts.floor || false;
-      const {
-        padTo,
-        floor,
-        ...otherOpts
-      } = opts;
-      if (!forceSimple || Object.keys(otherOpts).length > 0) {
-        const intlOpts = {
-          useGrouping: false,
-          ...opts
-        };
-        if (opts.padTo > 0) intlOpts.minimumIntegerDigits = opts.padTo;
-        this.inf = getCachedINF(intl, intlOpts);
+  function asNumber(value) {
+    const numericValue = Number(value);
+    if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue)) throw new InvalidArgumentError(`Invalid unit value ${value}`);
+    return numericValue;
+  }
+  function normalizeObject(obj, normalizer) {
+    const normalized = {};
+    for (const u in obj) {
+      if (hasOwnProperty(obj, u)) {
+        const v = obj[u];
+        if (v === undefined || v === null) continue;
+        normalized[normalizer(u)] = asNumber(v);
       }
     }
-    format(i) {
-      if (this.inf) {
-        const fixed = this.floor ? Math.floor(i) : i;
-        return this.inf.format(fixed);
-      } else {
-        // to match the browser's numberformatter defaults
-        const fixed = this.floor ? Math.floor(i) : roundTo(i, 3);
-        return padStart(fixed, this.padTo);
-      }
+    return normalized;
+  }
+  function formatOffset(offset, format) {
+    const hours = Math.trunc(Math.abs(offset / 60)),
+      minutes = Math.trunc(Math.abs(offset % 60)),
+      sign = offset >= 0 ? "+" : "-";
+    switch (format) {
+      case "short":
+        return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`;
+      case "narrow":
+        return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`;
+      case "techie":
+        return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`;
+      default:
+        throw new RangeError(`Value format ${format} is out of range for property format`);
     }
   }
+  function timeObject(obj) {
+    return pick(obj, ["hour", "minute", "second", "millisecond"]);
+  }
 
   /**
    * @private
    */
 
-  class PolyDateFormatter {
-    constructor(dt, intl, opts) {
-      this.opts = opts;
-      let z;
-      if (dt.zone.isUniversal) {
-        // UTC-8 or Etc/UTC-8 are not part of tzdata, only Etc/GMT+8 and the like.
-        // That is why fixed-offset TZ is set to that unless it is:
-        // 1. Representing offset 0 when UTC is used to maintain previous behavior and does not become GMT.
-        // 2. Unsupported by the browser:
-        //    - some do not support Etc/
-        //    - < Etc/GMT-14, > Etc/GMT+12, and 30-minute or 45-minute offsets are not part of tzdata
-        const gmtOffset = -1 * (dt.offset / 60);
-        const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`;
-        if (dt.offset !== 0 && IANAZone.create(offsetZ).valid) {
-          z = offsetZ;
-          this.dt = dt;
-        } else {
-          // Not all fixed-offset zones like Etc/+4:30 are present in tzdata.
-          // So we have to make do. Two cases:
-          // 1. The format options tell us to show the zone. We can't do that, so the best
-          // we can do is format the date in UTC.
-          // 2. The format options don't tell us to show the zone. Then we can adjust them
-          // the time and tell the formatter to show it to us in UTC, so that the time is right
-          // and the bad zone doesn't show up.
-          z = "UTC";
-          if (opts.timeZoneName) {
-            this.dt = dt;
-          } else {
-            this.dt = dt.offset === 0 ? dt : DateTime.fromMillis(dt.ts + dt.offset * 60 * 1000);
-          }
-        }
-      } else if (dt.zone.type === "system") {
-        this.dt = dt;
-      } else {
-        this.dt = dt;
-        z = dt.zone.name;
-      }
-      const intlOpts = {
-        ...this.opts
-      };
-      if (z) {
-        intlOpts.timeZone = z;
-      }
-      this.dtf = getCachedDTF(intl, intlOpts);
-    }
-    format() {
-      return this.dtf.format(this.dt.toJSDate());
-    }
-    formatToParts() {
-      return this.dtf.formatToParts(this.dt.toJSDate());
+  const monthsLong = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+  const monthsShort = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const monthsNarrow = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
+  function months(length) {
+    switch (length) {
+      case "narrow":
+        return [...monthsNarrow];
+      case "short":
+        return [...monthsShort];
+      case "long":
+        return [...monthsLong];
+      case "numeric":
+        return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
+      case "2-digit":
+        return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];
+      default:
+        return null;
     }
-    resolvedOptions() {
-      return this.dtf.resolvedOptions();
+  }
+  const weekdaysLong = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+  const weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+  const weekdaysNarrow = ["M", "T", "W", "T", "F", "S", "S"];
+  function weekdays(length) {
+    switch (length) {
+      case "narrow":
+        return [...weekdaysNarrow];
+      case "short":
+        return [...weekdaysShort];
+      case "long":
+        return [...weekdaysLong];
+      case "numeric":
+        return ["1", "2", "3", "4", "5", "6", "7"];
+      default:
+        return null;
     }
   }
-
-  /**
-   * @private
-   */
-  class PolyRelFormatter {
-    constructor(intl, isEnglish, opts) {
-      this.opts = {
-        style: "long",
-        ...opts
-      };
-      if (!isEnglish && hasRelative()) {
-        this.rtf = getCachedRTF(intl, opts);
-      }
+  const meridiems = ["AM", "PM"];
+  const erasLong = ["Before Christ", "Anno Domini"];
+  const erasShort = ["BC", "AD"];
+  const erasNarrow = ["B", "A"];
+  function eras(length) {
+    switch (length) {
+      case "narrow":
+        return [...erasNarrow];
+      case "short":
+        return [...erasShort];
+      case "long":
+        return [...erasLong];
+      default:
+        return null;
     }
-    format(count, unit) {
-      if (this.rtf) {
-        return this.rtf.format(count, unit);
-      } else {
-        return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
+  }
+  function meridiemForDateTime(dt) {
+    return meridiems[dt.hour < 12 ? 0 : 1];
+  }
+  function weekdayForDateTime(dt, length) {
+    return weekdays(length)[dt.weekday - 1];
+  }
+  function monthForDateTime(dt, length) {
+    return months(length)[dt.month - 1];
+  }
+  function eraForDateTime(dt, length) {
+    return eras(length)[dt.year < 0 ? 0 : 1];
+  }
+  function formatRelativeTime(unit, count, numeric = "always", narrow = false) {
+    const units = {
+      years: ["year", "yr."],
+      quarters: ["quarter", "qtr."],
+      months: ["month", "mo."],
+      weeks: ["week", "wk."],
+      days: ["day", "day", "days"],
+      hours: ["hour", "hr."],
+      minutes: ["minute", "min."],
+      seconds: ["second", "sec."]
+    };
+    const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1;
+    if (numeric === "auto" && lastable) {
+      const isDay = unit === "days";
+      switch (count) {
+        case 1:
+          return isDay ? "tomorrow" : `next ${units[unit][0]}`;
+        case -1:
+          return isDay ? "yesterday" : `last ${units[unit][0]}`;
+        case 0:
+          return isDay ? "today" : `this ${units[unit][0]}`;
       }
     }
-    formatToParts(count, unit) {
-      if (this.rtf) {
-        return this.rtf.formatToParts(count, unit);
+
+    const isInPast = Object.is(count, -0) || count < 0,
+      fmtValue = Math.abs(count),
+      singular = fmtValue === 1,
+      lilUnits = units[unit],
+      fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit;
+    return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`;
+  }
+
+  function stringifyTokens(splits, tokenToString) {
+    let s = "";
+    for (const token of splits) {
+      if (token.literal) {
+        s += token.val;
       } else {
-        return [];
+        s += tokenToString(token.val);
       }
     }
+    return s;
   }
-
-  /**
-   * @private
-   */
-
-  class Locale {
-    static fromOpts(opts) {
-      return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN);
-    }
-    static create(locale, numberingSystem, outputCalendar, defaultToEN = false) {
-      const specifiedLocale = locale || Settings.defaultLocale;
-      // the system locale is useful for human readable strings but annoying for parsing/formatting known formats
-      const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
-      const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
-      const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
-      return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
-    }
-    static resetCache() {
-      sysLocaleCache = null;
-      intlDTCache = {};
-      intlNumCache = {};
-      intlRelCache = {};
-    }
-    static fromObject({
-      locale,
-      numberingSystem,
-      outputCalendar
-    } = {}) {
-      return Locale.create(locale, numberingSystem, outputCalendar);
-    }
-    constructor(locale, numbering, outputCalendar, specifiedLocale) {
-      const [parsedLocale, parsedNumberingSystem, parsedOutputCalendar] = parseLocaleString(locale);
-      this.locale = parsedLocale;
-      this.numberingSystem = numbering || parsedNumberingSystem || null;
-      this.outputCalendar = outputCalendar || parsedOutputCalendar || null;
-      this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar);
-      this.weekdaysCache = {
-        format: {},
-        standalone: {}
-      };
-      this.monthsCache = {
-        format: {},
-        standalone: {}
-      };
-      this.meridiemCache = null;
-      this.eraCache = {};
-      this.specifiedLocale = specifiedLocale;
-      this.fastNumbersCached = null;
+  const macroTokenToFormatOpts = {
+    D: DATE_SHORT,
+    DD: DATE_MED,
+    DDD: DATE_FULL,
+    DDDD: DATE_HUGE,
+    t: TIME_SIMPLE,
+    tt: TIME_WITH_SECONDS,
+    ttt: TIME_WITH_SHORT_OFFSET,
+    tttt: TIME_WITH_LONG_OFFSET,
+    T: TIME_24_SIMPLE,
+    TT: TIME_24_WITH_SECONDS,
+    TTT: TIME_24_WITH_SHORT_OFFSET,
+    TTTT: TIME_24_WITH_LONG_OFFSET,
+    f: DATETIME_SHORT,
+    ff: DATETIME_MED,
+    fff: DATETIME_FULL,
+    ffff: DATETIME_HUGE,
+    F: DATETIME_SHORT_WITH_SECONDS,
+    FF: DATETIME_MED_WITH_SECONDS,
+    FFF: DATETIME_FULL_WITH_SECONDS,
+    FFFF: DATETIME_HUGE_WITH_SECONDS
+  };
+
+  /**
+   * @private
+   */
+
+  class Formatter {
+    static create(locale, opts = {}) {
+      return new Formatter(locale, opts);
     }
-    get fastNumbers() {
-      if (this.fastNumbersCached == null) {
-        this.fastNumbersCached = supportsFastNumbers(this);
+    static parseFormat(fmt) {
+      let current = null,
+        currentFull = "",
+        bracketed = false;
+      const splits = [];
+      for (let i = 0; i < fmt.length; i++) {
+        const c = fmt.charAt(i);
+        if (c === "'") {
+          if (currentFull.length > 0) {
+            splits.push({
+              literal: bracketed,
+              val: currentFull
+            });
+          }
+          current = null;
+          currentFull = "";
+          bracketed = !bracketed;
+        } else if (bracketed) {
+          currentFull += c;
+        } else if (c === current) {
+          currentFull += c;
+        } else {
+          if (currentFull.length > 0) {
+            splits.push({
+              literal: false,
+              val: currentFull
+            });
+          }
+          currentFull = c;
+          current = c;
+        }
       }
-      return this.fastNumbersCached;
+      if (currentFull.length > 0) {
+        splits.push({
+          literal: bracketed,
+          val: currentFull
+        });
+      }
+      return splits;
     }
-    listingMode() {
-      const isActuallyEn = this.isEnglish();
-      const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
-      return isActuallyEn && hasNoWeirdness ? "en" : "intl";
+    static macroTokenToFormatOpts(token) {
+      return macroTokenToFormatOpts[token];
     }
-    clone(alts) {
-      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);
-      }
+    constructor(locale, formatOpts) {
+      this.opts = formatOpts;
+      this.loc = locale;
+      this.systemLoc = null;
     }
-    redefaultToEN(alts = {}) {
-      return this.clone({
-        ...alts,
-        defaultToEN: true
+    formatWithSystemDefault(dt, opts) {
+      if (this.systemLoc === null) {
+        this.systemLoc = this.loc.redefaultToSystem();
+      }
+      const df = this.systemLoc.dtFormatter(dt, {
+        ...this.opts,
+        ...opts
       });
+      return df.format();
     }
-    redefaultToSystem(alts = {}) {
-      return this.clone({
-        ...alts,
-        defaultToEN: false
+    formatDateTime(dt, opts = {}) {
+      const df = this.loc.dtFormatter(dt, {
+        ...this.opts,
+        ...opts
       });
+      return df.format();
     }
-    months(length, format = false, defaultOK = true) {
-      return listStuff(this, length, defaultOK, months, () => {
-        const intl = format ? {
-            month: length,
-            day: "numeric"
-          } : {
-            month: length
-          },
-          formatStr = format ? "format" : "standalone";
-        if (!this.monthsCache[formatStr][length]) {
-          this.monthsCache[formatStr][length] = mapMonths(dt => this.extract(dt, intl, "month"));
-        }
-        return this.monthsCache[formatStr][length];
+    formatDateTimeParts(dt, opts = {}) {
+      const df = this.loc.dtFormatter(dt, {
+        ...this.opts,
+        ...opts
       });
+      return df.formatToParts();
     }
-    weekdays(length, format = false, defaultOK = true) {
-      return listStuff(this, length, defaultOK, weekdays, () => {
-        const intl = format ? {
-            weekday: length,
-            year: "numeric",
-            month: "long",
-            day: "numeric"
-          } : {
-            weekday: length
-          },
-          formatStr = format ? "format" : "standalone";
-        if (!this.weekdaysCache[formatStr][length]) {
-          this.weekdaysCache[formatStr][length] = mapWeekdays(dt => this.extract(dt, intl, "weekday"));
-        }
-        return this.weekdaysCache[formatStr][length];
+    formatInterval(interval, opts = {}) {
+      const df = this.loc.dtFormatter(interval.start, {
+        ...this.opts,
+        ...opts
       });
+      return df.dtf.formatRange(interval.start.toJSDate(), interval.end.toJSDate());
     }
-    meridiems(defaultOK = true) {
-      return listStuff(this, undefined, defaultOK, () => meridiems, () => {
-        // In theory there could be aribitrary day periods. We're gonna assume there are exactly two
-        // for AM and PM. This is probably wrong, but it's makes parsing way easier.
-        if (!this.meridiemCache) {
-          const intl = {
-            hour: "numeric",
-            hourCycle: "h12"
-          };
-          this.meridiemCache = [DateTime.utc(2016, 11, 13, 9), DateTime.utc(2016, 11, 13, 19)].map(dt => this.extract(dt, intl, "dayperiod"));
-        }
-        return this.meridiemCache;
+    resolvedOptions(dt, opts = {}) {
+      const df = this.loc.dtFormatter(dt, {
+        ...this.opts,
+        ...opts
       });
+      return df.resolvedOptions();
     }
-    eras(length, defaultOK = true) {
-      return listStuff(this, length, defaultOK, eras, () => {
-        const intl = {
+    num(n, p = 0) {
+      // we get some perf out of doing this here, annoyingly
+      if (this.opts.forceSimple) {
+        return padStart(n, p);
+      }
+      const opts = {
+        ...this.opts
+      };
+      if (p > 0) {
+        opts.padTo = p;
+      }
+      return this.loc.numberFormatter(opts).format(n);
+    }
+    formatDateTimeFromString(dt, fmt) {
+      const knownEnglish = this.loc.listingMode() === "en",
+        useDateTimeFormatter = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory",
+        string = (opts, extract) => this.loc.extract(dt, opts, extract),
+        formatOffset = opts => {
+          if (dt.isOffsetFixed && dt.offset === 0 && opts.allowZ) {
+            return "Z";
+          }
+          return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : "";
+        },
+        meridiem = () => knownEnglish ? meridiemForDateTime(dt) : string({
+          hour: "numeric",
+          hourCycle: "h12"
+        }, "dayperiod"),
+        month = (length, standalone) => knownEnglish ? monthForDateTime(dt, length) : string(standalone ? {
+          month: length
+        } : {
+          month: length,
+          day: "numeric"
+        }, "month"),
+        weekday = (length, standalone) => knownEnglish ? weekdayForDateTime(dt, length) : string(standalone ? {
+          weekday: length
+        } : {
+          weekday: length,
+          month: "long",
+          day: "numeric"
+        }, "weekday"),
+        maybeMacro = token => {
+          const formatOpts = Formatter.macroTokenToFormatOpts(token);
+          if (formatOpts) {
+            return this.formatWithSystemDefault(dt, formatOpts);
+          } else {
+            return token;
+          }
+        },
+        era = length => knownEnglish ? eraForDateTime(dt, length) : string({
           era: length
+        }, "era"),
+        tokenToString = token => {
+          // Where possible: http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles
+          switch (token) {
+            // ms
+            case "S":
+              return this.num(dt.millisecond);
+            case "u":
+            // falls through
+            case "SSS":
+              return this.num(dt.millisecond, 3);
+            // seconds
+            case "s":
+              return this.num(dt.second);
+            case "ss":
+              return this.num(dt.second, 2);
+            // fractional seconds
+            case "uu":
+              return this.num(Math.floor(dt.millisecond / 10), 2);
+            case "uuu":
+              return this.num(Math.floor(dt.millisecond / 100));
+            // minutes
+            case "m":
+              return this.num(dt.minute);
+            case "mm":
+              return this.num(dt.minute, 2);
+            // hours
+            case "h":
+              return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12);
+            case "hh":
+              return this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2);
+            case "H":
+              return this.num(dt.hour);
+            case "HH":
+              return this.num(dt.hour, 2);
+            // offset
+            case "Z":
+              // like +6
+              return formatOffset({
+                format: "narrow",
+                allowZ: this.opts.allowZ
+              });
+            case "ZZ":
+              // like +06:00
+              return formatOffset({
+                format: "short",
+                allowZ: this.opts.allowZ
+              });
+            case "ZZZ":
+              // like +0600
+              return formatOffset({
+                format: "techie",
+                allowZ: this.opts.allowZ
+              });
+            case "ZZZZ":
+              // like EST
+              return dt.zone.offsetName(dt.ts, {
+                format: "short",
+                locale: this.loc.locale
+              });
+            case "ZZZZZ":
+              // like Eastern Standard Time
+              return dt.zone.offsetName(dt.ts, {
+                format: "long",
+                locale: this.loc.locale
+              });
+            // zone
+            case "z":
+              // like America/New_York
+              return dt.zoneName;
+            // meridiems
+            case "a":
+              return meridiem();
+            // dates
+            case "d":
+              return useDateTimeFormatter ? string({
+                day: "numeric"
+              }, "day") : this.num(dt.day);
+            case "dd":
+              return useDateTimeFormatter ? string({
+                day: "2-digit"
+              }, "day") : this.num(dt.day, 2);
+            // weekdays - standalone
+            case "c":
+              // like 1
+              return this.num(dt.weekday);
+            case "ccc":
+              // like 'Tues'
+              return weekday("short", true);
+            case "cccc":
+              // like 'Tuesday'
+              return weekday("long", true);
+            case "ccccc":
+              // like 'T'
+              return weekday("narrow", true);
+            // weekdays - format
+            case "E":
+              // like 1
+              return this.num(dt.weekday);
+            case "EEE":
+              // like 'Tues'
+              return weekday("short", false);
+            case "EEEE":
+              // like 'Tuesday'
+              return weekday("long", false);
+            case "EEEEE":
+              // like 'T'
+              return weekday("narrow", false);
+            // months - standalone
+            case "L":
+              // like 1
+              return useDateTimeFormatter ? string({
+                month: "numeric",
+                day: "numeric"
+              }, "month") : this.num(dt.month);
+            case "LL":
+              // like 01, doesn't seem to work
+              return useDateTimeFormatter ? string({
+                month: "2-digit",
+                day: "numeric"
+              }, "month") : this.num(dt.month, 2);
+            case "LLL":
+              // like Jan
+              return month("short", true);
+            case "LLLL":
+              // like January
+              return month("long", true);
+            case "LLLLL":
+              // like J
+              return month("narrow", true);
+            // months - format
+            case "M":
+              // like 1
+              return useDateTimeFormatter ? string({
+                month: "numeric"
+              }, "month") : this.num(dt.month);
+            case "MM":
+              // like 01
+              return useDateTimeFormatter ? string({
+                month: "2-digit"
+              }, "month") : this.num(dt.month, 2);
+            case "MMM":
+              // like Jan
+              return month("short", false);
+            case "MMMM":
+              // like January
+              return month("long", false);
+            case "MMMMM":
+              // like J
+              return month("narrow", false);
+            // years
+            case "y":
+              // like 2014
+              return useDateTimeFormatter ? string({
+                year: "numeric"
+              }, "year") : this.num(dt.year);
+            case "yy":
+              // like 14
+              return useDateTimeFormatter ? string({
+                year: "2-digit"
+              }, "year") : this.num(dt.year.toString().slice(-2), 2);
+            case "yyyy":
+              // like 0012
+              return useDateTimeFormatter ? string({
+                year: "numeric"
+              }, "year") : this.num(dt.year, 4);
+            case "yyyyyy":
+              // like 000012
+              return useDateTimeFormatter ? string({
+                year: "numeric"
+              }, "year") : this.num(dt.year, 6);
+            // eras
+            case "G":
+              // like AD
+              return era("short");
+            case "GG":
+              // like Anno Domini
+              return era("long");
+            case "GGGGG":
+              return era("narrow");
+            case "kk":
+              return this.num(dt.weekYear.toString().slice(-2), 2);
+            case "kkkk":
+              return this.num(dt.weekYear, 4);
+            case "W":
+              return this.num(dt.weekNumber);
+            case "WW":
+              return this.num(dt.weekNumber, 2);
+            case "o":
+              return this.num(dt.ordinal);
+            case "ooo":
+              return this.num(dt.ordinal, 3);
+            case "q":
+              // like 1
+              return this.num(dt.quarter);
+            case "qq":
+              // like 01
+              return this.num(dt.quarter, 2);
+            case "X":
+              return this.num(Math.floor(dt.ts / 1000));
+            case "x":
+              return this.num(dt.ts);
+            default:
+              return maybeMacro(token);
+          }
         };
-
-        // This is problematic. Different calendars are going to define eras totally differently. What I need is the minimum set of dates
-        // to definitely enumerate them.
-        if (!this.eraCache[length]) {
-          this.eraCache[length] = [DateTime.utc(-40, 1, 1), DateTime.utc(2017, 1, 1)].map(dt => this.extract(dt, intl, "era"));
-        }
-        return this.eraCache[length];
-      });
-    }
-    extract(dt, intlOpts, field) {
-      const df = this.dtFormatter(dt, intlOpts),
-        results = df.formatToParts(),
-        matching = results.find(m => m.type.toLowerCase() === field);
-      return matching ? matching.value : null;
-    }
-    numberFormatter(opts = {}) {
-      // this forcesimple option is never used (the only caller short-circuits on it, but it seems safer to leave)
-      // (in contrast, the rest of the condition is used heavily)
-      return new PolyNumberFormatter(this.intl, opts.forceSimple || this.fastNumbers, opts);
-    }
-    dtFormatter(dt, intlOpts = {}) {
-      return new PolyDateFormatter(dt, this.intl, intlOpts);
-    }
-    relFormatter(opts = {}) {
-      return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
+      return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
     }
-    listFormatter(opts = {}) {
-      return getCachedLF(this.intl, opts);
+    formatDurationFromString(dur, fmt) {
+      const tokenToField = token => {
+          switch (token[0]) {
+            case "S":
+              return "millisecond";
+            case "s":
+              return "second";
+            case "m":
+              return "minute";
+            case "h":
+              return "hour";
+            case "d":
+              return "day";
+            case "w":
+              return "week";
+            case "M":
+              return "month";
+            case "y":
+              return "year";
+            default:
+              return null;
+          }
+        },
+        tokenToString = lildur => token => {
+          const mapped = tokenToField(token);
+          if (mapped) {
+            return this.num(lildur.get(mapped), token.length);
+          } else {
+            return token;
+          }
+        },
+        tokens = Formatter.parseFormat(fmt),
+        realTokens = tokens.reduce((found, {
+          literal,
+          val
+        }) => literal ? found : found.concat(val), []),
+        collapsed = dur.shiftTo(...realTokens.map(tokenToField).filter(t => t));
+      return stringifyTokens(tokens, tokenToString(collapsed));
     }
-    isEnglish() {
-      return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us");
+  }
+
+  class Invalid {
+    constructor(reason, explanation) {
+      this.reason = reason;
+      this.explanation = explanation;
     }
-    equals(other) {
-      return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
+    toMessage() {
+      if (this.explanation) {
+        return `${this.reason}: ${this.explanation}`;
+      } else {
+        return this.reason;
+      }
     }
   }
 
@@ -3344,6 +3380,7 @@
    * Some extractions are super dumb and simpleParse and fromStrings help DRY them.
    */
 
+  const ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
   function combineRegexes(...regexes) {
     const full = regexes.reduce((f, r) => f + r.source, "");
     return RegExp(`^${full}$`);
@@ -3496,7 +3533,7 @@
   }
   function preprocessRFC2822(s) {
     // Remove comments and folding whitespace and replace multiple-spaces with a single space
-    return s.replace(/\([^)]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
+    return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
   }
 
   // http date
@@ -3690,6 +3727,17 @@
     }, null);
   }
 
+  // Remove all properties with a value of 0 from an object
+  function removeZeroes(vals) {
+    const newVals = {};
+    for (const [key, value] of Object.entries(vals)) {
+      if (value !== 0) {
+        newVals[key] = value;
+      }
+    }
+    return newVals;
+  }
+
   /**
    * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". Conceptually, it's just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime#plus} to add a Duration object to a DateTime, producing another DateTime.
    *
@@ -4238,6 +4286,19 @@
       }, true);
     }
 
+    /**
+     * Rescale units to its largest representation
+     * @example Duration.fromObject({ milliseconds: 90000 }).rescale().toObject() //=> { minutes: 1, seconds: 30 }
+     * @return {Duration}
+     */
+    rescale() {
+      if (!this.isValid) return this;
+      const vals = removeZeroes(this.normalize().shiftToAll().toObject());
+      return clone$2(this, {
+        values: vals
+      }, true);
+    }
+
     /**
      * Convert this Duration into its representation in a different set of units.
      * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
@@ -4296,6 +4357,16 @@
       }, true).normalize();
     }
 
+    /**
+     * Shift this Duration to all available units.
+     * Same as shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds")
+     * @return {Duration}
+     */
+    shiftToAll() {
+      if (!this.isValid) return this;
+      return this.shiftTo("years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds");
+    }
+
     /**
      * Return the negative of this Duration.
      * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
@@ -4461,7 +4532,7 @@
    * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.
    * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval.merge}, {@link Interval.xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.
    * * **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#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.
+   * * **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}.
    */
   class Interval {
     /**
@@ -4941,6 +5012,28 @@
       return `[${this.s.toISO()} – ${this.e.toISO()})`;
     }
 
+    /**
+     * Returns a localized string representing this Interval. Accepts the same options as the
+     * Intl.DateTimeFormat constructor and any presets defined by Luxon, such as
+     * {@link DateTime.DATE_FULL} or {@link DateTime.TIME_SIMPLE}. The exact behavior of this method
+     * is browser-specific, but in general it will return an appropriate representation of the
+     * Interval in the assigned locale. Defaults to the system's locale if no locale has been
+     * specified.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
+     * @param {Object} [formatOpts=DateTime.DATE_SHORT] - Either a DateTime preset or
+     * Intl.DateTimeFormat constructor options.
+     * @param {Object} opts - Options to override the configuration of the start DateTime.
+     * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(); //=> 11/7/2022 – 11/8/2022
+     * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL); //=> November 7 – 8, 2022
+     * @example Interval.fromISO('2022-11-07T09:00Z/2022-11-08T09:00Z').toLocaleString(DateTime.DATE_FULL, { locale: 'fr-FR' }); //=> 7–8 novembre 2022
+     * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString(DateTime.TIME_SIMPLE); //=> 6:00 – 8:00 PM
+     * @example Interval.fromISO('2022-11-07T17:00Z/2022-11-07T19:00Z').toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> Mon, Nov 07, 6:00 – 8:00 p
+     * @return {string}
+     */
+    toLocaleString(formatOpts = DATE_SHORT, opts = {}) {
+      return this.isValid ? Formatter.create(this.s.loc.clone(opts), formatOpts).formatInterval(this) : INVALID$3;
+    }
+
     /**
      * Returns an ISO 8601-compliant string representation of this Interval.
      * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
@@ -4976,10 +5069,14 @@
     }
 
     /**
-     * Returns a string representation of this Interval formatted according to the specified format string.
-     * @param {string} dateFormat - the format string. This string formats the start and end time. See {@link DateTime#toFormat} for details.
-     * @param {Object} opts - options
-     * @param {string} [opts.separator =  ' – '] - a separator to place between the start and end representations
+     * Returns a string representation of this Interval formatted according to the specified format
+     * string. **You may not want this.** See {@link Interval#toLocaleString} for a more flexible
+     * formatting tool.
+     * @param {string} dateFormat - The format string. This string formats the start and end time.
+     * See {@link DateTime#toFormat} for details.
+     * @param {Object} opts - Options.
+     * @param {string} [opts.separator =  ' – '] - A separator to place between the start and end
+     * representations.
      * @return {string}
      */
     toFormat(dateFormat, {
@@ -5213,23 +5310,19 @@
       return (days - days % 7) / 7;
     }], ["days", dayDiff]];
     const results = {};
+    const earlier = cursor;
     let lowestOrder, highWater;
     for (const [unit, differ] of differs) {
       if (units.indexOf(unit) >= 0) {
         lowestOrder = unit;
-        let delta = differ(cursor, later);
-        highWater = cursor.plus({
-          [unit]: delta
-        });
+        results[unit] = differ(cursor, later);
+        highWater = earlier.plus(results);
         if (highWater > later) {
-          cursor = cursor.plus({
-            [unit]: delta - 1
-          });
-          delta -= 1;
+          results[unit]--;
+          cursor = earlier.plus(results);
         } else {
           cursor = highWater;
         }
-        results[unit] = delta;
       }
     }
     return [cursor, results, highWater, lowestOrder];
@@ -5554,7 +5647,7 @@
       short: "ZZZ"
     }
   };
-  function tokenForPart(part, locale, formatOpts) {
+  function tokenForPart(part, formatOpts) {
     const {
       type,
       value
@@ -5743,7 +5836,7 @@
     }
     const formatter = Formatter.create(locale, formatOpts);
     const parts = formatter.formatDateTimeParts(getDummyDateTime());
-    return parts.map(p => tokenForPart(p, locale, formatOpts));
+    return parts.map(p => tokenForPart(p, formatOpts));
   }
 
   const nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
@@ -7765,7 +7858,7 @@
 
     /**
      * Equality check
-     * Two DateTimes are equal iff they represent the same millisecond, have the same zone and location, and are both valid.
+     * Two DateTimes are equal if and only if they represent the same millisecond, have the same zone and location, and are both valid.
      * To compare just the millisecond values, use `+dt1 === +dt2`.
      * @param {DateTime} other - the other DateTime
      * @return {boolean}
@@ -47486,7 +47579,7 @@
               return e$1("div", {
                 class: "fjs-palette-field fjs-drag-copy fjs-no-drop",
                 "data-field-type": type,
-                title: `Create a ${label} element`,
+                title: `Create ${getIndefiniteArticle(type)} ${label} element`,
                 children: [Icon ? e$1(Icon, {
                   class: "fjs-palette-field-icon",
                   width: "36",
@@ -47525,6 +47618,12 @@
     });
     return groups.filter(g => g.entries.length);
   }
+  function getIndefiniteArticle(type) {
+    if (['image'].includes(type)) {
+      return 'an';
+    }
+    return 'a';
+  }
   const CURSOR_CLS_PATTERN = /^fjs-cursor-.*$/;
   function set(mode) {
     const classes$1 = classes(document.body);
@@ -52289,6 +52388,7 @@
       setValue
     });
   }
+  const EMPTY_OPTION = null;
   function DefaultOptionEntry(props) {
     const {
       editField,
@@ -52434,13 +52534,14 @@
       label
     } = props;
     const {
-      defaultValue,
+      defaultValue = EMPTY_OPTION,
       values = []
     } = field;
     const path = ['defaultValue'];
     const getOptions = () => {
       return [{
-        label: '<none>'
+        label: '<none>',
+        value: EMPTY_OPTION
       }, ...values];
     };
     const setValue = value => {