@extra-memoize/memory-cache 0.2.1 → 0.2.2

package/dist/es2018/index.umd.js

@@ -831,9 +831,9 @@
 	} (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 {
@@ -923,12 +923,12 @@
 	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;
 	                }
@@ -1080,9 +1080,9 @@
 	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 {
@@ -1205,9 +1205,9 @@
 	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 {
@@ -1252,9 +1252,9 @@
 	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 {
@@ -1287,7 +1287,7 @@
 	}
 	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;
@@ -1326,7 +1326,7 @@
 	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) {
@@ -1342,7 +1342,7 @@
 	}
 	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 = {};
@@ -1385,9 +1385,9 @@
 	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 {
@@ -1591,9 +1591,9 @@
 	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 {
@@ -1778,9 +1778,9 @@
 	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 {
@@ -1853,9 +1853,9 @@
 	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 {
@@ -1936,9 +1936,9 @@
 	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 {
@@ -2005,7 +2005,7 @@
 	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";
@@ -2019,7 +2019,7 @@
 	    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 {
@@ -2176,9 +2176,9 @@
 	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 {
@@ -2216,9 +2216,9 @@
 	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 {
@@ -2262,9 +2262,9 @@
 	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 {
@@ -2386,9 +2386,9 @@
 	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 {
@@ -2397,7 +2397,7 @@
 	}
 	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 {
@@ -2419,7 +2419,7 @@
 	    }
 	}
 	function reduceAsyncWithoutInitialValue$2(iterable, fn) {
-	    if ((0, types_1$N.isAsyncIterable)(iterable)) {
+	    if ((0, types_1$M.isAsyncIterable)(iterable)) {
 	        return reduceAsyncIterable(iterable);
 	    }
 	    else {
@@ -2482,9 +2482,9 @@
 	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 {
@@ -2529,9 +2529,9 @@
 	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 {
@@ -2746,11 +2746,11 @@
 	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;
@@ -2767,13 +2767,13 @@
 	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;
 
@@ -3343,9 +3343,9 @@
 	} (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 {
@@ -3427,12 +3427,12 @@
 	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;
 	                }
@@ -3560,9 +3560,9 @@
 	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 {
@@ -3677,9 +3677,9 @@
 	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 {
@@ -3724,9 +3724,9 @@
 	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 {
@@ -3759,7 +3759,7 @@
 	}
 	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;
@@ -3782,7 +3782,7 @@
 	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) {
@@ -3798,7 +3798,7 @@
 	}
 	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 = {};
@@ -3825,9 +3825,9 @@
 	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 {
@@ -3999,9 +3999,9 @@
 	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 {
@@ -4162,9 +4162,9 @@
 	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 {
@@ -4229,9 +4229,9 @@
 	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 {
@@ -4312,9 +4312,9 @@
 	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 {
@@ -4381,7 +4381,7 @@
 	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";
@@ -4395,7 +4395,7 @@
 	    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 {
@@ -4545,9 +4545,9 @@
 	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 {
@@ -4585,9 +4585,9 @@
 	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 {
@@ -4631,9 +4631,9 @@
 	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 {
@@ -4755,9 +4755,9 @@
 	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 {
@@ -4766,7 +4766,7 @@
 	}
 	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 {
@@ -4788,7 +4788,7 @@
 	    }
 	}
 	function reduceAsyncWithoutInitialValue$1(iterable, fn) {
-	    if ((0, types_1$t.isAsyncIterable)(iterable)) {
+	    if ((0, types_1$s.isAsyncIterable)(iterable)) {
 	        return reduceAsyncIterable(iterable);
 	    }
 	    else {
@@ -4851,9 +4851,9 @@
 	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 {
@@ -4898,9 +4898,9 @@
 	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 {
@@ -5564,6 +5564,7 @@
 
 	trieMap.TrieMap = void 0;
 	const iterable_operator_1 = es2018$d;
+	const types_1$p = es2018$c;
 	class TrieNode {
 	    constructor(value) {
 	        this.value = value;
@@ -5577,6 +5578,24 @@
 	    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) {
@@ -13152,6 +13171,7 @@
 		(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 = {}));
@@ -13227,20 +13247,33 @@
 	}
 	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);
@@ -13261,65 +13294,30 @@
 	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));
@@ -13327,7 +13325,7 @@
 	        try {
 	            const result = await pending;
 	            if (isSlowExecution(startTime)) {
-	                await cache.set(key, result);
+	                cache.set(key, result);
 	            }
 	            return result;
 	        }
@@ -13342,7 +13340,7 @@
 	        }
 	    }
 	}
-	memoizeWithAsyncCache$1.memoizeWithAsyncCache = memoizeWithAsyncCache;
+	memoizeAsync$1.memoizeAsync = memoizeAsync;
 
 	var memoizeStaleWhileRevalidate$1 = {};
 
@@ -13800,11 +13798,11 @@
 
 	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));
@@ -14345,9 +14343,9 @@
 	} (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 {
@@ -14429,12 +14427,12 @@
 	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;
 	                }
@@ -14562,9 +14560,9 @@
 	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 {
@@ -14679,9 +14677,9 @@
 	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 {
@@ -14726,9 +14724,9 @@
 	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 {
@@ -14761,7 +14759,7 @@
 	}
 	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;
@@ -14784,7 +14782,7 @@
 	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) {
@@ -14800,7 +14798,7 @@
 	}
 	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 = {};
@@ -14827,9 +14825,9 @@
 	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 {
@@ -15001,9 +14999,9 @@
 	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 {
@@ -15164,9 +15162,9 @@
 	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 {
@@ -15231,9 +15229,9 @@
 	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 {
@@ -15314,9 +15312,9 @@
 	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 {
@@ -15383,7 +15381,7 @@
 	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";
@@ -15397,7 +15395,7 @@
 	    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 {
@@ -15547,9 +15545,9 @@
 	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 {
@@ -15587,9 +15585,9 @@
 	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 {
@@ -15633,9 +15631,9 @@
 	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 {
@@ -15757,9 +15755,9 @@
 	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 {
@@ -15768,7 +15766,7 @@
 	}
 	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 {
@@ -15790,7 +15788,7 @@
 	    }
 	}
 	function reduceAsyncWithoutInitialValue(iterable, fn) {
-	    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+	    if ((0, types_1$6.isAsyncIterable)(iterable)) {
 	        return reduceAsyncIterable(iterable);
 	    }
 	    else {
@@ -15853,9 +15851,9 @@
 	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 {
@@ -15900,9 +15898,9 @@
 	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 {
@@ -16563,31 +16561,37 @@
 	} (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));
@@ -16615,49 +16619,57 @@
 	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));
@@ -16682,32 +16694,35 @@
 	}
 	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);
@@ -16728,101 +16743,48 @@
 	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));
@@ -16845,27 +16807,7 @@
 	        }
 	    }
 	}
-	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) {
@@ -16883,10 +16825,10 @@
 		    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));