@digipair/skill-cron 0.42.0 → 0.43.2

package/index.esm.js

@@ -553,7 +553,12 @@ var DATETIME_HUGE_WITH_SECONDS = {
         },
         {
             key: "ianaName",
-            get: function get() {
+            get: /**
+   * The IANA name of this zone.
+   * Defaults to `name` if not overwritten by a subclass.
+   * @abstract
+   * @type {string}
+   */ function get() {
                 return this.name;
             }
         },
@@ -776,37 +781,70 @@ var ianaZoneCache = {};
     _create_class$2(IANAZone, [
         {
             key: "type",
-            get: /** @override **/ function get() {
+            get: /**
+   * The type of zone. `iana` for all instances of `IANAZone`.
+   * @override
+   * @type {string}
+   */ function get() {
                 return "iana";
             }
         },
         {
             key: "name",
-            get: /** @override **/ function get() {
+            get: /**
+   * The name of this zone (i.e. the IANA zone name).
+   * @override
+   * @type {string}
+   */ function get() {
                 return this.zoneName;
             }
         },
         {
             key: "isUniversal",
-            get: /** @override **/ function get() {
+            get: /**
+   * Returns whether the offset is known to be fixed for the whole year:
+   * Always returns false for all IANA zones.
+   * @override
+   * @type {boolean}
+   */ function get() {
                 return false;
             }
         },
         {
-            /** @override **/ key: "offsetName",
+            /**
+   * Returns the offset's common name (such as EST) at the specified timestamp
+   * @override
+   * @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}
+   */ key: "offsetName",
             value: function offsetName(ts, param) {
                 var format = param.format, locale = param.locale;
                 return parseZoneInfo(ts, format, locale, this.name);
             }
         },
         {
-            /** @override **/ key: "formatOffset",
+            /**
+   * Returns the offset's value as a string
+   * @override
+   * @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}
+   */ key: "formatOffset",
             value: function formatOffset1(ts, format) {
                 return formatOffset(this.offset(ts), format);
             }
         },
         {
-            /** @override **/ key: "offset",
+            /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   * @override
+   * @param {number} ts - Epoch milliseconds for which to compute the offset
+   * @return {number}
+   */ key: "offset",
             value: function offset(ts) {
                 var date = new Date(ts);
                 if (isNaN(date)) return NaN;
@@ -833,14 +871,23 @@ var ianaZoneCache = {};
             }
         },
         {
-            /** @override **/ key: "equals",
+            /**
+   * Return whether this Zone is equal to another zone
+   * @override
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */ key: "equals",
             value: function equals(otherZone) {
                 return otherZone.type === "iana" && otherZone.name === this.name;
             }
         },
         {
             key: "isValid",
-            get: /** @override **/ function get() {
+            get: /**
+   * Return whether this Zone is valid.
+   * @override
+   * @type {boolean}
+   */ function get() {
                 return this.valid;
             }
         }
@@ -874,7 +921,7 @@ var ianaZoneCache = {};
    * @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.
+   * @deprecated For backward compatibility, this forwards to isValidZone, better use `isValidZone()` directly instead.
    * @return {boolean}
    */ function isValidSpecifier(s) {
                 return this.isValidZone(s);
@@ -1491,6 +1538,12 @@ var fallbackWeekSettings = {
             value: function equals(other) {
                 return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
             }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                return "Locale(".concat(this.locale, ", ").concat(this.numberingSystem, ", ").concat(this.outputCalendar, ")");
+            }
         }
     ], [
         {
@@ -1504,7 +1557,7 @@ var fallbackWeekSettings = {
             value: function create(locale, numberingSystem, outputCalendar, weekSettings) {
                 var defaultToEN = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
                 var specifiedLocale = locale || Settings.defaultLocale;
-                // the system locale is useful for human readable strings but annoying for parsing/formatting known formats
+                // the system locale is useful for human-readable strings but annoying for parsing/formatting known formats
                 var localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
                 var numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
                 var outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
@@ -1548,19 +1601,33 @@ var singleton = null;
     _create_class$2(FixedOffsetZone, [
         {
             key: "type",
-            get: /** @override **/ function get() {
+            get: /**
+   * The type of zone. `fixed` for all instances of `FixedOffsetZone`.
+   * @override
+   * @type {string}
+   */ function get() {
                 return "fixed";
             }
         },
         {
             key: "name",
-            get: /** @override **/ function get() {
+            get: /**
+   * The name of this zone.
+   * All fixed zones' names always start with "UTC" (plus optional offset)
+   * @override
+   * @type {string}
+   */ function get() {
                 return this.fixed === 0 ? "UTC" : "UTC".concat(formatOffset(this.fixed, "narrow"));
             }
         },
         {
             key: "ianaName",
-            get: function get() {
+            get: /**
+   * The IANA name of this zone, i.e. `Etc/UTC` or `Etc/GMT+/-nn`
+   *
+   * @override
+   * @type {string}
+   */ function get() {
                 if (this.fixed === 0) {
                     return "Etc/UTC";
                 } else {
@@ -1569,38 +1636,71 @@ var singleton = null;
             }
         },
         {
-            /** @override **/ key: "offsetName",
+            /**
+   * Returns the offset's common name at the specified timestamp.
+   *
+   * For fixed offset zones this equals to the zone name.
+   * @override
+   */ key: "offsetName",
             value: function offsetName() {
                 return this.name;
             }
         },
         {
-            /** @override **/ key: "formatOffset",
+            /**
+   * Returns the offset's value as a string
+   * @override
+   * @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}
+   */ key: "formatOffset",
             value: function formatOffset1(ts, format) {
                 return formatOffset(this.fixed, format);
             }
         },
         {
             key: "isUniversal",
-            get: /** @override **/ function get() {
+            get: /**
+   * Returns whether the offset is known to be fixed for the whole year:
+   * Always returns true for all fixed offset zones.
+   * @override
+   * @type {boolean}
+   */ function get() {
                 return true;
             }
         },
         {
-            /** @override **/ key: "offset",
+            /**
+   * Return the offset in minutes for this zone at the specified timestamp.
+   *
+   * For fixed offset zones, this is constant and does not depend on a timestamp.
+   * @override
+   * @return {number}
+   */ key: "offset",
             value: function offset() {
                 return this.fixed;
             }
         },
         {
-            /** @override **/ key: "equals",
+            /**
+   * Return whether this Zone is equal to another zone (i.e. also fixed and same offset)
+   * @override
+   * @param {Zone} otherZone - the zone to compare
+   * @return {boolean}
+   */ key: "equals",
             value: function equals(otherZone) {
                 return otherZone.type === "fixed" && otherZone.fixed === this.fixed;
             }
         },
         {
             key: "isValid",
-            get: /** @override **/ function get() {
+            get: /**
+   * Return whether this Zone is valid:
+   * All fixed offset zones are valid.
+   * @override
+   * @type {boolean}
+   */ function get() {
                 return true;
             }
         }
@@ -1737,6 +1837,146 @@ var singleton = null;
         return new InvalidZone(input);
     }
 }
+var numberingSystems = {
+    arab: "[٠-٩]",
+    arabext: "[۰-۹]",
+    bali: "[᭐-᭙]",
+    beng: "[০-৯]",
+    deva: "[०-९]",
+    fullwide: "[０-９]",
+    gujr: "[૦-૯]",
+    hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
+    khmr: "[០-៩]",
+    knda: "[೦-೯]",
+    laoo: "[໐-໙]",
+    limb: "[᥆-᥏]",
+    mlym: "[൦-൯]",
+    mong: "[᠐-᠙]",
+    mymr: "[၀-၉]",
+    orya: "[୦-୯]",
+    tamldec: "[௦-௯]",
+    telu: "[౦-౯]",
+    thai: "[๐-๙]",
+    tibt: "[༠-༩]",
+    latn: "\\d"
+};
+var numberingSystemsUTF16 = {
+    arab: [
+        1632,
+        1641
+    ],
+    arabext: [
+        1776,
+        1785
+    ],
+    bali: [
+        6992,
+        7001
+    ],
+    beng: [
+        2534,
+        2543
+    ],
+    deva: [
+        2406,
+        2415
+    ],
+    fullwide: [
+        65296,
+        65303
+    ],
+    gujr: [
+        2790,
+        2799
+    ],
+    khmr: [
+        6112,
+        6121
+    ],
+    knda: [
+        3302,
+        3311
+    ],
+    laoo: [
+        3792,
+        3801
+    ],
+    limb: [
+        6470,
+        6479
+    ],
+    mlym: [
+        3430,
+        3439
+    ],
+    mong: [
+        6160,
+        6169
+    ],
+    mymr: [
+        4160,
+        4169
+    ],
+    orya: [
+        2918,
+        2927
+    ],
+    tamldec: [
+        3046,
+        3055
+    ],
+    telu: [
+        3174,
+        3183
+    ],
+    thai: [
+        3664,
+        3673
+    ],
+    tibt: [
+        3872,
+        3881
+    ]
+};
+var hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split("");
+function parseDigits(str) {
+    var value = parseInt(str, 10);
+    if (isNaN(value)) {
+        value = "";
+        for(var i = 0; i < str.length; i++){
+            var code = str.charCodeAt(i);
+            if (str[i].search(numberingSystems.hanidec) !== -1) {
+                value += hanidecChars.indexOf(str[i]);
+            } else {
+                for(var key in numberingSystemsUTF16){
+                    var _numberingSystemsUTF16_key = _sliced_to_array$1(numberingSystemsUTF16[key], 2), min = _numberingSystemsUTF16_key[0], max = _numberingSystemsUTF16_key[1];
+                    if (code >= min && code <= max) {
+                        value += code - min;
+                    }
+                }
+            }
+        }
+        return parseInt(value, 10);
+    } else {
+        return value;
+    }
+}
+// cache of {numberingSystem: {append: regex}}
+var digitRegexCache = {};
+function resetDigitRegexCache() {
+    digitRegexCache = {};
+}
+function digitRegex(param) {
+    var numberingSystem = param.numberingSystem, append = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+    var ns = numberingSystem || "latn";
+    if (!digitRegexCache[ns]) {
+        digitRegexCache[ns] = {};
+    }
+    if (!digitRegexCache[ns][append]) {
+        digitRegexCache[ns][append] = new RegExp("".concat(numberingSystems[ns]).concat(append));
+    }
+    return digitRegexCache[ns][append];
+}
 var now = function() {
     return Date.now();
 }, defaultZone = "system", defaultLocale = null, defaultNumberingSystem = null, defaultOutputCalendar = null, twoDigitCutoffYear = 60, throwOnInvalid, defaultWeekSettings = null;
@@ -1852,16 +2092,17 @@ var now = function() {
         {
             key: "twoDigitCutoffYear",
             get: /**
-   * Get the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
+   * Get the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
    * @type {number}
    */ function get() {
                 return twoDigitCutoffYear;
             },
             set: /**
-   * Set the cutoff year after which a string encoding a year as two digits is interpreted to occur in the current century.
+   * Set the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
    * @type {number}
-   * @example Settings.twoDigitCutoffYear = 0 // cut-off year is 0, so all 'yy' are interpreted as current century
-   * @example Settings.twoDigitCutoffYear = 50 // '49' -> 1949; '50' -> 2050
+   * @example Settings.twoDigitCutoffYear = 0 // all 'yy' are interpreted as 20th century
+   * @example Settings.twoDigitCutoffYear = 99 // all 'yy' are interpreted as 21st century
+   * @example Settings.twoDigitCutoffYear = 50 // '49' -> 2049; '50' -> 1950
    * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50
    * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50
    */ function set(cutoffYear) {
@@ -1891,6 +2132,8 @@ var now = function() {
    */ function resetCaches() {
                 Locale.resetCache();
                 IANAZone.resetCache();
+                DateTime.resetCache();
+                resetDigitRegexCache();
             }
         }
     ]);
@@ -2339,7 +2582,13 @@ function normalizeObject(obj, normalizer) {
     }
     return normalized;
 }
-function formatOffset(offset, format) {
+/**
+ * Returns the offset's value as a string
+ * @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 formatOffset(offset, format) {
     var hours = Math.trunc(Math.abs(offset / 60)), minutes = Math.trunc(Math.abs(offset % 60)), sign = offset >= 0 ? "+" : "-";
     switch(format){
         case "short":
@@ -4781,7 +5030,7 @@ function validateStartEnd(start, end) {
         },
         {
             /**
-   * Return whether this Interval engulfs the start and end of the specified Interval.
+   * Returns true if this Interval fully contains the specified Interval, specifically if the intersect (of this Interval and the other Interval) is equal to the other Interval; false otherwise.
    * @param {Interval} other
    * @return {boolean}
    */ key: "engulfs",
@@ -5554,134 +5803,6 @@ function diff(earlier, later, units, opts) {
         return duration;
     }
 }
-var numberingSystems = {
-    arab: "[٠-٩]",
-    arabext: "[۰-۹]",
-    bali: "[᭐-᭙]",
-    beng: "[০-৯]",
-    deva: "[०-९]",
-    fullwide: "[０-９]",
-    gujr: "[૦-૯]",
-    hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
-    khmr: "[០-៩]",
-    knda: "[೦-೯]",
-    laoo: "[໐-໙]",
-    limb: "[᥆-᥏]",
-    mlym: "[൦-൯]",
-    mong: "[᠐-᠙]",
-    mymr: "[၀-၉]",
-    orya: "[୦-୯]",
-    tamldec: "[௦-௯]",
-    telu: "[౦-౯]",
-    thai: "[๐-๙]",
-    tibt: "[༠-༩]",
-    latn: "\\d"
-};
-var numberingSystemsUTF16 = {
-    arab: [
-        1632,
-        1641
-    ],
-    arabext: [
-        1776,
-        1785
-    ],
-    bali: [
-        6992,
-        7001
-    ],
-    beng: [
-        2534,
-        2543
-    ],
-    deva: [
-        2406,
-        2415
-    ],
-    fullwide: [
-        65296,
-        65303
-    ],
-    gujr: [
-        2790,
-        2799
-    ],
-    khmr: [
-        6112,
-        6121
-    ],
-    knda: [
-        3302,
-        3311
-    ],
-    laoo: [
-        3792,
-        3801
-    ],
-    limb: [
-        6470,
-        6479
-    ],
-    mlym: [
-        3430,
-        3439
-    ],
-    mong: [
-        6160,
-        6169
-    ],
-    mymr: [
-        4160,
-        4169
-    ],
-    orya: [
-        2918,
-        2927
-    ],
-    tamldec: [
-        3046,
-        3055
-    ],
-    telu: [
-        3174,
-        3183
-    ],
-    thai: [
-        3664,
-        3673
-    ],
-    tibt: [
-        3872,
-        3881
-    ]
-};
-var hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split("");
-function parseDigits(str) {
-    var value = parseInt(str, 10);
-    if (isNaN(value)) {
-        value = "";
-        for(var i = 0; i < str.length; i++){
-            var code = str.charCodeAt(i);
-            if (str[i].search(numberingSystems.hanidec) !== -1) {
-                value += hanidecChars.indexOf(str[i]);
-            } else {
-                for(var key in numberingSystemsUTF16){
-                    var _numberingSystemsUTF16_key = _sliced_to_array$1(numberingSystemsUTF16[key], 2), min = _numberingSystemsUTF16_key[0], max = _numberingSystemsUTF16_key[1];
-                    if (code >= min && code <= max) {
-                        value += code - min;
-                    }
-                }
-            }
-        }
-        return parseInt(value, 10);
-    } else {
-        return value;
-    }
-}
-function digitRegex(param) {
-    var numberingSystem = param.numberingSystem, append = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
-    return new RegExp("".concat(numberingSystems[numberingSystem || "latn"]).concat(append));
-}
 var MISSING_FTP = "missing Intl.DateTimeFormat.formatToParts support";
 function intUnit(regex) {
     var post = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function(i) {
@@ -6105,38 +6226,74 @@ function expandMacroTokens(tokens, locale) {
 }
 /**
  * @private
- */ function explainFromTokens(locale, input, format) {
-    var tokens = expandMacroTokens(Formatter.parseFormat(format), locale), units = tokens.map(function(t) {
-        return unitForToken(t, locale);
-    }), disqualifyingUnit = units.find(function(t) {
-        return t.invalidReason;
-    });
-    if (disqualifyingUnit) {
-        return {
-            input: input,
-            tokens: tokens,
-            invalidReason: disqualifyingUnit.invalidReason
-        };
-    } else {
-        var _buildRegex = _sliced_to_array$1(buildRegex(units), 2), regexString = _buildRegex[0], handlers = _buildRegex[1], regex = RegExp(regexString, "i"), _match = _sliced_to_array$1(match(input, regex, handlers), 2), rawMatches = _match[0], matches = _match[1], _ref = _sliced_to_array$1(matches ? dateTimeFromMatches(matches) : [
-            null,
-            null,
-            undefined
-        ], 3), result = _ref[0], zone = _ref[1], specificOffset = _ref[2];
-        if (hasOwnProperty(matches, "a") && hasOwnProperty(matches, "H")) {
-            throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
+ */ var TokenParser = /*#__PURE__*/ function() {
+    function TokenParser(locale, format) {
+        _class_call_check$3(this, TokenParser);
+        this.locale = locale;
+        this.format = format;
+        this.tokens = expandMacroTokens(Formatter.parseFormat(format), locale);
+        this.units = this.tokens.map(function(t) {
+            return unitForToken(t, locale);
+        });
+        this.disqualifyingUnit = this.units.find(function(t) {
+            return t.invalidReason;
+        });
+        if (!this.disqualifyingUnit) {
+            var _buildRegex = _sliced_to_array$1(buildRegex(this.units), 2), regexString = _buildRegex[0], handlers = _buildRegex[1];
+            this.regex = RegExp(regexString, "i");
+            this.handlers = handlers;
         }
-        return {
-            input: input,
-            tokens: tokens,
-            regex: regex,
-            rawMatches: rawMatches,
-            matches: matches,
-            result: result,
-            zone: zone,
-            specificOffset: specificOffset
-        };
     }
+    _create_class$2(TokenParser, [
+        {
+            key: "explainFromTokens",
+            value: function explainFromTokens(input) {
+                if (!this.isValid) {
+                    return {
+                        input: input,
+                        tokens: this.tokens,
+                        invalidReason: this.invalidReason
+                    };
+                } else {
+                    var _match = _sliced_to_array$1(match(input, this.regex, this.handlers), 2), rawMatches = _match[0], matches = _match[1], _ref = _sliced_to_array$1(matches ? dateTimeFromMatches(matches) : [
+                        null,
+                        null,
+                        undefined
+                    ], 3), result = _ref[0], zone = _ref[1], specificOffset = _ref[2];
+                    if (hasOwnProperty(matches, "a") && hasOwnProperty(matches, "H")) {
+                        throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
+                    }
+                    return {
+                        input: input,
+                        tokens: this.tokens,
+                        regex: this.regex,
+                        rawMatches: rawMatches,
+                        matches: matches,
+                        result: result,
+                        zone: zone,
+                        specificOffset: specificOffset
+                    };
+                }
+            }
+        },
+        {
+            key: "isValid",
+            get: function get() {
+                return !this.disqualifyingUnit;
+            }
+        },
+        {
+            key: "invalidReason",
+            get: function get() {
+                return this.disqualifyingUnit ? this.disqualifyingUnit.invalidReason : null;
+            }
+        }
+    ]);
+    return TokenParser;
+}();
+function explainFromTokens(locale, input, format) {
+    var parser = new TokenParser(locale, format);
+    return parser.explainFromTokens(input);
 }
 function parseFromTokens(locale, input, format) {
     var _explainFromTokens = explainFromTokens(locale, input, format), result = _explainFromTokens.result, zone = _explainFromTokens.zone, specificOffset = _explainFromTokens.specificOffset, invalidReason = _explainFromTokens.invalidReason;
@@ -6442,11 +6599,43 @@ function normalizeUnitWithLocalWeeks(unit) {
             return normalizeUnit(unit);
     }
 }
+// cache offsets for zones based on the current timestamp when this function is
+// first called. When we are handling a datetime from components like (year,
+// month, day, hour) in a time zone, we need a guess about what the timezone
+// offset is so that we can convert into a UTC timestamp. One way is to find the
+// offset of now in the zone. The actual date may have a different offset (for
+// example, if we handle a date in June while we're in December in a zone that
+// observes DST), but we can check and adjust that.
+//
+// When handling many dates, calculating the offset for now every time is
+// expensive. It's just a guess, so we can cache the offset to use even if we
+// are right on a time change boundary (we'll just correct in the other
+// direction). Using a timestamp from first read is a slight optimization for
+// handling dates close to the current date, since those dates will usually be
+// in the same offset (we could set the timestamp statically, instead). We use a
+// single timestamp for all zones to make things a bit more predictable.
+//
+// This is safe for quickDT (used by local() and utc()) because we don't fill in
+// higher-order units from tsNow (as we do in fromObject, this requires that
+// offset is calculated from tsNow).
+function guessOffsetForZone(zone) {
+    if (!zoneOffsetGuessCache[zone]) {
+        if (zoneOffsetTs === undefined) {
+            zoneOffsetTs = Settings.now();
+        }
+        zoneOffsetGuessCache[zone] = zone.offset(zoneOffsetTs);
+    }
+    return zoneOffsetGuessCache[zone];
+}
 // this is a dumbed down version of fromObject() that runs about 60% faster
 // but doesn't do any validation, makes a bunch of assumptions about what units
 // are present, and so on.
 function quickDT(obj, opts) {
-    var zone = normalizeZone(opts.zone, Settings.defaultZone), loc = Locale.fromObject(opts), tsNow = Settings.now();
+    var zone = normalizeZone(opts.zone, Settings.defaultZone);
+    if (!zone.isValid) {
+        return DateTime.invalid(unsupportedZone(zone));
+    }
+    var loc = Locale.fromObject(opts);
     var ts, o;
     // assume we have the higher-order units
     if (!isUndefined(obj.year)) {
@@ -6476,11 +6665,11 @@ function quickDT(obj, opts) {
         if (invalid) {
             return DateTime.invalid(invalid);
         }
-        var offsetProvis = zone.offset(tsNow);
+        var offsetProvis = guessOffsetForZone(zone);
         var ref;
         ref = _sliced_to_array$1(objToTS(obj, offsetProvis, zone), 2), ts = ref[0], o = ref[1];
     } else {
-        ts = tsNow;
+        ts = Settings.now();
     }
     return new DateTime({
         ts: ts,
@@ -6544,6 +6733,15 @@ function lastOpts(argList) {
         args
     ];
 }
+/**
+ * Timestamp to use for cached zone offset guesses (exposed for test)
+ */ var zoneOffsetTs;
+/**
+ * Cache for zone offset guesses (exposed for test).
+ *
+ * This optimizes quickDT via guessOffsetForZone to avoid repeated calls of
+ * zone.offset().
+ */ var zoneOffsetGuessCache = {};
 /**
  * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
  *
@@ -6581,7 +6779,9 @@ function lastOpts(argList) {
                     config.old.o
                 ], c = ref[0], o = ref[1];
             } else {
-                var ot = zone.offset(this.ts);
+                // If an offset has been passed and we have not been called from
+                // clone(), we can trust it and avoid the offset calculation.
+                var ot = isNumber(config.o) && !config.old ? config.o : zone.offset(this.ts);
                 c = tsToObj(this.ts, ot);
                 invalid = Number.isNaN(c.year) ? new Invalid("invalid input") : null;
                 c = invalid ? null : c;
@@ -7914,6 +8114,7 @@ function lastOpts(argList) {
    * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
    * @param {string} [options.outputCalendar] - the output calendar to set on the resulting DateTime instance
    * @param {string} [options.numberingSystem] - the numbering system to set on the resulting DateTime instance
+   * @param {string} [options.weekSettings] - the week settings to set on the resulting DateTime instance
    * @example DateTime.utc()                                              //~> now
    * @example DateTime.utc(2017)                                          //~> 2017-01-01T00:00:00Z
    * @example DateTime.utc(2017, 3)                                       //~> 2017-03-01T00:00:00Z
@@ -7973,13 +8174,14 @@ function lastOpts(argList) {
    * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
    * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
+   * @param {string} options.weekSettings - the week settings to set on the resulting DateTime instance
    * @return {DateTime}
    */ function fromMillis(milliseconds) {
                 var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
                 if (!isNumber(milliseconds)) {
                     throw new InvalidArgumentError("fromMillis requires a numerical input, but received a ".concat(typeof milliseconds === "undefined" ? "undefined" : _type_of$2(milliseconds), " with value ").concat(milliseconds));
                 } else if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) {
-                    // this isn't perfect because because we can still end up out of range because of additional shifting, but it's a start
+                    // this isn't perfect because we can still end up out of range because of additional shifting, but it's a start
                     return DateTime.invalid("Timestamp out of range");
                 } else {
                     return new DateTime({
@@ -8000,6 +8202,7 @@ function lastOpts(argList) {
    * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
    * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
+   * @param {string} options.weekSettings - the week settings to set on the resulting DateTime instance
    * @return {DateTime}
    */ function fromSeconds(seconds) {
                 var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
@@ -8038,6 +8241,7 @@ function lastOpts(argList) {
    * @param {string} [opts.locale='system\'s locale'] - a locale to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
+   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
    * @example DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25'
    * @example DateTime.fromObject({ year: 1982 }).toISODate() //=> '1982-01-01'
    * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }) //~> today at 10:26:06
@@ -8129,6 +8333,9 @@ function lastOpts(argList) {
                 if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) {
                     return DateTime.invalid("mismatched weekday", "you can't specify both a weekday of ".concat(normalized.weekday, " and a date of ").concat(inst.toISO()));
                 }
+                if (!inst.isValid) {
+                    return DateTime.invalid(inst.invalid);
+                }
                 return inst;
             }
         },
@@ -8143,6 +8350,7 @@ function lastOpts(argList) {
    * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
    * @param {string} [opts.outputCalendar] - the output calendar to set on the resulting DateTime instance
    * @param {string} [opts.numberingSystem] - the numbering system to set on the resulting DateTime instance
+   * @param {string} [opts.weekSettings] - the week settings to set on the resulting DateTime instance
    * @example DateTime.fromISO('2016-05-25T09:08:34.123')
    * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00')
    * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true})
@@ -8166,6 +8374,7 @@ function lastOpts(argList) {
    * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
+   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
    * @example DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT')
    * @example DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600')
    * @example DateTime.fromRFC2822('25 Nov 2016 13:23 Z')
@@ -8188,6 +8397,7 @@ function lastOpts(argList) {
    * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
+   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
    * @example DateTime.fromHTTP('Sun, 06 Nov 1994 08:49:37 GMT')
    * @example DateTime.fromHTTP('Sunday, 06-Nov-94 08:49:37 GMT')
    * @example DateTime.fromHTTP('Sun Nov  6 08:49:37 1994')
@@ -8210,6 +8420,7 @@ function lastOpts(argList) {
    * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
    * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
    * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
+   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @return {DateTime}
    */ function fromFormat(text, fmt) {
@@ -8249,6 +8460,7 @@ function lastOpts(argList) {
    * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
    * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
    * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
+   * @param {string} opts.weekSettings - the week settings to set on the resulting DateTime instance
    * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
    * @example DateTime.fromSQL('2017-05-15')
    * @example DateTime.fromSQL('2017-05-15 09:12:34')
@@ -8328,6 +8540,13 @@ function lastOpts(argList) {
                 }).join("");
             }
         },
+        {
+            key: "resetCache",
+            value: function resetCache() {
+                zoneOffsetTs = undefined;
+                zoneOffsetGuessCache = {};
+            }
+        },
         {
             key: "min",
             value: /**
@@ -8392,6 +8611,61 @@ function lastOpts(argList) {
                 return DateTime.fromFormatExplain(text, fmt, options);
             }
         },
+        {
+            key: "buildFormatParser",
+            value: /**
+   * Build a parser for `fmt` using the given locale. This parser can be passed
+   * to {@link DateTime.fromFormatParser} to a parse a date in this format. This
+   * can be used to optimize cases where many dates need to be parsed in a
+   * specific format.
+   *
+   * @param {String} fmt - the format the string is expected to be in (see
+   * description)
+   * @param {Object} options - options used to set locale and numberingSystem
+   * for parser
+   * @returns {TokenParser} - opaque object to be used
+   */ function buildFormatParser(fmt) {
+                var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+                var _options_locale = options.locale, locale = _options_locale === void 0 ? null : _options_locale, _options_numberingSystem = options.numberingSystem, numberingSystem = _options_numberingSystem === void 0 ? null : _options_numberingSystem, localeToUse = Locale.fromOpts({
+                    locale: locale,
+                    numberingSystem: numberingSystem,
+                    defaultToEN: true
+                });
+                return new TokenParser(localeToUse, fmt);
+            }
+        },
+        {
+            key: "fromFormatParser",
+            value: /**
+   * Create a DateTime from an input string and format parser.
+   *
+   * The format parser must have been created with the same locale as this call.
+   *
+   * @param {String} text - the string to parse
+   * @param {TokenParser} formatParser - parser from {@link DateTime.buildFormatParser}
+   * @param {Object} opts - options taken by fromFormat()
+   * @returns {DateTime}
+   */ function fromFormatParser(text, formatParser) {
+                var opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+                if (isUndefined(text) || isUndefined(formatParser)) {
+                    throw new InvalidArgumentError("fromFormatParser requires an input string and a format parser");
+                }
+                var _opts_locale = opts.locale, locale = _opts_locale === void 0 ? null : _opts_locale, _opts_numberingSystem = opts.numberingSystem, numberingSystem = _opts_numberingSystem === void 0 ? null : _opts_numberingSystem, localeToUse = Locale.fromOpts({
+                    locale: locale,
+                    numberingSystem: numberingSystem,
+                    defaultToEN: true
+                });
+                if (!localeToUse.equals(formatParser.locale)) {
+                    throw new InvalidArgumentError("fromFormatParser called with a locale of ".concat(localeToUse, ", ") + "but the format parser was created for ".concat(formatParser.locale));
+                }
+                var _formatParser_explainFromTokens = formatParser.explainFromTokens(text), result = _formatParser_explainFromTokens.result, zone = _formatParser_explainFromTokens.zone, specificOffset = _formatParser_explainFromTokens.specificOffset, invalidReason = _formatParser_explainFromTokens.invalidReason;
+                if (invalidReason) {
+                    return DateTime.invalid(invalidReason);
+                } else {
+                    return parseDataToDateTime(result, zone, opts, "format ".concat(formatParser.format), text, specificOffset);
+                }
+            }
+        },
         {
             key: "DATE_SHORT",
             get: // FORMAT PRESETS
@@ -8607,7 +8881,7 @@ function lastOpts(argList) {
         throw new InvalidArgumentError("Unknown datetime argument: ".concat(dateTimeish, ", of type ").concat(typeof dateTimeish === "undefined" ? "undefined" : _type_of$2(dateTimeish)));
     }
 }
-var VERSION = "3.4.4";
+var VERSION = "3.5.0";
 luxon.DateTime = DateTime;
 luxon.Duration = Duration;
 luxon.FixedOffsetZone = FixedOffsetZone;