init

node_modules/weak-lru-cache/LRFUExpirer.js

@@ -0,0 +1,151 @@
+const PINNED_IN_MEMORY = 0x7fffffff
+const NOT_IN_LRU = 0x40000000
+export const EXPIRED_ENTRY = {
+	description: 'This cache entry value has been expired from the LRFU cache, and is waiting for garbage collection to be removed.'
+}
+/* bit pattern:
+*  < is-in-lru 1 bit > ...< mask/or bits 6 bits > <lru index 2 bits > < position in cache - 22 bits >
+*/
+export class LRFUExpirer {
+	constructor(options) {
+		this.lruSize = options && options.lruSize || 0x2000
+		if (this.lruSize > 0x400000)
+			throw new Error('The LRU/cache size was larger than the maximum cache size of 16777216 (LRU size of 4194304)')
+		this.reset()
+		startTimedCleanup(new WeakRef(this), options && options.cleanupInterval || 60000)
+	}
+	delete(entry) {
+		if (entry.position < NOT_IN_LRU) {
+			this.lru[(entry.position >> 22) & 3][entry.position & 0x3fffff] = null
+		}
+		entry.position |= NOT_IN_LRU
+	}
+	used(entry, expirationPriority) {
+		let originalPosition = entry.position
+		let orMask
+		if (expirationPriority < 0) {
+			// pin this in memory, first remove from LRFU and then mark it as pinned in memory
+			if (entry.position < NOT_IN_LRU) {
+				this.lru[(entry.position >> 22) & 3][entry.position & 0x3fffff] = null
+			}
+			entry.position = PINNED_IN_MEMORY
+			return
+		} else if (entry.position == PINNED_IN_MEMORY && expirationPriority == undefined) {
+			return
+		} else if (expirationPriority >= 0) {
+			let bits = 0
+			if (expirationPriority > (this.lruSize >> 2))
+				expirationPriority = this.lruSize >> 2
+			while (expirationPriority > 0) {
+				expirationPriority = expirationPriority >> 1
+				bits++
+			}
+			expirationPriority = bits
+		} else {
+			if (originalPosition >= 0)
+				expirationPriority = (originalPosition >> 24) & 0x3f
+			else
+				expirationPriority = 0
+		}
+		
+		let lruPosition
+		let lruIndex
+		if (originalPosition < NOT_IN_LRU) {
+			lruIndex = (originalPosition >> 22) & 3
+			if (lruIndex >= 3)
+				return // can't get any higher than this, don't do anything
+			let lru = this.lru[lruIndex]
+			// check to see if it is in the same generation
+			lruPosition = lru.position
+			if ((originalPosition > lruPosition ? lruPosition + this.lruSize : lruPosition) - originalPosition < (this.lruSize >> 2))
+				return // only recently added, don't promote
+			lru[originalPosition & 0x3fffff] = null // remove it, we are going to move/promote it
+			lruIndex++
+		} else
+			lruIndex = 0
+		this.insertEntry(entry, lruIndex, expirationPriority)
+	}
+	insertEntry(entry, lruIndex, expirationPriority) {
+		let lruPosition, nextLru = this.lru[lruIndex]
+		let orMask = 0x3fffff >> (22 - expirationPriority)
+		do {
+			// put it in the next lru
+			lruPosition = nextLru.position | orMask
+			let previousEntry = nextLru[lruPosition & 0x3fffff]
+			nextLru[lruPosition & 0x3fffff] = entry
+			if (entry)
+				entry.position = lruPosition | (expirationPriority << 24)
+			nextLru.position = ++lruPosition
+			if ((lruPosition & 0x3fffff) >= this.lruSize) {
+				// reset at the beginning of the lru cache
+				lruPosition &= 0x7fc00000
+				nextLru.position = lruPosition
+				nextLru.cycles++
+			}
+			entry = previousEntry
+			if (entry && (nextLru = this.lru[--lruIndex])) {
+				expirationPriority = ((entry.position || 0) >> 24) & 0x3f
+				orMask = 0x3fffff >> (22 - expirationPriority)
+			} else
+				break
+		} while (true)
+		if (entry) {// this one was removed
+			entry.position |= NOT_IN_LRU
+			if (entry.cache)
+				entry.cache.onRemove(entry)
+			else if (entry.deref) // if we have already registered the entry in the finalization registry, just clear it
+				entry.value = EXPIRED_ENTRY
+		}
+	}
+	reset() {
+	/*	if (this.lru) {
+			for (let i = 0; i < 4; i++) {
+				for (let j = 0, l = this.lru.length; j < l; j++) {
+					let entry =	this.lru[i][j]
+					if (entry) {// this one was removed
+						entry.position |= NOT_IN_LRU
+						if (entry.cache)
+							entry.cache.onRemove(entry)
+						else if (entry.deref) // if we have already registered the entry in the finalization registry, just clear it
+							entry.value = EXPIRED_ENTRY
+					}
+				}
+			}
+		}*/
+		this.lru = []
+		for (let i = 0; i < 4; i++) {
+			this.lru[i] = new Array(this.lruSize)
+			this.lru[i].position = i << 22
+			this.lru[i].cycles = 0
+		}
+	}
+	cleanup() { // clean out a portion of the cache, so we can clean up over time if idle
+		let toClear = this.lruSize >> 4 // 1/16 of the lru cache at a time
+		for (let i = 3; i >= 0; i--) {
+			let lru = this.lru[i]
+			for (let j = 0, l = toClear; j < l; j++) {
+				if (lru[lru.position & 0x3fffff]) {
+					toClear--
+					this.insertEntry(null, i, 0)
+				} else {
+					if ((++lru.position & 0x3fffff) >= this.lruSize) {
+						// reset at the beginning of the lru cache
+						lru.position &= 0x7fc00000
+						lru.cycles++
+					}
+				}
+			}
+		}
+	}
+}
+function startTimedCleanup(reference, cleanupInterval) {
+	let interval = setInterval(() => {
+		let expirer = reference.deref()
+		if (expirer)
+			expirer.cleanup()
+		else
+			clearInterval(interval)
+	}, cleanupInterval)
+	if (interval.unref)
+		interval.unref()
+}

