@nmshd/runtime 2.2.0 → 2.2.1

package/lib-web/nmshd.runtime.js

@@ -466,11 +466,11 @@ const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 exports.buildInformation = {
-    version: "2.2.0",
-    build: "133",
-    date: "2022-12-05T13:59:01+00:00",
-    commit: "027cf5cd12fd1dc4afe025cf05ffdf1c7e606f46",
-    dependencies: {"@js-soft/docdb-querytranslator":"1.1.0","@js-soft/logging-abstractions":"1.0.0","@js-soft/ts-serval":"2.0.5","@js-soft/ts-utils":"^2.3.0","@nmshd/consumption":"2.3.0","@nmshd/content":"2.1.2","@nmshd/crypto":"2.0.3","@nmshd/transport":"2.0.0","ajv":"^8.11.2","ajv-errors":"^3.0.0","ajv-formats":"^2.1.1","json-stringify-safe":"^5.0.1","luxon":"^3.1.0","qrcode":"1.5.1","reflect-metadata":"0.1.13","ts-simple-nameof":"1.3.1","typescript-ioc":"3.2.2"},
+    version: "2.2.1",
+    build: "134",
+    date: "2022-12-06T13:09:23+00:00",
+    commit: "d7f19253acca6735402d45f41ccc4c30d42ff2b5",
+    dependencies: {"@js-soft/docdb-querytranslator":"1.1.0","@js-soft/logging-abstractions":"1.0.0","@js-soft/ts-serval":"2.0.5","@js-soft/ts-utils":"^2.3.0","@nmshd/consumption":"2.3.0","@nmshd/content":"2.1.2","@nmshd/crypto":"2.0.3","@nmshd/transport":"2.0.0","ajv":"^8.11.2","ajv-errors":"^3.0.0","ajv-formats":"^2.1.1","json-stringify-safe":"^5.0.1","luxon":"^3.1.1","qrcode":"1.5.1","reflect-metadata":"0.1.13","ts-simple-nameof":"1.3.1","typescript-ioc":"3.2.2"},
     libraries: {
         serval: ts_serval_1.buildInformation,
         consumption: consumption_1.buildInformation,
@@ -32464,7 +32464,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CreateOwnRelationshipTemplateUseCase = void 0;
+const ts_serval_1 = __webpack_require__(/*! @js-soft/ts-serval */ "@js-soft/ts-serval");
 const ts_utils_1 = __webpack_require__(/*! @js-soft/ts-utils */ "./node_modules/@js-soft/ts-utils/dist/index.js");
+const consumption_1 = __webpack_require__(/*! @nmshd/consumption */ "@nmshd/consumption");
+const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 const luxon_1 = __webpack_require__(/*! luxon */ "./node_modules/luxon/build/node/luxon.js");
 const ts_simple_nameof_1 = __webpack_require__(/*! ts-simple-nameof */ "./node_modules/ts-simple-nameof/index.js");
@@ -32490,12 +32493,16 @@ Validator = __decorate([
     __metadata("design:paramtypes", [common_1.SchemaRepository])
 ], Validator);
 let CreateOwnRelationshipTemplateUseCase = class CreateOwnRelationshipTemplateUseCase extends common_1.UseCase {
-    constructor(templateController, accountController, validator) {
+    constructor(templateController, accountController, outgoingRequestsController, validator) {
         super(validator);
         this.templateController = templateController;
         this.accountController = accountController;
+        this.outgoingRequestsController = outgoingRequestsController;
     }
     async executeInternal(request) {
+        const validationError = await this.validateRelationshipTemplateContent(request.content);
+        if (validationError)
+            return ts_utils_1.Result.fail(validationError);
         const relationshipTemplate = await this.templateController.sendRelationshipTemplate({
             content: request.content,
             expiresAt: transport_1.CoreDate.from(request.expiresAt),
@@ -32504,13 +32511,29 @@ let CreateOwnRelationshipTemplateUseCase = class CreateOwnRelationshipTemplateUs
         await this.accountController.syncDatawallet();
         return ts_utils_1.Result.ok(RelationshipTemplateMapper_1.RelationshipTemplateMapper.toRelationshipTemplateDTO(relationshipTemplate));
     }
+    async validateRelationshipTemplateContent(content) {
+        const transformedContent = ts_serval_1.Serializable.fromUnknown(content);
+        if (!(transformedContent instanceof content_1.RelationshipTemplateContent))
+            return;
+        const validationResult = await this.outgoingRequestsController.canCreate({ content: transformedContent.onNewRelationship });
+        if (validationResult.isError())
+            return validationResult.error;
+        if (transformedContent.onExistingRelationship) {
+            const validationResult = await this.outgoingRequestsController.canCreate({ content: transformedContent.onExistingRelationship });
+            if (validationResult.isError())
+                return validationResult.error;
+        }
+        return;
+    }
 };
 CreateOwnRelationshipTemplateUseCase = __decorate([
     __param(0, typescript_ioc_1.Inject),
     __param(1, typescript_ioc_1.Inject),
     __param(2, typescript_ioc_1.Inject),
+    __param(3, typescript_ioc_1.Inject),
     __metadata("design:paramtypes", [transport_1.RelationshipTemplateController,
         transport_1.AccountController,
+        consumption_1.OutgoingRequestsController,
         Validator])
 ], CreateOwnRelationshipTemplateUseCase);
 exports.CreateOwnRelationshipTemplateUseCase = CreateOwnRelationshipTemplateUseCase;
@@ -45671,1351 +45694,975 @@ const DATETIME_HUGE_WITH_SECONDS = {
   timeZoneName: l
 };
 
-/*
-  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
+ * @interface
  */
-// TYPES
-
-function isUndefined(o) {
-  return typeof o === "undefined";
-}
-function isNumber(o) {
-  return typeof o === "number";
-}
-function isInteger(o) {
-  return typeof o === "number" && o % 1 === 0;
-}
-function isString(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;
+class Zone {
+  /**
+   * The type of zone
+   * @abstract
+   * @type {string}
+   */
+  get type() {
+    throw new ZoneIsAbstractError();
   }
+  /**
+   * The name of this zone.
+   * @abstract
+   * @type {string}
+   */
 
-  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
+  get name() {
+    throw new ZoneIsAbstractError();
+  }
 
-function integerBetween(thing, bottom, top) {
-  return isInteger(thing) && thing >= bottom && thing <= top;
-} // x % n but takes the sign of n instead of x
+  get ianaName() {
+    return this.name;
+  }
+  /**
+   * Returns whether the offset is known to be fixed for the whole year.
+   * @abstract
+   * @type {boolean}
+   */
 
-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");
+  get isUniversal() {
+    throw new ZoneIsAbstractError();
   }
+  /**
+   * Returns the offset's common name (such as EST) at the specified timestamp
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to get the name
+   * @param {Object} opts - Options to affect the format
+   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
+   * @param {string} opts.locale - What locale to return the offset name in.
+   * @return {string}
+   */
 
-  return padded;
-}
-function parseInteger(string) {
-  if (isUndefined(string) || string === null || string === "") {
-    return undefined;
-  } else {
-    return parseInt(string, 10);
-  }
-}
-function parseFloating(string) {
-  if (isUndefined(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(fraction) || fraction === null || fraction === "") {
-    return undefined;
-  } else {
-    const f = parseFloat("0." + fraction) * 1000;
-    return Math.floor(f);
+
+  offsetName(ts, opts) {
+    throw new ZoneIsAbstractError();
   }
-}
-function roundTo(number, digits, towardZero = false) {
-  const factor = 10 ** digits,
-        rounder = towardZero ? Math.trunc : Math.round;
-  return rounder(number * factor) / factor;
-} // DATE BASICS
+  /**
+   * Returns the offset's value as a string
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to get the offset
+   * @param {string} format - What style of offset to return.
+   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
+   * @return {string}
+   */
 
-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];
+  formatOffset(ts, format) {
+    throw new ZoneIsAbstractError();
   }
-} // covert a calendar object to a local timestamp (epoch, but with the offset baked in)
+  /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   * @abstract
+   * @param {number} ts - Epoch milliseconds for which to compute the offset
+   * @return {number}
+   */
 
-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);
+  offset(ts) {
+    throw new ZoneIsAbstractError();
   }
+  /**
+   * Return whether this Zone is equal to another zone
+   * @abstract
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */
 
-  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;
+  equals(otherZone) {
+    throw new ZoneIsAbstractError();
   }
+  /**
+   * Return whether this Zone is valid.
+   * @abstract
+   * @type {boolean}
+   */
 
-  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;
+  get isValid() {
+    throw new ZoneIsAbstractError();
   }
 
-  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);
+let singleton$1 = null;
+/**
+ * Represents the local zone for this JavaScript environment.
+ * @implements {Zone}
+ */
+
+class SystemZone extends Zone {
+  /**
+   * Get a singleton instance of the local zone
+   * @return {SystemZone}
+   */
+  static get instance() {
+    if (singleton$1 === null) {
+      singleton$1 = new SystemZone();
     }
-  }
 
-  return normalized;
-}
-function formatOffset(offset, format) {
-  const hours = Math.trunc(Math.abs(offset / 60)),
-        minutes = Math.trunc(Math.abs(offset % 60)),
-        sign = offset >= 0 ? "+" : "-";
+    return singleton$1;
+  }
+  /** @override **/
 
-  switch (format) {
-    case "short":
-      return `${sign}${padStart(hours, 2)}:${padStart(minutes, 2)}`;
 
-    case "narrow":
-      return `${sign}${hours}${minutes > 0 ? `:${minutes}` : ""}`;
+  get type() {
+    return "system";
+  }
+  /** @override **/
 
-    case "techie":
-      return `${sign}${padStart(hours, 2)}${padStart(minutes, 2)}`;
 
-    default:
-      throw new RangeError(`Value format ${format} is out of range for property format`);
+  get name() {
+    return new Intl.DateTimeFormat().resolvedOptions().timeZone;
   }
-}
-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})?)?/;
+  /** @override **/
 
-/**
- * @private
- */
 
+  get isUniversal() {
+    return false;
+  }
+  /** @override **/
 
-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];
+  offsetName(ts, {
+    format,
+    locale
+  }) {
+    return parseZoneInfo(ts, format, locale);
+  }
+  /** @override **/
 
