@digipair/skill-keycloak 0.21.15 → 0.22.2

package/index.esm.js

@@ -10218,7 +10218,7 @@ var InvalidZone = /*#__PURE__*/ function(Zone) {
 
 /**
  * @private
- */ function _instanceof$g(left, right) {
+ */ function _instanceof$h(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -10228,7 +10228,7 @@ var InvalidZone = /*#__PURE__*/ function(Zone) {
 function normalizeZone(input, defaultZone) {
     if (isUndefined(input) || input === null) {
         return defaultZone;
-    } else if (_instanceof$g(input, Zone)) {
+    } else if (_instanceof$h(input, Zone)) {
         return input;
     } else if (isString$4(input)) {
         var lowered = input.toLowerCase();
@@ -12202,7 +12202,7 @@ function _define_property$4(obj, key, value) {
     }
     return obj;
 }
-function _instanceof$f(left, right) {
+function _instanceof$g(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -13338,7 +13338,7 @@ var Duration = /*#__PURE__*/ function() {
                 if (!reason) {
                     throw new InvalidArgumentError("need to specify a reason the Duration is invalid");
                 }
-                var invalid = _instanceof$f(reason, Invalid) ? reason : new Invalid(reason, explanation);
+                var invalid = _instanceof$g(reason, Invalid) ? reason : new Invalid(reason, explanation);
                 if (Settings.throwOnInvalid) {
                     throw new InvalidDurationError(invalid);
                 } else {
@@ -13421,7 +13421,7 @@ function _create_class$b(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties$b(Constructor, staticProps);
     return Constructor;
 }
-function _instanceof$e(left, right) {
+function _instanceof$f(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -13973,7 +13973,7 @@ var Interval = /*#__PURE__*/ function() {
                 if (!reason) {
                     throw new InvalidArgumentError("need to specify a reason the Interval is invalid");
                 }
-                var invalid = _instanceof$e(reason, Invalid) ? reason : new Invalid(reason, explanation);
+                var invalid = _instanceof$f(reason, Invalid) ? reason : new Invalid(reason, explanation);
                 if (Settings.throwOnInvalid) {
                     throw new InvalidIntervalError(invalid);
                 } else {
@@ -15368,7 +15368,7 @@ function _define_property$2(obj, key, value) {
     }
     return obj;
 }
-function _instanceof$d(left, right) {
+function _instanceof$e(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -17555,7 +17555,7 @@ var DateTime = /*#__PURE__*/ function() {
                 if (!reason) {
                     throw new InvalidArgumentError("need to specify a reason the DateTime is invalid");
                 }
-                var invalid = _instanceof$d(reason, Invalid) ? reason : new Invalid(reason, explanation);
+                var invalid = _instanceof$e(reason, Invalid) ? reason : new Invalid(reason, explanation);
                 if (Settings.throwOnInvalid) {
                     throw new InvalidDateTimeError(invalid);
                 } else {
@@ -17940,7 +17940,7 @@ function _inherits$2(subClass, superClass) {
     });
     if (superClass) _set_prototype_of$2(subClass, superClass);
 }
-function _instanceof$c(left, right) {
+function _instanceof$d(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -18869,14 +18869,14 @@ function resolveNode(node, pos, side, overlays) {
     var _a;
     // Move up to a node that actually holds the position, if possible
     while(node.from == node.to || (side < 1 ? node.from >= pos : node.from > pos) || (side > -1 ? node.to <= pos : node.to < pos)){
-        var parent = !overlays && _instanceof$c(node, TreeNode) && node.index < 0 ? null : node.parent;
+        var parent = !overlays && _instanceof$d(node, TreeNode) && node.index < 0 ? null : node.parent;
         if (!parent) return node;
         node = parent;
     }
     var mode = overlays ? 0 : IterMode.IgnoreOverlays;
     // Must go up out of overlays when those do not overlap with pos
     if (overlays) for(var scan = node, parent1 = scan.parent; parent1; scan = parent1, parent1 = scan.parent){
-        if (_instanceof$c(scan, TreeNode) && scan.index < 0 && ((_a = parent1.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from) node = parent1;
+        if (_instanceof$d(scan, TreeNode) && scan.index < 0 && ((_a = parent1.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from) node = parent1;
     }
     for(;;){
         var inner = node.enter(pos, side, mode);
@@ -19004,7 +19004,7 @@ var TreeNode = /*#__PURE__*/ function(BaseNode) {
                     for(var _parent__tree = parent._tree, children = _parent__tree.children, positions = _parent__tree.positions, e = dir > 0 ? children.length : -1; i != e; i += dir){
                         var next = children[i], start = positions[i] + parent.from;
                         if (!checkSide(side, pos, start, start + next.length)) continue;
-                        if (_instanceof$c(next, TreeBuffer)) {
+                        if (_instanceof$d(next, TreeBuffer)) {
                             if (mode & IterMode.ExcludeBuffers) continue;
                             var index = next.findChild(0, next.buffer.length, dir, pos - start, side);
                             if (index > -1) return new BufferNode(new BufferContext(parent, next, i, start), null, index);
@@ -19303,7 +19303,7 @@ function iterStack(heads) {
             pick = i;
         }
     }
-    var next = _instanceof$c(picked, TreeNode) && picked.index < 0 ? null : picked.parent;
+    var next = _instanceof$d(picked, TreeNode) && picked.index < 0 ? null : picked.parent;
     var newHeads = heads.slice();
     if (next) newHeads[pick] = next;
     else newHeads.splice(pick, 1);
@@ -19327,7 +19327,7 @@ var StackIterator = /*#__PURE__*/ function() {
 }();
 function stackIterator(tree, pos, side) {
     var inner = tree.resolveInner(pos, side), layers = null;
-    for(var scan = _instanceof$c(inner, TreeNode) ? inner : inner.context.parent; scan; scan = scan.parent){
+    for(var scan = _instanceof$d(inner, TreeNode) ? inner : inner.context.parent; scan; scan = scan.parent){
         if (scan.index < 0) {
             var parent = scan.parent;
             (layers || (layers = [
@@ -19365,7 +19365,7 @@ allows you to move to adjacent nodes.
         @internal
         */ this.index = 0;
         this.bufferNode = null;
-        if (_instanceof$c(node, TreeNode)) {
+        if (_instanceof$d(node, TreeNode)) {
             this.yieldNode(node);
         } else {
             this._tree = node.context.parent;
@@ -19412,7 +19412,7 @@ allows you to move to adjacent nodes.
     */ key: "yield",
             value: function _yield(node) {
                 if (!node) return false;
-                if (_instanceof$c(node, TreeNode)) {
+                if (_instanceof$d(node, TreeNode)) {
                     this.buffer = null;
                     return this.yieldNode(node);
                 }
@@ -19553,7 +19553,7 @@ allows you to move to adjacent nodes.
                 for(; parent; ref2 = parent, index = ref2.index, parent = ref2._parent, ref2){
                     if (index > -1) for(var i1 = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i1 != e; i1 += dir){
                         var child = parent._tree.children[i1];
-                        if (this.mode & IterMode.IncludeAnonymous || _instanceof$c(child, TreeBuffer) || !child.type.isAnonymous || hasChild(child)) return false;
+                        if (this.mode & IterMode.IncludeAnonymous || _instanceof$d(child, TreeBuffer) || !child.type.isAnonymous || hasChild(child)) return false;
                     }
                 }
                 return true;
@@ -19696,7 +19696,7 @@ allows you to move to adjacent nodes.
 }();
 function hasChild(tree) {
     return tree.children.some(function(ch) {
-        return _instanceof$c(ch, TreeBuffer) || !ch.type.isAnonymous || hasChild(ch);
+        return _instanceof$d(ch, TreeBuffer) || !ch.type.isAnonymous || hasChild(ch);
     });
 }
 function buildTree(data) {
@@ -19799,7 +19799,7 @@ function buildTree(data) {
     function makeBalanced(type) {
         return function(children, positions, length) {
             var lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;
-            if (lastI >= 0 && _instanceof$c(last = children[lastI], Tree)) {
+            if (lastI >= 0 && _instanceof$d(last = children[lastI], Tree)) {
                 if (!lastI && last.type == type && last.length == length) return last;
                 if (lookAheadProp = last.prop(NodeProp.lookAhead)) lookAhead = positions[lastI] + last.length + lookAheadProp;
             }
@@ -19921,7 +19921,7 @@ function buildTree(data) {
 }
 var nodeSizeCache = new WeakMap;
 function nodeSize(balanceType, node) {
-    if (!balanceType.isAnonymous || _instanceof$c(node, TreeBuffer) || node.type != balanceType) return 1;
+    if (!balanceType.isAnonymous || _instanceof$d(node, TreeBuffer) || node.type != balanceType) return 1;
     var size = nodeSizeCache.get(node);
     if (size == null) {
         size = 1;
@@ -19929,7 +19929,7 @@ function nodeSize(balanceType, node) {
         try {
             for(var _iterator = node.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var child = _step.value;
-                if (child.type != balanceType || !_instanceof$c(child, Tree)) {
+                if (child.type != balanceType || !_instanceof$d(child, Tree)) {
                     size = 1;
                     break;
                 }
@@ -20128,7 +20128,7 @@ function _inherits$1(subClass, superClass) {
     });
     if (superClass) _set_prototype_of$1(subClass, superClass);
 }
-function _instanceof$b(left, right) {
+function _instanceof$c(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -20327,7 +20327,6 @@ about the parse state.
                 var _a;
                 var depth = action >> 19 /* Action.ReduceDepthShift */ , type = action & 65535 /* Action.ValueMask */ ;
                 var parser = this.p.parser;
-                if (this.reducePos < this.pos - 25 /* Lookahead.Margin */ ) this.setLookAhead(this.pos);
                 var dPrec = parser.dynamicPrecedence(type);
                 if (dPrec) this.score += dPrec;
                 if (depth == 0) {
@@ -21280,7 +21279,7 @@ function cutAt(tree, pos, side) {
     cursor.moveTo(pos);
     for(;;){
         if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos))) for(;;){
-            if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError) return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Lookahead.Margin */ )) : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Lookahead.Margin */ ));
+            if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError) return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Safety.Margin */ )) : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Safety.Margin */ ));
             if (side < 0 ? cursor.prevSibling() : cursor.nextSibling()) break;
             if (!cursor.parent()) return side < 0 ? 0 : tree.length;
         }
@@ -21348,7 +21347,7 @@ var FragmentCursor = /*#__PURE__*/ function() {
                         this.nextStart = start;
                         return null;
                     }
-                    if (_instanceof$b(next, Tree)) {
+                    if (_instanceof$c(next, Tree)) {
                         if (start == pos) {
                             if (start < this.safeFrom) return null;
                             var end = start + next.length;
@@ -21403,7 +21402,7 @@ var TokenCache = /*#__PURE__*/ function() {
                         token.mask = mask;
                         token.context = context;
                     }
-                    if (token.lookAhead > token.end + 25 /* Lookahead.Margin */ ) lookAhead = Math.max(token.lookAhead, lookAhead);
+                    if (token.lookAhead > token.end + 25 /* Safety.Margin */ ) lookAhead = Math.max(token.lookAhead, lookAhead);
                     if (token.value != 0 /* Term.Err */ ) {
                         var startIndex = actionIndex;
                         if (token.extended > -1) actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);
@@ -21651,9 +21650,9 @@ var Parse = /*#__PURE__*/ function() {
                             if (verbose) console.log(base + this.stackID(stack) + " (via reuse of ".concat(parser.getName(cached.type.id), ")"));
                             return true;
                         }
-                        if (!_instanceof$b(cached, Tree) || cached.children.length == 0 || cached.positions[0] > 0) break;
+                        if (!_instanceof$c(cached, Tree) || cached.children.length == 0 || cached.positions[0] > 0) break;
                         var inner = cached.children[0];
-                        if (_instanceof$b(inner, Tree) && cached.positions[0] == 0) cached = inner;
+                        if (_instanceof$c(inner, Tree) && cached.positions[0] == 0) cached = inner;
                         else break;
                     }
                 }
@@ -23227,7 +23226,7 @@ function _define_property$1(obj, key, value) {
     }
     return obj;
 }
-function _instanceof$a(left, right) {
+function _instanceof$b(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -23494,14 +23493,14 @@ function indent(str, spaces) {
         var match = parseIdentifier(input, i1, namePart) || namePart && parseAdditionalSymbol(input, i1) || maybeSpace && parseSpaces(input, i1);
         // match is required
         if (!match) {
-            return i = i1, nextMatch = nextMatch1, tokens = tokens1, {
+            return nextMatch = nextMatch1, i = i1, tokens = tokens1, {
                 v: nextMatch1
             };
         }
         var token = match.token, offset = match.offset;
         i1 += offset;
         if (token === " ") {
-            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
+            return nextMatch = nextMatch1, i = i1, tokens = tokens1, "continue";
         }
         tokens1 = _to_consumable_array$3(tokens1).concat([
             token
@@ -23520,7 +23519,7 @@ function indent(str, spaces) {
         if (contextKeys.some(function(el) {
             return el.startsWith(name);
         })) {
-            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
+            return nextMatch = nextMatch1, i = i1, tokens = tokens1, "continue";
         }
         if (dateTimeIdentifiers.some(function(el) {
             return el === name;
@@ -23539,9 +23538,9 @@ function indent(str, spaces) {
         if (dateTimeIdentifiers.some(function(el) {
             return el.startsWith(name);
         })) {
-            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
+            return nextMatch = nextMatch1, i = i1, tokens = tokens1, "continue";
         }
-        return i = i1, nextMatch = nextMatch1, tokens = tokens1, {
+        return nextMatch = nextMatch1, i = i1, tokens = tokens1, {
             v: nextMatch1
         };
     };
@@ -23704,7 +23703,7 @@ var dateTimeIdentifiers = Object.keys(dateTimeLiterals);
    * @param {any} value
    * @returns {Boolean}
    */ function isAtomic(value) {
-                return !value || _instanceof$a(value, this) || _instanceof$a(value, ValueProducer) || typeof value !== "object";
+                return !value || _instanceof$b(value, this) || _instanceof$b(value, ValueProducer) || typeof value !== "object";
             }
         },
         {
@@ -23723,7 +23722,7 @@ var dateTimeIdentifiers = Object.keys(dateTimeLiterals);
                     if (!context || typeof context !== "object") {
                         return {};
                     }
-                    if (_instanceof$a(context, _this)) {
+                    if (_instanceof$b(context, _this)) {
                         return context.value;
                     }
                     return _object_spread({}, context);
@@ -23842,7 +23841,7 @@ var Variables = /*#__PURE__*/ function() {
                     return undefined;
                 }
                 var val = this.context.get(contextKey);
-                if (_instanceof$a(val, ValueProducer)) {
+                if (_instanceof$b(val, ValueProducer)) {
                     return val.get(this);
                 } else {
                     return val;
@@ -24344,7 +24343,6 @@ var parser = LRParser.deserialize({
     },
     dynamicPrecedences: {
         "31": -1,
-        "67": 1,
         "71": -1,
         "73": -1
     },
@@ -24444,7 +24442,7 @@ function _inherits(subClass, superClass) {
     });
     if (superClass) _set_prototype_of(subClass, superClass);
 }
-function _instanceof$9(left, right) {
+function _instanceof$a(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -24617,10 +24615,10 @@ function getType(e) {
         }
         return "date time";
     }
-    if (_instanceof$9(e, Range$c)) {
+    if (_instanceof$a(e, Range$c)) {
         return "range";
     }
-    if (_instanceof$9(e, FunctionWrapper)) {
+    if (_instanceof$a(e, FunctionWrapper)) {
         return "function";
     }
     return "literal";
@@ -25882,13 +25880,13 @@ function createArgsValidator(argDefinitions) {
  * @param {Range|number} a
  * @param {Range|number} b
  */ function before$1(a, b) {
-    if (_instanceof$9(a, Range$c) && _instanceof$9(b, Range$c)) {
+    if (_instanceof$a(a, Range$c) && _instanceof$a(b, Range$c)) {
         return a.end < b.start || (!a["end included"] || !b["start included"]) && a.end == b.start;
     }
-    if (_instanceof$9(a, Range$c)) {
+    if (_instanceof$a(a, Range$c)) {
         return a.end < b || !a["end included"] && a.end === b;
     }
-    if (_instanceof$9(b, Range$c)) {
+    if (_instanceof$a(b, Range$c)) {
         return b.start > a || !b["start included"] && b.start === a;
     }
     return a < b;
@@ -26554,7 +26552,7 @@ function evalNode(node, input, args) {
             return tag(function(context) {
                 var a = args[0](context);
                 var b = args[3](context);
-                return _instanceof$9(a, b);
+                return _instanceof$a(a, b);
             }, Test("boolean"));
         case "every":
             return tag(function(context) {
@@ -26831,7 +26829,7 @@ function evalNode(node, input, args) {
                     if (typeof result === "function") {
                         result = result(el);
                     }
-                    if (_instanceof$9(result, Range$c)) {
+                    if (_instanceof$a(result, Range$c)) {
                         result = result.includes(el);
                     }
                     if (result === true) {
@@ -26933,7 +26931,7 @@ function compareValue(test, value) {
     if (typeof test === "function") {
         return test(value);
     }
-    if (_instanceof$9(test, Range$c)) {
+    if (_instanceof$a(test, Range$c)) {
         return test.includes(value);
     }
     return equals(test, value);
@@ -27234,10 +27232,10 @@ function Test(type) {
     if (!fn) {
         return null;
     }
-    if (_instanceof$9(fn, FunctionWrapper)) {
+    if (_instanceof$a(fn, FunctionWrapper)) {
         return fn;
     }
-    if (_instanceof$9(fn, Range$c)) {
+    if (_instanceof$a(fn, Range$c)) {
         return new FunctionWrapper(function(value) {
             return fn.includes(value);
         }, [
@@ -27348,6 +27346,7 @@ const applyTemplate = (value, context)=>{
             const path = result.replace(/^EVALUATE:/, '');
             result = evaluate(path, _extends({}, context, {
                 getTime: (time)=>new Date(time).getTime(),
+                fromTime: (time)=>new Date(time).toISOString(),
                 atob: (value)=>atob(value),
                 btoa: (value)=>btoa(value),
                 encodeURIComponent: (value)=>encodeURIComponent(value),
@@ -28738,7 +28737,7 @@ function _create_class$3(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties$3(Constructor, staticProps);
     return Constructor;
 }
-function _instanceof$8(left, right) {
+function _instanceof$9(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -28758,7 +28757,7 @@ var SemVer$f = /*#__PURE__*/ function() {
     function SemVer(version, options) {
         _class_call_check$3(this, SemVer);
         options = parseOptions$2(options);
-        if (_instanceof$8(version, SemVer)) {
+        if (_instanceof$9(version, SemVer)) {
             if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
                 return version;
             } else {
@@ -28832,7 +28831,7 @@ var SemVer$f = /*#__PURE__*/ function() {
             key: "compare",
             value: function compare(other) {
                 debug$2("SemVer.compare", this.version, this.options, other);
-                if (!_instanceof$8(other, SemVer)) {
+                if (!_instanceof$9(other, SemVer)) {
                     if (typeof other === "string" && other === this.version) {
                         return 0;
                     }
@@ -28847,7 +28846,7 @@ var SemVer$f = /*#__PURE__*/ function() {
         {
             key: "compareMain",
             value: function compareMain(other) {
-                if (!_instanceof$8(other, SemVer)) {
+                if (!_instanceof$9(other, SemVer)) {
                     other = new SemVer(other, this.options);
                 }
                 return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
@@ -28856,7 +28855,7 @@ var SemVer$f = /*#__PURE__*/ function() {
         {
             key: "comparePre",
             value: function comparePre(other) {
-                if (!_instanceof$8(other, SemVer)) {
+                if (!_instanceof$9(other, SemVer)) {
                     other = new SemVer(other, this.options);
                 }
                 // NOT having a prerelease is > having one
@@ -28889,14 +28888,14 @@ var SemVer$f = /*#__PURE__*/ function() {
         {
             key: "compareBuild",
             value: function compareBuild(other) {
-                if (!_instanceof$8(other, SemVer)) {
+                if (!_instanceof$9(other, SemVer)) {
                     other = new SemVer(other, this.options);
                 }
                 var i = 0;
                 do {
                     var a = this.build[i];
                     var b = other.build[i];
-                    debug$2("build compare", i, a, b);
+                    debug$2("prerelease compare", i, a, b);
                     if (a === undefined && b === undefined) {
                         return 0;
                     } else if (b === undefined) {
@@ -29044,7 +29043,7 @@ var SemVer$f = /*#__PURE__*/ function() {
 }();
 var semver$4 = SemVer$f;
 
-function _instanceof$7(left, right) {
+function _instanceof$8(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -29054,7 +29053,7 @@ function _instanceof$7(left, right) {
 var SemVer$e = semver$4;
 var parse$6 = function(version, options) {
     var throwErrors = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
-    if (_instanceof$7(version, SemVer$e)) {
+    if (_instanceof$8(version, SemVer$e)) {
         return version;
     }
     try {
@@ -29082,7 +29081,7 @@ var clean$1 = function(version, options) {
 };
 var clean_1 = clean$1;
 
-function _instanceof$6(left, right) {
+function _instanceof$7(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -29097,7 +29096,7 @@ var inc$1 = function(version, release, options, identifier, identifierBase) {
         options = undefined;
     }
     try {
-        return new SemVer$d(_instanceof$6(version, SemVer$d) ? version.version : version, options).inc(release, identifier, identifierBase).version;
+        return new SemVer$d(_instanceof$7(version, SemVer$d) ? version.version : version, options).inc(release, identifier, identifierBase).version;
     } catch (er) {
         return null;
     }
@@ -29302,7 +29301,7 @@ var cmp$2 = function(a, op, b, loose) {
 };
 var cmp_1 = cmp$2;
 
-function _instanceof$5(left, right) {
+function _instanceof$6(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -29313,7 +29312,7 @@ var SemVer$7 = semver$4;
 var parse$1 = parse_1;
 var _require$4 = re$4.exports, re$2 = _require$4.safeRe, t$2 = _require$4.t;
 var coerce$1 = function(version, options) {
-    if (_instanceof$5(version, SemVer$7)) {
+    if (_instanceof$6(version, SemVer$7)) {
         return version;
     }
     if (typeof version === "number") {
@@ -29359,6 +29358,511 @@ var coerce$1 = function(version, options) {
 };
 var coerce_1 = coerce$1;
 
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var iterator = function(Yallist) {
+    Yallist.prototype[Symbol.iterator] = function() {
+        var walker;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    walker = this.head;
+                    _state.label = 1;
+                case 1:
+                    if (!walker) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        walker.value
+                    ];
+                case 2:
+                    _state.sent();
+                    _state.label = 3;
+                case 3:
+                    walker = walker.next;
+                    return [
+                        3,
+                        1
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    };
+};
+
+function _instanceof$5(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var yallist = Yallist$1;
+Yallist$1.Node = Node;
+Yallist$1.create = Yallist$1;
+function Yallist$1(list) {
+    var self = this;
+    if (!_instanceof$5(self, Yallist$1)) {
+        self = new Yallist$1();
+    }
+    self.tail = null;
+    self.head = null;
+    self.length = 0;
+    if (list && typeof list.forEach === "function") {
+        list.forEach(function(item) {
+            self.push(item);
+        });
+    } else if (arguments.length > 0) {
+        for(var i = 0, l = arguments.length; i < l; i++){
+            self.push(arguments[i]);
+        }
+    }
+    return self;
+}
+Yallist$1.prototype.removeNode = function(node) {
+    if (node.list !== this) {
+        throw new Error("removing node which does not belong to this list");
+    }
+    var next = node.next;
+    var prev = node.prev;
+    if (next) {
+        next.prev = prev;
+    }
+    if (prev) {
+        prev.next = next;
+    }
+    if (node === this.head) {
+        this.head = next;
+    }
+    if (node === this.tail) {
+        this.tail = prev;
+    }
+    node.list.length--;
+    node.next = null;
+    node.prev = null;
+    node.list = null;
+    return next;
+};
+Yallist$1.prototype.unshiftNode = function(node) {
+    if (node === this.head) {
+        return;
+    }
+    if (node.list) {
+        node.list.removeNode(node);
+    }
+    var head = this.head;
+    node.list = this;
+    node.next = head;
+    if (head) {
+        head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+        this.tail = node;
+    }
+    this.length++;
+};
+Yallist$1.prototype.pushNode = function(node) {
+    if (node === this.tail) {
+        return;
+    }
+    if (node.list) {
+        node.list.removeNode(node);
+    }
+    var tail = this.tail;
+    node.list = this;
+    node.prev = tail;
+    if (tail) {
+        tail.next = node;
+    }
+    this.tail = node;
+    if (!this.head) {
+        this.head = node;
+    }
+    this.length++;
+};
+Yallist$1.prototype.push = function() {
+    for(var i = 0, l = arguments.length; i < l; i++){
+        push(this, arguments[i]);
+    }
+    return this.length;
+};
+Yallist$1.prototype.unshift = function() {
+    for(var i = 0, l = arguments.length; i < l; i++){
+        unshift(this, arguments[i]);
+    }
+    return this.length;
+};
+Yallist$1.prototype.pop = function() {
+    if (!this.tail) {
+        return undefined;
+    }
+    var res = this.tail.value;
+    this.tail = this.tail.prev;
+    if (this.tail) {
+        this.tail.next = null;
+    } else {
+        this.head = null;
+    }
+    this.length--;
+    return res;
+};
+Yallist$1.prototype.shift = function() {
+    if (!this.head) {
+        return undefined;
+    }
+    var res = this.head.value;
+    this.head = this.head.next;
+    if (this.head) {
+        this.head.prev = null;
+    } else {
+        this.tail = null;
+    }
+    this.length--;
+    return res;
+};
+Yallist$1.prototype.forEach = function(fn, thisp) {
+    thisp = thisp || this;
+    for(var walker = this.head, i = 0; walker !== null; i++){
+        fn.call(thisp, walker.value, i, this);
+        walker = walker.next;
+    }
+};
+Yallist$1.prototype.forEachReverse = function(fn, thisp) {
+    thisp = thisp || this;
+    for(var walker = this.tail, i = this.length - 1; walker !== null; i--){
+        fn.call(thisp, walker.value, i, this);
+        walker = walker.prev;
+    }
+};
+Yallist$1.prototype.get = function(n) {
+    for(var i = 0, walker = this.head; walker !== null && i < n; i++){
+        // abort out of the list early if we hit a cycle
+        walker = walker.next;
+    }
+    if (i === n && walker !== null) {
+        return walker.value;
+    }
+};
+Yallist$1.prototype.getReverse = function(n) {
+    for(var i = 0, walker = this.tail; walker !== null && i < n; i++){
+        // abort out of the list early if we hit a cycle
+        walker = walker.prev;
+    }
+    if (i === n && walker !== null) {
+        return walker.value;
+    }
+};
+Yallist$1.prototype.map = function(fn, thisp) {
+    thisp = thisp || this;
+    var res = new Yallist$1();
+    for(var walker = this.head; walker !== null;){
+        res.push(fn.call(thisp, walker.value, this));
+        walker = walker.next;
+    }
+    return res;
+};
+Yallist$1.prototype.mapReverse = function(fn, thisp) {
+    thisp = thisp || this;
+    var res = new Yallist$1();
+    for(var walker = this.tail; walker !== null;){
+        res.push(fn.call(thisp, walker.value, this));
+        walker = walker.prev;
+    }
+    return res;
+};
+Yallist$1.prototype.reduce = function(fn, initial) {
+    var acc;
+    var walker = this.head;
+    if (arguments.length > 1) {
+        acc = initial;
+    } else if (this.head) {
+        walker = this.head.next;
+        acc = this.head.value;
+    } else {
+        throw new TypeError("Reduce of empty list with no initial value");
+    }
+    for(var i = 0; walker !== null; i++){
+        acc = fn(acc, walker.value, i);
+        walker = walker.next;
+    }
+    return acc;
+};
+Yallist$1.prototype.reduceReverse = function(fn, initial) {
+    var acc;
+    var walker = this.tail;
+    if (arguments.length > 1) {
+        acc = initial;
+    } else if (this.tail) {
+        walker = this.tail.prev;
+        acc = this.tail.value;
+    } else {
+        throw new TypeError("Reduce of empty list with no initial value");
+    }
+    for(var i = this.length - 1; walker !== null; i--){
+        acc = fn(acc, walker.value, i);
+        walker = walker.prev;
+    }
+    return acc;
+};
+Yallist$1.prototype.toArray = function() {
+    var arr = new Array(this.length);
+    for(var i = 0, walker = this.head; walker !== null; i++){
+        arr[i] = walker.value;
+        walker = walker.next;
+    }
+    return arr;
+};
+Yallist$1.prototype.toArrayReverse = function() {
+    var arr = new Array(this.length);
+    for(var i = 0, walker = this.tail; walker !== null; i++){
+        arr[i] = walker.value;
+        walker = walker.prev;
+    }
+    return arr;
+};
+Yallist$1.prototype.slice = function(from, to) {
+    to = to || this.length;
+    if (to < 0) {
+        to += this.length;
+    }
+    from = from || 0;
+    if (from < 0) {
+        from += this.length;
+    }
+    var ret = new Yallist$1();
+    if (to < from || to < 0) {
+        return ret;
+    }
+    if (from < 0) {
+        from = 0;
+    }
+    if (to > this.length) {
+        to = this.length;
+    }
+    for(var i = 0, walker = this.head; walker !== null && i < from; i++){
+        walker = walker.next;
+    }
+    for(; walker !== null && i < to; i++, walker = walker.next){
+        ret.push(walker.value);
+    }
+    return ret;
+};
+Yallist$1.prototype.sliceReverse = function(from, to) {
+    to = to || this.length;
+    if (to < 0) {
+        to += this.length;
+    }
+    from = from || 0;
+    if (from < 0) {
+        from += this.length;
+    }
+    var ret = new Yallist$1();
+    if (to < from || to < 0) {
+        return ret;
+    }
+    if (from < 0) {
+        from = 0;
+    }
+    if (to > this.length) {
+        to = this.length;
+    }
+    for(var i = this.length, walker = this.tail; walker !== null && i > to; i--){
+        walker = walker.prev;
+    }
+    for(; walker !== null && i > from; i--, walker = walker.prev){
+        ret.push(walker.value);
+    }
+    return ret;
+};
+Yallist$1.prototype.splice = function(start, deleteCount) {
+    for(var _len = arguments.length, nodes = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+        nodes[_key - 2] = arguments[_key];
+    }
+    if (start > this.length) {
+        start = this.length - 1;
+    }
+    if (start < 0) {
+        start = this.length + start;
+    }
+    for(var i = 0, walker = this.head; walker !== null && i < start; i++){
+        walker = walker.next;
+    }
+    var ret = [];
+    for(var i = 0; walker && i < deleteCount; i++){
+        ret.push(walker.value);
+        walker = this.removeNode(walker);
+    }
+    if (walker === null) {
+        walker = this.tail;
+    }
+    if (walker !== this.head && walker !== this.tail) {
+        walker = walker.prev;
+    }
+    for(var i = 0; i < nodes.length; i++){
+        walker = insert(this, walker, nodes[i]);
+    }
+    return ret;
+};
+Yallist$1.prototype.reverse = function() {
+    var head = this.head;
+    var tail = this.tail;
+    for(var walker = head; walker !== null; walker = walker.prev){
+        var p = walker.prev;
+        walker.prev = walker.next;
+        walker.next = p;
+    }
+    this.head = tail;
+    this.tail = head;
+    return this;
+};
+function insert(self, node, value) {
+    var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
+    if (inserted.next === null) {
+        self.tail = inserted;
+    }
+    if (inserted.prev === null) {
+        self.head = inserted;
+    }
+    self.length++;
+    return inserted;
+}
+function push(self, item) {
+    self.tail = new Node(item, self.tail, null, self);
+    if (!self.head) {
+        self.head = self.tail;
+    }
+    self.length++;
+}
+function unshift(self, item) {
+    self.head = new Node(item, null, self.head, self);
+    if (!self.tail) {
+        self.tail = self.head;
+    }
+    self.length++;
+}
+function Node(value, prev, next, list) {
+    if (!_instanceof$5(this, Node)) {
+        return new Node(value, prev, next, list);
+    }
+    this.list = list;
+    this.value = value;
+    if (prev) {
+        prev.next = this;
+        this.prev = prev;
+    } else {
+        this.prev = null;
+    }
+    if (next) {
+        next.prev = this;
+        this.next = next;
+    } else {
+        this.next = null;
+    }
+}
+try {
+    // add if support for Symbol.iterator is present
+    iterator(Yallist$1);
+} catch (er) {}
+
 function _class_call_check$2(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -29378,53 +29882,361 @@ function _create_class$2(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties$2(Constructor, staticProps);
     return Constructor;
 }
+// A linked list to keep track of recently-used-ness
+var Yallist = yallist;
+var MAX = Symbol("max");
+var LENGTH = Symbol("length");
+var LENGTH_CALCULATOR = Symbol("lengthCalculator");
+var ALLOW_STALE = Symbol("allowStale");
+var MAX_AGE = Symbol("maxAge");
+var DISPOSE = Symbol("dispose");
+var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+var LRU_LIST = Symbol("lruList");
+var CACHE = Symbol("cache");
+var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+var naiveLength = function() {
+    return 1;
+};
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest.  the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node.  This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
 var LRUCache = /*#__PURE__*/ function() {
-    function LRUCache() {
+    function LRUCache(options) {
         _class_call_check$2(this, LRUCache);
-        this.max = 1000;
-        this.map = new Map();
+        if (typeof options === "number") options = {
+            max: options
+        };
+        if (!options) options = {};
+        if (options.max && (typeof options.max !== "number" || options.max < 0)) throw new TypeError("max must be a non-negative number");
+        // Kind of weird to have a default max of Infinity, but oh well.
+        this[MAX] = options.max || Infinity;
+        var lc = options.length || naiveLength;
+        this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
+        this[ALLOW_STALE] = options.stale || false;
+        if (options.maxAge && typeof options.maxAge !== "number") throw new TypeError("maxAge must be a number");
+        this[MAX_AGE] = options.maxAge || 0;
+        this[DISPOSE] = options.dispose;
+        this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+        this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+        this.reset();
     }
     _create_class$2(LRUCache, [
         {
-            key: "get",
-            value: function get(key) {
-                var value = this.map.get(key);
-                if (value === undefined) {
-                    return undefined;
-                } else {
-                    // Remove the key from the map and add it to the end
-                    this.map.delete(key);
-                    this.map.set(key, value);
-                    return value;
+            key: "max",
+            get: function get() {
+                return this[MAX];
+            },
+            set: // resize the cache when the max changes.
+            function set(mL) {
+                if (typeof mL !== "number" || mL < 0) throw new TypeError("max must be a non-negative number");
+                this[MAX] = mL || Infinity;
+                trim(this);
+            }
+        },
+        {
+            key: "allowStale",
+            get: function get() {
+                return this[ALLOW_STALE];
+            },
+            set: function set(allowStale) {
+                this[ALLOW_STALE] = !!allowStale;
+            }
+        },
+        {
+            key: "maxAge",
+            get: function get() {
+                return this[MAX_AGE];
+            },
+            set: function set(mA) {
+                if (typeof mA !== "number") throw new TypeError("maxAge must be a non-negative number");
+                this[MAX_AGE] = mA;
+                trim(this);
+            }
+        },
+        {
+            key: "lengthCalculator",
+            get: function get() {
+                return this[LENGTH_CALCULATOR];
+            },
+            set: // resize the cache when the lengthCalculator changes.
+            function set(lC) {
+                var _this = this;
+                if (typeof lC !== "function") lC = naiveLength;
+                if (lC !== this[LENGTH_CALCULATOR]) {
+                    this[LENGTH_CALCULATOR] = lC;
+                    this[LENGTH] = 0;
+                    this[LRU_LIST].forEach(function(hit) {
+                        hit.length = _this[LENGTH_CALCULATOR](hit.value, hit.key);
+                        _this[LENGTH] += hit.length;
+                    });
+                }
+                trim(this);
+            }
+        },
+        {
+            key: "length",
+            get: function get() {
+                return this[LENGTH];
+            }
+        },
+        {
+            key: "itemCount",
+            get: function get() {
+                return this[LRU_LIST].length;
+            }
+        },
+        {
+            key: "rforEach",
+            value: function rforEach(fn, thisp) {
+                thisp = thisp || this;
+                for(var walker = this[LRU_LIST].tail; walker !== null;){
+                    var prev = walker.prev;
+                    forEachStep(this, fn, walker, thisp);
+                    walker = prev;
+                }
+            }
+        },
+        {
+            key: "forEach",
+            value: function forEach(fn, thisp) {
+                thisp = thisp || this;
+                for(var walker = this[LRU_LIST].head; walker !== null;){
+                    var next = walker.next;
+                    forEachStep(this, fn, walker, thisp);
+                    walker = next;
+                }
+            }
+        },
+        {
+            key: "keys",
+            value: function keys() {
+                return this[LRU_LIST].toArray().map(function(k) {
+                    return k.key;
+                });
+            }
+        },
+        {
+            key: "values",
+            value: function values() {
+                return this[LRU_LIST].toArray().map(function(k) {
+                    return k.value;
+                });
+            }
+        },
+        {
+            key: "reset",
+            value: function reset() {
+                var _this = this;
+                if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+                    this[LRU_LIST].forEach(function(hit) {
+                        return _this[DISPOSE](hit.key, hit.value);
+                    });
                 }
+                this[CACHE] = new Map() // hash of items by key
+                ;
+                this[LRU_LIST] = new Yallist() // list of items in order of use recency
+                ;
+                this[LENGTH] = 0 // length of items in the list
+                ;
+            }
+        },
+        {
+            key: "dump",
+            value: function dump() {
+                var _this = this;
+                return this[LRU_LIST].map(function(hit) {
+                    return isStale(_this, hit) ? false : {
+                        k: hit.key,
+                        v: hit.value,
+                        e: hit.now + (hit.maxAge || 0)
+                    };
+                }).toArray().filter(function(h) {
+                    return h;
+                });
             }
         },
         {
-            key: "delete",
-            value: function _delete(key) {
-                return this.map.delete(key);
+            key: "dumpLru",
+            value: function dumpLru() {
+                return this[LRU_LIST];
             }
         },
         {
             key: "set",
-            value: function set(key, value) {
-                var deleted = this.delete(key);
-                if (!deleted && value !== undefined) {
-                    // If cache is full, delete the least recently used item
-                    if (this.map.size >= this.max) {
-                        var firstKey = this.map.keys().next().value;
-                        this.delete(firstKey);
+            value: function set(key, value, maxAge) {
+                maxAge = maxAge || this[MAX_AGE];
+                if (maxAge && typeof maxAge !== "number") throw new TypeError("maxAge must be a number");
+                var now = maxAge ? Date.now() : 0;
+                var len = this[LENGTH_CALCULATOR](value, key);
+                if (this[CACHE].has(key)) {
+                    if (len > this[MAX]) {
+                        del(this, this[CACHE].get(key));
+                        return false;
+                    }
+                    var node = this[CACHE].get(key);
+                    var item = node.value;
+                    // dispose of the old one before overwriting
+                    // split out into 2 ifs for better coverage tracking
+                    if (this[DISPOSE]) {
+                        if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
                     }
-                    this.map.set(key, value);
+                    item.now = now;
+                    item.maxAge = maxAge;
+                    item.value = value;
+                    this[LENGTH] += len - item.length;
+                    item.length = len;
+                    this.get(key);
+                    trim(this);
+                    return true;
                 }
-                return this;
+                var hit = new Entry(key, value, len, now, maxAge);
+                // oversized objects fall out of cache automatically.
+                if (hit.length > this[MAX]) {
+                    if (this[DISPOSE]) this[DISPOSE](key, value);
+                    return false;
+                }
+                this[LENGTH] += hit.length;
+                this[LRU_LIST].unshift(hit);
+                this[CACHE].set(key, this[LRU_LIST].head);
+                trim(this);
+                return true;
+            }
+        },
+        {
+            key: "has",
+            value: function has(key) {
+                if (!this[CACHE].has(key)) return false;
+                var hit = this[CACHE].get(key).value;
+                return !isStale(this, hit);
+            }
+        },
+        {
+            key: "get",
+            value: function get1(key) {
+                return get(this, key, true);
+            }
+        },
+        {
+            key: "peek",
+            value: function peek(key) {
+                return get(this, key, false);
+            }
+        },
+        {
+            key: "pop",
+            value: function pop() {
+                var node = this[LRU_LIST].tail;
+                if (!node) return null;
+                del(this, node);
+                return node.value;
+            }
+        },
+        {
+            key: "del",
+            value: function del1(key) {
+                del(this, this[CACHE].get(key));
+            }
+        },
+        {
+            key: "load",
+            value: function load(arr) {
+                // reset the cache
+                this.reset();
+                var now = Date.now();
+                // A previous serialized cache has the most recent items first
+                for(var l = arr.length - 1; l >= 0; l--){
+                    var hit = arr[l];
+                    var expiresAt = hit.e || 0;
+                    if (expiresAt === 0) // the item was created without expiration in a non aged cache
+                    this.set(hit.k, hit.v);
+                    else {
+                        var maxAge = expiresAt - now;
+                        // dont add already expired items
+                        if (maxAge > 0) {
+                            this.set(hit.k, hit.v, maxAge);
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "prune",
+            value: function prune() {
+                var _this = this;
+                this[CACHE].forEach(function(value, key) {
+                    return get(_this, key, false);
+                });
             }
         }
     ]);
     return LRUCache;
 }();
-var lrucache = LRUCache;
+var get = function(self, key, doUse) {
+    var node = self[CACHE].get(key);
+    if (node) {
+        var hit = node.value;
+        if (isStale(self, hit)) {
+            del(self, node);
+            if (!self[ALLOW_STALE]) return undefined;
+        } else {
+            if (doUse) {
+                if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
+                self[LRU_LIST].unshiftNode(node);
+            }
+        }
+        return hit.value;
+    }
+};
+var isStale = function(self, hit) {
+    if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
+    var diff = Date.now() - hit.now;
+    return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
+};
+var trim = function(self) {
+    if (self[LENGTH] > self[MAX]) {
+        for(var walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;){
+            // We know that we're about to delete this one, and also
+            // what the next least recently used key will be, so just
+            // go ahead and set it now.
+            var prev = walker.prev;
+            del(self, walker);
+            walker = prev;
+        }
+    }
+};
+var del = function(self, node) {
+    if (node) {
+        var hit = node.value;
+        if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
+        self[LENGTH] -= hit.length;
+        self[CACHE].delete(hit.key);
+        self[LRU_LIST].removeNode(node);
+    }
+};
+var Entry = function Entry(key, value, length, now, maxAge) {
+    _class_call_check$2(this, Entry);
+    this.key = key;
+    this.value = value;
+    this.length = length;
+    this.now = now;
+    this.maxAge = maxAge || 0;
+};
+var forEachStep = function(self, fn, node, thisp) {
+    var hit = node.value;
+    if (isStale(self, hit)) {
+        del(self, node);
+        if (!self[ALLOW_STALE]) hit = undefined;
+    }
+    if (hit) fn.call(thisp, hit.value, hit.key, self);
+};
+var lruCache = LRUCache;
 
+// hoisted class for cyclic dependency
 function _array_like_to_array$1(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -29476,8 +30288,6 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
 }
-var SPACE_CHARACTERS = /\s+/g;
-// hoisted class for cyclic dependency
 var Range$b = /*#__PURE__*/ function() {
     function Range(range, options) {
         var _this = this;
@@ -29498,7 +30308,7 @@ var Range$b = /*#__PURE__*/ function() {
                     range
                 ]
             ];
-            this.formatted = undefined;
+            this.format();
             return this;
         }
         this.options = options;
@@ -29507,7 +30317,7 @@ var Range$b = /*#__PURE__*/ function() {
         // First reduce all whitespace as much as possible so we do not have to rely
         // on potentially slow regexes like \s*. This is then stored and used for
         // future error messages as well.
-        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.raw = range.trim().split(/\s+/).join(" ");
         // First, split on ||
         this.set = this.raw.split("||")// map the range to a 2d array of comparators
         .map(function(r) {
@@ -29561,33 +30371,15 @@ var Range$b = /*#__PURE__*/ function() {
                 }
             }
         }
-        this.formatted = undefined;
+        this.format();
     }
     _create_class$1(Range, [
-        {
-            key: "range",
-            get: function get() {
-                if (this.formatted === undefined) {
-                    this.formatted = "";
-                    for(var i = 0; i < this.set.length; i++){
-                        if (i > 0) {
-                            this.formatted += "||";
-                        }
-                        var comps = this.set[i];
-                        for(var k = 0; k < comps.length; k++){
-                            if (k > 0) {
-                                this.formatted += " ";
-                            }
-                            this.formatted += comps[k].toString().trim();
-                        }
-                    }
-                }
-                return this.formatted;
-            }
-        },
         {
             key: "format",
             value: function format() {
+                this.range = this.set.map(function(comps) {
+                    return comps.join(" ").trim();
+                }).join("||").trim();
                 return this.range;
             }
         },
@@ -29722,8 +30514,10 @@ var Range$b = /*#__PURE__*/ function() {
     return Range;
 }();
 var range = Range$b;
-var LRU = lrucache;
-var cache = new LRU();
+var LRU = lruCache;
+var cache = new LRU({
+    max: 1000
+});
 var parseOptions$1 = parseOptions_1;
 var Comparator$4 = comparator;
 var debug$1 = debug_1;
@@ -29947,9 +30741,8 @@ var replaceGTE0 = function(comp, options) {
 // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
 // 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
 // 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-// TODO build?
 var hyphenReplace = function(incPr) {
-    return function($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) {
+    return function($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
         if (isX(fM)) {
             from = "";
         } else if (isX(fm)) {