@extra-memoize/memory-cache 0.2.1 → 0.2.2

package/dist/es2015/index.mjs

@@ -825,9 +825,9 @@ url$4.isAbsoluteURL = isAbsoluteURL$4;
 } (es2018$f));
 
 chunkByAsync$5.chunkByAsync = void 0;
-const types_1$10 = es2018$f;
+const types_1$$ = es2018$f;
 function chunkByAsync$4(iterable, predicate) {
-    if ((0, types_1$10.isAsyncIterable)(iterable)) {
+    if ((0, types_1$$.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -917,12 +917,12 @@ chunk$4.chunk = void 0;
 var concatAsync$5 = {};
 
 concatAsync$5.concatAsync = void 0;
-const types_1$$ = es2018$f;
+const types_1$_ = es2018$f;
 const go_1$x = es2018$g;
 function concatAsync$4(iterable, ...otherIterables) {
     return (0, go_1$x.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if ((0, types_1$$.isAsyncIterable)(iter)) {
+            if ((0, types_1$_.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -1074,9 +1074,9 @@ dropRight$4.dropRight = void 0;
 var dropUntilAsync$5 = {};
 
 dropUntilAsync$5.dropUntilAsync = void 0;
-const types_1$_ = es2018$f;
+const types_1$Z = es2018$f;
 function dropUntilAsync$4(iterable, predicate) {
-    if ((0, types_1$_.isAsyncIterable)(iterable)) {
+    if ((0, types_1$Z.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -1199,9 +1199,9 @@ drop$4.drop = void 0;
 var filterAsync$5 = {};
 
 filterAsync$5.filterAsync = void 0;
-const types_1$Z = es2018$f;
+const types_1$Y = es2018$f;
 function filterAsync$4(iterable, predicate) {
-    if ((0, types_1$Z.isAsyncIterable)(iterable)) {
+    if ((0, types_1$Y.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -1246,9 +1246,9 @@ var flattenDeepAsync$4 = {};
 var flattenByAsync$5 = {};
 
 flattenByAsync$5.flattenByAsync = void 0;
-const types_1$Y = es2018$f;
+const types_1$X = es2018$f;
 function flattenByAsync$4(iterable, predicate) {
-    if ((0, types_1$Y.isAsyncIterable)(iterable)) {
+    if ((0, types_1$X.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -1281,7 +1281,7 @@ function flattenByAsync$4(iterable, predicate) {
 }
 flattenByAsync$5.flattenByAsync = flattenByAsync$4;
 function isFiniteIterable$5(val) {
-    return (0, types_1$Y.isIterable)(val) && (0, types_1$Y.isntChar)(val);
+    return (0, types_1$X.isIterable)(val) && (0, types_1$X.isntChar)(val);
 }
 
 var hasRequiredFlattenDeepAsync;
@@ -1320,7 +1320,7 @@ flattenAsync$4.flattenAsync = void 0;
 var flattenBy$5 = {};
 
 flattenBy$5.flattenBy = void 0;
-const types_1$X = es2018$f;
+const types_1$W = es2018$f;
 function flattenBy$4(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1336,7 +1336,7 @@ function flattenBy$4(iterable, predicate) {
 }
 flattenBy$5.flattenBy = flattenBy$4;
 function isFiniteIterable$4(val) {
-    return (0, types_1$X.isIterable)(val) && (0, types_1$X.isntChar)(val);
+    return (0, types_1$W.isIterable)(val) && (0, types_1$W.isntChar)(val);
 }
 
 var flattenDeep$4 = {};
@@ -1379,9 +1379,9 @@ flatten$4.flatten = void 0;
 var mapAsync$5 = {};
 
 mapAsync$5.mapAsync = void 0;
-const types_1$W = es2018$f;
+const types_1$V = es2018$f;
 function mapAsync$4(iterable, fn) {
-    if ((0, types_1$W.isAsyncIterable)(iterable)) {
+    if ((0, types_1$V.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -1585,9 +1585,9 @@ splitAsync$5.splitAsync = splitAsync$4;
 var splitByAsync$5 = {};
 
 splitByAsync$5.splitByAsync = void 0;
-const types_1$V = es2018$f;
+const types_1$U = es2018$f;
 function splitByAsync$4(iterable, predicate) {
-    if ((0, types_1$V.isAsyncIterable)(iterable)) {
+    if ((0, types_1$U.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -1772,9 +1772,9 @@ takeRight$4.takeRight = void 0;
 var takeUntilAsync$5 = {};
 
 takeUntilAsync$5.takeUntilAsync = void 0;
-const types_1$U = es2018$f;
+const types_1$T = es2018$f;
 function takeUntilAsync$4(iterable, predicate) {
-    if ((0, types_1$U.isAsyncIterable)(iterable)) {
+    if ((0, types_1$T.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -1847,9 +1847,9 @@ take$6.take = void 0;
 var tapAsync$5 = {};
 
 tapAsync$5.tapAsync = void 0;
-const types_1$T = es2018$f;
+const types_1$S = es2018$f;
 function tapAsync$4(iterable, fn) {
-    if ((0, types_1$T.isAsyncIterable)(iterable)) {
+    if ((0, types_1$S.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -1930,9 +1930,9 @@ uniqAsync$5.uniqAsync = uniqAsync$4;
 var uniqByAsync$5 = {};
 
 uniqByAsync$5.uniqByAsync = void 0;
-const types_1$S = es2018$f;
+const types_1$R = es2018$f;
 function uniqByAsync$4(iterable, fn) {
-    if ((0, types_1$S.isAsyncIterable)(iterable)) {
+    if ((0, types_1$R.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -1999,7 +1999,7 @@ uniq$5.uniq = uniq$4;
 var zipAsync$5 = {};
 
 zipAsync$5.zipAsync = void 0;
-const types_1$R = es2018$f;
+const types_1$Q = es2018$f;
 var Kind$2;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2013,7 +2013,7 @@ async function* zipWithSize$5(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if ((0, types_1$R.isAsyncIterable)(iterable)) {
+        if ((0, types_1$Q.isAsyncIterable)(iterable)) {
             return [Kind$2.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -2170,9 +2170,9 @@ consume$5.consume = consume$4;
 var eachAsync$5 = {};
 
 eachAsync$5.eachAsync = void 0;
-const types_1$Q = es2018$f;
+const types_1$P = es2018$f;
 function eachAsync$4(iterable, fn) {
-    if ((0, types_1$Q.isAsyncIterable)(iterable)) {
+    if ((0, types_1$P.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -2210,9 +2210,9 @@ each$5.each = each$4;
 var everyAsync$5 = {};
 
 everyAsync$5.everyAsync = void 0;
-const types_1$P = es2018$f;
+const types_1$O = es2018$f;
 function everyAsync$4(iterable, predicate) {
-    if ((0, types_1$P.isAsyncIterable)(iterable)) {
+    if ((0, types_1$O.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -2256,9 +2256,9 @@ every$7.every = every$6;
 var findAsync$5 = {};
 
 findAsync$5.findAsync = void 0;
-const types_1$O = es2018$f;
+const types_1$N = es2018$f;
 function findAsync$4(iterable, predicate) {
-    if ((0, types_1$O.isAsyncIterable)(iterable)) {
+    if ((0, types_1$N.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -2380,9 +2380,9 @@ match$5.match = match$4;
 var reduceAsync$5 = {};
 
 reduceAsync$5.reduceAsync = void 0;
-const types_1$N = es2018$f;
+const types_1$M = es2018$f;
 function reduceAsync$4(iterable, fn, initialValue) {
-    if ((0, types_1$N.isUndefined)(initialValue)) {
+    if ((0, types_1$M.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$2(iterable, fn);
     }
     else {
@@ -2391,7 +2391,7 @@ function reduceAsync$4(iterable, fn, initialValue) {
 }
 reduceAsync$5.reduceAsync = reduceAsync$4;
 function reduceAsyncWithInitialValue$2(iterable, fn, initialValue) {
-    if ((0, types_1$N.isAsyncIterable)(iterable)) {
+    if ((0, types_1$M.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2413,7 +2413,7 @@ function reduceAsyncWithInitialValue$2(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue$2(iterable, fn) {
-    if ((0, types_1$N.isAsyncIterable)(iterable)) {
+    if ((0, types_1$M.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2476,9 +2476,9 @@ function reduceAsyncWithoutInitialValue$2(iterable, fn) {
 var reduce$7 = {};
 
 reduce$7.reduce = void 0;
-const types_1$M = es2018$f;
+const types_1$L = es2018$f;
 function reduce$6(iterable, fn, initialValue) {
-    if ((0, types_1$M.isUndefined)(initialValue)) {
+    if ((0, types_1$L.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$2(iterable, fn);
     }
     else {
@@ -2523,9 +2523,9 @@ function reduceWithoutInitialValue$2(iterable, fn) {
 var someAsync$5 = {};
 
 someAsync$5.someAsync = void 0;
-const types_1$L = es2018$f;
+const types_1$K = es2018$f;
 function someAsync$4(iterable, predicate) {
-    if ((0, types_1$L.isAsyncIterable)(iterable)) {
+    if ((0, types_1$K.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -2740,11 +2740,11 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$K = es2018$f;
+const types_1$J = es2018$f;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
-    if ((0, types_1$K.isError)(err)) {
+    if ((0, types_1$J.isError)(err)) {
         for (const prototype of (0, traverse_error_prototype_chain_1.traverseErrorPrototypeChain)(err)) {
             if ((_a = prototype.constructor) === null || _a === void 0 ? void 0 : _a.name) {
                 yield prototype.constructor.name;
@@ -2761,13 +2761,13 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$J = es2018$f;
+const types_1$I = es2018$f;
 function isSerializableError(val) {
-    return (0, types_1$J.isObject)(val)
-        && (0, types_1$J.isString)(val.name)
-        && (0, types_1$J.isString)(val.message)
-        && ((0, types_1$J.isString)(val.stack) || (0, types_1$J.isNull)(val.stack))
-        && ((0, types_1$J.isArray)(val.ancestors) && val.ancestors.every(types_1$J.isString));
+    return (0, types_1$I.isObject)(val)
+        && (0, types_1$I.isString)(val.name)
+        && (0, types_1$I.isString)(val.message)
+        && ((0, types_1$I.isString)(val.stack) || (0, types_1$I.isNull)(val.stack))
+        && ((0, types_1$I.isArray)(val.ancestors) && val.ancestors.every(types_1$I.isString));
 }
 serializableError.isSerializableError = isSerializableError;
 
@@ -3337,9 +3337,9 @@ url$3.isAbsoluteURL = isAbsoluteURL$3;
 } (es2018$c));
 
 chunkByAsync$3.chunkByAsync = void 0;
-const types_1$I = es2018$c;
+const types_1$H = es2018$c;
 function chunkByAsync$2(iterable, predicate) {
-    if ((0, types_1$I.isAsyncIterable)(iterable)) {
+    if ((0, types_1$H.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -3421,12 +3421,12 @@ chunk$3.chunk = chunk$2;
 var concatAsync$3 = {};
 
 concatAsync$3.concatAsync = void 0;
-const types_1$H = es2018$c;
+const types_1$G = es2018$c;
 const go_1$t = es2018$g;
 function concatAsync$2(iterable, ...otherIterables) {
     return (0, go_1$t.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if ((0, types_1$H.isAsyncIterable)(iter)) {
+            if ((0, types_1$G.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -3554,9 +3554,9 @@ dropRight$3.dropRight = dropRight$2;
 var dropUntilAsync$3 = {};
 
 dropUntilAsync$3.dropUntilAsync = void 0;
-const types_1$G = es2018$c;
+const types_1$F = es2018$c;
 function dropUntilAsync$2(iterable, predicate) {
-    if ((0, types_1$G.isAsyncIterable)(iterable)) {
+    if ((0, types_1$F.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -3671,9 +3671,9 @@ drop$3.drop = drop$2;
 var filterAsync$3 = {};
 
 filterAsync$3.filterAsync = void 0;
-const types_1$F = es2018$c;
+const types_1$E = es2018$c;
 function filterAsync$2(iterable, predicate) {
-    if ((0, types_1$F.isAsyncIterable)(iterable)) {
+    if ((0, types_1$E.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -3718,9 +3718,9 @@ var flattenDeepAsync$3 = {};
 var flattenByAsync$3 = {};
 
 flattenByAsync$3.flattenByAsync = void 0;
-const types_1$E = es2018$c;
+const types_1$D = es2018$c;
 function flattenByAsync$2(iterable, predicate) {
-    if ((0, types_1$E.isAsyncIterable)(iterable)) {
+    if ((0, types_1$D.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -3753,7 +3753,7 @@ function flattenByAsync$2(iterable, predicate) {
 }
 flattenByAsync$3.flattenByAsync = flattenByAsync$2;
 function isFiniteIterable$3(val) {
-    return (0, types_1$E.isIterable)(val) && (0, types_1$E.isntChar)(val);
+    return (0, types_1$D.isIterable)(val) && (0, types_1$D.isntChar)(val);
 }
 
 flattenDeepAsync$3.flattenDeepAsync = void 0;
@@ -3776,7 +3776,7 @@ flattenAsync$3.flattenAsync = flattenAsync$2;
 var flattenBy$3 = {};
 
 flattenBy$3.flattenBy = void 0;
-const types_1$D = es2018$c;
+const types_1$C = es2018$c;
 function flattenBy$2(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -3792,7 +3792,7 @@ function flattenBy$2(iterable, predicate) {
 }
 flattenBy$3.flattenBy = flattenBy$2;
 function isFiniteIterable$2(val) {
-    return (0, types_1$D.isIterable)(val) && (0, types_1$D.isntChar)(val);
+    return (0, types_1$C.isIterable)(val) && (0, types_1$C.isntChar)(val);
 }
 
 var flattenDeep$3 = {};
@@ -3819,9 +3819,9 @@ flatten$3.flatten = flatten$2;
 var mapAsync$3 = {};
 
 mapAsync$3.mapAsync = void 0;
-const types_1$C = es2018$c;
+const types_1$B = es2018$c;
 function mapAsync$2(iterable, fn) {
-    if ((0, types_1$C.isAsyncIterable)(iterable)) {
+    if ((0, types_1$B.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -3993,9 +3993,9 @@ splitAsync$3.splitAsync = splitAsync$2;
 var splitByAsync$3 = {};
 
 splitByAsync$3.splitByAsync = void 0;
-const types_1$B = es2018$c;
+const types_1$A = es2018$c;
 function splitByAsync$2(iterable, predicate) {
-    if ((0, types_1$B.isAsyncIterable)(iterable)) {
+    if ((0, types_1$A.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -4156,9 +4156,9 @@ takeRight$3.takeRight = takeRight$2;
 var takeUntilAsync$3 = {};
 
 takeUntilAsync$3.takeUntilAsync = void 0;
-const types_1$A = es2018$c;
+const types_1$z = es2018$c;
 function takeUntilAsync$2(iterable, predicate) {
-    if ((0, types_1$A.isAsyncIterable)(iterable)) {
+    if ((0, types_1$z.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -4223,9 +4223,9 @@ take$5.take = take$4;
 var tapAsync$3 = {};
 
 tapAsync$3.tapAsync = void 0;
-const types_1$z = es2018$c;
+const types_1$y = es2018$c;
 function tapAsync$2(iterable, fn) {
-    if ((0, types_1$z.isAsyncIterable)(iterable)) {
+    if ((0, types_1$y.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -4306,9 +4306,9 @@ uniqAsync$3.uniqAsync = uniqAsync$2;
 var uniqByAsync$3 = {};
 
 uniqByAsync$3.uniqByAsync = void 0;
-const types_1$y = es2018$c;
+const types_1$x = es2018$c;
 function uniqByAsync$2(iterable, fn) {
-    if ((0, types_1$y.isAsyncIterable)(iterable)) {
+    if ((0, types_1$x.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -4375,7 +4375,7 @@ uniq$3.uniq = uniq$2;
 var zipAsync$3 = {};
 
 zipAsync$3.zipAsync = void 0;
-const types_1$x = es2018$c;
+const types_1$w = es2018$c;
 var Kind$1;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -4389,7 +4389,7 @@ async function* zipWithSize$3(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if ((0, types_1$x.isAsyncIterable)(iterable)) {
+        if ((0, types_1$w.isAsyncIterable)(iterable)) {
             return [Kind$1.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -4539,9 +4539,9 @@ consume$3.consume = consume$2;
 var eachAsync$3 = {};
 
 eachAsync$3.eachAsync = void 0;
-const types_1$w = es2018$c;
+const types_1$v = es2018$c;
 function eachAsync$2(iterable, fn) {
-    if ((0, types_1$w.isAsyncIterable)(iterable)) {
+    if ((0, types_1$v.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -4579,9 +4579,9 @@ each$3.each = each$2;
 var everyAsync$3 = {};
 
 everyAsync$3.everyAsync = void 0;
-const types_1$v = es2018$c;
+const types_1$u = es2018$c;
 function everyAsync$2(iterable, predicate) {
-    if ((0, types_1$v.isAsyncIterable)(iterable)) {
+    if ((0, types_1$u.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -4625,9 +4625,9 @@ every$5.every = every$4;
 var findAsync$3 = {};
 
 findAsync$3.findAsync = void 0;
-const types_1$u = es2018$c;
+const types_1$t = es2018$c;
 function findAsync$2(iterable, predicate) {
-    if ((0, types_1$u.isAsyncIterable)(iterable)) {
+    if ((0, types_1$t.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -4749,9 +4749,9 @@ match$3.match = match$2;
 var reduceAsync$3 = {};
 
 reduceAsync$3.reduceAsync = void 0;
-const types_1$t = es2018$c;
+const types_1$s = es2018$c;
 function reduceAsync$2(iterable, fn, initialValue) {
-    if ((0, types_1$t.isUndefined)(initialValue)) {
+    if ((0, types_1$s.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$1(iterable, fn);
     }
     else {
@@ -4760,7 +4760,7 @@ function reduceAsync$2(iterable, fn, initialValue) {
 }
 reduceAsync$3.reduceAsync = reduceAsync$2;
 function reduceAsyncWithInitialValue$1(iterable, fn, initialValue) {
-    if ((0, types_1$t.isAsyncIterable)(iterable)) {
+    if ((0, types_1$s.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -4782,7 +4782,7 @@ function reduceAsyncWithInitialValue$1(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue$1(iterable, fn) {
-    if ((0, types_1$t.isAsyncIterable)(iterable)) {
+    if ((0, types_1$s.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -4845,9 +4845,9 @@ function reduceAsyncWithoutInitialValue$1(iterable, fn) {
 var reduce$5 = {};
 
 reduce$5.reduce = void 0;
-const types_1$s = es2018$c;
+const types_1$r = es2018$c;
 function reduce$4(iterable, fn, initialValue) {
-    if ((0, types_1$s.isUndefined)(initialValue)) {
+    if ((0, types_1$r.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$1(iterable, fn);
     }
     else {
@@ -4892,9 +4892,9 @@ function reduceWithoutInitialValue$1(iterable, fn) {
 var someAsync$3 = {};
 
 someAsync$3.someAsync = void 0;
-const types_1$r = es2018$c;
+const types_1$q = es2018$c;
 function someAsync$2(iterable, predicate) {
-    if ((0, types_1$r.isAsyncIterable)(iterable)) {
+    if ((0, types_1$q.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -5558,6 +5558,7 @@ var trieMap = {};
 
 trieMap.TrieMap = void 0;
 const iterable_operator_1 = es2018$d;
+const types_1$p = es2018$c;
 class TrieNode {
     constructor(value) {
         this.value = value;
@@ -5571,6 +5572,24 @@ class TrieMap {
     get [Symbol.toStringTag]() {
         return this.constructor.name;
     }
+    *entries() {
+        yield* dfs(this.root, []);
+        function* dfs(node, paths) {
+            for (const [path, childNode] of node.children) {
+                const newPaths = [...paths, path];
+                if ((0, types_1$p.isntUndefined)(childNode.value)) {
+                    yield [newPaths, childNode.value];
+                }
+                yield* dfs(childNode, newPaths);
+            }
+        }
+    }
+    keys() {
+        return (0, iterable_operator_1.map)(this.entries(), ([key]) => key);
+    }
+    values() {
+        return (0, iterable_operator_1.map)(this.entries(), ([_, value]) => value);
+    }
     set(key, value) {
         let node = this.root;
         for (const part of key) {
@@ -13146,6 +13165,7 @@ exports.State = void 0;
 	(function (State) {
 	    State["Miss"] = "miss";
 	    State["Hit"] = "hit";
+	    State["Reuse"] = "reuse";
 	    State["StaleWhileRevalidate"] = "stale-while-revalidate";
 	    State["StaleIfError"] = "state-if-error";
 	})(exports.State || (exports.State = {}));
@@ -13221,20 +13241,33 @@ function defaultCreateKey(args, name) {
 }
 defaultCreateKey$1.defaultCreateKey = defaultCreateKey;
 
+var createVerboseResult$1 = {};
+
+createVerboseResult$1.createVerboseResult = void 0;
+function createVerboseResult(value, state) {
+    return [value, state];
+}
+createVerboseResult$1.createVerboseResult = createVerboseResult;
+
 memoize$1.memoize = void 0;
-const types_1$q = types;
-const default_create_key_1$7 = defaultCreateKey$1;
-function memoize({ cache, name, createKey = default_create_key_1$7.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const types_1$o = types;
+const default_create_key_1$5 = defaultCreateKey$1;
+const create_verbose_result_1$5 = createVerboseResult$1;
+function memoize({ cache, name, createKey = default_create_key_1$5.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     return function (...args) {
+        const [value, state] = memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
+    };
+    function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = cache.get(key);
-        if (state === types_1$q.State.Hit) {
-            return value;
+        if (state === types_1$o.State.Hit) {
+            return (0, create_verbose_result_1$5.createVerboseResult)(value, state);
         }
         else {
-            return refresh.call(this, key, args);
+            return (0, create_verbose_result_1$5.createVerboseResult)(refresh.call(this, key, args), state);
         }
-    };
+    }
     function refresh(key, args) {
         const startTime = Date.now();
         const result = fn.apply(this, args);
@@ -13255,65 +13288,30 @@ memoize$1.memoize = memoize;
 var memoizeAsync$1 = {};
 
 memoizeAsync$1.memoizeAsync = void 0;
-const types_1$p = types;
-const default_create_key_1$6 = defaultCreateKey$1;
-function memoizeAsync({ cache, name, createKey = default_create_key_1$6.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const types_1$n = types;
+const default_create_key_1$4 = defaultCreateKey$1;
+const create_verbose_result_1$4 = createVerboseResult$1;
+function memoizeAsync({ cache, name, createKey = default_create_key_1$4.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     const pendings = new Map();
     return async function (...args) {
-        const key = createKey(args, name);
-        const [state, value] = cache.get(key);
-        if (state === types_1$p.State.Hit) {
-            return value;
-        }
-        else {
-            if (pendings.has(key))
-                return pendings.get(key);
-            return await refresh.call(this, key, args);
-        }
+        const [value, state] = await memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
     };
-    async function refresh(key, args) {
-        const startTime = Date.now();
-        const pending = Promise.resolve(fn.apply(this, args));
-        pendings.set(key, pending);
-        try {
-            const result = await pending;
-            if (isSlowExecution(startTime)) {
-                cache.set(key, result);
-            }
-            return result;
-        }
-        finally {
-            pendings.delete(key);
-        }
-    }
-    function isSlowExecution(startTime) {
-        return getElapsed() >= executionTimeThreshold;
-        function getElapsed() {
-            return Date.now() - startTime;
-        }
-    }
-}
-memoizeAsync$1.memoizeAsync = memoizeAsync;
-
-var memoizeWithAsyncCache$1 = {};
-
-memoizeWithAsyncCache$1.memoizeWithAsyncCache = void 0;
-const types_1$o = types;
-const default_create_key_1$5 = defaultCreateKey$1;
-function memoizeWithAsyncCache({ cache, name, createKey = default_create_key_1$5.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
-    const pendings = new Map();
-    return async function (...args) {
+    async function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = await cache.get(key);
-        if (state === types_1$o.State.Hit) {
-            return value;
+        if (state === types_1$n.State.Hit) {
+            return (0, create_verbose_result_1$4.createVerboseResult)(value, state);
         }
         else {
-            if (pendings.has(key))
-                return pendings.get(key);
-            return await refresh.call(this, key, args);
+            if (pendings.has(key)) {
+                return (0, create_verbose_result_1$4.createVerboseResult)(await pendings.get(key), types_1$n.State.Reuse);
+            }
+            else {
+                return (0, create_verbose_result_1$4.createVerboseResult)(await refresh.call(this, key, args), state);
+            }
         }
-    };
+    }
     async function refresh(key, args) {
         const startTime = Date.now();
         const pending = Promise.resolve(fn.apply(this, args));
@@ -13321,7 +13319,7 @@ function memoizeWithAsyncCache({ cache, name, createKey = default_create_key_1$5
         try {
             const result = await pending;
             if (isSlowExecution(startTime)) {
-                await cache.set(key, result);
+                cache.set(key, result);
             }
             return result;
         }
@@ -13336,7 +13334,7 @@ function memoizeWithAsyncCache({ cache, name, createKey = default_create_key_1$5
         }
     }
 }
-memoizeWithAsyncCache$1.memoizeWithAsyncCache = memoizeWithAsyncCache;
+memoizeAsync$1.memoizeAsync = memoizeAsync;
 
 var memoizeStaleWhileRevalidate$1 = {};
 
@@ -13794,11 +13792,11 @@ url$2.isAbsoluteURL = isAbsoluteURL$2;
 
 time$1.time = void 0;
 const high_resolution_timestamp_1$2 = highResolutionTimestamp_browser;
-const types_1$n = es2018$5;
+const types_1$m = es2018$5;
 function time(message, fn) {
     const startTime = (0, high_resolution_timestamp_1$2.now)();
     const result = fn();
-    if ((0, types_1$n.isPromiseLike)(result)) {
+    if ((0, types_1$m.isPromiseLike)(result)) {
         return result.then(() => {
             const endTime = (0, high_resolution_timestamp_1$2.now)();
             console.log(message, (0, high_resolution_timestamp_1$2.elapsed)(startTime, endTime));
@@ -14339,9 +14337,9 @@ url$1.isAbsoluteURL = isAbsoluteURL$1;
 } (es2018$1));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$m = es2018$1;
+const types_1$l = es2018$1;
 function chunkByAsync(iterable, predicate) {
-    if ((0, types_1$m.isAsyncIterable)(iterable)) {
+    if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -14423,12 +14421,12 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$l = es2018$1;
+const types_1$k = es2018$1;
 const go_1$d = es2018$2;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if ((0, types_1$l.isAsyncIterable)(iter)) {
+            if ((0, types_1$k.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -14556,9 +14554,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$k = es2018$1;
+const types_1$j = es2018$1;
 function dropUntilAsync(iterable, predicate) {
-    if ((0, types_1$k.isAsyncIterable)(iterable)) {
+    if ((0, types_1$j.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -14673,9 +14671,9 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$j = es2018$1;
+const types_1$i = es2018$1;
 function filterAsync(iterable, predicate) {
-    if ((0, types_1$j.isAsyncIterable)(iterable)) {
+    if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -14720,9 +14718,9 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$i = es2018$1;
+const types_1$h = es2018$1;
 function flattenByAsync(iterable, predicate) {
-    if ((0, types_1$i.isAsyncIterable)(iterable)) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -14755,7 +14753,7 @@ function flattenByAsync(iterable, predicate) {
 }
 flattenByAsync$1.flattenByAsync = flattenByAsync;
 function isFiniteIterable$1(val) {
-    return (0, types_1$i.isIterable)(val) && (0, types_1$i.isntChar)(val);
+    return (0, types_1$h.isIterable)(val) && (0, types_1$h.isntChar)(val);
 }
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
@@ -14778,7 +14776,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$h = es2018$1;
+const types_1$g = es2018$1;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -14794,7 +14792,7 @@ function flattenBy(iterable, predicate) {
 }
 flattenBy$1.flattenBy = flattenBy;
 function isFiniteIterable(val) {
-    return (0, types_1$h.isIterable)(val) && (0, types_1$h.isntChar)(val);
+    return (0, types_1$g.isIterable)(val) && (0, types_1$g.isntChar)(val);
 }
 
 var flattenDeep$1 = {};
@@ -14821,9 +14819,9 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$g = es2018$1;
+const types_1$f = es2018$1;
 function mapAsync(iterable, fn) {
-    if ((0, types_1$g.isAsyncIterable)(iterable)) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -14995,9 +14993,9 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$f = es2018$1;
+const types_1$e = es2018$1;
 function splitByAsync(iterable, predicate) {
-    if ((0, types_1$f.isAsyncIterable)(iterable)) {
+    if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -15158,9 +15156,9 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$e = es2018$1;
+const types_1$d = es2018$1;
 function takeUntilAsync(iterable, predicate) {
-    if ((0, types_1$e.isAsyncIterable)(iterable)) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -15225,9 +15223,9 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$d = es2018$1;
+const types_1$c = es2018$1;
 function tapAsync(iterable, fn) {
-    if ((0, types_1$d.isAsyncIterable)(iterable)) {
+    if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -15308,9 +15306,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$c = es2018$1;
+const types_1$b = es2018$1;
 function uniqByAsync(iterable, fn) {
-    if ((0, types_1$c.isAsyncIterable)(iterable)) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -15377,7 +15375,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$b = es2018$1;
+const types_1$a = es2018$1;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -15391,7 +15389,7 @@ async function* zipWithSize$1(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if ((0, types_1$b.isAsyncIterable)(iterable)) {
+        if ((0, types_1$a.isAsyncIterable)(iterable)) {
             return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -15541,9 +15539,9 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$a = es2018$1;
+const types_1$9 = es2018$1;
 function eachAsync(iterable, fn) {
-    if ((0, types_1$a.isAsyncIterable)(iterable)) {
+    if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -15581,9 +15579,9 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$9 = es2018$1;
+const types_1$8 = es2018$1;
 function everyAsync(iterable, predicate) {
-    if ((0, types_1$9.isAsyncIterable)(iterable)) {
+    if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -15627,9 +15625,9 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$8 = es2018$1;
+const types_1$7 = es2018$1;
 function findAsync(iterable, predicate) {
-    if ((0, types_1$8.isAsyncIterable)(iterable)) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -15751,9 +15749,9 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$7 = es2018$1;
+const types_1$6 = es2018$1;
 function reduceAsync(iterable, fn, initialValue) {
-    if ((0, types_1$7.isUndefined)(initialValue)) {
+    if ((0, types_1$6.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
     }
     else {
@@ -15762,7 +15760,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 reduceAsync$1.reduceAsync = reduceAsync;
 function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -15784,7 +15782,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -15847,9 +15845,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$6 = es2018$1;
+const types_1$5 = es2018$1;
 function reduce(iterable, fn, initialValue) {
-    if ((0, types_1$6.isUndefined)(initialValue)) {
+    if ((0, types_1$5.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
     }
     else {
@@ -15894,9 +15892,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$5 = es2018$1;
+const types_1$4 = es2018$1;
 function someAsync(iterable, predicate) {
-    if ((0, types_1$5.isAsyncIterable)(iterable)) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -16557,31 +16555,37 @@ exports.isntObject = exports.isntNumber = exports.isntNull = exports.isntJson =
 } (es2018$8));
 
 memoizeStaleWhileRevalidate$1.memoizeStaleWhileRevalidate = void 0;
-const types_1$4 = types;
+const types_1$3 = types;
 const prelude_1$1 = es2018$8;
-const default_create_key_1$4 = defaultCreateKey$1;
-function memoizeStaleWhileRevalidate({ cache, name, createKey = default_create_key_1$4.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const default_create_key_1$3 = defaultCreateKey$1;
+const create_verbose_result_1$3 = createVerboseResult$1;
+function memoizeStaleWhileRevalidate({ cache, name, createKey = default_create_key_1$3.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     const pendings = new Map();
     return async function (...args) {
+        const [value, state] = await memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
+    };
+    async function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = await cache.get(key);
-        if (state === types_1$4.State.Hit) {
-            return value;
+        if (state === types_1$3.State.Hit) {
+            return (0, create_verbose_result_1$3.createVerboseResult)(value, state);
         }
-        else if (state === types_1$4.State.StaleWhileRevalidate) {
+        else if (state === types_1$3.State.StaleWhileRevalidate) {
             queueMicrotask(async () => {
                 if (!pendings.has(key)) {
                     refresh.call(this, key, args).catch(prelude_1$1.pass);
                 }
             });
-            return value;
+            return (0, create_verbose_result_1$3.createVerboseResult)(value, state);
         }
         else {
-            if (pendings.has(key))
-                return await pendings.get(key);
-            return await refresh.call(this, key, args);
+            if (pendings.has(key)) {
+                return (0, create_verbose_result_1$3.createVerboseResult)(await pendings.get(key), types_1$3.State.Reuse);
+            }
+            return (0, create_verbose_result_1$3.createVerboseResult)(await refresh.call(this, key, args), state);
         }
-    };
+    }
     async function refresh(key, args) {
         const startTime = Date.now();
         const promise = Promise.resolve(fn.apply(this, args));
@@ -16609,49 +16613,57 @@ memoizeStaleWhileRevalidate$1.memoizeStaleWhileRevalidate = memoizeStaleWhileRev
 var memoizeStaleWhileRevalidateAndStaleIfError$1 = {};
 
 memoizeStaleWhileRevalidateAndStaleIfError$1.memoizeStaleWhileRevalidateAndStaleIfError = void 0;
-const types_1$3 = types;
+const types_1$2 = types;
 const prelude_1 = es2018$8;
-const default_create_key_1$3 = defaultCreateKey$1;
-function memoizeStaleWhileRevalidateAndStaleIfError({ cache, name, createKey = default_create_key_1$3.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const default_create_key_1$2 = defaultCreateKey$1;
+const create_verbose_result_1$2 = createVerboseResult$1;
+function memoizeStaleWhileRevalidateAndStaleIfError({ cache, name, createKey = default_create_key_1$2.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     const pendings = new Map();
     return async function (...args) {
+        const [value, state] = await memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
+    };
+    async function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = await cache.get(key);
-        if (state === types_1$3.State.Hit) {
-            return value;
+        if (state === types_1$2.State.Hit) {
+            return (0, create_verbose_result_1$2.createVerboseResult)(value, state);
         }
-        else if (state === types_1$3.State.StaleWhileRevalidate) {
+        else if (state === types_1$2.State.StaleWhileRevalidate) {
             queueMicrotask(async () => {
                 if (!pendings.has(key)) {
                     refresh.call(this, key, args).catch(prelude_1.pass);
                 }
             });
-            return value;
+            return (0, create_verbose_result_1$2.createVerboseResult)(value, state);
         }
-        else if (state === types_1$3.State.StaleIfError) {
+        else if (state === types_1$2.State.StaleIfError) {
             if (pendings.has(key)) {
                 try {
-                    return await pendings.get(key);
+                    return (0, create_verbose_result_1$2.createVerboseResult)(await pendings.get(key), types_1$2.State.Reuse);
                 }
                 catch (_a) {
-                    return value;
+                    return (0, create_verbose_result_1$2.createVerboseResult)(value, state);
                 }
             }
             else {
                 try {
-                    return await refresh.call(this, key, args);
+                    return (0, create_verbose_result_1$2.createVerboseResult)(await refresh.call(this, key, args), state);
                 }
                 catch (_b) {
-                    return value;
+                    return (0, create_verbose_result_1$2.createVerboseResult)(value, state);
                 }
             }
         }
         else {
-            if (pendings.has(key))
-                return await pendings.get(key);
-            return await refresh.call(this, key, args);
+            if (pendings.has(key)) {
+                return (0, create_verbose_result_1$2.createVerboseResult)(await pendings.get(key), types_1$2.State.Reuse);
+            }
+            else {
+                return (0, create_verbose_result_1$2.createVerboseResult)(await refresh.call(this, key, args), state);
+            }
         }
-    };
+    }
     async function refresh(key, args) {
         const startTime = Date.now();
         const promise = Promise.resolve(fn.apply(this, args));
@@ -16676,32 +16688,35 @@ function memoizeStaleWhileRevalidateAndStaleIfError({ cache, name, createKey = d
 }
 memoizeStaleWhileRevalidateAndStaleIfError$1.memoizeStaleWhileRevalidateAndStaleIfError = memoizeStaleWhileRevalidateAndStaleIfError;
 
-var staleIfError = {};
-
 var memoizeStaleIfError$1 = {};
 
 memoizeStaleIfError$1.memoizeStaleIfError = void 0;
-const types_1$2 = types;
-const default_create_key_1$2 = defaultCreateKey$1;
-function memoizeStaleIfError({ cache, name, createKey = default_create_key_1$2.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const types_1$1 = types;
+const default_create_key_1$1 = defaultCreateKey$1;
+const create_verbose_result_1$1 = createVerboseResult$1;
+function memoizeStaleIfError({ cache, name, createKey = default_create_key_1$1.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     return function (...args) {
+        const [value, state] = memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
+    };
+    function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = cache.get(key);
-        if (state === types_1$2.State.Hit) {
-            return value;
+        if (state === types_1$1.State.Hit) {
+            return (0, create_verbose_result_1$1.createVerboseResult)(value, state);
         }
-        else if (state === types_1$2.State.StaleIfError) {
+        else if (state === types_1$1.State.StaleIfError) {
             try {
-                return refresh.call(this, key, args);
+                return (0, create_verbose_result_1$1.createVerboseResult)(refresh.call(this, key, args), state);
             }
             catch (_a) {
-                return value;
+                return (0, create_verbose_result_1$1.createVerboseResult)(value, state);
             }
         }
         else {
-            return refresh.call(this, key, args);
+            return (0, create_verbose_result_1$1.createVerboseResult)(refresh.call(this, key, args), state);
         }
-    };
+    }
     function refresh(key, args) {
         const startTime = Date.now();
         const result = fn.apply(this, args);
@@ -16722,101 +16737,48 @@ memoizeStaleIfError$1.memoizeStaleIfError = memoizeStaleIfError;
 var memoizeAsyncStaleIfError$1 = {};
 
 memoizeAsyncStaleIfError$1.memoizeAsyncStaleIfError = void 0;
-const types_1$1 = types;
-const default_create_key_1$1 = defaultCreateKey$1;
-function memoizeAsyncStaleIfError({ cache, name, createKey = default_create_key_1$1.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
-    const pendings = new Map();
-    return async function (...args) {
-        const key = createKey(args, name);
-        const [state, value] = cache.get(key);
-        if (state === types_1$1.State.Hit) {
-            return value;
-        }
-        else if (state === types_1$1.State.StaleIfError) {
-            if (pendings.has(key)) {
-                try {
-                    return await pendings.get(key);
-                }
-                catch (_a) {
-                    return value;
-                }
-            }
-            else {
-                try {
-                    return await refresh.call(this, key, args);
-                }
-                catch (_b) {
-                    return value;
-                }
-            }
-        }
-        else {
-            if (pendings.has(key))
-                return await pendings.get(key);
-            return await refresh.call(this, key, args);
-        }
-    };
-    async function refresh(key, args) {
-        const startTime = Date.now();
-        const promise = Promise.resolve(fn.apply(this, args));
-        pendings.set(key, promise);
-        try {
-            const result = await promise;
-            if (isSlowExecution(startTime)) {
-                cache.set(key, result);
-            }
-            return result;
-        }
-        finally {
-            pendings.delete(key);
-        }
-    }
-    function isSlowExecution(startTime) {
-        return getElapsed() >= executionTimeThreshold;
-        function getElapsed() {
-            return Date.now() - startTime;
-        }
-    }
-}
-memoizeAsyncStaleIfError$1.memoizeAsyncStaleIfError = memoizeAsyncStaleIfError;
-
-var memoizeStaleIfErrorWithAsyncCache$1 = {};
-
-memoizeStaleIfErrorWithAsyncCache$1.memoizeStaleIfErrorWithAsyncCache = void 0;
 const types_1 = types;
 const default_create_key_1 = defaultCreateKey$1;
-function memoizeStaleIfErrorWithAsyncCache({ cache, name, createKey = default_create_key_1.defaultCreateKey, executionTimeThreshold = 0 }, fn) {
+const create_verbose_result_1 = createVerboseResult$1;
+function memoizeAsyncStaleIfError({ cache, name, createKey = default_create_key_1.defaultCreateKey, executionTimeThreshold = 0, verbose = false }, fn) {
     const pendings = new Map();
     return async function (...args) {
+        const [value, state] = await memoizedFunction.apply(this, args);
+        return verbose ? [value, state] : value;
+    };
+    async function memoizedFunction(...args) {
         const key = createKey(args, name);
         const [state, value] = await cache.get(key);
         if (state === types_1.State.Hit) {
-            return value;
+            return (0, create_verbose_result_1.createVerboseResult)(value, state);
         }
         else if (state === types_1.State.StaleIfError) {
             if (pendings.has(key)) {
                 try {
-                    return await pendings.get(key);
+                    return (0, create_verbose_result_1.createVerboseResult)(await pendings.get(key), types_1.State.Reuse);
                 }
                 catch (_a) {
-                    return value;
+                    return (0, create_verbose_result_1.createVerboseResult)(value, state);
                 }
             }
             else {
                 try {
-                    return await refresh.call(this, key, args);
+                    return (0, create_verbose_result_1.createVerboseResult)(await refresh.call(this, key, args), state);
                 }
                 catch (_b) {
-                    return value;
+                    return (0, create_verbose_result_1.createVerboseResult)(value, state);
                 }
             }
         }
         else {
-            if (pendings.has(key))
-                return await pendings.get(key);
-            return await refresh.call(this, key, args);
+            if (pendings.has(key)) {
+                return (0, create_verbose_result_1.createVerboseResult)(await pendings.get(key), types_1.State.Reuse);
+            }
+            else {
+                return (0, create_verbose_result_1.createVerboseResult)(await refresh.call(this, key, args), state);
+            }
         }
-    };
+    }
     async function refresh(key, args) {
         const startTime = Date.now();
         const promise = Promise.resolve(fn.apply(this, args));
@@ -16839,27 +16801,7 @@ function memoizeStaleIfErrorWithAsyncCache({ cache, name, createKey = default_cr
         }
     }
 }
-memoizeStaleIfErrorWithAsyncCache$1.memoizeStaleIfErrorWithAsyncCache = memoizeStaleIfErrorWithAsyncCache;
-
-(function (exports) {
-	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    var desc = Object.getOwnPropertyDescriptor(m, k);
-	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-	      desc = { enumerable: true, get: function() { return m[k]; } };
-	    }
-	    Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    o[k2] = m[k];
-	}));
-	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(memoizeStaleIfError$1, exports);
-	__exportStar(memoizeAsyncStaleIfError$1, exports);
-	__exportStar(memoizeStaleIfErrorWithAsyncCache$1, exports);
-	
-} (staleIfError));
+memoizeAsyncStaleIfError$1.memoizeAsyncStaleIfError = memoizeAsyncStaleIfError;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -16877,10 +16819,10 @@ memoizeStaleIfErrorWithAsyncCache$1.memoizeStaleIfErrorWithAsyncCache = memoizeS
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};__exportStar(memoize$1, exports);
 	__exportStar(memoizeAsync$1, exports);
-	__exportStar(memoizeWithAsyncCache$1, exports);
 	__exportStar(memoizeStaleWhileRevalidate$1, exports);
 	__exportStar(memoizeStaleWhileRevalidateAndStaleIfError$1, exports);
-	__exportStar(staleIfError, exports);
+	__exportStar(memoizeStaleIfError$1, exports);
+	__exportStar(memoizeAsyncStaleIfError$1, exports);
 	
 } (memoizes));