-    case "long":
-      return [...monthsLong];
 
-    case "numeric":
-      return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
+  formatOffset(ts, format) {
+    return formatOffset(this.offset(ts), format);
+  }
+  /** @override **/
 
-    case "2-digit":
-      return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];
 
-    default:
-      return null;
+  offset(ts) {
+    return -new Date(ts).getTimezoneOffset();
   }
-}
-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];
+  /** @override **/
 
-    case "short":
-      return [...weekdaysShort];
 
-    case "long":
-      return [...weekdaysLong];
+  equals(otherZone) {
+    return otherZone.type === "system";
+  }
+  /** @override **/
 
-    case "numeric":
-      return ["1", "2", "3", "4", "5", "6", "7"];
 
-    default:
-      return null;
+  get isValid() {
+    return true;
   }
-}
-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];
+let dtfCache = {};
 
-    default:
-      return null;
+function makeDTF(zone) {
+  if (!dtfCache[zone]) {
+    dtfCache[zone] = new Intl.DateTimeFormat("en-US", {
+      hour12: false,
+      timeZone: zone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      era: "short"
+    });
   }
+
+  return dtfCache[zone];
 }
-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";
+const typeToPos = {
+  year: 0,
+  month: 1,
+  day: 2,
+  era: 3,
+  hour: 4,
+  minute: 5,
+  second: 6
+};
 
