LRU cache implementation in base JS

[LTLA]

As promised. As JS doesn't have a base ordered map, we instead use a history array that cross-references a key-value store. Touching the store will update the history, and when we hit the limit, we search the history to evict old entries from the store. This requires some semi-regular garbage collection on the history array to avoid accumulating the access records.

class LeastRecentlyUsedCache {
    #store;
    #history;
    #limit;
    #callback;

    constructor(limit, { callback = null } = {}) {
        this.#store = new Map;
        this.#history = [];
        this.#limit = limit;
        this.#callback = (callback == null ? x => {} : callback);
    }

    #gc() {
        if (this.#history > this.#limit * 5) {
            let replacement = [];
            for (const x of this.#history) {
                if (x !== null) {
                    this.#store.get(x).last_access = replacement.length;
                    replacement.push(x);
                }
            }
            this.#history = replacement;
        }
    }

    #touch(key, exists) {
        // Don't bother updating it if it's already the last-accessed.
        if (exists.last_access !== this.#history - 1) {
            this.#history[exists.last_access] = null;
            exists.last_access = this.#history.length;
        }
        this.#gc();
        this.#history.push(key);
    }

    set(key, value) {
        let exists = this.#store.get(key);
        if (typeof exists !== "undefined") {
            this.#touch(key, exists);
            exists.value = value;
        } else {
            // Flushing.
            if (this.#store.size == this.#limit) {
                let i = 0;
                while (i < this.#history.length) {
                    let x = this.#history[i];
                    if (x !== null) {
                        this.#history[i] = null;
                        this.#callback(this.#store.get(x).value);
                        this.#store.delete(x);
                        break;
                    }
                    i++;
                }
            }

            this.#gc();
            this.#store.set(key, { value: value, last_access: this.#history.length });
            this.#history.push(key);
        }
    }

    get(key) {
        let exists = this.#store.get(key);
        if (typeof exists === "undefined") {
            throw new Error("failed to find key '" + key + "' in the cache");
        }
        this.#touch(key, exists);
        return exists.value;
    }

    delete(key) {
        let exists = this.#store.get(key);
        if (typeof exists === "undefined") {
            throw new Error("failed to find key '" + key + "' in the cache");
        }
        this.#history[exists.last_access] = null;
        this.#callback(exists.value);
        this.#store.delete(key);
        return;
    }
};

Usage is something like:

let cache = new LeastRecentlyUsedCache(1);
cache.set("A", "FOO");
console.log(cache.get("A"));
cache.set("B", "WHEE");
console.log(cache.get("B"));
console.log(cache.get("A"));

Which gives the expected eviction:

FOO
WHEE
/home/luna/Downloads/lru.js:67
            throw new Error("failed to find key '" + key + "' in the cache");