@common.js/quick-lru 6.1.2 → 7.3.0

package/README.md

@@ -2,4 +2,4 @@
 
 The [quick-lru](https://www.npmjs.com/package/quick-lru) package exported as CommonJS modules.
 
-Exported from [quick-lru@6.1.2](https://www.npmjs.com/package/quick-lru/v/6.1.2) using https://github.com/etienne-martin/common.js.
+Exported from [quick-lru@7.3.0](https://www.npmjs.com/package/quick-lru/v/7.3.0) using https://github.com/etienne-martin/common.js.

package/index.d.ts

@@ -1,35 +1,35 @@
-export interface Options<KeyType, ValueType> {
+export type Options<KeyType, ValueType> = {
 	/**
 	The maximum number of milliseconds an item should remain in the cache.
 
 	@default Infinity
 
 	By default, `maxAge` will be `Infinity`, which means that items will never expire.
-	Lazy expiration upon the next write or read call.
+	Lazy expiration occurs upon the next write or read call.
 
-	Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
+	Individual expiration of an item can be specified with the `set(key, value, {maxAge})` method.
 	*/
 	readonly maxAge?: number;
 
 	/**
-	The maximum number of items before evicting the least recently used items.
+	The target maximum number of items before evicting the least recently used items.
+
+	__Note:__ This package uses an [algorithm](https://github.com/sindresorhus/quick-lru#algorithm) which maintains between `maxSize` and `2 × maxSize` items for performance reasons. The cache may temporarily contain up to twice the specified size due to the dual-cache design that avoids expensive delete operations.
 	*/
 	readonly maxSize: number;
 
 	/**
-	Called right before an item is evicted from the cache.
+	Called right before an item is evicted from the cache due to LRU pressure, TTL expiration, or manual eviction via `evict()`.
 
 	Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
-	*/
-	onEviction?: (key: KeyType, value: ValueType) => void;
-}
 
-export default class QuickLRU<KeyType, ValueType> extends Map implements Iterable<[KeyType, ValueType]> {
-	/**
-	The stored item count.
+	__Note:__ This callback is not called for manual removals via `delete()` or `clear()`. It fires for automatic evictions and manual evictions via `evict()`.
 	*/
-	readonly size: number;
+	onEviction?: (key: KeyType, value: ValueType) => void;
+};
 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export default class QuickLRU<KeyType, ValueType> extends Map<KeyType, ValueType> implements Iterable<[KeyType, ValueType]> {
 	/**
 	Simple ["Least Recently Used" (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29).
 
@@ -57,9 +57,9 @@ export default class QuickLRU<KeyType, ValueType> extends Map implements Iterabl
 	/**
 	Set an item. Returns the instance.
 
-	Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified in the constructor, otherwise the item will never expire.
+	Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified in the constructor; otherwise the item will never expire.
 
-	@returns The list instance.
+	@returns The cache instance.
 	*/
 	set(key: KeyType, value: ValueType, options?: {maxAge?: number}): this;
 
@@ -94,6 +94,18 @@ export default class QuickLRU<KeyType, ValueType> extends Map implements Iterabl
 	*/
 	clear(): void;
 
+	/**
+	Get the remaining time to live (in milliseconds) for the given item, or `undefined` when the item is not in the cache.
+
+	- Does not mark the item as recently used.
+	- Does not trigger lazy expiration or remove the entry when it is expired.
+	- Returns `Infinity` if the item has no expiration.
+	- May return a negative number if the item is already expired but not yet lazily removed.
+
+	@returns Remaining time to live in milliseconds when set, `Infinity` when there is no expiration, or `undefined` when the item does not exist.
+	*/
+	expiresIn(key: KeyType): number | undefined;
+
 	/**
 	Update the `maxSize` in-place, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
 
@@ -101,6 +113,21 @@ export default class QuickLRU<KeyType, ValueType> extends Map implements Iterabl
 	*/
 	resize(maxSize: number): void;
 
+	/**
+	The stored item count.
+	*/
+	get size(): number;
+
+	/**
+	The set max size.
+	*/
+	get maxSize(): number;
+
+	/**
+	The set max age.
+	*/
+	get maxAge(): number;
+
 	/**
 	Iterable for all the keys.
 	*/
@@ -120,4 +147,32 @@ export default class QuickLRU<KeyType, ValueType> extends Map implements Iterabl
 	Iterable for all entries, starting with the newest (descending in recency).
 	*/
 	entriesDescending(): IterableIterator<[KeyType, ValueType]>;
+
+	/**
+	Evict the least recently used items from the cache.
+
+	@param count - The number of items to evict. Defaults to 1.
+
+	It will always keep at least one item in the cache.
+
+	@example
+	```
+	import QuickLRU from 'quick-lru';
+
+	const lru = new QuickLRU({maxSize: 10});
+
+	lru.set('a', 1);
+	lru.set('b', 2);
+	lru.set('c', 3);
+
+	lru.evict(2); // Evicts 'a' and 'b'
+
+	console.log(lru.has('a'));
+	//=> false
+
+	console.log(lru.has('c'));
+	//=> true
+	```
+	*/
+	evict(count?: number): void;
 }

package/index.js

@@ -25,11 +25,85 @@ function _assertThisInitialized(self) {
     }
     return self;
 }
+function _checkPrivateRedeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _classApplyDescriptorGet(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _classApplyDescriptorSet(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _classApplyDescriptorUpdate(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!("__destrWrapper" in descriptor)) {
+            descriptor.__destrWrapper = {
+                set value (v){
+                    descriptor.set.call(receiver, v);
+                },
+                get value () {
+                    return descriptor.get.call(receiver);
+                }
+            };
+        }
+        return descriptor.__destrWrapper;
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        return descriptor;
+    }
+}
 function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
+function _classExtractFieldDescriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _classPrivateFieldGet(receiver, privateMap) {
+    var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
+    return _classApplyDescriptorGet(receiver, descriptor);
+}
+function _classPrivateFieldInit(obj, privateMap, value) {
+    _checkPrivateRedeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _classPrivateFieldSet(receiver, privateMap, value) {
+    var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
+    _classApplyDescriptorSet(receiver, descriptor, value);
+    return value;
+}
+function _classPrivateFieldUpdate(receiver, privateMap) {
+    var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "update");
+    return _classApplyDescriptorUpdate(receiver, descriptor);
+}
+function _classPrivateMethodGet(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _classPrivateMethodInit(obj, privateSet) {
+    _checkPrivateRedeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 function isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
@@ -226,10 +300,10 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
         return this;
     }), g;
     function verb(n) {
-        return function(v) {
+        return function(v1) {
             return step([
                 n,
-                v
+                v1
             ]);
         };
     }
@@ -303,6 +377,8 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
         };
     }
 };
+var _size = /*#__PURE__*/ new WeakMap(), _cache = /*#__PURE__*/ new WeakMap(), _oldCache = /*#__PURE__*/ new WeakMap(), _maxSize = /*#__PURE__*/ new WeakMap(), _maxAge = /*#__PURE__*/ new WeakMap(), _onEviction = /*#__PURE__*/ new WeakMap(), _emitEvictions = /*#__PURE__*/ new WeakSet(), _deleteIfExpired = /*#__PURE__*/ new WeakSet(), _getOrDeleteIfExpired = /*#__PURE__*/ new WeakSet(), _getItemValue = /*#__PURE__*/ new WeakSet(), _peek = /*#__PURE__*/ new WeakSet(), _set = /*#__PURE__*/ new WeakSet(), _moveToRecent = /*#__PURE__*/ new WeakSet(), _entriesAscending = /*#__PURE__*/ new WeakSet();
+var _iterator = Symbol.iterator, _toStringTag = Symbol.toStringTag, tmp = Symbol.for("nodejs.util.inspect.custom");
 var QuickLRU = /*#__PURE__*/ function(Map1) {
     "use strict";
     _inherits(QuickLRU, Map1);
@@ -312,260 +388,68 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
         _classCallCheck(this, QuickLRU);
         var _this;
         _this = _super.call(this);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _emitEvictions);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _deleteIfExpired);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _getOrDeleteIfExpired);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _getItemValue);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _peek);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _set);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _moveToRecent);