-    switch (count) {
-      case 1:
-        return isDay ? "tomorrow" : `next ${units[unit][0]}`;
+function hackyOffset(dtf, date) {
+  const formatted = dtf.format(date).replace(/\u200E/g, ""),
+        parsed = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(formatted),
+        [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed;
+  return [fYear, fMonth, fDay, fadOrBc, fHour, fMinute, fSecond];
+}
 
-      case -1:
-        return isDay ? "yesterday" : `last ${units[unit][0]}`;
+function partsOffset(dtf, date) {
+  const formatted = dtf.formatToParts(date);
+  const filled = [];
 
-      case 0:
-        return isDay ? "today" : `this ${units[unit][0]}`;
+  for (let i = 0; i < formatted.length; i++) {
+    const {
+      type,
+      value
+    } = formatted[i];
+    const pos = typeToPos[type];
 
+    if (type === "era") {
+      filled[pos] = value;
+    } else if (!isUndefined(pos)) {
+      filled[pos] = parseInt(value, 10);
     }
   }
 
-  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}`;
+  return filled;
 }
 
-function stringifyTokens(splits, tokenToString) {
-  let s = "";
+let ianaZoneCache = {};
+/**
+ * A zone identified by an IANA identifier, like America/New_York
+ * @implements {Zone}
+ */
 
-  for (const token of splits) {
-    if (token.literal) {
-      s += token.val;
-    } else {
-      s += tokenToString(token.val);
+class IANAZone extends Zone {
+  /**
+   * @param {string} name - Zone name
+   * @return {IANAZone}
+   */
+  static create(name) {
+    if (!ianaZoneCache[name]) {
+      ianaZoneCache[name] = new IANAZone(name);
     }
-  }
 
-  return s;
-}
+    return ianaZoneCache[name];
+  }
+  /**
+   * Reset local caches. Should only be necessary in testing scenarios.
+   * @return {void}
+   */
 
-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 resetCache() {
+    ianaZoneCache = {};
+    dtfCache = {};
   }
+  /**
+   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
+   * @param {string} s - The string to check validity on
+   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
+   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
+   * @deprecated This method returns false for some valid IANA names. Use isValidZone instead.
+   * @return {boolean}
+   */
 
-  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
-          });
-        }
+  static isValidSpecifier(s) {
+    return this.isValidZone(s);
+  }
+  /**
+   * Returns whether the provided string identifies a real zone
+   * @param {string} zone - The string to check
+   * @example IANAZone.isValidZone("America/New_York") //=> true
+   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
+   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
+   * @return {boolean}
+   */
 
-        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;
-      }
+  static isValidZone(zone) {
+    if (!zone) {
+      return false;
     }
 
-    if (currentFull.length > 0) {
-      splits.push({
-        literal: bracketed,
-        val: currentFull
-      });
+    try {
+      new Intl.DateTimeFormat("en-US", {
+        timeZone: zone
+      }).format();
+      return true;
+    } catch (e) {
+      return false;
     }
-
-    return splits;
-  }
-
-  static macroTokenToFormatOpts(token) {
-    return macroTokenToFormatOpts[token];
   }
 
-  constructor(locale, formatOpts) {
-    this.opts = formatOpts;
-    this.loc = locale;
-    this.systemLoc = null;
-  }
+  constructor(name) {
+    super();
+    /** @private **/
 
-  formatWithSystemDefault(dt, opts) {
-    if (this.systemLoc === null) {
-      this.systemLoc = this.loc.redefaultToSystem();
-    }
+    this.zoneName = name;
+    /** @private **/
 
-    const df = this.systemLoc.dtFormatter(dt, { ...this.opts,
-      ...opts
-    });
-    return df.format();
+    this.valid = IANAZone.isValidZone(name);
   }
+  /** @override **/
 
-  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();
+  get type() {
+    return "iana";
   }
+  /** @override **/
 
-  resolvedOptions(dt, opts = {}) {
-    const df = this.loc.dtFormatter(dt, { ...this.opts,
-      ...opts
-    });
-    return df.resolvedOptions();
+
+  get name() {
+    return this.zoneName;
   }
+  /** @override **/
 
-  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
-    };
+  get isUniversal() {
+    return false;
+  }
+  /** @override **/
 
-    if (p > 0) {
-      opts.padTo = p;
-    }
 
-    return this.loc.numberFormatter(opts).format(n);
+  offsetName(ts, {
+    format,
+    locale
+  }) {
+    return parseZoneInfo(ts, format, locale, this.name);
   }
+  /** @override **/
 
-  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);
+  formatOffset(ts, format) {
+    return formatOffset(this.offset(ts), format);
+  }
+  /** @override **/
 
-      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
+  offset(ts) {
+    const date = new Date(ts);
+    if (isNaN(date)) return NaN;
+    const dtf = makeDTF(this.name);
+    let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts ? partsOffset(dtf, date) : hackyOffset(dtf, date);
 
-        case "SSS":
-          return this.num(dt.millisecond, 3);
-        // seconds
+    if (adOrBc === "BC") {
+      year = -Math.abs(year) + 1;
+    } // because we're using hour12 and https://bugs.chromium.org/p/chromium/issues/detail?id=1025564&can=2&q=%2224%3A00%22%20datetimeformat
 
-        case "s":
-          return this.num(dt.second);
 
-        case "ss":
-          return this.num(dt.second, 2);
-        // fractional seconds
+    const adjustedHour = hour === 24 ? 0 : hour;
+    const asUTC = objToLocalTS({
+      year,
+      month,
+      day,
+      hour: adjustedHour,
+      minute,
+      second,
+      millisecond: 0
+    });
+    let asTS = +date;
+    const over = asTS % 1000;
+    asTS -= over >= 0 ? over : 1000 + over;
+    return (asUTC - asTS) / (60 * 1000);
+  }
+  /** @override **/
 
-        case "uu":
-          return this.num(Math.floor(dt.millisecond / 10), 2);
 
-        case "uuu":
-          return this.num(Math.floor(dt.millisecond / 100));
-        // minutes
+  equals(otherZone) {
+    return otherZone.type === "iana" && otherZone.name === this.name;
+  }
+  /** @override **/
 
-        case "m":
-          return this.num(dt.minute);
 
-        case "mm":
-          return this.num(dt.minute, 2);
-        // hours
+  get isValid() {
+    return this.valid;
+  }
 
-        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);
+let intlLFCache = {};
 
-        case "H":
-          return this.num(dt.hour);
+function getCachedLF(locString, opts = {}) {
+  const key = JSON.stringify([locString, opts]);
+  let dtf = intlLFCache[key];
 
-        case "HH":
-          return this.num(dt.hour, 2);
-        // offset
+  if (!dtf) {
+    dtf = new Intl.ListFormat(locString, opts);
+    intlLFCache[key] = dtf;
+  }
 
-        case "Z":
-          // like +6
-          return formatOffset({
-            format: "narrow",
-            allowZ: this.opts.allowZ
-          });
+  return dtf;
+}
 
-        case "ZZ":
-          // like +06:00
-          return formatOffset({
-            format: "short",
-            allowZ: this.opts.allowZ
-          });
+let intlDTCache = {};
 
-        case "ZZZ":
-          // like +0600
-          return formatOffset({
-            format: "techie",
-            allowZ: this.opts.allowZ
-          });
+function getCachedDTF(locString, opts = {}) {
+  const key = JSON.stringify([locString, opts]);
+  let dtf = intlDTCache[key];
 
-        case "ZZZZ":
-          // like EST
-          return dt.zone.offsetName(dt.ts, {
-            format: "short",
-            locale: this.loc.locale
-          });
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat(locString, opts);
+    intlDTCache[key] = dtf;
+  }
 
-        case "ZZZZZ":
-          // like Eastern Standard Time
-          return dt.zone.offsetName(dt.ts, {
-            format: "long",
-            locale: this.loc.locale
-          });
-        // zone
+  return dtf;
+}
 
-        case "z":
-          // like America/New_York
-          return dt.zoneName;
-        // meridiems
+let intlNumCache = {};
 
-        case "a":
-          return meridiem();
-        // dates
+function getCachedINF(locString, opts = {}) {
+  const key = JSON.stringify([locString, opts]);
+  let inf = intlNumCache[key];
 
-        case "d":
-          return useDateTimeFormatter ? string({
-            day: "numeric"
-          }, "day") : this.num(dt.day);
+  if (!inf) {
+    inf = new Intl.NumberFormat(locString, opts);
+    intlNumCache[key] = inf;
+  }
 
-        case "dd":
-          return useDateTimeFormatter ? string({
-            day: "2-digit"
-          }, "day") : this.num(dt.day, 2);
-        // weekdays - standalone
+  return inf;
+}
 
-        case "c":
-          // like 1
-          return this.num(dt.weekday);
+let intlRelCache = {};
 
-        case "ccc":
-          // like 'Tues'
-          return weekday("short", true);
+function getCachedRTF(locString, opts = {}) {
+  const {
+    base,
+    ...cacheKeyOpts
+  } = opts; // exclude `base` from the options
 
-        case "cccc":
-          // like 'Tuesday'
-          return weekday("long", true);
+  const key = JSON.stringify([locString, cacheKeyOpts]);
+  let inf = intlRelCache[key];
 
-        case "ccccc":
-          // like 'T'
-          return weekday("narrow", true);
-        // weekdays - format
+  if (!inf) {
+    inf = new Intl.RelativeTimeFormat(locString, opts);
+    intlRelCache[key] = inf;
+  }
 
-        case "E":
-          // like 1
-          return this.num(dt.weekday);
+  return inf;
+}
 
-        case "EEE":
-          // like 'Tues'
-          return weekday("short", false);
+let sysLocaleCache = null;
 
-        case "EEEE":
-          // like 'Tuesday'
-          return weekday("long", false);
+function systemLocale() {
+  if (sysLocaleCache) {
+    return sysLocaleCache;
+  } else {
+    sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
+    return sysLocaleCache;
+  }
+}
 
-        case "EEEEE":
-          // like 'T'
-          return weekday("narrow", false);
-        // months - standalone
+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
+  const uIndex = localeStr.indexOf("-u-");
 
-        case "L":
-          // like 1
-          return useDateTimeFormatter ? string({
-            month: "numeric",
-            day: "numeric"
-          }, "month") : this.num(dt.month);
+  if (uIndex === -1) {
+    return [localeStr];
+  } else {
+    let options;
+    const smaller = localeStr.substring(0, uIndex);
 
-        case "LL":
-          // like 01, doesn't seem to work
-          return useDateTimeFormatter ? string({
-            month: "2-digit",
-            day: "numeric"
-          }, "month") : this.num(dt.month, 2);
+    try {
+      options = getCachedDTF(localeStr).resolvedOptions();
+    } catch (e) {
+      options = getCachedDTF(smaller).resolvedOptions();
+    }
 
-        case "LLL":
-          // like Jan
-          return month("short", true);
+    const {
+      numberingSystem,
+      calendar
+    } = options; // return the smaller one so that we can append the calendar and numbering overrides to it
 
-        case "LLLL":
-          // like January
-          return month("long", true);
+    return [smaller, numberingSystem, calendar];
+  }
+}
 
-        case "LLLLL":
-          // like J
-          return month("narrow", true);
-        // months - format
+function intlConfigString(localeStr, numberingSystem, outputCalendar) {
+  if (outputCalendar || numberingSystem) {
+    localeStr += "-u";
 
-        case "M":
-          // like 1
-          return useDateTimeFormatter ? string({
-            month: "numeric"
-          }, "month") : this.num(dt.month);
+    if (outputCalendar) {
+      localeStr += `-ca-${outputCalendar}`;
+    }
 
-        case "MM":
-          // like 01
-          return useDateTimeFormatter ? string({
-            month: "2-digit"
-          }, "month") : this.num(dt.month, 2);
+    if (numberingSystem) {
+      localeStr += `-nu-${numberingSystem}`;
+    }
 
-        case "MMM":
-          // like Jan
-          return month("short", false);
+    return localeStr;
+  } else {
+    return localeStr;
+  }
+}
 
-        case "MMMM":
-          // like January
-          return month("long", false);
+function mapMonths(f) {
+  const ms = [];
 
-        case "MMMMM":
-          // like J
-          return month("narrow", false);
-        // years
+  for (let i = 1; i <= 12; i++) {
+    const dt = DateTime.utc(2016, i, 1);
+    ms.push(f(dt));
+  }
 
-        case "y":
-          // like 2014
-          return useDateTimeFormatter ? string({
-            year: "numeric"
-          }, "year") : this.num(dt.year);
+  return ms;
+}
 
-        case "yy":
-          // like 14
-          return useDateTimeFormatter ? string({
-            year: "2-digit"
-          }, "year") : this.num(dt.year.toString().slice(-2), 2);
+function mapWeekdays(f) {
+  const ms = [];
 
-        case "yyyy":
-          // like 0012
-          return useDateTimeFormatter ? string({
-            year: "numeric"
-          }, "year") : this.num(dt.year, 4);
+  for (let i = 1; i <= 7; i++) {
+    const dt = DateTime.utc(2016, 11, 13 + i);
+    ms.push(f(dt));
+  }
 
-        case "yyyyyy":
-          // like 000012
-          return useDateTimeFormatter ? string({
-            year: "numeric"
-          }, "year") : this.num(dt.year, 6);
-        // eras
+  return ms;
+}
 
-        case "G":
-          // like AD
-          return era("short");
+function listStuff(loc, length, defaultOK, englishFn, intlFn) {
+  const mode = loc.listingMode(defaultOK);
 
-        case "GG":
-          // like Anno Domini
-          return era("long");
+  if (mode === "error") {
+    return null;
+  } else if (mode === "en") {
+    return englishFn(length);
+  } else {
+    return intlFn(length);
+  }
+}
 
-        case "GGGGG":
-          return era("narrow");
-
-        case "kk":
-          return this.num(dt.weekYear.toString().slice(-2), 2);
+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
+ */
 
-        case "kkkk":
-          return this.num(dt.weekYear, 4);
 
-        case "W":
-          return this.num(dt.weekNumber);
+class PolyNumberFormatter {
+  constructor(intl, forceSimple, opts) {
+    this.padTo = opts.padTo || 0;
+    this.floor = opts.floor || false;
+    const {
+      padTo,
+      floor,
+      ...otherOpts
+    } = opts;
 
-        case "WW":
-          return this.num(dt.weekNumber, 2);
+    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);
+    }
+  }
 
-        case "o":
-          return this.num(dt.ordinal);
+  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);
+    }
+  }
 
-        case "ooo":
-          return this.num(dt.ordinal, 3);
+}
+/**
+ * @private
+ */
 
-        case "q":
-          // like 1
-          return this.num(dt.quarter);
 
-        case "qq":
-          // like 01
-          return this.num(dt.quarter, 2);
+class PolyDateFormatter {
+  constructor(dt, intl, opts) {
+    this.opts = opts;
+    let z;
 
-        case "X":
-          return this.num(Math.floor(dt.ts / 1000));
+    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}`;
 
-        case "x":
-          return this.num(dt.ts);
+      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";
 
-        default:
-          return maybeMacro(token);
+        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
     };
 
-    return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
+    if (z) {
+      intlOpts.timeZone = z;
+    }
+
+    this.dtf = getCachedDTF(intl, intlOpts);
   }
 