node_modules/weak-lru-cache/README.md

@@ -0,0 +1,80 @@
+[![npm version](https://img.shields.io/npm/dw/weak-lru-cache)](https://www.npmjs.org/package/weak-lru-cache)
+[![npm version](https://img.shields.io/npm/v/weak-lru-cache.svg?style=flat-square)](https://www.npmjs.org/package/weak-lru-cache)
+[![license](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
+
+# weak-lru-cache
+
+The weak-lru-cache package provides a powerful cache that works in harmony with the JS garbage collection (GC) and least-recently used (LRU) and least-freqently used (LFU) expiration strategy to help cache data with highly optimized cache retention. It uses LRU/LFU (LRFU) expiration to retain referenced data, and then once data has been inactive, it uses weak references (and finalization registry) to allow GC to remove the cached data as part of the normal GC cycles, but still continue to provide cached access to the data as long as it still resides in memory and hasn't been collected. This provides the best of modern expiration strategies combined with optimal GC interaction.
+
+In a typical GC'ed VM, objects may continue to exist in memory long after they are no longer (strongly) referenced, but using a weak-referencing cached, we allow the GC to collect such data, but the cache can return this data up until the point it is garbaged collected, ensuring much more efficient use of memory.
+
+This can also be used to ensure a single object identity per key. By storing an object in the cache for a given key, we can check the cache whenever we need that object, and before recreating it, thereby giving us the means to ensure we also use the same object for a given key as long as it still exists in memory.
+
+This project is tested and run NodeJS and Deno (requires NodeJS v14.10 or higher or Node v13.0 with --harmony-weak-ref flag).
+
+## Setup
+
+Install with (NPM):
+
+```
+npm i weak-lru-cache
+```
+And `import` or `require` it to access the constructor:
+```
+import { WeakLRUCache } from 'weak-lru-cache';
+
+let myCache = new WeakLRUCache();
+myValue.setValue('key', { greeting: 'hello world' });
+myValue.getValue('key') -> return the object above as long as it is still cached
+```
+Or in Deno, import directly from the [`weakcache` deno.land package](https://deno.land/x/weakcache):
+```
+import { WeakLRUCache } from 'https://deno.land/x/weakcache/index.js';
+...
+```
+
+## Basic Usage
+
+The `WeakLRUCache` class extends the native `Map` class and also includes the following methods, which are the primary intended interactions with the cache:
+
+### getValue(key)
+Gets the value referenced by the given key and returns it. If the value is no longer cached, will return undefined. 
+
+### setValue(key, value, expirationPriority?)
+Sets or inserts the value into the cache, with the given key. This will create a new cache entry to reference your provided value. This also returns the cache entry.
+
+The `key` can be any JS value.
+
+If the `value` is an object, it will be stored in the cache, until it expires (as determined by the LRFU expiration policy), *and* is garbage collected. If you provide a primitive value (string, number, boolean, null, etc.), this can not be weakly referenced, so the value will still be stored in the LRFU cache, but once it expires, it will immediately be removed, rather than waiting for GC.
+
+The `expirationPriority` is an optional directive indicating how quickly the cache entry should expire. A higher value will indicate the entry should expire sooner. This can be used to help limit the amount of memory used by cache if you are loading large objects. Using the default cache size, and entries with varied expirationPriority values, the expiration cache will typically hold a sum of about 100,000 of the expirationPriority values. This means that if you wanted to have a cache to stay around or under 100MB, you could provide the size, divided by 1000 (or using `>> 10` is much faster), as the expirationPriority:
+```
+myCache.setValue('key', bigObject, sizeOfObject >> 10);
+```
+The `expirationPriority` can also be set to `-1` that the value should be `pinned` in memory and never expire, until the entry has been changed (with a positive `expirationPriority`).
+
+## `WeakLRUCache(options)` Constructor
+
+The `WeakLRUCache` constructor supports an optional `options` object parameter that allows specific configuration and cache tuning. The following properties (all optional) can be defined on the `options` object:
+
+### cacheSize
+This indicates the number of entries to allocate in the cache. This defaults to 32,768, and the maximum allowed value is 16,777,216.
+
+### expirer
+By default there is a single shared expiration cache, that is a single instance of `LRFUExpirer`. However, you can define your own expiration cache or create separate instances of LRFUExpirer. Generally using a (the default) single instance is preferable since it naturally gives higher priority/recency to more heavily used caches, and allows lesser used caches to expire more of their entries.
+
+You can also set this to `false` to indicate that no LRU/LRFU cache should be used and the cache should rely entirely on weak-references.
+
+### deferRegister
+This flag can be set to true to save key and cache information so that it can defer the finalization registration. This tends to be slightly faster for caches that are more heavily dominated by lots of entry replacements (multiple setValue calls to same entries before they expire). However, for (what is generally considered more typical) usage more dominated by setting values and getting them until they expire, the default setting will probably be faster.
+
+
+## Using Cache Entries
+
+The `WeakLRUCache` class extends the native `Map` class, and consequently, all the standard Map methods are available. As a Map, all the values are cache entries, which are typically `WeakRef` objects that hold a reference to the cached value, along with retention information. This means that the `get(key)` differs from `getValue(key)` in that it returns the cache entry, which references the value, rather than the value itself.
+
+The cache entries also can contain metadata about the entry, including information about the cache entries position in the LRFU cache that informs when it will expire. However, you can also set your own properties on the cache entry to store you own metadata. This will be retained until the entry is removed/collected.
+
+## License
+
+MIT

node_modules/weak-lru-cache/dist/index.cjs

@@ -0,0 +1,292 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const PINNED_IN_MEMORY = 0x7fffffff;
+const NOT_IN_LRU = 0x40000000;
+const EXPIRED_ENTRY = {
+	description: 'This cache entry value has been expired from the LRFU cache, and is waiting for garbage collection to be removed.'
+};
+/* bit pattern:
+*  < is-in-lru 1 bit > ...< mask/or bits 6 bits > <lru index 2 bits > < position in cache - 22 bits >
+*/
+class LRFUExpirer {
+	constructor(options) {
+		this.lruSize = options && options.lruSize || 0x2000;
+		if (this.lruSize > 0x400000)
+			throw new Error('The LRU/cache size was larger than the maximum cache size of 16777216 (LRU size of 4194304)')
+		this.reset();
+		startTimedCleanup(new WeakRef(this), options && options.cleanupInterval || 60000);
+	}
+	delete(entry) {
+		if (entry.position < NOT_IN_LRU) {
+			this.lru[(entry.position >> 22) & 3][entry.position & 0x3fffff] = null;
+		}
+		entry.position |= NOT_IN_LRU;
+	}
+	used(entry, expirationPriority) {
+		let originalPosition = entry.position;
+		if (expirationPriority < 0) {
+			// pin this in memory, first remove from LRFU and then mark it as pinned in memory
+			if (entry.position < NOT_IN_LRU) {
+				this.lru[(entry.position >> 22) & 3][entry.position & 0x3fffff] = null;
+			}
+			entry.position = PINNED_IN_MEMORY;
+			return
+		} else if (entry.position == PINNED_IN_MEMORY && expirationPriority == undefined) {
+			return
+		} else if (expirationPriority >= 0) {
+			let bits = 0;
+			if (expirationPriority > (this.lruSize >> 2))
+				expirationPriority = this.lruSize >> 2;
+			while (expirationPriority > 0) {
+				expirationPriority = expirationPriority >> 1;
+				bits++;
+			}
+			expirationPriority = bits;
+		} else {
+			if (originalPosition >= 0)
+				expirationPriority = (originalPosition >> 24) & 0x3f;
+			else
+				expirationPriority = 0;
+		}
+		
+		let lruPosition;
+		let lruIndex;
+		if (originalPosition < NOT_IN_LRU) {
+			lruIndex = (originalPosition >> 22) & 3;
+			if (lruIndex >= 3)
+				return // can't get any higher than this, don't do anything
+			let lru = this.lru[lruIndex];
+			// check to see if it is in the same generation
+			lruPosition = lru.position;
+			if ((originalPosition > lruPosition ? lruPosition + this.lruSize : lruPosition) - originalPosition < (this.lruSize >> 2))
+				return // only recently added, don't promote
+			lru[originalPosition & 0x3fffff] = null; // remove it, we are going to move/promote it
+			lruIndex++;
+		} else
+			lruIndex = 0;
+		this.insertEntry(entry, lruIndex, expirationPriority);
+	}
+	insertEntry(entry, lruIndex, expirationPriority) {
+		let lruPosition, nextLru = this.lru[lruIndex];
+		let orMask = 0x3fffff >> (22 - expirationPriority);
+		do {
+			// put it in the next lru
+			lruPosition = nextLru.position | orMask;
+			let previousEntry = nextLru[lruPosition & 0x3fffff];
+			nextLru[lruPosition & 0x3fffff] = entry;
+			if (entry)
+				entry.position = lruPosition | (expirationPriority << 24);
+			nextLru.position = ++lruPosition;
+			if ((lruPosition & 0x3fffff) >= this.lruSize) {
+				// reset at the beginning of the lru cache
+				lruPosition &= 0x7fc00000;
+				nextLru.position = lruPosition;
+				nextLru.cycles++;
+			}
+			entry = previousEntry;
+			if (entry && (nextLru = this.lru[--lruIndex])) {
+				expirationPriority = ((entry.position || 0) >> 24) & 0x3f;
+				orMask = 0x3fffff >> (22 - expirationPriority);
+			} else
+				break
+		} while (true)
+		if (entry) {// this one was removed
+			entry.position |= NOT_IN_LRU;
+			if (entry.cache)
+				entry.cache.onRemove(entry);
+			else if (entry.deref) // if we have already registered the entry in the finalization registry, just clear it
+				entry.value = EXPIRED_ENTRY;
+		}
+	}
+	reset() {
+	/*	if (this.lru) {
+			for (let i = 0; i < 4; i++) {
+				for (let j = 0, l = this.lru.length; j < l; j++) {
+					let entry =	this.lru[i][j]
+					if (entry) {// this one was removed
+						entry.position |= NOT_IN_LRU
+						if (entry.cache)
+							entry.cache.onRemove(entry)
+						else if (entry.deref) // if we have already registered the entry in the finalization registry, just clear it
+							entry.value = EXPIRED_ENTRY
+					}
+				}
+			}
+		}*/
+		this.lru = [];
+		for (let i = 0; i < 4; i++) {
+			this.lru[i] = new Array(this.lruSize);
+			this.lru[i].position = i << 22;
+			this.lru[i].cycles = 0;
+		}
+	}
+	cleanup() { // clean out a portion of the cache, so we can clean up over time if idle
+		let toClear = this.lruSize >> 4; // 1/16 of the lru cache at a time
+		for (let i = 3; i >= 0; i--) {
+			let lru = this.lru[i];
+			for (let j = 0, l = toClear; j < l; j++) {
+				if (lru[lru.position & 0x3fffff]) {
+					toClear--;
+					this.insertEntry(null, i, 0);
+				} else {
+					if ((++lru.position & 0x3fffff) >= this.lruSize) {
+						// reset at the beginning of the lru cache
+						lru.position &= 0x7fc00000;
+						lru.cycles++;
+					}
+				}
+			}
+		}
+	}
+}
+function startTimedCleanup(reference, cleanupInterval) {
+	let interval = setInterval(() => {
+		let expirer = reference.deref();
+		if (expirer)
+			expirer.cleanup();
+		else
+			clearInterval(interval);
+	}, cleanupInterval);
+	if (interval.unref)
+		interval.unref();
+}
+
+let defaultExpirer;
+class WeakLRUCache extends Map  {
+	constructor(options) {
+		super();
+		this.hits = 0;
+		this.misses = 0;
+		if (options && options.cacheSize) {
+			options.lruSize = options.cacheSize >> 2;
+		}
+		if (options && options.clearKeptInterval) {
+			this.clearKeptInterval = options.clearKeptInterval;
+			this.clearKeptCount = 0;
+			this.clearKeptObjects = options.clearKeptObjects;
+		}
+		this.expirer = (options ? options.expirer === false ? defaultNoLRUExpirer : options.expirer : null) || defaultExpirer || (defaultExpirer = new LRFUExpirer(options));
+		this.deferRegister = Boolean(options && options.deferRegister);
+		let registry = this.registry = new FinalizationRegistry(key => {
+			let entry = super.get(key);
+			if (entry && entry.deref && entry.deref() === undefined)
+				super.delete(key);
+		});
+	}
+	onRemove(entry) {
+		let target = entry.deref && entry.deref();
+		if (target) {
+			// remove strong reference, so only a weak reference, wait until it is finalized to remove
+			this.registry.register(target, entry.key);
+			entry.value = undefined;
+		} else if (entry.key) {
+			let currentEntry = super.get(entry.key);
+			if (currentEntry === entry)
+				super.delete(entry.key);
+		}
+	}
+	get(key, mode) {
+		let entry = super.get(key);
+		let value;
+		if (entry) {
+			this.hits++;
+			value = entry.value;
+			if (value === EXPIRED_ENTRY) {
+				value = entry.deref && entry.deref();
+				if (value === undefined)
+					super.delete(key);
+				else {
+					entry.value = value;
+					if (this.clearKeptInterval)
+						this.incrementClearKeptCount();
+					if (mode !== 1)
+						this.expirer.used(entry);
+					return mode === 2 ? value : entry
+				}
+			}
+			else {
+				if (mode !== 1)
+					this.expirer.used(entry);
+				return mode === 2 ? value : entry
+			}
+		} else
+			this.misses++;
+	}
+	getValue(key) {
+		return this.get(key, 2)
+	}
+
+	setValue(key, value, expirationPriority) {
+		let entry;
+		if (value && typeof value == 'object') {
+			entry = new WeakRef(value);
+			if (this.clearKeptInterval)
+				this.incrementClearKeptCount();
+			entry.value = value;
+			if (this.deferRegister) {
+				entry.key = key;
+				entry.cache = this;
+			} else
+				this.registry.register(value, key);
+		} else if (value !== undefined)
+			entry = { value, key, cache: this };
+		// else entry is undefined
+		this.set(key, entry, expirationPriority);
+		return entry
+	}
+	incrementClearKeptCount() {
+		if (++this.clearKeptCount >= this.clearKeptInterval) {
+			this.clearKeptCount = 0;
+			if (this.clearKeptObjects)
+				this.clearKeptObjects();
+			if (this.registry.cleanupSome)
+				this.registry.cleanupSome();
+		}
+	}
+	set(key, entry, expirationPriority) {
+		let oldEntry = super.get(key);
+		if (oldEntry)
+			this.expirer.delete(oldEntry);
+		return this.insert(key, entry, expirationPriority)
+	}
+	insert(key, entry, expirationPriority) {
+		if (entry) {
+			this.expirer.used(entry, expirationPriority);
+		}
+		return super.set(key, entry)
+	}
+	delete(key) {
+		let oldEntry = super.get(key);
+		if (oldEntry) {
+			this.expirer.delete(oldEntry);
+		}
+		return super.delete(key)
+	}
+	used(entry, expirationPriority) {
+		this.expirer.used(entry, expirationPriority);
+	}
+	clear() {
+		for (let [ key, entry ] of this) {
+			this.expirer.delete(entry);
+			super.delete(key);
+		}
+	}
+}
+
+class NoLRUExpirer {
+	used(entry) {
+		if (entry.cache)
+			entry.cache.onRemove(entry);
+		else if (entry.deref) // if we have already registered the entry in the finalization registry, just mark it expired from the beginning
+			entry.value = EXPIRED_ENTRY;
+	}
+	delete(entry) {
+		// nothing to do here, we don't have a separate cache here
+	}
+}
+const defaultNoLRUExpirer = new NoLRUExpirer();
+
+exports.LRFUExpirer = LRFUExpirer;
+exports.WeakLRUCache = WeakLRUCache;

node_modules/weak-lru-cache/index.d.ts

@@ -0,0 +1,36 @@
+interface LRFUExpirerOptions {
+  lruSize?: number;
+  cleanupInterval?: number;
+}
+
+export class LRFUExpirer {
+  constructor(options?: LRFUExpirerOptions);
+}
+
+interface WeakLRUCacheOptions {
+  cacheSize?: number;
+  expirer?: LRFUExpirer | false;
+  deferRegister?: boolean;
+}
+
+export class CacheEntry<V> {
+  value?: V
+  deref?(): V
+}
+
+export class WeakLRUCache<K, V> extends Map<K, CacheEntry<V>> {
+  constructor(options?: WeakLRUCacheOptions);
+
+  /**
+   * Get a value from the cache, if it is still in memory. If the value is no longer cached, will return undefined.
+   * @param key The key to use to retrieve the value
+   */
+  getValue(key: K): V | undefined;
+  /**
+   * Put a key-value into the cache
+   * @param key The key to use to insert the entry
+   * @param value The value to insert into the cache
+   * @param expirationPriority A priority for expiration, a higher value will expire sooner
+   */
+   setValue(key: K, value: V, expirationPriority?: number): void;
+}

node_modules/weak-lru-cache/index.js

@@ -0,0 +1,137 @@
+import { LRFUExpirer, EXPIRED_ENTRY } from './LRFUExpirer.js'
+export { LRFUExpirer } from './LRFUExpirer.js'
+
+let defaultExpirer
+export class WeakLRUCache extends Map  {
+	constructor(options) {
+		super()
+		this.hits = 0
+		this.misses = 0
+		if (options && options.cacheSize) {
+			options.lruSize = options.cacheSize >> 2
+		}
+		if (options && options.clearKeptInterval) {
+			this.clearKeptInterval = options.clearKeptInterval
+			this.clearKeptCount = 0
+			this.clearKeptObjects = options.clearKeptObjects
+		}
+		this.expirer = (options ? options.expirer === false ? defaultNoLRUExpirer : options.expirer : null) || defaultExpirer || (defaultExpirer = new LRFUExpirer(options))
+		this.deferRegister = Boolean(options && options.deferRegister)
+		let registry = this.registry = new FinalizationRegistry(key => {
+			let entry = super.get(key)
+			if (entry && entry.deref && entry.deref() === undefined)
+				super.delete(key)
+		})
+	}
+	onRemove(entry) {
+		let target = entry.deref && entry.deref()
+		if (target) {
+			// remove strong reference, so only a weak reference, wait until it is finalized to remove
+			this.registry.register(target, entry.key)
+			entry.value = undefined
+		} else if (entry.key) {
+			let currentEntry = super.get(entry.key)
+			if (currentEntry === entry)
+				super.delete(entry.key)
+		}
+	}
+	get(key, mode) {
+		let entry = super.get(key)
+		let value
+		if (entry) {
+			this.hits++
+			value = entry.value
+			if (value === EXPIRED_ENTRY) {
+				value = entry.deref && entry.deref()
+				if (value === undefined)
+					super.delete(key)
+				else {
+					entry.value = value
+					if (this.clearKeptInterval)
+						this.incrementClearKeptCount()
+					if (mode !== 1)
+						this.expirer.used(entry)
+					return mode === 2 ? value : entry
+				}
+			}
+			else {
+				if (mode !== 1)
+					this.expirer.used(entry)
+				return mode === 2 ? value : entry
+			}
+		} else
+			this.misses++
+	}
+	getValue(key) {
+		return this.get(key, 2)
+	}
+
+	setValue(key, value, expirationPriority) {
+		let entry
+		if (value && typeof value == 'object') {
+			entry = new WeakRef(value)
+			if (this.clearKeptInterval)
+				this.incrementClearKeptCount()
+			entry.value = value
+			if (this.deferRegister) {
+				entry.key = key
+				entry.cache = this
+			} else
+				this.registry.register(value, key)
+		} else if (value !== undefined)
+			entry = { value, key, cache: this }
+		// else entry is undefined
+		this.set(key, entry, expirationPriority)
+		return entry
+	}
+	incrementClearKeptCount() {
+		if (++this.clearKeptCount >= this.clearKeptInterval) {
+			this.clearKeptCount = 0
+			if (this.clearKeptObjects)
+				this.clearKeptObjects()
+			if (this.registry.cleanupSome)
+				this.registry.cleanupSome()
+		}
+	}
+	set(key, entry, expirationPriority) {
+		let oldEntry = super.get(key)
+		if (oldEntry)
+			this.expirer.delete(oldEntry)
+		return this.insert(key, entry, expirationPriority)
+	}
+	insert(key, entry, expirationPriority) {
+		if (entry) {
+			this.expirer.used(entry, expirationPriority)
+		}
+		return super.set(key, entry)
+	}
+	delete(key) {
+		let oldEntry = super.get(key)
+		if (oldEntry) {
+			this.expirer.delete(oldEntry)
+		}
+		return super.delete(key)
+	}
+	used(entry, expirationPriority) {
+		this.expirer.used(entry, expirationPriority)
+	}
+	clear() {
+		for (let [ key, entry ] of this) {
+			this.expirer.delete(entry)
+			super.delete(key)
+		}
+	}
+}
+
+class NoLRUExpirer {
+	used(entry) {
+		if (entry.cache)
+			entry.cache.onRemove(entry)
+		else if (entry.deref) // if we have already registered the entry in the finalization registry, just mark it expired from the beginning
+			entry.value = EXPIRED_ENTRY
+	}
+	delete(entry) {
+		// nothing to do here, we don't have a separate cache here
+	}
+}
+const defaultNoLRUExpirer = new NoLRUExpirer()

node_modules/weak-lru-cache/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "weak-lru-cache",
+  "author": "Kris Zyp",
+  "version": "1.2.2",
+  "description": "An LRU cache of weak references",
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "keywords": [
+    "cache",
+    "weak",
+    "references",
+    "LRU",
+    "LRFU"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/kriszyp/weak-lru-cache"
+  },
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./index.js"
+    },
+    "./index.js": {
+      "require": "./dist/index.cjs",
+      "import": "./index.js"
+    }
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "prepare": "rollup -c",
+    "test": "./node_modules/.bin/mocha tests/test*.js -u tdd"
+  },
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "chai": "^4",
+    "mocha": "^8",
+    "rollup": "^1.20.3"
+  }
+}

node_modules/weak-lru-cache/rollup.config.js

@@ -0,0 +1,11 @@
+export default [
+    {
+        input: "index.js",
+        output: [
+            {
+                file: "dist/index.cjs",
+                format: "cjs"
+            }
+        ]
+    }
+];

node_modules/weak-lru-cache/tests/benchmark.js

@@ -0,0 +1,46 @@
+var inspector = require('inspector')
+//inspector.open(9330, null, true)
+var benchmark = require('benchmark')
+const { WeakLRUCache } = require('..')
+var suite = new benchmark.Suite();
+
+let cache = new WeakLRUCache()
+cache.loadValue = function() {
+	return {}
+}
+let strongObject = cache.getValue(1)
+
+function hit() {
+	let o = cache.getValue(1)
+}
+let i = 0
+let time = 0
+function miss(deferred) {
+	i++
+	cache.getValue(i)
+	if (i % 30000== 0) {
+		let lastTime = time
+		time = Date.now()
+		sizes.push(cache.size, time-lastTime)
+		return setImmediate(() => deferred.resolve(), 10)
+	}
+	if (i % 100 == 0)
+		return Promise.resolve().then(() => deferred.resolve())
+
+	deferred.resolve()
+}
+let sizes = []
+//suite.add('hit', hit);
+suite.add('miss', {
+	defer: true,
+	fn: miss,
+})
+suite.on('cycle', function (event) {
+console.log(String(event.target));
+});
+suite.on('complete', function () {
+  console.log('Fastest is ' + this.filter('fastest').map('name'));
+  console.log(JSON.stringify(sizes))
+});
+
+suite.run({ async: true });

node_modules/weak-lru-cache/tests/test.js

@@ -0,0 +1,18 @@
+import { WeakLRUCache } from '../index.js'
+import chai from 'chai'
+const assert = chai.assert
+let cache = new WeakLRUCache()
+
+suite('WeakLRUCache basic tests', function(){
+	test('add entries', function(){
+		let entry = cache.getValue(2)
+		assert.equal(entry, undefined)
+		let obj = {}
+		cache.setValue(2, obj)
+		assert.equal(cache.getValue(2), obj)
+		debugger
+		if (cache.expirer.clean)
+			cache.expirer.clean()
+		assert.equal(cache.getValue(2), obj)
+	})
+})