+        _classPrivateMethodInit(_assertThisInitialized(_this), _entriesAscending);
+        _classPrivateFieldInit(_assertThisInitialized(_this), _size, {
+            writable: true,
+            value: 0
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _cache, {
+            writable: true,
+            value: new Map()
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _oldCache, {
+            writable: true,
+            value: new Map()
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _maxSize, {
+            writable: true,
+            value: void 0
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _maxAge, {
+            writable: true,
+            value: void 0
+        });
+        _classPrivateFieldInit(_assertThisInitialized(_this), _onEviction, {
+            writable: true,
+            value: void 0
+        });
         if (!(options.maxSize && options.maxSize > 0)) {
             throw new TypeError("`maxSize` must be a number greater than 0");
         }
         if (typeof options.maxAge === "number" && options.maxAge === 0) {
             throw new TypeError("`maxAge` must be a number greater than 0");
         }
-        // TODO: Use private class fields when ESLint supports them.
-        _this.maxSize = options.maxSize;
-        _this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
-        _this.onEviction = options.onEviction;
-        _this.cache = new Map();
-        _this.oldCache = new Map();
-        _this._size = 0;
+        _classPrivateFieldSet(_assertThisInitialized(_this), _maxSize, options.maxSize);
+        _classPrivateFieldSet(_assertThisInitialized(_this), _maxAge, options.maxAge || Number.POSITIVE_INFINITY);
+        _classPrivateFieldSet(_assertThisInitialized(_this), _onEviction, options.onEviction);
         return _this;
     }
     _createClass(QuickLRU, [
         {
-            // TODO: Use private class methods when targeting Node.js 16.
-            key: "_emitEvictions",
-            value: function _emitEvictions(cache) {
-                if (typeof this.onEviction !== "function") {
-                    return;
-                }
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = cache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var _value = _slicedToArray(_step.value, 2), key = _value[0], item = _value[1];
-                        this.onEviction(key, item.value);
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            }
-        },
-        {
-            key: "_deleteIfExpired",
-            value: function _deleteIfExpired(key, item) {
-                if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
-                    if (typeof this.onEviction === "function") {
-                        this.onEviction(key, item.value);
-                    }
-                    return this.delete(key);
-                }
-                return false;
-            }
-        },
-        {
-            key: "_getOrDeleteIfExpired",
-            value: function _getOrDeleteIfExpired(key, item) {
-                var deleted = this._deleteIfExpired(key, item);
-                if (deleted === false) {
-                    return item.value;
-                }
-            }
-        },
-        {
-            key: "_getItemValue",
-            value: function _getItemValue(key, item) {
-                return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
-            }
-        },
-        {
-            key: "_peek",
-            value: function _peek(key, cache) {
-                var item = cache.get(key);
-                return this._getItemValue(key, item);
-            }
-        },
-        {
-            key: "_set",
-            value: function _set(key, value) {
-                this.cache.set(key, value);
-                this._size++;
-                if (this._size >= this.maxSize) {
-                    this._size = 0;
-                    this._emitEvictions(this.oldCache);
-                    this.oldCache = this.cache;
-                    this.cache = new Map();
-                }
-            }
-        },
-        {
-            key: "_moveToRecent",
-            value: function _moveToRecent(key, item) {
-                this.oldCache.delete(key);
-                this._set(key, item);
-            }
-        },
-        {
-            key: "_entriesAscending",
-            value: function _entriesAscending() {
-                var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _item, key, value, deleted, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, item1, _item1, key1, value1, deleted1, err;
-                return __generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                            _state.label = 1;
-                        case 1:
-                            _state.trys.push([
-                                1,
-                                6,
-                                7,
-                                8
-                            ]);
-                            _iterator = this.oldCache[Symbol.iterator]();
-                            _state.label = 2;
-                        case 2:
-                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
-                                3,
-                                5
-                            ];
-                            item = _step.value;
-                            _item = _slicedToArray(item, 2), key = _item[0], value = _item[1];
-                            if (!!this.cache.has(key)) return [
-                                3,
-                                4
-                            ];
-                            deleted = this._deleteIfExpired(key, value);
-                            if (!(deleted === false)) return [
-                                3,
-                                4
-                            ];
-                            return [
-                                4,
-                                item
-                            ];
-                        case 3:
-                            _state.sent();
-                            _state.label = 4;
-                        case 4:
-                            _iteratorNormalCompletion = true;
-                            return [
-                                3,
-                                2
-                            ];
-                        case 5:
-                            return [
-                                3,
-                                8
-                            ];
-                        case 6:
-                            err = _state.sent();
-                            _didIteratorError = true;
-                            _iteratorError = err;
-                            return [
-                                3,
-                                8
-                            ];
-                        case 7:
-                            try {
-                                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                    _iterator.return();
-                                }
-                            } finally{
-                                if (_didIteratorError) {
-                                    throw _iteratorError;
-                                }
-                            }
-                            return [
-                                7
-                            ];
-                        case 8:
-                            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                            _state.label = 9;
-                        case 9:
-                            _state.trys.push([
-                                9,
-                                14,
-                                15,
-                                16
-                            ]);
-                            _iterator1 = this.cache[Symbol.iterator]();
-                            _state.label = 10;
-                        case 10:
-                            if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
-                                3,
-                                13
-                            ];
-                            item1 = _step1.value;
-                            _item1 = _slicedToArray(item1, 2), key1 = _item1[0], value1 = _item1[1];
-                            deleted1 = this._deleteIfExpired(key1, value1);
-                            if (!(deleted1 === false)) return [
-                                3,
-                                12
-                            ];
-                            return [
-                                4,
-                                item1
-                            ];
-                        case 11:
-                            _state.sent();
-                            _state.label = 12;
-                        case 12:
-                            _iteratorNormalCompletion1 = true;
-                            return [
-                                3,
-                                10
-                            ];
-                        case 13:
-                            return [
-                                3,
-                                16
-                            ];
-                        case 14:
-                            err = _state.sent();
-                            _didIteratorError1 = true;
-                            _iteratorError1 = err;
-                            return [
-                                3,
-                                16
-                            ];
-                        case 15:
-                            try {
-                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                    _iterator1.return();
-                                }
-                            } finally{
-                                if (_didIteratorError1) {
-                                    throw _iteratorError1;
-                                }
-                            }
-                            return [
-                                7
-                            ];
-                        case 16:
-                            return [
-                                2
-                            ];
-                    }
-                });
+            key: "__oldCache",
+            get: // For tests.
+            function get() {
+                return _classPrivateFieldGet(this, _oldCache);
             }
         },
         {
             key: "get",
             value: function get(key) {
-                if (this.cache.has(key)) {
-                    var item = this.cache.get(key);
-                    return this._getItemValue(key, item);
+                if (_classPrivateFieldGet(this, _cache).has(key)) {
+                    var item = _classPrivateFieldGet(this, _cache).get(key);
+                    return _classPrivateMethodGet(this, _getItemValue, getItemValue).call(this, key, item);
                 }
-                if (this.oldCache.has(key)) {
-                    var item1 = this.oldCache.get(key);
-                    if (this._deleteIfExpired(key, item1) === false) {
-                        this._moveToRecent(key, item1);
+                if (_classPrivateFieldGet(this, _oldCache).has(key)) {
+                    var item1 = _classPrivateFieldGet(this, _oldCache).get(key);
+                    if (_classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, item1) === false) {
+                        _classPrivateMethodGet(this, _moveToRecent, moveToRecent).call(this, key, item1);
                         return item1.value;
                     }
                 }
@@ -573,16 +457,16 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
         },
         {
             key: "set",
-            value: function set(key, value) {
-                var ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _maxAge = ref.maxAge, maxAge = _maxAge === void 0 ? this.maxAge : _maxAge;
+            value: function set1(key, value) {
+                var ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _maxAge1 = ref.maxAge, maxAge = _maxAge1 === void 0 ? _classPrivateFieldGet(this, _maxAge) : _maxAge1;
                 var expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : undefined;
-                if (this.cache.has(key)) {
-                    this.cache.set(key, {
+                if (_classPrivateFieldGet(this, _cache).has(key)) {
+                    _classPrivateFieldGet(this, _cache).set(key, {
                         value: value,
                         expiry: expiry
                     });
                 } else {
-                    this._set(key, {
+                    _classPrivateMethodGet(this, _set, set).call(this, key, {
                         value: value,
                         expiry: expiry
                     });
@@ -593,42 +477,52 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
         {
             key: "has",
             value: function has(key) {
-                if (this.cache.has(key)) {
-                    return !this._deleteIfExpired(key, this.cache.get(key));
+                if (_classPrivateFieldGet(this, _cache).has(key)) {
+                    return !_classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, _classPrivateFieldGet(this, _cache).get(key));
                 }
-                if (this.oldCache.has(key)) {
-                    return !this._deleteIfExpired(key, this.oldCache.get(key));
+                if (_classPrivateFieldGet(this, _oldCache).has(key)) {
+                    return !_classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, _classPrivateFieldGet(this, _oldCache).get(key));
                 }
                 return false;
             }
         },
         {
             key: "peek",
-            value: function peek(key) {
-                if (this.cache.has(key)) {
-                    return this._peek(key, this.cache);
+            value: function peek1(key) {
+                if (_classPrivateFieldGet(this, _cache).has(key)) {
+                    return _classPrivateMethodGet(this, _peek, peek).call(this, key, _classPrivateFieldGet(this, _cache));
                 }
-                if (this.oldCache.has(key)) {
-                    return this._peek(key, this.oldCache);
+                if (_classPrivateFieldGet(this, _oldCache).has(key)) {
+                    return _classPrivateMethodGet(this, _peek, peek).call(this, key, _classPrivateFieldGet(this, _oldCache));
+                }
+            }
+        },
+        {
+            key: "expiresIn",
+            value: function expiresIn(key) {
+                var ref;
+                var item = (ref = _classPrivateFieldGet(this, _cache).get(key)) !== null && ref !== void 0 ? ref : _classPrivateFieldGet(this, _oldCache).get(key);
+                if (item) {
+                    return item.expiry ? item.expiry - Date.now() : Number.POSITIVE_INFINITY;
                 }
             }
         },
         {
             key: "delete",
             value: function _delete(key) {
-                var deleted = this.cache.delete(key);
+                var deleted = _classPrivateFieldGet(this, _cache).delete(key);
                 if (deleted) {
-                    this._size--;
+                    _classPrivateFieldUpdate(this, _size).value--;
                 }
-                return this.oldCache.delete(key) || deleted;
+                return _classPrivateFieldGet(this, _oldCache).delete(key) || deleted;
             }
         },
         {
             key: "clear",
             value: function clear() {
-                this.cache.clear();
-                this.oldCache.clear();
-                this._size = 0;
+                _classPrivateFieldGet(this, _cache).clear();
+                _classPrivateFieldGet(this, _oldCache).clear();
+                _classPrivateFieldSet(this, _size, 0);
             }
         },
         {
@@ -637,21 +531,40 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                 if (!(newSize && newSize > 0)) {
                     throw new TypeError("`maxSize` must be a number greater than 0");
                 }
-                var items = _toConsumableArray(this._entriesAscending());
+                var items = _toConsumableArray(_classPrivateMethodGet(this, _entriesAscending, entriesAscending).call(this));
                 var removeCount = items.length - newSize;
                 if (removeCount < 0) {
-                    this.cache = new Map(items);
-                    this.oldCache = new Map();
-                    this._size = items.length;
+                    _classPrivateFieldSet(this, _cache, new Map(items));
+                    _classPrivateFieldSet(this, _oldCache, new Map());
+                    _classPrivateFieldSet(this, _size, items.length);
                 } else {
                     if (removeCount > 0) {
-                        this._emitEvictions(items.slice(0, removeCount));
+                        _classPrivateMethodGet(this, _emitEvictions, emitEvictions).call(this, items.slice(0, removeCount));
                     }
-                    this.oldCache = new Map(items.slice(removeCount));
-                    this.cache = new Map();
-                    this._size = 0;
+                    _classPrivateFieldSet(this, _oldCache, new Map(items.slice(removeCount)));
+                    _classPrivateFieldSet(this, _cache, new Map());
+                    _classPrivateFieldSet(this, _size, 0);
+                }
+                _classPrivateFieldSet(this, _maxSize, newSize);
+            }
+        },
+        {
+            key: "evict",
+            value: function evict() {
+                var count = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 1;
+                var requested = Number(count);
+                if (!requested || requested <= 0) {
+                    return;
+                }
+                var items = _toConsumableArray(_classPrivateMethodGet(this, _entriesAscending, entriesAscending).call(this));
+                var evictCount = Math.trunc(Math.min(requested, Math.max(items.length - 1, 0)));
+                if (evictCount <= 0) {
+                    return;
                 }
-                this.maxSize = newSize;
+                _classPrivateMethodGet(this, _emitEvictions, emitEvictions).call(this, items.slice(0, evictCount));
+                _classPrivateFieldSet(this, _oldCache, new Map(items.slice(evictCount)));
+                _classPrivateFieldSet(this, _cache, new Map());
+                _classPrivateFieldSet(this, _size, 0);
             }
         },
         {
@@ -797,7 +710,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
             }
         },
         {
-            key: Symbol.iterator,
+            key: _iterator,
             value: function value() {
                 var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _item, key, value1, deleted, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, item1, _item1, key1, value2, deleted1, err;
                 return __generator(this, function(_state) {
@@ -812,7 +725,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                                 7,
                                 8
                             ]);
-                            _iterator = this.cache[Symbol.iterator]();
+                            _iterator = _classPrivateFieldGet(this, _cache)[Symbol.iterator]();
                             _state.label = 2;
                         case 2:
                             if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
@@ -821,7 +734,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                             ];
                             item = _step.value;
                             _item = _slicedToArray(item, 2), key = _item[0], value1 = _item[1];
-                            deleted = this._deleteIfExpired(key, value1);
+                            deleted = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, value1);
                             if (!(deleted === false)) return [
                                 3,
                                 4
@@ -878,7 +791,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                                 15,
                                 16
                             ]);
-                            _iterator1 = this.oldCache[Symbol.iterator]();
+                            _iterator1 = _classPrivateFieldGet(this, _oldCache)[Symbol.iterator]();
                             _state.label = 10;
                         case 10:
                             if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
@@ -887,11 +800,11 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                             ];
                             item1 = _step1.value;
                             _item1 = _slicedToArray(item1, 2), key1 = _item1[0], value2 = _item1[1];
-                            if (!!this.cache.has(key1)) return [
+                            if (!!_classPrivateFieldGet(this, _cache).has(key1)) return [
                                 3,
                                 12
                             ];
-                            deleted1 = this._deleteIfExpired(key1, value2);
+                            deleted1 = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key1, value2);
                             if (!(deleted1 === false)) return [
                                 3,
                                 12
@@ -953,7 +866,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                 return __generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
-                            items = _toConsumableArray(this.cache);
+                            items = _toConsumableArray(_classPrivateFieldGet(this, _cache));
                             i = items.length - 1;
                             _state.label = 1;
                         case 1:
@@ -963,7 +876,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                             ];
                             item = items[i];
                             _item = _slicedToArray(item, 2), key = _item[0], value = _item[1];
-                            deleted = this._deleteIfExpired(key, value);
+                            deleted = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, value);
                             if (!(deleted === false)) return [
                                 3,
                                 3
@@ -985,7 +898,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                                 1
                             ];
                         case 4:
-                            items = _toConsumableArray(this.oldCache);
+                            items = _toConsumableArray(_classPrivateFieldGet(this, _oldCache));
                             i1 = items.length - 1;
                             _state.label = 5;
                         case 5:
@@ -995,11 +908,11 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                             ];
                             item1 = items[i1];
                             _item1 = _slicedToArray(item1, 2), key1 = _item1[0], value1 = _item1[1];
-                            if (!!this.cache.has(key1)) return [
+                            if (!!_classPrivateFieldGet(this, _cache).has(key1)) return [
                                 3,
                                 7
                             ];
-                            deleted1 = this._deleteIfExpired(key1, value1);
+                            deleted1 = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key1, value1);
                             if (!(deleted1 === false)) return [
                                 3,
                                 7
@@ -1030,7 +943,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
         },
         {
             key: "entriesAscending",
-            value: function entriesAscending() {
+            value: function entriesAscending1() {
                 var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, key, value, err;
                 return __generator(this, function(_state) {
                     switch(_state.label){
@@ -1044,7 +957,7 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                                 7,
                                 8
                             ]);
-                            _iterator = this._entriesAscending()[Symbol.iterator]();
+                            _iterator = _classPrivateMethodGet(this, _entriesAscending, entriesAscending).call(this)[Symbol.iterator]();
                             _state.label = 2;
                         case 2:
                             if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
@@ -1105,15 +1018,15 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
         {
             key: "size",
             get: function get() {
-                if (!this._size) {
-                    return this.oldCache.size;
+                if (!_classPrivateFieldGet(this, _size)) {
+                    return _classPrivateFieldGet(this, _oldCache).size;
                 }
                 var oldCacheSize = 0;
                 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                 try {
-                    for(var _iterator = this.oldCache.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    for(var _iterator = _classPrivateFieldGet(this, _oldCache).keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                         var key = _step.value;
-                        if (!this.cache.has(key)) {
+                        if (!_classPrivateFieldGet(this, _cache).has(key)) {
                             oldCacheSize++;
                         }
                     }
@@ -1131,7 +1044,19 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
                         }
                     }
                 }
-                return Math.min(this._size + oldCacheSize, this.maxSize);
+                return Math.min(_classPrivateFieldGet(this, _size) + oldCacheSize, _classPrivateFieldGet(this, _maxSize));
+            }
+        },
+        {
+            key: "maxSize",
+            get: function get() {
+                return _classPrivateFieldGet(this, _maxSize);
+            }
+        },
+        {
+            key: "maxAge",
+            get: function get() {
+                return _classPrivateFieldGet(this, _maxAge);
             }
         },
         {
@@ -1167,11 +1092,225 @@ var QuickLRU = /*#__PURE__*/ function(Map1) {
             }
         },
         {
-            key: Symbol.toStringTag,
+            key: _toStringTag,
             get: function get() {
-                return JSON.stringify(_toConsumableArray(this.entriesAscending()));
+                return "QuickLRU";
+            }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                return "QuickLRU(".concat(this.size, "/").concat(this.maxSize, ")");
+            }
+        },
+        {
+            key: tmp,
+            value: function value() {
+                return this.toString();
             }
         }
     ]);
     return QuickLRU;
 }(_wrapNativeSuper(Map));
+function emitEvictions(cache) {
+    if (typeof _classPrivateFieldGet(this, _onEviction) !== "function") {
+        return;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = cache[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], item = _value[1];
+            _classPrivateFieldGet(this, _onEviction).call(this, key, item.value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+function deleteIfExpired(key, item) {
+    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
+        if (typeof _classPrivateFieldGet(this, _onEviction) === "function") {
+            _classPrivateFieldGet(this, _onEviction).call(this, key, item.value);
+        }
+        return this.delete(key);
+    }
+    return false;
+}
+function getOrDeleteIfExpired(key, item) {
+    var deleted = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, item);
+    if (deleted === false) {
+        return item.value;
+    }
+}
+function getItemValue(key, item) {
+    return item.expiry ? _classPrivateMethodGet(this, _getOrDeleteIfExpired, getOrDeleteIfExpired).call(this, key, item) : item.value;
+}
+function peek(key, cache) {
+    var item = cache.get(key);
+    return _classPrivateMethodGet(this, _getItemValue, getItemValue).call(this, key, item);
+}
+function set(key, value) {
+    _classPrivateFieldGet(this, _cache).set(key, value);
+    _classPrivateFieldUpdate(this, _size).value++;
+    if (_classPrivateFieldGet(this, _size) >= _classPrivateFieldGet(this, _maxSize)) {
+        _classPrivateFieldSet(this, _size, 0);
+        _classPrivateMethodGet(this, _emitEvictions, emitEvictions).call(this, _classPrivateFieldGet(this, _oldCache));
+        _classPrivateFieldSet(this, _oldCache, _classPrivateFieldGet(this, _cache));
+        _classPrivateFieldSet(this, _cache, new Map());
+    }
+}
+function moveToRecent(key, item) {
+    _classPrivateFieldGet(this, _oldCache).delete(key);
+    _classPrivateMethodGet(this, _set, set).call(this, key, item);
+}
+function entriesAscending() {
+    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _item, key, value, deleted, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, item1, _item1, key1, value1, deleted1, err;
+    return __generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    6,
+                    7,
+                    8
+                ]);
+                _iterator = _classPrivateFieldGet(this, _oldCache)[Symbol.iterator]();
+                _state.label = 2;
+            case 2:
+                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                    3,
+                    5
+                ];
+                item = _step.value;
+                _item = _slicedToArray(item, 2), key = _item[0], value = _item[1];
+                if (!!_classPrivateFieldGet(this, _cache).has(key)) return [
+                    3,
+                    4
+                ];
+                deleted = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key, value);
+                if (!(deleted === false)) return [
+                    3,
+                    4
+                ];
+                return [
+                    4,
+                    item
+                ];
+            case 3:
+                _state.sent();
+                _state.label = 4;
+            case 4:
+                _iteratorNormalCompletion = true;
+                return [
+                    3,
+                    2
+                ];
+            case 5:
+                return [
+                    3,
+                    8
+                ];
+            case 6:
+                err = _state.sent();
+                _didIteratorError = true;
+                _iteratorError = err;
+                return [
+                    3,
+                    8
+                ];
+            case 7:
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 8:
+                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                _state.label = 9;
+            case 9:
+                _state.trys.push([
+                    9,
+                    14,
+                    15,
+                    16
+                ]);
+                _iterator1 = _classPrivateFieldGet(this, _cache)[Symbol.iterator]();
+                _state.label = 10;
+            case 10:
+                if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                    3,
+                    13
+                ];
+                item1 = _step1.value;
+                _item1 = _slicedToArray(item1, 2), key1 = _item1[0], value1 = _item1[1];
+                deleted1 = _classPrivateMethodGet(this, _deleteIfExpired, deleteIfExpired).call(this, key1, value1);
+                if (!(deleted1 === false)) return [
+                    3,
+                    12
+                ];
+                return [
+                    4,
+                    item1
+                ];
+            case 11:
+                _state.sent();
+                _state.label = 12;
+            case 12:
+                _iteratorNormalCompletion1 = true;
+                return [
+                    3,
+                    10
+                ];
+            case 13:
+                return [
+                    3,
+                    16
+                ];
+            case 14:
+                err = _state.sent();
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+                return [
+                    3,
+                    16
+                ];
+            case 15:
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+                return [
+                    7
+                ];
+            case 16:
+                return [
+                    2
+                ];
+        }
+    });
+}

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@common.js/quick-lru",
-  "version": "6.1.2",
+  "version": "7.3.0",
   "description": "quick-lru package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",
   "type": "commonjs",
+  "sideEffects": false,
   "engines": {
-    "node": ">=12"
+    "node": ">=18"
   },
   "scripts": {
-    "//test": "xo && nyc ava && tsd",
-    "test": "xo && ava"
+    "test": "xo && nyc ava && tsd"
   },
   "files": [
     "index.js",
     "index.d.ts"
   ],
   "devDependencies": {
-    "ava": "^3.15.0",
+    "ava": "^5.3.1",
     "nyc": "^15.1.0",
-    "tsd": "^0.14.0",
-    "xo": "^0.37.1"
+    "tsd": "^0.29.0",
+    "xo": "^0.56.0"
   },
   "nyc": {
     "reporter": [
@@ -31,5 +31,6 @@
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
   "dependencies": {},
-  "main": "./index.js"
+  "main": "./index.js",
+  "types": "./index.d.ts"
 }