-  formatDurationFromString(dur, fmt) {
-    const tokenToField = token => {
-      switch (token[0]) {
-        case "S":
-          return "millisecond";
+  format() {
+    return this.dtf.format(this.dt.toJSDate());
+  }
 
-        case "s":
-          return "second";
+  formatToParts() {
+    return this.dtf.formatToParts(this.dt.toJSDate());
+  }
 
-        case "m":
-          return "minute";
+  resolvedOptions() {
+    return this.dtf.resolvedOptions();
+  }
 
-        case "h":
-          return "hour";
+}
+/**
+ * @private
+ */
 
-        case "d":
-          return "day";
 
-        case "w":
-          return "week";
+class PolyRelFormatter {
+  constructor(intl, isEnglish, opts) {
+    this.opts = {
+      style: "long",
+      ...opts
+    };
 
-        case "M":
-          return "month";
+    if (!isEnglish && hasRelative()) {
+      this.rtf = getCachedRTF(intl, opts);
+    }
+  }
 
-        case "y":
-          return "year";
+  format(count, unit) {
+    if (this.rtf) {
+      return this.rtf.format(count, unit);
+    } else {
+      return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
+    }
+  }
 
-        default:
-          return null;
-      }
-    },
-          tokenToString = lildur => token => {
-      const mapped = tokenToField(token);
+  formatToParts(count, unit) {
+    if (this.rtf) {
+      return this.rtf.formatToParts(count, unit);
+    } else {
+      return [];
+    }
+  }
 
-      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));
+}
+/**
+ * @private
+ */
 
-    return stringifyTokens(tokens, tokenToString(collapsed));
+
+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
 
-class Invalid {
-  constructor(reason, explanation) {
-    this.reason = reason;
-    this.explanation = explanation;
+    const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
+    const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
+    const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
+    return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
   }
 
-  toMessage() {
-    if (this.explanation) {
-      return `${this.reason}: ${this.explanation}`;
-    } else {
-      return this.reason;
-    }
+  static resetCache() {
+    sysLocaleCache = null;
+    intlDTCache = {};
+    intlNumCache = {};
+    intlRelCache = {};
   }
 
-}
+  static fromObject({
+    locale,
+    numberingSystem,
+    outputCalendar
+  } = {}) {
+    return Locale.create(locale, numberingSystem, outputCalendar);
+  }
 
-/**
- * @interface
- */
+  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;
+  }
 
-class Zone {
-  /**
-   * The type of zone
-   * @abstract
-   * @type {string}
-   */
-  get type() {
-    throw new ZoneIsAbstractError();
+  get fastNumbers() {
+    if (this.fastNumbersCached == null) {
+      this.fastNumbersCached = supportsFastNumbers(this);
+    }
+
+    return this.fastNumbersCached;
   }
-  /**
-   * The name of this zone.
-   * @abstract
-   * @type {string}
-   */
 
+  listingMode() {
+    const isActuallyEn = this.isEnglish();
+    const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
+    return isActuallyEn && hasNoWeirdness ? "en" : "intl";
+  }
 
-  get name() {
-    throw new ZoneIsAbstractError();
+  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);
+    }
   }
 
-  get ianaName() {
-    return this.name;
+  redefaultToEN(alts = {}) {
+    return this.clone({ ...alts,
+      defaultToEN: true
+    });
   }
-  /**
-   * Returns whether the offset is known to be fixed for the whole year.
-   * @abstract
-   * @type {boolean}
-   */
 
+  redefaultToSystem(alts = {}) {
+    return this.clone({ ...alts,
+      defaultToEN: false
+    });
+  }
 
-  get isUniversal() {
-    throw new ZoneIsAbstractError();
+  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];
+    });
   }
-  /**
-   * Returns the offset's common name (such as EST) at the specified timestamp
-   * @abstract
-   * @param {number} ts - Epoch milliseconds for which to get the name
-   * @param {Object} opts - Options to affect the format
-   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
-   * @param {string} opts.locale - What locale to return the offset name in.
-   * @return {string}
-   */
 
+  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";
 
-  offsetName(ts, opts) {
-    throw new ZoneIsAbstractError();
+      if (!this.weekdaysCache[formatStr][length]) {
+        this.weekdaysCache[formatStr][length] = mapWeekdays(dt => this.extract(dt, intl, "weekday"));
+      }
+
+      return this.weekdaysCache[formatStr][length];
+    });
   }
-  /**
-   * Returns the offset's value as a string
-   * @abstract
-   * @param {number} ts - Epoch milliseconds for which to get the offset
-   * @param {string} format - What style of offset to return.
-   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
-   * @return {string}
-   */
 
+  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"));
+      }
 
-  formatOffset(ts, format) {
-    throw new ZoneIsAbstractError();
+      return this.meridiemCache;
+    });
   }
-  /**
-   * Return the offset in minutes for this zone at the specified timestamp.
-   * @abstract
-   * @param {number} ts - Epoch milliseconds for which to compute the offset
-   * @return {number}
-   */
 
+  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.
 
-  offset(ts) {
-    throw new ZoneIsAbstractError();
+      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];
+    });
   }
-  /**
-   * Return whether this Zone is equal to another zone
-   * @abstract
-   * @param {Zone} otherZone - the zone to compare
-   * @return {boolean}
-   */
 
+  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;
+  }
 
-  equals(otherZone) {
-    throw new ZoneIsAbstractError();
+  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);
   }
-  /**
-   * Return whether this Zone is valid.
-   * @abstract
-   * @type {boolean}
-   */
 
+  relFormatter(opts = {}) {
+    return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
+  }
 
-  get isValid() {
-    throw new ZoneIsAbstractError();
+  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$1 = null;
+let singleton = null;
 /**
- * Represents the local zone for this JavaScript environment.
+ * A zone with a fixed offset (meaning no DST)
  * @implements {Zone}
  */
 
-class SystemZone extends Zone {
+class FixedOffsetZone extends Zone {
   /**
-   * Get a singleton instance of the local zone
-   * @return {SystemZone}
+   * Get a singleton instance of UTC
+   * @return {FixedOffsetZone}
    */
-  static get instance() {
-    if (singleton$1 === null) {
-      singleton$1 = new SystemZone();
+  static get utcInstance() {
+    if (singleton === null) {
+      singleton = new FixedOffsetZone(0);
     }
 
-    return singleton$1;
+    return singleton;
   }
-  /** @override **/
+  /**
+   * Get an instance with a specified offset
+   * @param {number} offset - The offset in minutes
+   * @return {FixedOffsetZone}
+   */
 
 
-  get type() {
-    return "system";
+  static instance(offset) {
+    return offset === 0 ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset);
   }
-  /** @override **/
+  /**
+   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
+   * @param {string} s - The offset string to parse
+   * @example FixedOffsetZone.parseSpecifier("UTC+6")
+   * @example FixedOffsetZone.parseSpecifier("UTC+06")
+   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
+   * @return {FixedOffsetZone}
+   */
 
 
-  get name() {
-    return new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  static parseSpecifier(s) {
+    if (s) {
+      const r = s.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
+
+      if (r) {
+        return new FixedOffsetZone(signedOffset(r[1], r[2]));
+      }
+    }
+
+    return null;
   }
-  /** @override **/
 
+  constructor(offset) {
+    super();
+    /** @private **/
 
-  get isUniversal() {
-    return false;
+    this.fixed = offset;
   }
   /** @override **/
 
 
-  offsetName(ts, {
-    format,
-    locale
-  }) {
-    return parseZoneInfo(ts, format, locale);
+  get type() {
+    return "fixed";
   }
   /** @override **/
 
 
-  formatOffset(ts, format) {
-    return formatOffset(this.offset(ts), format);
+  get name() {
+    return this.fixed === 0 ? "UTC" : `UTC${formatOffset(this.fixed, "narrow")}`;
+  }
+
+  get ianaName() {
+    if (this.fixed === 0) {
+      return "Etc/UTC";
+    } else {
+      return `Etc/GMT${formatOffset(-this.fixed, "narrow")}`;
+    }
   }
   /** @override **/
 
 
-  offset(ts) {
-    return -new Date(ts).getTimezoneOffset();
+  offsetName() {
+    return this.name;
   }
   /** @override **/
 
 
-  equals(otherZone) {
-    return otherZone.type === "system";
+  formatOffset(ts, format) {
+    return formatOffset(this.fixed, format);
   }
   /** @override **/
 
 
-  get isValid() {
+  get isUniversal() {
     return true;
   }
-
-}
-
-let dtfCache = {};
-
-function makeDTF(zone) {
-  if (!dtfCache[zone]) {
-    dtfCache[zone] = new Intl.DateTimeFormat("en-US", {
-      hour12: false,
-      timeZone: zone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      era: "short"
-    });
-  }
-
-  return dtfCache[zone];
-}
-
-const typeToPos = {
-  year: 0,
-  month: 1,
-  day: 2,
-  era: 3,
-  hour: 4,
-  minute: 5,
-  second: 6
-};
-
-function hackyOffset(dtf, date) {
-  const formatted = dtf.format(date).replace(/\u200E/g, ""),
-        parsed = /(\d+)\/(\d+)\/(\d+) (AD|BC),? (\d+):(\d+):(\d+)/.exec(formatted),
-        [, fMonth, fDay, fYear, fadOrBc, fHour, fMinute, fSecond] = parsed;
-  return [fYear, fMonth, fDay, fadOrBc, fHour, fMinute, fSecond];
-}
-
-function partsOffset(dtf, date) {
-  const formatted = dtf.formatToParts(date);
-  const filled = [];
-
-  for (let i = 0; i < formatted.length; i++) {
-    const {
-      type,
-      value
-    } = formatted[i];
-    const pos = typeToPos[type];
-
-    if (type === "era") {
-      filled[pos] = value;
-    } else if (!isUndefined(pos)) {
-      filled[pos] = parseInt(value, 10);
-    }
-  }
-
-  return filled;
-}
-
-let ianaZoneCache = {};
-/**
- * A zone identified by an IANA identifier, like America/New_York
- * @implements {Zone}
- */
-
-class IANAZone extends Zone {
-  /**
-   * @param {string} name - Zone name
-   * @return {IANAZone}
-   */
-  static create(name) {
-    if (!ianaZoneCache[name]) {
-      ianaZoneCache[name] = new IANAZone(name);
-    }
-
-    return ianaZoneCache[name];
-  }
-  /**
-   * Reset local caches. Should only be necessary in testing scenarios.
-   * @return {void}
-   */
-
-
-  static resetCache() {
-    ianaZoneCache = {};
-    dtfCache = {};
-  }
-  /**
-   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
-   * @param {string} s - The string to check validity on
-   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
-   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
-   * @deprecated This method returns false for some valid IANA names. Use isValidZone instead.
-   * @return {boolean}
-   */
-
-
-  static isValidSpecifier(s) {
-    return this.isValidZone(s);
-  }
-  /**
-   * Returns whether the provided string identifies a real zone
-   * @param {string} zone - The string to check
-   * @example IANAZone.isValidZone("America/New_York") //=> true
-   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
-   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
-   * @return {boolean}
-   */
-
-
-  static isValidZone(zone) {
-    if (!zone) {
-      return false;
-    }
-
-    try {
-      new Intl.DateTimeFormat("en-US", {
-        timeZone: zone
-      }).format();
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  constructor(name) {
-    super();
-    /** @private **/
-
-    this.zoneName = name;
-    /** @private **/
-
-    this.valid = IANAZone.isValidZone(name);
-  }
-  /** @override **/
-
-
-  get type() {
-    return "iana";
-  }
-  /** @override **/
-
-
-  get name() {
-    return this.zoneName;
-  }
-  /** @override **/
-
-
-  get isUniversal() {
-    return false;
-  }
-  /** @override **/
-
-
-  offsetName(ts, {
-    format,
-    locale
-  }) {
-    return parseZoneInfo(ts, format, locale, this.name);
-  }
-  /** @override **/
-
-
-  formatOffset(ts, format) {
-    return formatOffset(this.offset(ts), format);
-  }
-  /** @override **/
-
-
-  offset(ts) {
-    const date = new Date(ts);
-    if (isNaN(date)) return NaN;
-    const dtf = makeDTF(this.name);
-    let [year, month, day, adOrBc, hour, minute, second] = dtf.formatToParts ? partsOffset(dtf, date) : hackyOffset(dtf, date);
-
-    if (adOrBc === "BC") {
-      year = -Math.abs(year) + 1;
-    } // because we're using hour12 and https://bugs.chromium.org/p/chromium/issues/detail?id=1025564&can=2&q=%2224%3A00%22%20datetimeformat
-
-
-    const adjustedHour = hour === 24 ? 0 : hour;
-    const asUTC = objToLocalTS({
-      year,
-      month,
-      day,
-      hour: adjustedHour,
-      minute,
-      second,
-      millisecond: 0
-    });
-    let asTS = +date;
-    const over = asTS % 1000;
-    asTS -= over >= 0 ? over : 1000 + over;
-    return (asUTC - asTS) / (60 * 1000);
-  }
-  /** @override **/
-
-
-  equals(otherZone) {
-    return otherZone.type === "iana" && otherZone.name === this.name;
-  }
-  /** @override **/
-
-
-  get isValid() {
-    return this.valid;
-  }
-
-}
-
-let singleton = null;
-/**
- * A zone with a fixed offset (meaning no DST)
- * @implements {Zone}
- */
-
-class FixedOffsetZone extends Zone {
-  /**
-   * Get a singleton instance of UTC
-   * @return {FixedOffsetZone}
-   */
-  static get utcInstance() {
-    if (singleton === null) {
-      singleton = new FixedOffsetZone(0);
-    }
-
-    return singleton;
-  }
-  /**
-   * Get an instance with a specified offset
-   * @param {number} offset - The offset in minutes
-   * @return {FixedOffsetZone}
-   */
-
-
-  static instance(offset) {
-    return offset === 0 ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset);
-  }
-  /**
-   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
-   * @param {string} s - The offset string to parse
-   * @example FixedOffsetZone.parseSpecifier("UTC+6")
-   * @example FixedOffsetZone.parseSpecifier("UTC+06")
-   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
-   * @return {FixedOffsetZone}
-   */
-
-
-  static parseSpecifier(s) {
-    if (s) {
-      const r = s.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
-
-      if (r) {
-        return new FixedOffsetZone(signedOffset(r[1], r[2]));
-      }
-    }
-
-    return null;
-  }
-
-  constructor(offset) {
-    super();
-    /** @private **/
-
-    this.fixed = offset;
-  }
-  /** @override **/
-
-
-  get type() {
-    return "fixed";
-  }
-  /** @override **/
-
-
-  get name() {
-    return this.fixed === 0 ? "UTC" : `UTC${formatOffset(this.fixed, "narrow")}`;
-  }
-
-  get ianaName() {
-    if (this.fixed === 0) {
-      return "Etc/UTC";
-    } else {
-      return `Etc/GMT${formatOffset(-this.fixed, "narrow")}`;
-    }
-  }
-  /** @override **/
-
-
-  offsetName() {
-    return this.name;
-  }
-  /** @override **/
-
-
-  formatOffset(ts, format) {
-    return formatOffset(this.fixed, format);
-  }
-  /** @override **/
-
-
-  get isUniversal() {
-    return true;
-  }
-  /** @override **/
+  /** @override **/
 
 
   offset() {
@@ -47127,6 +46774,7 @@ let now = () => Date.now(),
     defaultLocale = null,
     defaultNumberingSystem = null,
     defaultOutputCalendar = null,
+    twoDigitCutoffYear = 60,
     throwOnInvalid;
 /**
  * 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.
@@ -47227,6 +46875,28 @@ class Settings {
   static set defaultOutputCalendar(outputCalendar) {
     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}
@@ -47258,495 +46928,870 @@ class Settings {
 
 }
 
-let intlLFCache = {};
+/*
+  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 getCachedLF(locString, opts = {}) {
-  const key = JSON.stringify([locString, opts]);
-  let dtf = intlLFCache[key];
+function isUndefined(o) {
+  return typeof o === "undefined";
+}
+function isNumber(o) {
+  return typeof o === "number";
+}
+function isInteger(o) {
+  return typeof o === "number" && o % 1 === 0;
+}
+function isString(o) {
+  return typeof o === "string";
+}
+function isDate(o) {
+  return Object.prototype.toString.call(o) === "[object Date]";
+} // CAPABILITIES
 
-  if (!dtf) {
-    dtf = new Intl.ListFormat(locString, opts);
-    intlLFCache[key] = dtf;
+function hasRelative() {
+  try {
+    return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat;
+  } catch (e) {
+    return false;
   }
+} // OBJECTS AND ARRAYS
 
-  return dtf;
+function maybeArray(thing) {
+  return Array.isArray(thing) ? thing : [thing];
 }
+function bestBy(arr, by, compare) {
+  if (arr.length === 0) {
+    return undefined;
+  }
 
-let intlDTCache = {};
+  return arr.reduce((best, next) => {
+    const pair = [by(next), next];
 
-function getCachedDTF(locString, opts = {}) {
-  const key = JSON.stringify([locString, opts]);
-  let dtf = intlDTCache[key];
+    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
 
-  if (!dtf) {
-    dtf = new Intl.DateTimeFormat(locString, opts);
-    intlDTCache[key] = dtf;
+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 dtf;
+  return padded;
 }
+function parseInteger(string) {
+  if (isUndefined(string) || string === null || string === "") {
+    return undefined;
+  } else {
+    return parseInt(string, 10);
+  }
+}
+function parseFloating(string) {
+  if (isUndefined(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(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
 
-let intlNumCache = {};
+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;
 
-function getCachedINF(locString, opts = {}) {
-  const key = JSON.stringify([locString, opts]);
-  let inf = intlNumCache[key];
+  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)
 
-  if (!inf) {
-    inf = new Intl.NumberFormat(locString, opts);
-    intlNumCache[key] = inf;
+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 inf;
+  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 > Settings.twoDigitCutoffYear ? 1900 + year : 2000 + year;
+} // PARSING
 
-let intlRelCache = {};
+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"
+  };
 
-function getCachedRTF(locString, opts = {}) {
-  const {
-    base,
-    ...cacheKeyOpts
-  } = opts; // exclude `base` from the options
+  if (timeZone) {
+    intlOpts.timeZone = timeZone;
+  }
 
-  const key = JSON.stringify([locString, cacheKeyOpts]);
-  let inf = intlRelCache[key];
+  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
 
-  if (!inf) {
-    inf = new Intl.RelativeTimeFormat(locString, opts);
-    intlRelCache[key] = inf;
+function signedOffset(offHourStr, offMinuteStr) {
+  let offHour = parseInt(offHourStr, 10); // don't || this because we want to preserve -0
+
+  if (Number.isNaN(offHour)) {
+    offHour = 0;
   }
 
-  return inf;
+  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 = {};
 
-let sysLocaleCache = null;
+  for (const u in obj) {
+    if (hasOwnProperty(obj, u)) {
+      const v = obj[u];
+      if (v === undefined || v === null) continue;
+      normalized[normalizer(u)] = asNumber(v);
+    }
+  }
 
-function systemLocale() {
-  if (sysLocaleCache) {
-    return sysLocaleCache;
-  } else {
-    sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
-    return sysLocaleCache;
+  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"]);
+}
 
-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
-  const uIndex = localeStr.indexOf("-u-");
+/**
+ * @private
+ */
 
-  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 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 {
-      numberingSystem,
-      calendar
-    } = options; // return the smaller one so that we can append the calendar and numbering overrides to it
+  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}`;
+}
 
-    return [smaller, numberingSystem, calendar];
+function stringifyTokens(splits, tokenToString) {
+  let s = "";
+
+  for (const token of splits) {
+    if (token.literal) {
+      s += token.val;
+    } else {
+      s += tokenToString(token.val);
+    }
   }
+
+  return s;
 }
 
-function intlConfigString(localeStr, numberingSystem, outputCalendar) {
-  if (outputCalendar || numberingSystem) {
-    localeStr += "-u";
+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
+ */
 
-    if (outputCalendar) {
-      localeStr += `-ca-${outputCalendar}`;
+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 (numberingSystem) {
-      localeStr += `-nu-${numberingSystem}`;
+    if (currentFull.length > 0) {
+      splits.push({
+        literal: bracketed,
+        val: currentFull
+      });
     }
 
-    return localeStr;
-  } else {
-    return localeStr;
+    return splits;
   }
-}
 
-function mapMonths(f) {
-  const ms = [];
+  static macroTokenToFormatOpts(token) {
+    return macroTokenToFormatOpts[token];
+  }
 
-  for (let i = 1; i <= 12; i++) {
-    const dt = DateTime.utc(2016, i, 1);
-    ms.push(f(dt));
+  constructor(locale, formatOpts) {
+    this.opts = formatOpts;
+    this.loc = locale;
+    this.systemLoc = null;
   }
 
-  return ms;
-}
+  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
+          });
 
-function mapWeekdays(f) {
-  const ms = [];
+        case "ZZ":
+          // like +06:00
+          return formatOffset({
+            format: "short",
+            allowZ: this.opts.allowZ
+          });
 
-  for (let i = 1; i <= 7; i++) {
-    const dt = DateTime.utc(2016, 11, 13 + i);
-    ms.push(f(dt));
-  }
+        case "ZZZ":
+          // like +0600
+          return formatOffset({
+            format: "techie",
+            allowZ: this.opts.allowZ
+          });
 
-  return ms;
-}
+        case "ZZZZ":
+          // like EST
+          return dt.zone.offsetName(dt.ts, {
+            format: "short",
+            locale: this.loc.locale
+          });
 
-function listStuff(loc, length, defaultOK, englishFn, intlFn) {
-  const mode = loc.listingMode(defaultOK);
+        case "ZZZZZ":
+          // like Eastern Standard Time
+          return dt.zone.offsetName(dt.ts, {
+            format: "long",
+            locale: this.loc.locale
+          });
+        // zone
 
-  if (mode === "error") {
-    return null;
-  } else if (mode === "en") {
-    return englishFn(length);
-  } else {
-    return intlFn(length);
-  }
-}
+        case "z":
+          // like America/New_York
+          return dt.zoneName;
+        // meridiems
 
-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
- */
+        case "a":
+          return meridiem();
+        // dates
 
+        case "d":
+          return useDateTimeFormatter ? string({
+            day: "numeric"
+          }, "day") : this.num(dt.day);
 
-class PolyNumberFormatter {
-  constructor(intl, forceSimple, opts) {
-    this.padTo = opts.padTo || 0;
-    this.floor = opts.floor || false;
-    const {
-      padTo,
-      floor,
-      ...otherOpts
-    } = opts;
+        case "dd":
+          return useDateTimeFormatter ? string({
+            day: "2-digit"
+          }, "day") : this.num(dt.day, 2);
+        // weekdays - standalone
 
-    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);
-    }
-  }
+        case "c":
+          // like 1
+          return this.num(dt.weekday);
 
-  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);
-    }
-  }
+        case "ccc":
+          // like 'Tues'
+          return weekday("short", true);
 
-}
-/**
- * @private
- */
+        case "cccc":
+          // like 'Tuesday'
+          return weekday("long", true);
 
+        case "ccccc":
+          // like 'T'
+          return weekday("narrow", true);
+        // weekdays - format
 
-class PolyDateFormatter {
-  constructor(dt, intl, opts) {
-    this.opts = opts;
-    let z;
+        case "E":
+          // like 1
+          return this.num(dt.weekday);
 
-    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}`;
+        case "EEE":
+          // like 'Tues'
+          return weekday("short", false);
 
-      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";
+        case "EEEE":
+          // like 'Tuesday'
+          return weekday("long", false);
 
-        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;
-    }
+        case "EEEEE":
+          // like 'T'
+          return weekday("narrow", false);
+        // months - standalone
 
-    const intlOpts = { ...this.opts
-    };
+        case "L":
+          // like 1
+          return useDateTimeFormatter ? string({
+            month: "numeric",
+            day: "numeric"
+          }, "month") : this.num(dt.month);
 
-    if (z) {
-      intlOpts.timeZone = z;
-    }
+        case "LL":
+          // like 01, doesn't seem to work
+          return useDateTimeFormatter ? string({
+            month: "2-digit",
+            day: "numeric"
+          }, "month") : this.num(dt.month, 2);
 
-    this.dtf = getCachedDTF(intl, intlOpts);
-  }
+        case "LLL":
+          // like Jan
+          return month("short", true);
 
-  format() {
-    return this.dtf.format(this.dt.toJSDate());
-  }
+        case "LLLL":
+          // like January
+          return month("long", true);
 
-  formatToParts() {
-    return this.dtf.formatToParts(this.dt.toJSDate());
-  }
+        case "LLLLL":
+          // like J
+          return month("narrow", true);
+        // months - format
 
-  resolvedOptions() {
-    return this.dtf.resolvedOptions();
-  }
+        case "M":
+          // like 1
+          return useDateTimeFormatter ? string({
+            month: "numeric"
+          }, "month") : this.num(dt.month);
 
-}
-/**
- * @private
- */
+        case "MM":
+          // like 01
+          return useDateTimeFormatter ? string({
+            month: "2-digit"
+          }, "month") : this.num(dt.month, 2);
 
+        case "MMM":
+          // like Jan
+          return month("short", false);
 
-class PolyRelFormatter {
-  constructor(intl, isEnglish, opts) {
-    this.opts = {
-      style: "long",
-      ...opts
-    };
+        case "MMMM":
+          // like January
+          return month("long", false);
 
-    if (!isEnglish && hasRelative()) {
-      this.rtf = getCachedRTF(intl, opts);
-    }
-  }
+        case "MMMMM":
+          // like J
+          return month("narrow", false);
+        // years
 
-  format(count, unit) {
-    if (this.rtf) {
-      return this.rtf.format(count, unit);
-    } else {
-      return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
-    }
-  }
+        case "y":
+          // like 2014
+          return useDateTimeFormatter ? string({
+            year: "numeric"
+          }, "year") : this.num(dt.year);
 
-  formatToParts(count, unit) {
-    if (this.rtf) {
-      return this.rtf.formatToParts(count, unit);
-    } else {
-      return [];
-    }
-  }
+        case "yy":
+          // like 14
+          return useDateTimeFormatter ? string({
+            year: "2-digit"
+          }, "year") : this.num(dt.year.toString().slice(-2), 2);
 
-}
-/**
- * @private
- */
+        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
 
-class Locale {
-  static fromOpts(opts) {
-    return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN);
-  }
+        case "G":
+          // like AD
+          return era("short");
 
-  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
+        case "GG":
+          // like Anno Domini
+          return era("long");
 
-    const localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
-    const numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
-    const outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
-    return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
-  }
+        case "GGGGG":
+          return era("narrow");
 
-  static resetCache() {
-    sysLocaleCache = null;
-    intlDTCache = {};
-    intlNumCache = {};
-    intlRelCache = {};
-  }
+        case "kk":
+          return this.num(dt.weekYear.toString().slice(-2), 2);
 
-  static fromObject({
-    locale,
-    numberingSystem,
-    outputCalendar
-  } = {}) {
-    return Locale.create(locale, numberingSystem, outputCalendar);
-  }
+        case "kkkk":
+          return this.num(dt.weekYear, 4);
 
-  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;
-  }
+        case "W":
+          return this.num(dt.weekNumber);
 
-  get fastNumbers() {
-    if (this.fastNumbersCached == null) {
-      this.fastNumbersCached = supportsFastNumbers(this);
-    }
+        case "WW":
+          return this.num(dt.weekNumber, 2);
 
-    return this.fastNumbersCached;
-  }
+        case "o":
+          return this.num(dt.ordinal);
 
-  listingMode() {
-    const isActuallyEn = this.isEnglish();
-    const hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
-    return isActuallyEn && hasNoWeirdness ? "en" : "intl";
-  }
+        case "ooo":
+          return this.num(dt.ordinal, 3);
 
-  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);
-    }
-  }
+        case "q":
+          // like 1
+          return this.num(dt.quarter);
 
-  redefaultToEN(alts = {}) {
-    return this.clone({ ...alts,
-      defaultToEN: true
-    });
-  }
+        case "qq":
+          // like 01
+          return this.num(dt.quarter, 2);
 
-  redefaultToSystem(alts = {}) {
-    return this.clone({ ...alts,
-      defaultToEN: false
-    });
-  }
+        case "X":
+          return this.num(Math.floor(dt.ts / 1000));
 
-  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";
+        case "x":
+          return this.num(dt.ts);
 
-      if (!this.monthsCache[formatStr][length]) {
-        this.monthsCache[formatStr][length] = mapMonths(dt => this.extract(dt, intl, "month"));
+        default:
+          return maybeMacro(token);
       }
+    };
 
-      return this.monthsCache[formatStr][length];
-    });
+    return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
   }
 
-  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"));
-      }
+  formatDurationFromString(dur, fmt) {
+    const tokenToField = token => {
+      switch (token[0]) {
+        case "S":
+          return "millisecond";
 
-      return this.weekdaysCache[formatStr][length];
-    });
-  }
+        case "s":
+          return "second";
 
-  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"));
-      }
+        case "m":
+          return "minute";
 
-      return this.meridiemCache;
-    });
-  }
+        case "h":
+          return "hour";
 
-  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.
+        case "d":
+          return "day";
 
-      if (!this.eraCache[length]) {
-        this.eraCache[length] = [DateTime.utc(-40, 1, 1), DateTime.utc(2017, 1, 1)].map(dt => this.extract(dt, intl, "era"));
-      }
+        case "w":
+          return "week";
 
-      return this.eraCache[length];
-    });
-  }
+        case "M":
+          return "month";
 
-  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;
-  }
+        case "y":
+          return "year";
 
-  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);
-  }
+        default:
+          return null;
+      }
+    },
+          tokenToString = lildur => token => {
+      const mapped = tokenToField(token);
 
-  dtFormatter(dt, intlOpts = {}) {
-    return new PolyDateFormatter(dt, this.intl, intlOpts);
-  }
+      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));
 
-  relFormatter(opts = {}) {
-    return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
+    return stringifyTokens(tokens, tokenToString(collapsed));
   }
 
-  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");
+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;
+    }
   }
 
 }
@@ -47761,6 +47806,8 @@ class Locale {
  * 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}$`);
@@ -53026,7 +53073,7 @@ function friendlyDateTime(dateTimeish) {
   }
 }
 
-const VERSION = "3.1.0";
+const VERSION = "3.1.1";
 
 exports.DateTime = DateTime;
 exports.Duration = Duration;