@jujulego/jill 3.0.8 → 3.0.9

package/dist/main.js

@@ -1,4 +1,4 @@
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"jill@3.0.8"};var n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="0ababa30-bd28-44f9-ab35-b37a3474aa90",e._sentryDebugIdIdentifier="sentry-dbid-0ababa30-bd28-44f9-ab35-b37a3474aa90");}catch(e){}}();import { startSpan, startInactiveSpan, getActiveSpan, updateSpanName, getRootSpan, captureException, flush } from '@sentry/node';
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"jill@3.0.9"};var n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bfa80f19-f695-4bc1-b1d8-5744e3e8229e",e._sentryDebugIdIdentifier="sentry-dbid-bfa80f19-f695-4bc1-b1d8-5744e3e8229e");}catch(e){}}();import { startSpan, startInactiveSpan, getActiveSpan, updateSpanName, getRootSpan, captureException, flush } from '@sentry/node';
 import process$1 from 'node:process';
 import { hideBin } from 'yargs/helpers';
 import path, { win32, posix } from 'node:path';
@@ -1539,31 +1539,35 @@ const QUICK_CONDITION_INJECTOR = Symbol.for('jujulego/quick-tag:condition-inject
     };
 }
 
-function safeStringifyReplacer(seen) {
-    const replacer = function(key, value) {
-        // Handle objects with a custom `.toJSON()` method.
-        if (typeof value?.toJSON === 'function') {
-            value = value.toJSON();
-        }
-        if (!(value !== null && typeof value === 'object')) {
-            return value;
-        }
-        if (seen.has(value)) {
+function serializeValue(value, seen, trace, currentPath) {
+    // Handle objects with a custom `.toJSON()` method.
+    if (typeof value?.toJSON === 'function') {
+        value = value.toJSON();
+    }
+    if (!(value !== null && typeof value === 'object')) {
+        return value;
+    }
+    if (seen.has(value)) {
+        if (!trace) {
             return '[Circular]';
         }
-        seen.add(value);
-        const newValue = Array.isArray(value) ? [] : {};
-        for (const [key2, value2] of Object.entries(value)){
-            newValue[key2] = replacer(key2, value2);
-        }
-        seen.delete(value);
-        return newValue;
-    };
-    return replacer;
+        const existingPath = seen.get(value);
+        const circularPath = existingPath === '' ? '*' : `*${existingPath}`;
+        return `[Circular ${circularPath}]`;
+    }
+    seen.set(value, currentPath);
+    const newValue = Array.isArray(value) ? [] : {};
+    for (const [propertyKey, propertyValue] of Object.entries(value)){
+        const nextPath = currentPath === '' ? propertyKey : `${currentPath}.${propertyKey}`;
+        newValue[propertyKey] = serializeValue(propertyValue, seen, trace, nextPath);
+    }
+    seen.delete(value);
+    return newValue;
 }
-function safeStringify(object, { indentation } = {}) {
-    const seen = new WeakSet();
-    return JSON.stringify(object, safeStringifyReplacer(seen), indentation);
+function safeStringify(value, { indentation, trace } = {}) {
+    const seen = new WeakMap();
+    const serializedValue = serializeValue(value, seen, trace, '');
+    return JSON.stringify(serializedValue, undefined, indentation);
 }
 
 /**
@@ -2037,1435 +2041,631 @@ function logger$(...fns) {
 }
 
 var _computedKey$3, _computedKey1$3;
-/**
- * @module LRUCache
- */ const defaultPerf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date;
-const warned = new Set();
-/* c8 ignore start */ const PROCESS = typeof process === 'object' && !!process ? process : {};
-/* c8 ignore start */ const emitWarning = (msg, type, code, fn)=>{
-    typeof PROCESS.emitWarning === 'function' ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
-};
-let AC = globalThis.AbortController;
-let AS = globalThis.AbortSignal;
-/* c8 ignore start */ if (typeof AC === 'undefined') {
-    //@ts-ignore
-    AS = class AbortSignal {
+var x$1 = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, I$1 = new Set, R$1 = typeof process == "object" && process ? process : {}, U$1 = (c, t, e, i)=>{
+    typeof R$1.emitWarning == "function" ? R$1.emitWarning(c, t, e, i) : console.error(`[${e}] ${t}: ${c}`);
+}, C$1 = globalThis.AbortController, D$1 = globalThis.AbortSignal;
+if (typeof C$1 > "u") {
+    D$1 = class {
         onabort;
         _onabort = [];
         reason;
         aborted = false;
-        addEventListener(_, fn) {
-            this._onabort.push(fn);
+        addEventListener(i, s) {
+            this._onabort.push(s);
         }
-    };
-    //@ts-ignore
-    AC = class AbortController {
+    }, C$1 = class {
         constructor(){
-            warnACPolyfill();
+            t();
         }
-        signal = new AS();
-        abort(reason) {
-            if (this.signal.aborted) return;
-            //@ts-ignore
-            this.signal.reason = reason;
-            //@ts-ignore
-            this.signal.aborted = true;
-            //@ts-ignore
-            for (const fn of this.signal._onabort){
-                fn(reason);
+        signal = new D$1;
+        abort(i) {
+            if (!this.signal.aborted) {
+                this.signal.reason = i, this.signal.aborted = true;
+                for (let s of this.signal._onabort)s(i);
+                this.signal.onabort?.(i);
             }
-            this.signal.onabort?.(reason);
         }
     };
-    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
-    const warnACPolyfill = ()=>{
-        if (!printACPolyfillWarning) return;
-        printACPolyfillWarning = false;
-        emitWarning('AbortController is not defined. If using lru-cache in ' + 'node 14, load an AbortController polyfill from the ' + '`node-abort-controller` package. A minimal polyfill is ' + 'provided for use by LRUCache.fetch(), but it should not be ' + 'relied upon in other contexts (eg, passing it to other APIs that ' + 'use AbortController/AbortSignal might have undesirable effects). ' + 'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.', 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+    let c = R$1.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = ()=>{
+        c && (c = false, U$1("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
     };
 }
-/* c8 ignore stop */ const shouldWarn = (code)=>!warned.has(code);
-const isPosInt = (n)=>n && n === Math.floor(n) && n > 0 && isFinite(n);
-/* c8 ignore start */ // This is a little bit ridiculous, tbh.
-// The maximum array length is 2^32-1 or thereabouts on most JS impls.
-// And well before that point, you're caching the entire world, I mean,
-// that's ~32GB of just integers for the next/prev links, plus whatever
-// else to hold that many keys and values.  Just filling the memory with
-// zeroes at init time is brutal when you get that big.
-// But why not be complete?
-// Maybe in the future, these limits will have expanded.
-const getUintArray = (max)=>!isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
-/* c8 ignore stop */ class ZeroArray extends Array {
-    constructor(size){
-        super(size);
-        this.fill(0);
-    }
-}
-class Stack {
+_computedKey$3 = Symbol.iterator, _computedKey1$3 = Symbol.toStringTag;
+var G$1 = (c)=>!I$1.has(c), y = (c)=>c && c === Math.floor(c) && c > 0 && isFinite(c), M$1 = (c)=>y(c) ? c <= Math.pow(2, 8) ? Uint8Array : c <= Math.pow(2, 16) ? Uint16Array : c <= Math.pow(2, 32) ? Uint32Array : c <= Number.MAX_SAFE_INTEGER ? z : null : null, z = class extends Array {
+    constructor(t){
+        super(t), this.fill(0);
+    }
+}, W$1 = class c {
     heap;
     length;
-    // private constructor
-    static #constructing = false;
-    static create(max) {
-        const HeapCls = getUintArray(max);
-        if (!HeapCls) return [];
-        Stack.#constructing = true;
-        const s = new Stack(max, HeapCls);
-        Stack.#constructing = false;
-        return s;
+    static #o = false;
+    static create(t) {
+        let e = M$1(t);
+        if (!e) return [];
+        c.#o = true;
+        let i = new c(t, e);
+        return c.#o = false, i;
     }
-    constructor(max, HeapCls){
-        /* c8 ignore start */ if (!Stack.#constructing) {
-            throw new TypeError('instantiate Stack using Stack.create(n)');
-        }
-        /* c8 ignore stop */ this.heap = new HeapCls(max);
-        this.length = 0;
+    constructor(t, e){
+        if (!c.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+        this.heap = new e(t), this.length = 0;
     }
-    push(n) {
-        this.heap[this.length++] = n;
+    push(t) {
+        this.heap[this.length++] = t;
     }
     pop() {
         return this.heap[--this.length];
     }
-}
-_computedKey$3 = Symbol.iterator, _computedKey1$3 = Symbol.toStringTag;
-/**
- * Default export, the thing you're using this module to get.
- *
- * The `K` and `V` types define the key and value types, respectively. The
- * optional `FC` type defines the type of the `context` object passed to
- * `cache.fetch()` and `cache.memo()`.
- *
- * Keys and values **must not** be `null` or `undefined`.
- *
- * All properties from the options object (with the exception of `max`,
- * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
- * added as normal public members. (The listed options are read-only getters.)
- *
- * Changing any of these will alter the defaults for subsequent method calls.
- */ class LRUCache {
-    // options that cannot be changed without disaster
-    #max;
-    #maxSize;
-    #dispose;
-    #onInsert;
-    #disposeAfter;
-    #fetchMethod;
-    #memoMethod;
-    #perf;
-    /**
-     * {@link LRUCache.OptionsBase.perf}
-     */ get perf() {
-        return this.#perf;
+}, L$1 = class c {
+    #o;
+    #c;
+    #w;
+    #C;
+    #S;
+    #L;
+    #I;
+    #m;
+    get perf() {
+        return this.#m;
     }
-    /**
-     * {@link LRUCache.OptionsBase.ttl}
-     */ ttl;
-    /**
-     * {@link LRUCache.OptionsBase.ttlResolution}
-     */ ttlResolution;
-    /**
-     * {@link LRUCache.OptionsBase.ttlAutopurge}
-     */ ttlAutopurge;
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnGet}
-     */ updateAgeOnGet;
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnHas}
-     */ updateAgeOnHas;
-    /**
-     * {@link LRUCache.OptionsBase.allowStale}
-     */ allowStale;
-    /**
-     * {@link LRUCache.OptionsBase.noDisposeOnSet}
-     */ noDisposeOnSet;
-    /**
-     * {@link LRUCache.OptionsBase.noUpdateTTL}
-     */ noUpdateTTL;
-    /**
-     * {@link LRUCache.OptionsBase.maxEntrySize}
-     */ maxEntrySize;
-    /**
-     * {@link LRUCache.OptionsBase.sizeCalculation}
-     */ sizeCalculation;
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-     */ noDeleteOnFetchRejection;
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-     */ noDeleteOnStaleGet;
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-     */ allowStaleOnFetchAbort;
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-     */ allowStaleOnFetchRejection;
-    /**
-     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-     */ ignoreFetchAbort;
-    // computed properties
-    #size;
-    #calculatedSize;
-    #keyMap;
-    #keyList;
-    #valList;
-    #next;
-    #prev;
-    #head;
-    #tail;
-    #free;
-    #disposed;
-    #sizes;
-    #starts;
-    #ttls;
-    #hasDispose;
-    #hasFetchMethod;
-    #hasDisposeAfter;
-    #hasOnInsert;
-    /**
-     * Do not call this method unless you need to inspect the
-     * inner workings of the cache.  If anything returned by this
-     * object is modified in any way, strange breakage may occur.
-     *
-     * These fields are private for a reason!
-     *
-     * @internal
-     */ static unsafeExposeInternals(c) {
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #n;
+    #_;
+    #s;
+    #i;
+    #t;
+    #a;
+    #u;
+    #l;
+    #h;
+    #b;
+    #r;
+    #y;
+    #A;
+    #d;
+    #g;
+    #T;
+    #v;
+    #f;
+    #U;
+    static unsafeExposeInternals(t) {
         return {
-            // properties
-            starts: c.#starts,
-            ttls: c.#ttls,
-            sizes: c.#sizes,
-            keyMap: c.#keyMap,
-            keyList: c.#keyList,
-            valList: c.#valList,
-            next: c.#next,
-            prev: c.#prev,
+            starts: t.#A,
+            ttls: t.#d,
+            autopurgeTimers: t.#g,
+            sizes: t.#y,
+            keyMap: t.#s,
+            keyList: t.#i,
+            valList: t.#t,
+            next: t.#a,
+            prev: t.#u,
             get head () {
-                return c.#head;
+                return t.#l;
             },
             get tail () {
-                return c.#tail;
+                return t.#h;
             },
-            free: c.#free,
-            // methods
-            isBackgroundFetch: (p)=>c.#isBackgroundFetch(p),
-            backgroundFetch: (k, index, options, context)=>c.#backgroundFetch(k, index, options, context),
-            moveToTail: (index)=>c.#moveToTail(index),
-            indexes: (options)=>c.#indexes(options),
-            rindexes: (options)=>c.#rindexes(options),
-            isStale: (index)=>c.#isStale(index)
+            free: t.#b,
+            isBackgroundFetch: (e)=>t.#e(e),
+            backgroundFetch: (e, i, s, n)=>t.#G(e, i, s, n),
+            moveToTail: (e)=>t.#D(e),
+            indexes: (e)=>t.#F(e),
+            rindexes: (e)=>t.#O(e),
+            isStale: (e)=>t.#p(e)
         };
     }
-    // Protected read-only members
-    /**
-     * {@link LRUCache.OptionsBase.max} (read-only)
-     */ get max() {
-        return this.#max;
+    get max() {
+        return this.#o;
     }
-    /**
-     * {@link LRUCache.OptionsBase.maxSize} (read-only)
-     */ get maxSize() {
-        return this.#maxSize;
+    get maxSize() {
+        return this.#c;
     }
-    /**
-     * The total computed size of items in the cache (read-only)
-     */ get calculatedSize() {
-        return this.#calculatedSize;
+    get calculatedSize() {
+        return this.#_;
     }
-    /**
-     * The number of items stored in the cache (read-only)
-     */ get size() {
-        return this.#size;
+    get size() {
+        return this.#n;
     }
-    /**
-     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-     */ get fetchMethod() {
-        return this.#fetchMethod;
+    get fetchMethod() {
+        return this.#L;
     }
     get memoMethod() {
-        return this.#memoMethod;
+        return this.#I;
     }
-    /**
-     * {@link LRUCache.OptionsBase.dispose} (read-only)
-     */ get dispose() {
-        return this.#dispose;
+    get dispose() {
+        return this.#w;
     }
-    /**
-     * {@link LRUCache.OptionsBase.onInsert} (read-only)
-     */ get onInsert() {
-        return this.#onInsert;
+    get onInsert() {
+        return this.#C;
     }
-    /**
-     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-     */ get disposeAfter() {
-        return this.#disposeAfter;
-    }
-    constructor(options){
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf } = options;
-        if (perf !== undefined) {
-            if (typeof perf?.now !== 'function') {
-                throw new TypeError('perf option must have a now() method if specified');
-            }
-        }
-        this.#perf = perf ?? defaultPerf;
-        if (max !== 0 && !isPosInt(max)) {
-            throw new TypeError('max option must be a nonnegative integer');
-        }
-        const UintArray = max ? getUintArray(max) : Array;
-        if (!UintArray) {
-            throw new Error('invalid max value: ' + max);
-        }
-        this.#max = max;
-        this.#maxSize = maxSize;
-        this.maxEntrySize = maxEntrySize || this.#maxSize;
-        this.sizeCalculation = sizeCalculation;
-        if (this.sizeCalculation) {
-            if (!this.#maxSize && !this.maxEntrySize) {
-                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
-            }
-            if (typeof this.sizeCalculation !== 'function') {
-                throw new TypeError('sizeCalculation set to non-function');
-            }
-        }
-        if (memoMethod !== undefined && typeof memoMethod !== 'function') {
-            throw new TypeError('memoMethod must be a function if defined');
-        }
-        this.#memoMethod = memoMethod;
-        if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
-            throw new TypeError('fetchMethod must be a function if specified');
-        }
-        this.#fetchMethod = fetchMethod;
-        this.#hasFetchMethod = !!fetchMethod;
-        this.#keyMap = new Map();
-        this.#keyList = new Array(max).fill(undefined);
-        this.#valList = new Array(max).fill(undefined);
-        this.#next = new UintArray(max);
-        this.#prev = new UintArray(max);
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free = Stack.create(max);
-        this.#size = 0;
-        this.#calculatedSize = 0;
-        if (typeof dispose === 'function') {
-            this.#dispose = dispose;
-        }
-        if (typeof onInsert === 'function') {
-            this.#onInsert = onInsert;
-        }
-        if (typeof disposeAfter === 'function') {
-            this.#disposeAfter = disposeAfter;
-            this.#disposed = [];
-        } else {
-            this.#disposeAfter = undefined;
-            this.#disposed = undefined;
-        }
-        this.#hasDispose = !!this.#dispose;
-        this.#hasOnInsert = !!this.#onInsert;
-        this.#hasDisposeAfter = !!this.#disposeAfter;
-        this.noDisposeOnSet = !!noDisposeOnSet;
-        this.noUpdateTTL = !!noUpdateTTL;
-        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
-        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
-        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
-        this.ignoreFetchAbort = !!ignoreFetchAbort;
-        // NB: maxEntrySize is set to maxSize if it's set
-        if (this.maxEntrySize !== 0) {
-            if (this.#maxSize !== 0) {
-                if (!isPosInt(this.#maxSize)) {
-                    throw new TypeError('maxSize must be a positive integer if specified');
-                }
-            }
-            if (!isPosInt(this.maxEntrySize)) {
-                throw new TypeError('maxEntrySize must be a positive integer if specified');
-            }
-            this.#initializeSizeTracking();
-        }
-        this.allowStale = !!allowStale;
-        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-        this.updateAgeOnGet = !!updateAgeOnGet;
-        this.updateAgeOnHas = !!updateAgeOnHas;
-        this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
-        this.ttlAutopurge = !!ttlAutopurge;
-        this.ttl = ttl || 0;
-        if (this.ttl) {
-            if (!isPosInt(this.ttl)) {
-                throw new TypeError('ttl must be a positive integer if specified');
-            }
-            this.#initializeTTLTracking();
-        }
-        // do not allow completely unbounded caches
-        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
-            throw new TypeError('At least one of max, maxSize, or ttl is required');
-        }
-        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-            const code = 'LRU_CACHE_UNBOUNDED';
-            if (shouldWarn(code)) {
-                warned.add(code);
-                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' + 'result in unbounded memory consumption.';
-                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
-            }
+    get disposeAfter() {
+        return this.#S;
+    }
+    constructor(t){
+        let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: r, dispose: a, onInsert: w, disposeAfter: f, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+        if (v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+        if (this.#m = v ?? x$1, e !== 0 && !y(e)) throw new TypeError("max option must be a nonnegative integer");
+        let O = e ? M$1(e) : Array;
+        if (!O) throw new Error("invalid max value: " + e);
+        if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+            if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+            if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+        }
+        if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+        if (this.#I = S, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+        if (this.#L = l, this.#v = !!l, this.#s = new Map, this.#i = new Array(e).fill(void 0), this.#t = new Array(e).fill(void 0), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W$1.create(e), this.#n = 0, this.#_ = 0, typeof a == "function" && (this.#w = a), typeof w == "function" && (this.#C = w), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#U = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, this.allowStaleOnFetchAbort = !!T, this.ignoreFetchAbort = !!F, this.maxEntrySize !== 0) {
+            if (this.#c !== 0 && !y(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+            if (!y(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+            this.#B();
+        }
+        if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+            if (!y(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+            this.#j();
+        }
+        if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+        if (!this.ttlAutopurge && !this.#o && !this.#c) {
+            let E = "LRU_CACHE_UNBOUNDED";
+            G$1(E) && (I$1.add(E), U$1("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c));
         }
     }
-    /**
-     * Return the number of ms left in the item's TTL. If item is not in cache,
-     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
-     */ getRemainingTTL(key) {
-        return this.#keyMap.has(key) ? Infinity : 0;
-    }
-    #initializeTTLTracking() {
-        const ttls = new ZeroArray(this.#max);
-        const starts = new ZeroArray(this.#max);
-        this.#ttls = ttls;
-        this.#starts = starts;
-        this.#setItemTTL = (index, ttl, start = this.#perf.now())=>{
-            starts[index] = ttl !== 0 ? start : 0;
-            ttls[index] = ttl;
-            if (ttl !== 0 && this.ttlAutopurge) {
-                const t = setTimeout(()=>{
-                    if (this.#isStale(index)) {
-                        this.#delete(this.#keyList[index], 'expire');
-                    }
-                }, ttl + 1);
-                // unref() not supported on all platforms
-                /* c8 ignore start */ if (t.unref) {
-                    t.unref();
-                }
-            /* c8 ignore stop */ }
-        };
-        this.#updateItemAge = (index)=>{
-            starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+    getRemainingTTL(t) {
+        return this.#s.has(t) ? 1 / 0 : 0;
+    }
+    #j() {
+        let t = new z(this.#o), e = new z(this.#o);
+        this.#d = t, this.#A = e;
+        let i = this.ttlAutopurge ? new Array(this.#o) : void 0;
+        this.#g = i, this.#N = (h, r, a = this.#m.now())=>{
+            e[h] = r !== 0 ? a : 0, t[h] = r, s(h, r);
+        }, this.#R = (h)=>{
+            e[h] = t[h] !== 0 ? this.#m.now() : 0, s(h, t[h]);
         };
-        this.#statusTTL = (status, index)=>{
-            if (ttls[index]) {
-                const ttl = ttls[index];
-                const start = starts[index];
-                /* c8 ignore next */ if (!ttl || !start) return;
-                status.ttl = ttl;
-                status.start = start;
-                status.now = cachedNow || getNow();
-                const age = status.now - start;
-                status.remainingTTL = ttl - age;
+        let s = this.ttlAutopurge ? (h, r)=>{
+            if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), r && r !== 0 && i) {
+                let a = setTimeout(()=>{
+                    this.#p(h) && this.#E(this.#i[h], "expire");
+                }, r + 1);
+                a.unref && a.unref(), i[h] = a;
+            }
+        } : ()=>{};
+        this.#z = (h, r)=>{
+            if (t[r]) {
+                let a = t[r], w = e[r];
+                if (!a || !w) return;
+                h.ttl = a, h.start = w, h.now = n || o();
+                let f = h.now - w;
+                h.remainingTTL = a - f;
             }
         };
-        // debounce calls to perf.now() to 1s so we're not hitting
-        // that costly call repeatedly.
-        let cachedNow = 0;
-        const getNow = ()=>{
-            const n = this.#perf.now();
+        let n = 0, o = ()=>{
+            let h = this.#m.now();
             if (this.ttlResolution > 0) {
-                cachedNow = n;
-                const t = setTimeout(()=>cachedNow = 0, this.ttlResolution);
-                // not available on all platforms
-                /* c8 ignore start */ if (t.unref) {
-                    t.unref();
-                }
-            /* c8 ignore stop */ }
-            return n;
-        };
-        this.getRemainingTTL = (key)=>{
-            const index = this.#keyMap.get(key);
-            if (index === undefined) {
-                return 0;
+                n = h;
+                let r = setTimeout(()=>n = 0, this.ttlResolution);
+                r.unref && r.unref();
             }
-            const ttl = ttls[index];
-            const start = starts[index];
-            if (!ttl || !start) {
-                return Infinity;
-            }
-            const age = (cachedNow || getNow()) - start;
-            return ttl - age;
+            return h;
         };
-        this.#isStale = (index)=>{
-            const s = starts[index];
-            const t = ttls[index];
-            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        this.getRemainingTTL = (h)=>{
+            let r = this.#s.get(h);
+            if (r === void 0) return 0;
+            let a = t[r], w = e[r];
+            if (!a || !w) return 1 / 0;
+            let f = (n || o()) - w;
+            return a - f;
+        }, this.#p = (h)=>{
+            let r = e[h], a = t[h];
+            return !!a && !!r && (n || o()) - r > a;
         };
     }
-    // conditionally set private methods related to TTL
-    #updateItemAge = ()=>{};
-    #statusTTL = ()=>{};
-    #setItemTTL = ()=>{};
-    /* c8 ignore stop */ #isStale = ()=>false;
-    #initializeSizeTracking() {
-        const sizes = new ZeroArray(this.#max);
-        this.#calculatedSize = 0;
-        this.#sizes = sizes;
-        this.#removeItemSize = (index)=>{
-            this.#calculatedSize -= sizes[index];
-            sizes[index] = 0;
-        };
-        this.#requireSize = (k, v, size, sizeCalculation)=>{
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
-            if (!isPosInt(size)) {
-                if (sizeCalculation) {
-                    if (typeof sizeCalculation !== 'function') {
-                        throw new TypeError('sizeCalculation must be a function');
-                    }
-                    size = sizeCalculation(v, k);
-                    if (!isPosInt(size)) {
-                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
-                    }
-                } else {
-                    throw new TypeError('invalid size value (must be positive integer). ' + 'When maxSize or maxEntrySize is used, sizeCalculation ' + 'or size must be set.');
-                }
-            }
-            return size;
-        };
-        this.#addItemSize = (index, size, status)=>{
-            sizes[index] = size;
-            if (this.#maxSize) {
-                const maxSize = this.#maxSize - sizes[index];
-                while(this.#calculatedSize > maxSize){
-                    this.#evict(true);
-                }
-            }
-            this.#calculatedSize += sizes[index];
-            if (status) {
-                status.entrySize = size;
-                status.totalCalculatedSize = this.#calculatedSize;
+    #R = ()=>{};
+    #z = ()=>{};
+    #N = ()=>{};
+    #p = ()=>false;
+    #B() {
+        let t = new z(this.#o);
+        this.#_ = 0, this.#y = t, this.#W = (e)=>{
+            this.#_ -= t[e], t[e] = 0;
+        }, this.#P = (e, i, s, n)=>{
+            if (this.#e(i)) return 0;
+            if (!y(s)) if (n) {
+                if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+                if (s = n(i, e), !y(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+            } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+            return s;
+        }, this.#M = (e, i, s)=>{
+            if (t[e] = i, this.#c) {
+                let n = this.#c - t[e];
+                for(; this.#_ > n;)this.#x(true);
             }
+            this.#_ += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
         };
     }
-    #removeItemSize = (_i)=>{};
-    #addItemSize = (_i, _s, _st)=>{};
-    #requireSize = (_k, _v, size, sizeCalculation)=>{
-        if (size || sizeCalculation) {
-            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
-        }
+    #W = (t)=>{};
+    #M = (t, e, i)=>{};
+    #P = (t, e, i, s)=>{
+        if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
         return 0;
     };
-    *#indexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-            for(let i = this.#tail; true;){
-                if (!this.#isValidIndex(i)) {
-                    break;
-                }
-                if (allowStale || !this.#isStale(i)) {
-                    yield i;
-                }
-                if (i === this.#head) {
-                    break;
-                } else {
-                    i = this.#prev[i];
-                }
-            }
-        }
+    *#F({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for(let e = this.#h; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l));)e = this.#u[e];
     }
-    *#rindexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-            for(let i = this.#head; true;){
-                if (!this.#isValidIndex(i)) {
-                    break;
-                }
-                if (allowStale || !this.#isStale(i)) {
-                    yield i;
-                }
-                if (i === this.#tail) {
-                    break;
-                } else {
-                    i = this.#next[i];
-                }
-            }
-        }
+    *#O({ allowStale: t = this.allowStale } = {}) {
+        if (this.#n) for(let e = this.#l; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h));)e = this.#a[e];
     }
-    #isValidIndex(index) {
-        return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+    #H(t) {
+        return t !== void 0 && this.#s.get(this.#i[t]) === t;
     }
-    /**
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from most recently used to least recently used.
-     */ *entries() {
-        for (const i of this.#indexes()){
-            if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield [
-                    this.#keyList[i],
-                    this.#valList[i]
-                ];
-            }
-        }
+    *entries() {
+        for (let t of this.#F())this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [
+            this.#i[t],
+            this.#t[t]
+        ]);
     }
-    /**
-     * Inverse order version of {@link LRUCache.entries}
-     *
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from least recently used to most recently used.
-     */ *rentries() {
-        for (const i of this.#rindexes()){
-            if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield [
-                    this.#keyList[i],
-                    this.#valList[i]
-                ];
-            }
-        }
+    *rentries() {
+        for (let t of this.#O())this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [
+            this.#i[t],
+            this.#t[t]
+        ]);
     }
-    /**
-     * Return a generator yielding the keys in the cache,
-     * in order from most recently used to least recently used.
-     */ *keys() {
-        for (const i of this.#indexes()){
-            const k = this.#keyList[i];
-            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield k;
-            }
+    *keys() {
+        for (let t of this.#F()){
+            let e = this.#i[t];
+            e !== void 0 && !this.#e(this.#t[t]) && (yield e);
         }
     }
-    /**
-     * Inverse order version of {@link LRUCache.keys}
-     *
-     * Return a generator yielding the keys in the cache,
-     * in order from least recently used to most recently used.
-     */ *rkeys() {
-        for (const i of this.#rindexes()){
-            const k = this.#keyList[i];
-            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield k;
-            }
+    *rkeys() {
+        for (let t of this.#O()){
+            let e = this.#i[t];
+            e !== void 0 && !this.#e(this.#t[t]) && (yield e);
         }
     }
-    /**
-     * Return a generator yielding the values in the cache,
-     * in order from most recently used to least recently used.
-     */ *values() {
-        for (const i of this.#indexes()){
-            const v = this.#valList[i];
-            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield this.#valList[i];
-            }
-        }
+    *values() {
+        for (let t of this.#F())this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
     }
-    /**
-     * Inverse order version of {@link LRUCache.values}
-     *
-     * Return a generator yielding the values in the cache,
-     * in order from least recently used to most recently used.
-     */ *rvalues() {
-        for (const i of this.#rindexes()){
-            const v = this.#valList[i];
-            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                yield this.#valList[i];
-            }
-        }
+    *rvalues() {
+        for (let t of this.#O())this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
     }
-    /**
-     * Iterating over the cache itself yields the same results as
-     * {@link LRUCache.entries}
-     */ [_computedKey$3]() {
+    [_computedKey$3]() {
         return this.entries();
     }
-    /**
-     * A String value that is used in the creation of the default string
-     * description of an object. Called by the built-in method
-     * `Object.prototype.toString`.
-     */ [_computedKey1$3] = 'LRUCache';
-    /**
-     * Find a value for which the supplied fn method returns a truthy value,
-     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
-     */ find(fn, getOptions = {}) {
-        for (const i of this.#indexes()){
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            if (value === undefined) continue;
-            if (fn(value, this.#keyList[i], this)) {
-                return this.get(this.#keyList[i], getOptions);
-            }
+    [_computedKey1$3] = "LRUCache";
+    find(t, e = {}) {
+        for (let i of this.#F()){
+            let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+            if (n !== void 0 && t(n, this.#i[i], this)) return this.get(this.#i[i], e);
         }
     }
-    /**
-     * Call the supplied function on each item in the cache, in order from most
-     * recently used to least recently used.
-     *
-     * `fn` is called as `fn(value, key, cache)`.
-     *
-     * If `thisp` is provided, function will be called in the `this`-context of
-     * the provided object, or the cache if no `thisp` object is provided.
-     *
-     * Does not update age or recenty of use, or iterate over stale values.
-     */ forEach(fn, thisp = this) {
-        for (const i of this.#indexes()){
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            if (value === undefined) continue;
-            fn.call(thisp, value, this.#keyList[i], this);
+    forEach(t, e = this) {
+        for (let i of this.#F()){
+            let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+            n !== void 0 && t.call(e, n, this.#i[i], this);
         }
     }
-    /**
-     * The same as {@link LRUCache.forEach} but items are iterated over in
-     * reverse order.  (ie, less recently used items are iterated over first.)
-     */ rforEach(fn, thisp = this) {
-        for (const i of this.#rindexes()){
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            if (value === undefined) continue;
-            fn.call(thisp, value, this.#keyList[i], this);
+    rforEach(t, e = this) {
+        for (let i of this.#O()){
+            let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+            n !== void 0 && t.call(e, n, this.#i[i], this);
         }
     }
-    /**
-     * Delete any stale entries. Returns true if anything was removed,
-     * false otherwise.
-     */ purgeStale() {
-        let deleted = false;
-        for (const i of this.#rindexes({
+    purgeStale() {
+        let t = false;
+        for (let e of this.#O({
             allowStale: true
-        })){
-            if (this.#isStale(i)) {
-                this.#delete(this.#keyList[i], 'expire');
-                deleted = true;
-            }
-        }
-        return deleted;
+        }))this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+        return t;
     }
-    /**
-     * Get the extended info about a given entry, to get its value, size, and
-     * TTL info simultaneously. Returns `undefined` if the key is not present.
-     *
-     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
-     * serialization, the `start` value is always the current timestamp, and the
-     * `ttl` is a calculated remaining time to live (negative if expired).
-     *
-     * Always returns stale values, if their info is found in the cache, so be
-     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
-     * if relevant.
-     */ info(key) {
-        const i = this.#keyMap.get(key);
-        if (i === undefined) return undefined;
-        const v = this.#valList[i];
-        /* c8 ignore start - this isn't tested for the info function,
-         * but it's the same logic as found in other places. */ const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-        if (value === undefined) return undefined;
-        /* c8 ignore end */ const entry = {
-            value
+    info(t) {
+        let e = this.#s.get(t);
+        if (e === void 0) return;
+        let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+        if (s === void 0) return;
+        let n = {
+            value: s
         };
-        if (this.#ttls && this.#starts) {
-            const ttl = this.#ttls[i];
-            const start = this.#starts[i];
-            if (ttl && start) {
-                const remain = ttl - (this.#perf.now() - start);
-                entry.ttl = remain;
-                entry.start = Date.now();
+        if (this.#d && this.#A) {
+            let o = this.#d[e], h = this.#A[e];
+            if (o && h) {
+                let r = o - (this.#m.now() - h);
+                n.ttl = r, n.start = Date.now();
             }
         }
-        if (this.#sizes) {
-            entry.size = this.#sizes[i];
-        }
-        return entry;
+        return this.#y && (n.size = this.#y[e]), n;
     }
-    /**
-     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-     * passed to {@link LRUCache#load}.
-     *
-     * The `start` fields are calculated relative to a portable `Date.now()`
-     * timestamp, even if `performance.now()` is available.
-     *
-     * Stale entries are always included in the `dump`, even if
-     * {@link LRUCache.OptionsBase.allowStale} is false.
-     *
-     * Note: this returns an actual array, not a generator, so it can be more
-     * easily passed around.
-     */ dump() {
-        const arr = [];
-        for (const i of this.#indexes({
+    dump() {
+        let t = [];
+        for (let e of this.#F({
             allowStale: true
         })){
-            const key = this.#keyList[i];
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            if (value === undefined || key === undefined) continue;
-            const entry = {
-                value
+            let i = this.#i[e], s = this.#t[e], n = this.#e(s) ? s.__staleWhileFetching : s;
+            if (n === void 0 || i === void 0) continue;
+            let o = {
+                value: n
             };
-            if (this.#ttls && this.#starts) {
-                entry.ttl = this.#ttls[i];
-                // always dump the start relative to a portable timestamp
-                // it's ok for this to be a bit slow, it's a rare operation.
-                const age = this.#perf.now() - this.#starts[i];
-                entry.start = Math.floor(Date.now() - age);
-            }
-            if (this.#sizes) {
-                entry.size = this.#sizes[i];
-            }
-            arr.unshift([
-                key,
-                entry
+            if (this.#d && this.#A) {
+                o.ttl = this.#d[e];
+                let h = this.#m.now() - this.#A[e];
+                o.start = Math.floor(Date.now() - h);
+            }
+            this.#y && (o.size = this.#y[e]), t.unshift([
+                i,
+                o
             ]);
         }
-        return arr;
+        return t;
     }
-    /**
-     * Reset the cache and load in the items in entries in the order listed.
-     *
-     * The shape of the resulting cache may be different if the same options are
-     * not used in both caches.
-     *
-     * The `start` fields are assumed to be calculated relative to a portable
-     * `Date.now()` timestamp, even if `performance.now()` is available.
-     */ load(arr) {
+    load(t) {
         this.clear();
-        for (const [key, entry] of arr){
-            if (entry.start) {
-                // entry.start is a portable timestamp, but we may be using
-                // node's performance.now(), so calculate the offset, so that
-                // we get the intended remaining TTL, no matter how long it's
-                // been on ice.
-                //
-                // it's ok for this to be a bit slow, it's a rare operation.
-                const age = Date.now() - entry.start;
-                entry.start = this.#perf.now() - age;
+        for (let [e, i] of t){
+            if (i.start) {
+                let s = Date.now() - i.start;
+                i.start = this.#m.now() - s;
             }
-            this.set(key, entry.value, entry);
+            this.set(e, i.value, i);
         }
     }
-    /**
-     * Add a value to the cache.
-     *
-     * Note: if `undefined` is specified as a value, this is an alias for
-     * {@link LRUCache#delete}
-     *
-     * Fields on the {@link LRUCache.SetOptions} options param will override
-     * their corresponding values in the constructor options for the scope
-     * of this single `set()` operation.
-     *
-     * If `start` is provided, then that will set the effective start
-     * time for the TTL calculation. Note that this must be a previous
-     * value of `performance.now()` if supported, or a previous value of
-     * `Date.now()` if not.
-     *
-     * Options object may also include `size`, which will prevent
-     * calling the `sizeCalculation` function and just use the specified
-     * number if it is a positive integer, and `noDisposeOnSet` which
-     * will prevent calling a `dispose` function in the case of
-     * overwrites.
-     *
-     * If the `size` (or return value of `sizeCalculation`) for a given
-     * entry is greater than `maxEntrySize`, then the item will not be
-     * added to the cache.
-     *
-     * Will update the recency of the entry.
-     *
-     * If the value is `undefined`, then this is an alias for
-     * `cache.delete(key)`. `undefined` is never stored in the cache.
-     */ set(k, v, setOptions = {}) {
-        if (v === undefined) {
-            this.delete(k);
-            return this;
-        }
-        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
-        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-        // if the item doesn't fit, don't do anything
-        // NB: maxEntrySize set to maxSize by default
-        if (this.maxEntrySize && size > this.maxEntrySize) {
-            if (status) {
-                status.set = 'miss';
-                status.maxEntrySizeExceeded = true;
-            }
-            // have to delete, in case something is there already.
-            this.#delete(k, 'set');
-            return this;
-        }
-        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
-        if (index === undefined) {
-            // addition
-            index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-            this.#keyList[index] = k;
-            this.#valList[index] = v;
-            this.#keyMap.set(k, index);
-            this.#next[this.#tail] = index;
-            this.#prev[index] = this.#tail;
-            this.#tail = index;
-            this.#size++;
-            this.#addItemSize(index, size, status);
-            if (status) status.set = 'add';
-            noUpdateTTL = false;
-            if (this.#hasOnInsert) {
-                this.#onInsert?.(v, k, 'add');
-            }
-        } else {
-            // update
-            this.#moveToTail(index);
-            const oldVal = this.#valList[index];
-            if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                    const { __staleWhileFetching: s } = oldVal;
-                    if (s !== undefined && !noDisposeOnSet) {
-                        if (this.#hasDispose) {
-                            this.#dispose?.(s, k, 'set');
-                        }
-                        if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([
-                                s,
-                                k,
-                                'set'
-                            ]);
-                        }
-                    }
-                } else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([
-                            oldVal,
-                            k,
-                            'set'
-                        ]);
-                    }
-                }
-                this.#removeItemSize(index);
-                this.#addItemSize(index, size, status);
-                this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
-                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
-                    if (oldValue !== undefined) status.oldValue = oldValue;
+    set(t, e, i = {}) {
+        if (e === void 0) return this.delete(t), this;
+        let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, { noUpdateTTL: a = this.noUpdateTTL } = i, w = this.#P(t, e, i.size || 0, h);
+        if (this.maxEntrySize && w > this.maxEntrySize) return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+        let f = this.#n === 0 ? void 0 : this.#s.get(t);
+        if (f === void 0) f = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#x(false) : this.#n, this.#i[f] = t, this.#t[f] = e, this.#s.set(t, f), this.#a[this.#h] = f, this.#u[f] = this.#h, this.#h = f, this.#n++, this.#M(f, w, r), r && (r.set = "add"), a = false, this.#U && this.#C?.(e, t, "add");
+        else {
+            this.#D(f);
+            let d = this.#t[f];
+            if (e !== d) {
+                if (this.#v && this.#e(d)) {
+                    d.__abortController.abort(new Error("replaced"));
+                    let { __staleWhileFetching: g } = d;
+                    g !== void 0 && !o && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([
+                        g,
+                        t,
+                        "set"
+                    ]));
+                } else o || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([
+                    d,
+                    t,
+                    "set"
+                ]));
+                if (this.#W(f), this.#M(f, w, r), this.#t[f] = e, r) {
+                    r.set = "replace";
+                    let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+                    g !== void 0 && (r.oldValue = g);
                 }
-            } else if (status) {
-                status.set = 'update';
-            }
-            if (this.#hasOnInsert) {
-                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
-            }
+            } else r && (r.set = "update");
+            this.#U && this.onInsert?.(e, t, e === d ? "update" : "replace");
         }
-        if (ttl !== 0 && !this.#ttls) {
-            this.#initializeTTLTracking();
-        }
-        if (this.#ttls) {
-            if (!noUpdateTTL) {
-                this.#setItemTTL(index, ttl, start);
-            }
-            if (status) this.#statusTTL(status, index);
-        }
-        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while(task = dt?.shift()){
-                this.#disposeAfter?.(...task);
-            }
+        if (s !== 0 && !this.#d && this.#j(), this.#d && (a || this.#N(f, s, n), r && this.#z(r, f)), !o && this.#f && this.#r) {
+            let d = this.#r, g;
+            for(; g = d?.shift();)this.#S?.(...g);
         }
         return this;
     }
-    /**
-     * Evict the least recently used item, returning its value or
-     * `undefined` if cache is empty.
-     */ pop() {
+    pop() {
         try {
-            while(this.#size){
-                const val = this.#valList[this.#head];
-                this.#evict(true);
-                if (this.#isBackgroundFetch(val)) {
-                    if (val.__staleWhileFetching) {
-                        return val.__staleWhileFetching;
-                    }
-                } else if (val !== undefined) {
-                    return val;
-                }
+            for(; this.#n;){
+                let t = this.#t[this.#l];
+                if (this.#x(!0), this.#e(t)) {
+                    if (t.__staleWhileFetching) return t.__staleWhileFetching;
+                } else if (t !== void 0) return t;
             }
         } finally{
-            if (this.#hasDisposeAfter && this.#disposed) {
-                const dt = this.#disposed;
-                let task;
-                while(task = dt?.shift()){
-                    this.#disposeAfter?.(...task);
-                }
-            }
-        }
-    }
-    #evict(free) {
-        const head = this.#head;
-        const k = this.#keyList[head];
-        const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-            v.__abortController.abort(new Error('evicted'));
-        } else if (this.#hasDispose || this.#hasDisposeAfter) {
-            if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
-            }
-            if (this.#hasDisposeAfter) {
-                this.#disposed?.push([
-                    v,
-                    k,
-                    'evict'
-                ]);
+            if (this.#f && this.#r) {
+                let t = this.#r, e;
+                for(; e = t?.shift();)this.#S?.(...e);
             }
         }
-        this.#removeItemSize(head);
-        // if we aren't about to use the index, then null these out
-        if (free) {
-            this.#keyList[head] = undefined;
-            this.#valList[head] = undefined;
-            this.#free.push(head);
-        }
-        if (this.#size === 1) {
-            this.#head = this.#tail = 0;
-            this.#free.length = 0;
-        } else {
-            this.#head = this.#next[head];
-        }
-        this.#keyMap.delete(k);
-        this.#size--;
-        return head;
     }
-    /**
-     * Check if a key is in the cache, without updating the recency of use.
-     * Will return false if the item is stale, even though it is technically
-     * in the cache.
-     *
-     * Check if a key is in the cache, without updating the recency of
-     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
-     * to `true` in either the options or the constructor.
-     *
-     * Will return `false` if the item is stale, even though it is technically in
-     * the cache. The difference can be determined (if it matters) by using a
-     * `status` argument, and inspecting the `has` field.
-     *
-     * Will not update item age unless
-     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-     */ has(k, hasOptions = {}) {
-        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== undefined) {
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
-                return false;
-            }
-            if (!this.#isStale(index)) {
-                if (updateAgeOnHas) {
-                    this.#updateItemAge(index);
-                }
-                if (status) {
-                    status.has = 'hit';
-                    this.#statusTTL(status, index);
-                }
-                return true;
-            } else if (status) {
-                status.has = 'stale';
-                this.#statusTTL(status, index);
-            }
-        } else if (status) {
-            status.has = 'miss';
-        }
-        return false;
+    #x(t) {
+        let e = this.#l, i = this.#i[e], s = this.#t[e];
+        return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([
+            s,
+            i,
+            "evict"
+        ])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i), this.#n--, e;
     }
-    /**
-     * Like {@link LRUCache#get} but doesn't update recency or delete stale
-     * items.
-     *
-     * Returns `undefined` if the item is stale, unless
-     * {@link LRUCache.OptionsBase.allowStale} is set.
-     */ peek(k, peekOptions = {}) {
-        const { allowStale = this.allowStale } = peekOptions;
-        const index = this.#keyMap.get(k);
-        if (index === undefined || !allowStale && this.#isStale(index)) {
-            return;
-        }
-        const v = this.#valList[index];
-        // either stale and allowed, or forcing a refresh of non-stale value
-        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    has(t, e = {}) {
+        let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, n = this.#s.get(t);
+        if (n !== void 0) {
+            let o = this.#t[n];
+            if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
+            if (this.#p(n)) s && (s.has = "stale", this.#z(s, n));
+            else return i && this.#R(n), s && (s.has = "hit", this.#z(s, n)), true;
+        } else s && (s.has = "miss");
+        return false;
     }
-    #backgroundFetch(k, index, options, context) {
-        const v = index === undefined ? undefined : this.#valList[index];
-        if (this.#isBackgroundFetch(v)) {
-            return v;
-        }
-        const ac = new AC();
-        const { signal } = options;
-        // when/if our AC signals, then stop listening to theirs.
-        signal?.addEventListener('abort', ()=>ac.abort(signal.reason), {
-            signal: ac.signal
+    peek(t, e = {}) {
+        let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+        if (s === void 0 || !i && this.#p(s)) return;
+        let n = this.#t[s];
+        return this.#e(n) ? n.__staleWhileFetching : n;
+    }
+    #G(t, e, i, s) {
+        let n = e === void 0 ? void 0 : this.#t[e];
+        if (this.#e(n)) return n;
+        let o = new C$1, { signal: h } = i;
+        h?.addEventListener("abort", ()=>o.abort(h.reason), {
+            signal: o.signal
         });
-        const fetchOpts = {
-            signal: ac.signal,
-            options,
-            context
-        };
-        const cb = (v, updateCache = false)=>{
-            const { aborted } = ac.signal;
-            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
-            if (options.status) {
-                if (aborted && !updateCache) {
-                    options.status.fetchAborted = true;
-                    options.status.fetchError = ac.signal.reason;
-                    if (ignoreAbort) options.status.fetchAbortIgnored = true;
-                } else {
-                    options.status.fetchResolved = true;
-                }
-            }
-            if (aborted && !ignoreAbort && !updateCache) {
-                return fetchFail(ac.signal.reason);
-            }
-            // either we didn't abort, and are still here, or we did, and ignored
-            const bf = p;
-            // if nothing else has been written there but we're set to update the
-            // cache and ignore the abort, or if it's still pending on this specific
-            // background request, then write it to the cache.
-            const vl = this.#valList[index];
-            if (vl === p || ignoreAbort && updateCache && vl === undefined) {
-                if (v === undefined) {
-                    if (bf.__staleWhileFetching !== undefined) {
-                        this.#valList[index] = bf.__staleWhileFetching;
-                    } else {
-                        this.#delete(k, 'fetch');
-                    }
-                } else {
-                    if (options.status) options.status.fetchUpdated = true;
-                    this.set(k, v, fetchOpts.options);
-                }
-            }
-            return v;
-        };
-        const eb = (er)=>{
-            if (options.status) {
-                options.status.fetchRejected = true;
-                options.status.fetchError = er;
-            }
-            return fetchFail(er);
-        };
-        const fetchFail = (er)=>{
-            const { aborted } = ac.signal;
-            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-            const noDelete = allowStale || options.noDeleteOnFetchRejection;
-            const bf = p;
-            if (this.#valList[index] === p) {
-                // if we allow stale on fetch rejections, then we need to ensure that
-                // the stale value is not removed from the cache when the fetch fails.
-                const del = !noDelete || bf.__staleWhileFetching === undefined;
-                if (del) {
-                    this.#delete(k, 'fetch');
-                } else if (!allowStaleAborted) {
-                    // still replace the *promise* with the stale value,
-                    // since we are done with the promise at this point.
-                    // leave it untouched if we're still waiting for an
-                    // aborted background fetch that hasn't yet returned.
-                    this.#valList[index] = bf.__staleWhileFetching;
-                }
-            }
-            if (allowStale) {
-                if (options.status && bf.__staleWhileFetching !== undefined) {
-                    options.status.returnedStale = true;
-                }
-                return bf.__staleWhileFetching;
-            } else if (bf.__returned === bf) {
-                throw er;
-            }
-        };
-        const pcall = (res, rej)=>{
-            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then((v)=>res(v === undefined ? undefined : v), rej);
-            }
-            // ignored, we go until we finish, regardless.
-            // defer check until we are actually aborting,
-            // so fetchMethod can override.
-            ac.signal.addEventListener('abort', ()=>{
-                if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-                    res(undefined);
-                    // when it eventually resolves, update the cache.
-                    if (options.allowStaleOnFetchAbort) {
-                        res = (v)=>cb(v, true);
-                    }
-                }
+        let r = {
+            signal: o.signal,
+            options: i,
+            context: s
+        }, a = (p, _ = false)=>{
+            let { aborted: l } = o.signal, S = i.ignoreFetchAbort && p !== void 0, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== void 0);
+            if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, S && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !S && !_) return f(o.signal.reason, b);
+            let m = g, u = this.#t[e];
+            return (u === g || S && _ && u === void 0) && (p === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[e] = m.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+        }, w = (p)=>(i.status && (i.status.fetchRejected = true, i.status.fetchError = p), f(p, false)), f = (p, _)=>{
+            let { aborted: l } = o.signal, S = l && i.allowStaleOnFetchAbort, b = S || i.allowStaleOnFetchRejection, m = b || i.noDeleteOnFetchRejection, u = g;
+            if (this.#t[e] === g && (!m || !_ && u.__staleWhileFetching === void 0 ? this.#E(t, "fetch") : S || (this.#t[e] = u.__staleWhileFetching)), b) return i.status && u.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), u.__staleWhileFetching;
+            if (u.__returned === u) throw p;
+        }, d = (p, _)=>{
+            let l = this.#L?.(t, n, r);
+            l && l instanceof Promise && l.then((S)=>p(S === void 0 ? void 0 : S), _), o.signal.addEventListener("abort", ()=>{
+                (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(void 0), i.allowStaleOnFetchAbort && (p = (S)=>a(S, true)));
             });
         };
-        if (options.status) options.status.fetchDispatched = true;
-        const p = new Promise(pcall).then(cb, eb);
-        const bf = Object.assign(p, {
-            __abortController: ac,
-            __staleWhileFetching: v,
-            __returned: undefined
+        i.status && (i.status.fetchDispatched = true);
+        let g = new Promise(d).then(a, w), A = Object.assign(g, {
+            __abortController: o,
+            __staleWhileFetching: n,
+            __returned: void 0
         });
-        if (index === undefined) {
-            // internal, don't expose status.
-            this.set(k, bf, {
-                ...fetchOpts.options,
-                status: undefined
-            });
-            index = this.#keyMap.get(k);
+        return e === void 0 ? (this.set(t, A, {
+            ...r.options,
+            status: void 0
+        }), e = this.#s.get(t)) : this.#t[e] = A, A;
+    }
+    #e(t) {
+        if (!this.#v) return false;
+        let e = t;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C$1;
+    }
+    async fetch(t, e = {}) {
+        let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: r = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: w = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: S } = e;
+        if (!this.#v) return l && (l.fetch = "get"), this.get(t, {
+            allowStale: i,
+            updateAgeOnGet: s,
+            noDeleteOnStaleGet: n,
+            status: l
+        });
+        let b = {
+            allowStale: i,
+            updateAgeOnGet: s,
+            noDeleteOnStaleGet: n,
+            ttl: o,
+            noDisposeOnSet: h,
+            size: r,
+            sizeCalculation: a,
+            noUpdateTTL: w,
+            noDeleteOnFetchRejection: f,
+            allowStaleOnFetchRejection: d,
+            allowStaleOnFetchAbort: A,
+            ignoreFetchAbort: g,
+            status: l,
+            signal: S
+        }, m = this.#s.get(t);
+        if (m === void 0) {
+            l && (l.fetch = "miss");
+            let u = this.#G(t, m, b, p);
+            return u.__returned = u;
         } else {
-            this.#valList[index] = bf;
-        }
-        return bf;
-    }
-    #isBackgroundFetch(p) {
-        if (!this.#hasFetchMethod) return false;
-        const b = p;
-        return !!b && b instanceof Promise && b.hasOwnProperty('__staleWhileFetching') && b.__abortController instanceof AC;
-    }
-    async fetch(k, fetchOptions = {}) {
-        const { // get options
-        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, // set options
-        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, // fetch exclusive options
-        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
-        if (!this.#hasFetchMethod) {
-            if (status) status.fetch = 'get';
-            return this.get(k, {
-                allowStale,
-                updateAgeOnGet,
-                noDeleteOnStaleGet,
-                status
-            });
+            let u = this.#t[m];
+            if (this.#e(u)) {
+                let E = i && u.__staleWhileFetching !== void 0;
+                return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
+            }
+            let T = this.#p(m);
+            if (!_ && !T) return l && (l.fetch = "hit"), this.#D(m), s && this.#R(m), l && this.#z(l, m), u;
+            let F = this.#G(t, m, b, p), O = F.__staleWhileFetching !== void 0 && i;
+            return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
         }
-        const options = {
-            allowStale,
-            updateAgeOnGet,
-            noDeleteOnStaleGet,
-            ttl,
-            noDisposeOnSet,
-            size,
-            sizeCalculation,
-            noUpdateTTL,
-            noDeleteOnFetchRejection,
-            allowStaleOnFetchRejection,
-            allowStaleOnFetchAbort,
-            ignoreFetchAbort,
-            status,
-            signal
-        };
-        let index = this.#keyMap.get(k);
-        if (index === undefined) {
-            if (status) status.fetch = 'miss';
-            const p = this.#backgroundFetch(k, index, options, context);
-            return p.__returned = p;
-        } else {
-            // in cache, maybe already fetching
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v)) {
-                const stale = allowStale && v.__staleWhileFetching !== undefined;
-                if (status) {
-                    status.fetch = 'inflight';
-                    if (stale) status.returnedStale = true;
-                }
-                return stale ? v.__staleWhileFetching : v.__returned = v;
-            }
-            // if we force a refresh, that means do NOT serve the cached value,
-            // unless we are already in the process of refreshing the cache.
-            const isStale = this.#isStale(index);
-            if (!forceRefresh && !isStale) {
-                if (status) status.fetch = 'hit';
-                this.#moveToTail(index);
-                if (updateAgeOnGet) {
-                    this.#updateItemAge(index);
-                }
-                if (status) this.#statusTTL(status, index);
-                return v;
-            }
-            // ok, it is stale or a forced refresh, and not already fetching.
-            // refresh the cache.
-            const p = this.#backgroundFetch(k, index, options, context);
-            const hasStale = p.__staleWhileFetching !== undefined;
-            const staleVal = hasStale && allowStale;
-            if (status) {
-                status.fetch = isStale ? 'stale' : 'refresh';
-                if (staleVal && isStale) status.returnedStale = true;
-            }
-            return staleVal ? p.__staleWhileFetching : p.__returned = p;
-        }
-    }
-    async forceFetch(k, fetchOptions = {}) {
-        const v = await this.fetch(k, fetchOptions);
-        if (v === undefined) throw new Error('fetch() returned undefined');
-        return v;
-    }
-    memo(k, memoOptions = {}) {
-        const memoMethod = this.#memoMethod;
-        if (!memoMethod) {
-            throw new Error('no memoMethod provided to constructor');
-        }
-        const { context, forceRefresh, ...options } = memoOptions;
-        const v = this.get(k, options);
-        if (!forceRefresh && v !== undefined) return v;
-        const vv = memoMethod(k, v, {
-            options,
-            context
+    }
+    async forceFetch(t, e = {}) {
+        let i = await this.fetch(t, e);
+        if (i === void 0) throw new Error("fetch() returned undefined");
+        return i;
+    }
+    memo(t, e = {}) {
+        let i = this.#I;
+        if (!i) throw new Error("no memoMethod provided to constructor");
+        let { context: s, forceRefresh: n, ...o } = e, h = this.get(t, o);
+        if (!n && h !== void 0) return h;
+        let r = i(t, h, {
+            options: o,
+            context: s
         });
-        this.set(k, vv, options);
-        return vv;
+        return this.set(t, r, o), r;
     }
-    /**
-     * Return a value from the cache. Will update the recency of the cache
-     * entry found.
-     *
-     * If the key is not found, get() will return `undefined`.
-     */ get(k, getOptions = {}) {
-        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== undefined) {
-            const value = this.#valList[index];
-            const fetching = this.#isBackgroundFetch(value);
-            if (status) this.#statusTTL(status, index);
-            if (this.#isStale(index)) {
-                if (status) status.get = 'stale';
-                // delete only if not an in-flight background fetch
-                if (!fetching) {
-                    if (!noDeleteOnStaleGet) {
-                        this.#delete(k, 'expire');
-                    }
-                    if (status && allowStale) status.returnedStale = true;
-                    return allowStale ? value : undefined;
-                } else {
-                    if (status && allowStale && value.__staleWhileFetching !== undefined) {
-                        status.returnedStale = true;
-                    }
-                    return allowStale ? value.__staleWhileFetching : undefined;
-                }
-            } else {
-                if (status) status.get = 'hit';
-                // if we're currently fetching it, we don't actually have it yet
-                // it's not stale, which means this isn't a staleWhileRefetching.
-                // If it's not stale, and fetching, AND has a __staleWhileFetching
-                // value, then that means the user fetched with {forceRefresh:true},
-                // so it's safe to return that value.
-                if (fetching) {
-                    return value.__staleWhileFetching;
-                }
-                this.#moveToTail(index);
-                if (updateAgeOnGet) {
-                    this.#updateItemAge(index);
-                }
-                return value;
-            }
-        } else if (status) {
-            status.get = 'miss';
-        }
-    }
-    #connect(p, n) {
-        this.#prev[n] = p;
-        this.#next[p] = n;
-    }
-    #moveToTail(index) {
-        // if tail already, nothing to do
-        // if head, move head to next[index]
-        // else
-        //   move next[prev[index]] to next[index] (head has no prev)
-        //   move prev[next[index]] to prev[index]
-        // prev[index] = tail
-        // next[tail] = index
-        // tail = index
-        if (index !== this.#tail) {
-            if (index === this.#head) {
-                this.#head = this.#next[index];
-            } else {
-                this.#connect(this.#prev[index], this.#next[index]);
-            }
-            this.#connect(this.#tail, index);
-            this.#tail = index;
-        }
+    get(t, e = {}) {
+        let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = e, h = this.#s.get(t);
+        if (h !== void 0) {
+            let r = this.#t[h], a = this.#e(r);
+            return o && this.#z(o, h), this.#p(h) ? (o && (o.get = "stale"), a ? (o && i && r.__staleWhileFetching !== void 0 && (o.returnedStale = true), i ? r.__staleWhileFetching : void 0) : (n || this.#E(t, "expire"), o && i && (o.returnedStale = true), i ? r : void 0)) : (o && (o.get = "hit"), a ? r.__staleWhileFetching : (this.#D(h), s && this.#R(h), r));
+        } else o && (o.get = "miss");
     }
-    /**
-     * Deletes a key out of the cache.
-     *
-     * Returns true if the key was deleted, false otherwise.
-     */ delete(k) {
-        return this.#delete(k, 'delete');
-    }
-    #delete(k, reason) {
-        let deleted = false;
-        if (this.#size !== 0) {
-            const index = this.#keyMap.get(k);
-            if (index !== undefined) {
-                deleted = true;
-                if (this.#size === 1) {
-                    this.#clear(reason);
-                } else {
-                    this.#removeItemSize(index);
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v)) {
-                        v.__abortController.abort(new Error('deleted'));
-                    } else if (this.#hasDispose || this.#hasDisposeAfter) {
-                        if (this.#hasDispose) {
-                            this.#dispose?.(v, k, reason);
-                        }
-                        if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([
-                                v,
-                                k,
-                                reason
-                            ]);
-                        }
-                    }
-                    this.#keyMap.delete(k);
-                    this.#keyList[index] = undefined;
-                    this.#valList[index] = undefined;
-                    if (index === this.#tail) {
-                        this.#tail = this.#prev[index];
-                    } else if (index === this.#head) {
-                        this.#head = this.#next[index];
-                    } else {
-                        const pi = this.#prev[index];
-                        this.#next[pi] = this.#next[index];
-                        const ni = this.#next[index];
-                        this.#prev[ni] = this.#prev[index];
-                    }
-                    this.#size--;
-                    this.#free.push(index);
+    #k(t, e) {
+        this.#u[e] = t, this.#a[t] = e;
+    }
+    #D(t) {
+        t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+    }
+    delete(t) {
+        return this.#E(t, "delete");
+    }
+    #E(t, e) {
+        let i = false;
+        if (this.#n !== 0) {
+            let s = this.#s.get(t);
+            if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#V(e);
+            else {
+                this.#W(s);
+                let n = this.#t[s];
+                if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, t, e), this.#f && this.#r?.push([
+                    n,
+                    t,
+                    e
+                ])), this.#s.delete(t), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+                else if (s === this.#l) this.#l = this.#a[s];
+                else {
+                    let o = this.#u[s];
+                    this.#a[o] = this.#a[s];
+                    let h = this.#a[s];
+                    this.#u[h] = this.#u[s];
                 }
+                this.#n--, this.#b.push(s);
             }
         }
-        if (this.#hasDisposeAfter && this.#disposed?.length) {
-            const dt = this.#disposed;
-            let task;
-            while(task = dt?.shift()){
-                this.#disposeAfter?.(...task);
-            }
+        if (this.#f && this.#r?.length) {
+            let s = this.#r, n;
+            for(; n = s?.shift();)this.#S?.(...n);
         }
-        return deleted;
+        return i;
     }
-    /**
-     * Clear the cache entirely, throwing away all values.
-     */ clear() {
-        return this.#clear('delete');
+    clear() {
+        return this.#V("delete");
     }
-    #clear(reason) {
-        for (const index of this.#rindexes({
+    #V(t) {
+        for (let e of this.#O({
             allowStale: true
         })){
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v)) {
-                v.__abortController.abort(new Error('deleted'));
-            } else {
-                const k = this.#keyList[index];
-                if (this.#hasDispose) {
-                    this.#dispose?.(v, k, reason);
-                }
-                if (this.#hasDisposeAfter) {
-                    this.#disposed?.push([
-                        v,
-                        k,
-                        reason
-                    ]);
-                }
+            let i = this.#t[e];
+            if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+            else {
+                let s = this.#i[e];
+                this.#T && this.#w?.(i, s, t), this.#f && this.#r?.push([
+                    i,
+                    s,
+                    t
+                ]);
             }
         }
-        this.#keyMap.clear();
-        this.#valList.fill(undefined);
-        this.#keyList.fill(undefined);
-        if (this.#ttls && this.#starts) {
-            this.#ttls.fill(0);
-            this.#starts.fill(0);
+        if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#A) {
+            this.#d.fill(0), this.#A.fill(0);
+            for (let e of this.#g ?? [])e !== void 0 && clearTimeout(e);
+            this.#g?.fill(void 0);
         }
-        if (this.#sizes) {
-            this.#sizes.fill(0);
-        }
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free.length = 0;
-        this.#calculatedSize = 0;
-        this.#size = 0;
-        if (this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while(task = dt?.shift()){
-                this.#disposeAfter?.(...task);
-            }
+        if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+            let e = this.#r, i;
+            for(; i = e?.shift();)this.#S?.(...i);
         }
     }
-}
+};
 
 var _computedKey$2, _computedKey1$2, _computedKey2$1, _computedKey3$1;
 const proc = typeof process === 'object' && process ? process : {
@@ -4397,7 +3597,7 @@ const ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
 const TYPEMASK = 1023;
 const entToType = (s)=>s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
 // normalize unicode path names
-const normalizeCache = new LRUCache({
+const normalizeCache = new L$1({
     max: 2 ** 12
 });
 const normalize$1 = (s)=>{
@@ -4407,7 +3607,7 @@ const normalize$1 = (s)=>{
     normalizeCache.set(s, n);
     return n;
 };
-const normalizeNocaseCache = new LRUCache({
+const normalizeNocaseCache = new L$1({
     max: 2 ** 12
 });
 const normalizeNocase = (s)=>{
@@ -4420,7 +3620,7 @@ const normalizeNocase = (s)=>{
 /**
  * An LRUCache for storing resolved path strings or Path objects.
  * @internal
- */ class ResolveCache extends LRUCache {
+ */ class ResolveCache extends L$1 {
     constructor(){
         super({
             max: 256
@@ -4441,7 +3641,7 @@ const normalizeNocase = (s)=>{
 /**
  * an LRUCache for storing child entries.
  * @internal
- */ class ChildrenCache extends LRUCache {
+ */ class ChildrenCache extends L$1 {
     constructor(maxSize = 16 * 1024){
         super({
             maxSize,
@@ -10212,6 +9412,7 @@ var require$$1$2 = [
 	"AGPL-1.0-or-later",
 	"AGPL-3.0-only",
 	"AGPL-3.0-or-later",
+	"ALGLIB-Documentation",
 	"AMD-newlib",
 	"AMDPLPA",
 	"AML",
@@ -10233,6 +9434,7 @@ var require$$1$2 = [
 	"Adobe-Display-PostScript",
 	"Adobe-Glyph",
 	"Adobe-Utopia",
+	"Advanced-Cryptics-Dictionary",
 	"Afmparse",
 	"Aladdin",
 	"Apache-1.0",
@@ -10246,6 +9448,7 @@ var require$$1$2 = [
 	"Artistic-2.0",
 	"Artistic-dist",
 	"Aspell-RU",
+	"BOLA-1.1",
 	"BSD-1-Clause",
 	"BSD-2-Clause",
 	"BSD-2-Clause-Darwin",
@@ -10265,6 +9468,7 @@ var require$$1$2 = [
 	"BSD-3-Clause-No-Nuclear-Warranty",
 	"BSD-3-Clause-Open-MPI",
 	"BSD-3-Clause-Sun",
+	"BSD-3-Clause-Tso",
 	"BSD-3-Clause-acpica",
 	"BSD-3-Clause-flex",
 	"BSD-4-Clause",
@@ -10275,6 +9479,7 @@ var require$$1$2 = [
 	"BSD-Advertising-Acknowledgement",
 	"BSD-Attribution-HPND-disclaimer",
 	"BSD-Inferno-Nettverk",
+	"BSD-Mark-Modifications",
 	"BSD-Protection",
 	"BSD-Source-Code",
 	"BSD-Source-beginning-file",
@@ -10296,9 +9501,11 @@ var require$$1$2 = [
 	"Borceux",
 	"Brian-Gladman-2-Clause",
 	"Brian-Gladman-3-Clause",
+	"Buddy",
 	"C-UDA-1.0",
 	"CAL-1.0",
 	"CAL-1.0-Combined-Work-Exception",
+	"CAPEC-tou",
 	"CATOSL-1.1",
 	"CC-BY-1.0",
 	"CC-BY-2.0",
@@ -10416,6 +9623,9 @@ var require$$1$2 = [
 	"EPICS",
 	"EPL-1.0",
 	"EPL-2.0",
+	"ESA-PL-permissive-2.4",
+	"ESA-PL-strong-copyleft-2.4",
+	"ESA-PL-weak-copyleft-2.4",
 	"EUDatagrid",
 	"EUPL-1.0",
 	"EUPL-1.1",
@@ -10489,6 +9699,7 @@ var require$$1$2 = [
 	"HPND-Markus-Kuhn",
 	"HPND-Netrek",
 	"HPND-Pbmplus",
+	"HPND-SMC",
 	"HPND-UC",
 	"HPND-UC-export-US",
 	"HPND-doc",
@@ -10503,6 +9714,7 @@ var require$$1$2 = [
 	"HPND-sell-variant",
 	"HPND-sell-variant-MIT-disclaimer",
 	"HPND-sell-variant-MIT-disclaimer-rev",
+	"HPND-sell-variant-critical-systems",
 	"HTMLTIDY",
 	"HaskellReport",
 	"Hippocratic-2.1",
@@ -10515,6 +9727,7 @@ var require$$1$2 = [
 	"IPL-1.0",
 	"ISC",
 	"ISC-Veillard",
+	"ISO-permission",
 	"ImageMagick",
 	"Imlib2",
 	"Info-ZIP",
@@ -10572,6 +9785,7 @@ var require$$1$2 = [
 	"MIT-Festival",
 	"MIT-Khronos-old",
 	"MIT-Modern-Variant",
+	"MIT-STK",
 	"MIT-Wu",
 	"MIT-advertising",
 	"MIT-enna",
@@ -10580,6 +9794,7 @@ var require$$1$2 = [
 	"MIT-testregex",
 	"MITNFA",
 	"MMIXware",
+	"MMPL-1.0.1",
 	"MPEG-SSG",
 	"MPL-1.0",
 	"MPL-1.1",
@@ -10611,6 +9826,7 @@ var require$$1$2 = [
 	"NGPL",
 	"NICTA-1.0",
 	"NIST-PD",
+	"NIST-PD-TNT",
 	"NIST-PD-fallback",
 	"NIST-Software",
 	"NLOD-1.0",
@@ -10670,12 +9886,15 @@ var require$$1$2 = [
 	"OPL-1.0",
 	"OPL-UK-3.0",
 	"OPUBL-1.0",
+	"OSC-1.0",
 	"OSET-PL-2.1",
 	"OSL-1.0",
 	"OSL-1.1",
 	"OSL-2.0",
 	"OSL-2.1",
 	"OSL-3.0",
+	"OSSP",
+	"OpenMDW-1.0",
 	"OpenPBS-2.3",
 	"OpenSSL",
 	"OpenSSL-standalone",
@@ -10686,6 +9905,7 @@ var require$$1$2 = [
 	"PHP-3.01",
 	"PPL",
 	"PSF-2.0",
+	"ParaType-Free-Font-1.3",
 	"Parity-6.0.0",
 	"Parity-7.0.0",
 	"Pixar",
@@ -10714,6 +9934,7 @@ var require$$1$2 = [
 	"SGI-B-1.1",
 	"SGI-B-2.0",
 	"SGI-OpenGL",
+	"SGMLUG-PM",
 	"SGP4",
 	"SHL-0.5",
 	"SHL-0.51",
@@ -10761,6 +9982,7 @@ var require$$1$2 = [
 	"TTYP0",
 	"TU-Berlin-1.0",
 	"TU-Berlin-2.0",
+	"TekHVC",
 	"TermReadKey",
 	"ThirdEye",
 	"TrustedQSL",
@@ -10770,6 +9992,7 @@ var require$$1$2 = [
 	"UPL-1.0",
 	"URT-RLE",
 	"Ubuntu-font-1.0",
+	"UnRAR",
 	"Unicode-3.0",
 	"Unicode-DFS-2015",
 	"Unicode-DFS-2016",
@@ -10781,15 +10004,19 @@ var require$$1$2 = [
 	"VOSTROM",
 	"VSL-1.0",
 	"Vim",
+	"Vixie-Cron",
 	"W3C",
 	"W3C-19980720",
 	"W3C-20150513",
+	"WTFNMFPL",
 	"WTFPL",
 	"Watcom-1.0",
 	"Widget-Workshop",
+	"WordNet",
 	"Wsuipa",
 	"X11",
 	"X11-distribute-modifications-variant",
+	"X11-no-permit-persons",
 	"X11-swapped",
 	"XFree86-1.1",
 	"XSkat",
@@ -10830,6 +10057,7 @@ var require$$1$2 = [
 	"gnuplot",
 	"gtkbook",
 	"hdparm",
+	"hyphen-bulgarian",
 	"iMatix",
 	"jove",
 	"libpng-1.6.35",
@@ -11853,1449 +11081,645 @@ function requireValidateNpmPackageLicense() {
     return validateNpmPackageLicense;
 }
 
-var commonjs = {};
+var index_min = {};
 
-var hasRequiredCommonjs;
-function requireCommonjs() {
+var hasRequiredIndex_min;
+function requireIndex_min() {
     var _computedKey, _computedKey1;
-    if (hasRequiredCommonjs) return commonjs;
-    hasRequiredCommonjs = 1;
-    /**
-	 * @module LRUCache
-	 */ Object.defineProperty(commonjs, "__esModule", {
+    if (hasRequiredIndex_min) return index_min;
+    hasRequiredIndex_min = 1;
+    Object.defineProperty(index_min, "__esModule", {
         value: true
     });
-    commonjs.LRUCache = void 0;
-    const defaultPerf = typeof performance === 'object' && performance && typeof performance.now === 'function' ? performance : Date;
-    const warned = new Set();
-    /* c8 ignore start */ const PROCESS = typeof process === 'object' && !!process ? process : {};
-    /* c8 ignore start */ const emitWarning = (msg, type, code, fn)=>{
-        typeof PROCESS.emitWarning === 'function' ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
-    };
-    let AC = globalThis.AbortController;
-    let AS = globalThis.AbortSignal;
-    /* c8 ignore start */ if (typeof AC === 'undefined') {
-        //@ts-ignore
-        AS = class AbortSignal {
+    index_min.LRUCache = void 0;
+    var G = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, U = new Set, R = typeof process == "object" && process ? process : {}, I = (c, t, e, i)=>{
+        typeof R.emitWarning == "function" ? R.emitWarning(c, t, e, i) : console.error(`[${e}] ${t}: ${c}`);
+    }, C = globalThis.AbortController, L = globalThis.AbortSignal;
+    if (typeof C > "u") {
+        L = class {
             onabort;
             _onabort = [];
             reason;
             aborted = false;
-            addEventListener(_, fn) {
-                this._onabort.push(fn);
+            addEventListener(i, s) {
+                this._onabort.push(s);
             }
-        };
-        //@ts-ignore
-        AC = class AbortController {
+        }, C = class {
             constructor(){
-                warnACPolyfill();
+                t();
             }
-            signal = new AS();
-            abort(reason) {
-                if (this.signal.aborted) return;
-                //@ts-ignore
-                this.signal.reason = reason;
-                //@ts-ignore
-                this.signal.aborted = true;
-                //@ts-ignore
-                for (const fn of this.signal._onabort){
-                    fn(reason);
+            signal = new L;
+            abort(i) {
+                if (!this.signal.aborted) {
+                    this.signal.reason = i, this.signal.aborted = true;
+                    for (let s of this.signal._onabort)s(i);
+                    this.signal.onabort?.(i);
                 }
-                this.signal.onabort?.(reason);
             }
         };
-        let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
-        const warnACPolyfill = ()=>{
-            if (!printACPolyfillWarning) return;
-            printACPolyfillWarning = false;
-            emitWarning('AbortController is not defined. If using lru-cache in ' + 'node 14, load an AbortController polyfill from the ' + '`node-abort-controller` package. A minimal polyfill is ' + 'provided for use by LRUCache.fetch(), but it should not be ' + 'relied upon in other contexts (eg, passing it to other APIs that ' + 'use AbortController/AbortSignal might have undesirable effects). ' + 'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.', 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+        let c = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = ()=>{
+            c && (c = false, I("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
         };
     }
-    /* c8 ignore stop */ const shouldWarn = (code)=>!warned.has(code);
-    const isPosInt = (n)=>n && n === Math.floor(n) && n > 0 && isFinite(n);
-    /* c8 ignore start */ // This is a little bit ridiculous, tbh.
-    // The maximum array length is 2^32-1 or thereabouts on most JS impls.
-    // And well before that point, you're caching the entire world, I mean,
-    // that's ~32GB of just integers for the next/prev links, plus whatever
-    // else to hold that many keys and values.  Just filling the memory with
-    // zeroes at init time is brutal when you get that big.
-    // But why not be complete?
-    // Maybe in the future, these limits will have expanded.
-    const getUintArray = (max)=>!isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
-    /* c8 ignore stop */ class ZeroArray extends Array {
-        constructor(size){
-            super(size);
-            this.fill(0);
-        }
-    }
-    class Stack {
+    _computedKey = Symbol.iterator, _computedKey1 = Symbol.toStringTag;
+    var x = (c)=>!U.has(c), y = (c)=>c && c === Math.floor(c) && c > 0 && isFinite(c), M = (c)=>y(c) ? c <= Math.pow(2, 8) ? Uint8Array : c <= Math.pow(2, 16) ? Uint16Array : c <= Math.pow(2, 32) ? Uint32Array : c <= Number.MAX_SAFE_INTEGER ? z : null : null, z = class extends Array {
+        constructor(t){
+            super(t), this.fill(0);
+        }
+    }, W = class c {
         heap;
         length;
-        // private constructor
-        static #constructing = false;
-        static create(max) {
-            const HeapCls = getUintArray(max);
-            if (!HeapCls) return [];
-            Stack.#constructing = true;
-            const s = new Stack(max, HeapCls);
-            Stack.#constructing = false;
-            return s;
-        }
-        constructor(max, HeapCls){
-            /* c8 ignore start */ if (!Stack.#constructing) {
-                throw new TypeError('instantiate Stack using Stack.create(n)');
-            }
-            /* c8 ignore stop */ this.heap = new HeapCls(max);
-            this.length = 0;
-        }
-        push(n) {
-            this.heap[this.length++] = n;
+        static #o = false;
+        static create(t) {
+            let e = M(t);
+            if (!e) return [];
+            c.#o = true;
+            let i = new c(t, e);
+            return c.#o = false, i;
         }
-        pop() {
-            return this.heap[--this.length];
-        }
-    }
-    _computedKey = Symbol.iterator, _computedKey1 = Symbol.toStringTag;
-    /**
-	 * Default export, the thing you're using this module to get.
-	 *
-	 * The `K` and `V` types define the key and value types, respectively. The
-	 * optional `FC` type defines the type of the `context` object passed to
-	 * `cache.fetch()` and `cache.memo()`.
-	 *
-	 * Keys and values **must not** be `null` or `undefined`.
-	 *
-	 * All properties from the options object (with the exception of `max`,
-	 * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
-	 * added as normal public members. (The listed options are read-only getters.)
-	 *
-	 * Changing any of these will alter the defaults for subsequent method calls.
-	 */ class LRUCache {
-        // options that cannot be changed without disaster
-        #max;
-        #maxSize;
-        #dispose;
-        #onInsert;
-        #disposeAfter;
-        #fetchMethod;
-        #memoMethod;
-        #perf;
-        /**
-	     * {@link LRUCache.OptionsBase.perf}
-	     */ get perf() {
-            return this.#perf;
+        constructor(t, e){
+            if (!c.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
+            this.heap = new e(t), this.length = 0;
         }
-        /**
-	     * {@link LRUCache.OptionsBase.ttl}
-	     */ ttl;
-        /**
-	     * {@link LRUCache.OptionsBase.ttlResolution}
-	     */ ttlResolution;
-        /**
-	     * {@link LRUCache.OptionsBase.ttlAutopurge}
-	     */ ttlAutopurge;
-        /**
-	     * {@link LRUCache.OptionsBase.updateAgeOnGet}
-	     */ updateAgeOnGet;
-        /**
-	     * {@link LRUCache.OptionsBase.updateAgeOnHas}
-	     */ updateAgeOnHas;
-        /**
-	     * {@link LRUCache.OptionsBase.allowStale}
-	     */ allowStale;
-        /**
-	     * {@link LRUCache.OptionsBase.noDisposeOnSet}
-	     */ noDisposeOnSet;
-        /**
-	     * {@link LRUCache.OptionsBase.noUpdateTTL}
-	     */ noUpdateTTL;
-        /**
-	     * {@link LRUCache.OptionsBase.maxEntrySize}
-	     */ maxEntrySize;
-        /**
-	     * {@link LRUCache.OptionsBase.sizeCalculation}
-	     */ sizeCalculation;
-        /**
-	     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-	     */ noDeleteOnFetchRejection;
-        /**
-	     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-	     */ noDeleteOnStaleGet;
-        /**
-	     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-	     */ allowStaleOnFetchAbort;
-        /**
-	     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-	     */ allowStaleOnFetchRejection;
-        /**
-	     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-	     */ ignoreFetchAbort;
-        // computed properties
-        #size;
-        #calculatedSize;
-        #keyMap;
-        #keyList;
-        #valList;
-        #next;
-        #prev;
-        #head;
-        #tail;
-        #free;
-        #disposed;
-        #sizes;
-        #starts;
-        #ttls;
-        #hasDispose;
-        #hasFetchMethod;
-        #hasDisposeAfter;
-        #hasOnInsert;
-        /**
-	     * Do not call this method unless you need to inspect the
-	     * inner workings of the cache.  If anything returned by this
-	     * object is modified in any way, strange breakage may occur.
-	     *
-	     * These fields are private for a reason!
-	     *
-	     * @internal
-	     */ static unsafeExposeInternals(c) {
+        push(t) {
+            this.heap[this.length++] = t;
+        }
+        pop() {
+            return this.heap[--this.length];
+        }
+    }, D = class c {
+        #o;
+        #c;
+        #w;
+        #C;
+        #S;
+        #L;
+        #U;
+        #m;
+        get perf() {
+            return this.#m;
+        }
+        ttl;
+        ttlResolution;
+        ttlAutopurge;
+        updateAgeOnGet;
+        updateAgeOnHas;
+        allowStale;
+        noDisposeOnSet;
+        noUpdateTTL;
+        maxEntrySize;
+        sizeCalculation;
+        noDeleteOnFetchRejection;
+        noDeleteOnStaleGet;
+        allowStaleOnFetchAbort;
+        allowStaleOnFetchRejection;
+        ignoreFetchAbort;
+        #n;
+        #_;
+        #s;
+        #i;
+        #t;
+        #a;
+        #u;
+        #l;
+        #h;
+        #b;
+        #r;
+        #y;
+        #A;
+        #d;
+        #g;
+        #T;
+        #v;
+        #f;
+        #I;
+        static unsafeExposeInternals(t) {
             return {
-                // properties
-                starts: c.#starts,
-                ttls: c.#ttls,
-                sizes: c.#sizes,
-                keyMap: c.#keyMap,
-                keyList: c.#keyList,
-                valList: c.#valList,
-                next: c.#next,
-                prev: c.#prev,
+                starts: t.#A,
+                ttls: t.#d,
+                autopurgeTimers: t.#g,
+                sizes: t.#y,
+                keyMap: t.#s,
+                keyList: t.#i,
+                valList: t.#t,
+                next: t.#a,
+                prev: t.#u,
                 get head () {
-                    return c.#head;
+                    return t.#l;
                 },
                 get tail () {
-                    return c.#tail;
+                    return t.#h;
                 },
-                free: c.#free,
-                // methods
-                isBackgroundFetch: (p)=>c.#isBackgroundFetch(p),
-                backgroundFetch: (k, index, options, context)=>c.#backgroundFetch(k, index, options, context),
-                moveToTail: (index)=>c.#moveToTail(index),
-                indexes: (options)=>c.#indexes(options),
-                rindexes: (options)=>c.#rindexes(options),
-                isStale: (index)=>c.#isStale(index)
+                free: t.#b,
+                isBackgroundFetch: (e)=>t.#e(e),
+                backgroundFetch: (e, i, s, n)=>t.#x(e, i, s, n),
+                moveToTail: (e)=>t.#D(e),
+                indexes: (e)=>t.#F(e),
+                rindexes: (e)=>t.#O(e),
+                isStale: (e)=>t.#p(e)
             };
         }
-        // Protected read-only members
-        /**
-	     * {@link LRUCache.OptionsBase.max} (read-only)
-	     */ get max() {
-            return this.#max;
+        get max() {
+            return this.#o;
         }
-        /**
-	     * {@link LRUCache.OptionsBase.maxSize} (read-only)
-	     */ get maxSize() {
-            return this.#maxSize;
+        get maxSize() {
+            return this.#c;
         }
-        /**
-	     * The total computed size of items in the cache (read-only)
-	     */ get calculatedSize() {
-            return this.#calculatedSize;
+        get calculatedSize() {
+            return this.#_;
         }
-        /**
-	     * The number of items stored in the cache (read-only)
-	     */ get size() {
-            return this.#size;
+        get size() {
+            return this.#n;
         }
-        /**
-	     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-	     */ get fetchMethod() {
-            return this.#fetchMethod;
+        get fetchMethod() {
+            return this.#L;
         }
         get memoMethod() {
-            return this.#memoMethod;
-        }
-        /**
-	     * {@link LRUCache.OptionsBase.dispose} (read-only)
-	     */ get dispose() {
-            return this.#dispose;
-        }
-        /**
-	     * {@link LRUCache.OptionsBase.onInsert} (read-only)
-	     */ get onInsert() {
-            return this.#onInsert;
-        }
-        /**
-	     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-	     */ get disposeAfter() {
-            return this.#disposeAfter;
-        }
-        constructor(options){
-            const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf } = options;
-            if (perf !== undefined) {
-                if (typeof perf?.now !== 'function') {
-                    throw new TypeError('perf option must have a now() method if specified');
-                }
-            }
-            this.#perf = perf ?? defaultPerf;
-            if (max !== 0 && !isPosInt(max)) {
-                throw new TypeError('max option must be a nonnegative integer');
-            }
-            const UintArray = max ? getUintArray(max) : Array;
-            if (!UintArray) {
-                throw new Error('invalid max value: ' + max);
-            }
-            this.#max = max;
-            this.#maxSize = maxSize;
-            this.maxEntrySize = maxEntrySize || this.#maxSize;
-            this.sizeCalculation = sizeCalculation;
-            if (this.sizeCalculation) {
-                if (!this.#maxSize && !this.maxEntrySize) {
-                    throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
-                }
-                if (typeof this.sizeCalculation !== 'function') {
-                    throw new TypeError('sizeCalculation set to non-function');
-                }
-            }
-            if (memoMethod !== undefined && typeof memoMethod !== 'function') {
-                throw new TypeError('memoMethod must be a function if defined');
-            }
-            this.#memoMethod = memoMethod;
-            if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
-                throw new TypeError('fetchMethod must be a function if specified');
-            }
-            this.#fetchMethod = fetchMethod;
-            this.#hasFetchMethod = !!fetchMethod;
-            this.#keyMap = new Map();
-            this.#keyList = new Array(max).fill(undefined);
-            this.#valList = new Array(max).fill(undefined);
-            this.#next = new UintArray(max);
-            this.#prev = new UintArray(max);
-            this.#head = 0;
-            this.#tail = 0;
-            this.#free = Stack.create(max);
-            this.#size = 0;
-            this.#calculatedSize = 0;
-            if (typeof dispose === 'function') {
-                this.#dispose = dispose;
-            }
-            if (typeof onInsert === 'function') {
-                this.#onInsert = onInsert;
-            }
-            if (typeof disposeAfter === 'function') {
-                this.#disposeAfter = disposeAfter;
-                this.#disposed = [];
-            } else {
-                this.#disposeAfter = undefined;
-                this.#disposed = undefined;
-            }
-            this.#hasDispose = !!this.#dispose;
-            this.#hasOnInsert = !!this.#onInsert;
-            this.#hasDisposeAfter = !!this.#disposeAfter;
-            this.noDisposeOnSet = !!noDisposeOnSet;
-            this.noUpdateTTL = !!noUpdateTTL;
-            this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
-            this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
-            this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
-            this.ignoreFetchAbort = !!ignoreFetchAbort;
-            // NB: maxEntrySize is set to maxSize if it's set
-            if (this.maxEntrySize !== 0) {
-                if (this.#maxSize !== 0) {
-                    if (!isPosInt(this.#maxSize)) {
-                        throw new TypeError('maxSize must be a positive integer if specified');
-                    }
-                }
-                if (!isPosInt(this.maxEntrySize)) {
-                    throw new TypeError('maxEntrySize must be a positive integer if specified');
-                }
-                this.#initializeSizeTracking();
-            }
-            this.allowStale = !!allowStale;
-            this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-            this.updateAgeOnGet = !!updateAgeOnGet;
-            this.updateAgeOnHas = !!updateAgeOnHas;
-            this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
-            this.ttlAutopurge = !!ttlAutopurge;
-            this.ttl = ttl || 0;
-            if (this.ttl) {
-                if (!isPosInt(this.ttl)) {
-                    throw new TypeError('ttl must be a positive integer if specified');
-                }
-                this.#initializeTTLTracking();
-            }
-            // do not allow completely unbounded caches
-            if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
-                throw new TypeError('At least one of max, maxSize, or ttl is required');
-            }
-            if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-                const code = 'LRU_CACHE_UNBOUNDED';
-                if (shouldWarn(code)) {
-                    warned.add(code);
-                    const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' + 'result in unbounded memory consumption.';
-                    emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
-                }
-            }
-        }
-        /**
-	     * Return the number of ms left in the item's TTL. If item is not in cache,
-	     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
-	     */ getRemainingTTL(key) {
-            return this.#keyMap.has(key) ? Infinity : 0;
-        }
-        #initializeTTLTracking() {
-            const ttls = new ZeroArray(this.#max);
-            const starts = new ZeroArray(this.#max);
-            this.#ttls = ttls;
-            this.#starts = starts;
-            this.#setItemTTL = (index, ttl, start = this.#perf.now())=>{
-                starts[index] = ttl !== 0 ? start : 0;
-                ttls[index] = ttl;
-                if (ttl !== 0 && this.ttlAutopurge) {
-                    const t = setTimeout(()=>{
-                        if (this.#isStale(index)) {
-                            this.#delete(this.#keyList[index], 'expire');
-                        }
-                    }, ttl + 1);
-                    // unref() not supported on all platforms
-                    /* c8 ignore start */ if (t.unref) {
-                        t.unref();
-                    }
-                /* c8 ignore stop */ }
-            };
-            this.#updateItemAge = (index)=>{
-                starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+            return this.#U;
+        }
+        get dispose() {
+            return this.#w;
+        }
+        get onInsert() {
+            return this.#C;
+        }
+        get disposeAfter() {
+            return this.#S;
+        }
+        constructor(t){
+            let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: r, dispose: a, onInsert: w, disposeAfter: f, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: S, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: m, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+            if (v !== void 0 && typeof v?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+            if (this.#m = v ?? G, e !== 0 && !y(e)) throw new TypeError("max option must be a nonnegative integer");
+            let O = e ? M(e) : Array;
+            if (!O) throw new Error("invalid max value: " + e);
+            if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+                if (!this.#c && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+                if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+            }
+            if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+            if (this.#U = S, l !== void 0 && typeof l != "function") throw new TypeError("fetchMethod must be a function if specified");
+            if (this.#L = l, this.#v = !!l, this.#s = new Map, this.#i = new Array(e).fill(void 0), this.#t = new Array(e).fill(void 0), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W.create(e), this.#n = 0, this.#_ = 0, typeof a == "function" && (this.#w = a), typeof w == "function" && (this.#C = w), typeof f == "function" ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#I = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, this.allowStaleOnFetchAbort = !!T, this.ignoreFetchAbort = !!F, this.maxEntrySize !== 0) {
+                if (this.#c !== 0 && !y(this.#c)) throw new TypeError("maxSize must be a positive integer if specified");
+                if (!y(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+                this.#B();
+            }
+            if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!m, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
+                if (!y(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+                this.#j();
+            }
+            if (this.#o === 0 && this.ttl === 0 && this.#c === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+            if (!this.ttlAutopurge && !this.#o && !this.#c) {
+                let E = "LRU_CACHE_UNBOUNDED";
+                x(E) && (U.add(E), I("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, c));
+            }
+        }
+        getRemainingTTL(t) {
+            return this.#s.has(t) ? 1 / 0 : 0;
+        }
+        #j() {
+            let t = new z(this.#o), e = new z(this.#o);
+            this.#d = t, this.#A = e;
+            let i = this.ttlAutopurge ? new Array(this.#o) : void 0;
+            this.#g = i, this.#N = (h, r, a = this.#m.now())=>{
+                e[h] = r !== 0 ? a : 0, t[h] = r, s(h, r);
+            }, this.#R = (h)=>{
+                e[h] = t[h] !== 0 ? this.#m.now() : 0, s(h, t[h]);
             };
-            this.#statusTTL = (status, index)=>{
-                if (ttls[index]) {
-                    const ttl = ttls[index];
-                    const start = starts[index];
-                    /* c8 ignore next */ if (!ttl || !start) return;
-                    status.ttl = ttl;
-                    status.start = start;
-                    status.now = cachedNow || getNow();
-                    const age = status.now - start;
-                    status.remainingTTL = ttl - age;
+            let s = this.ttlAutopurge ? (h, r)=>{
+                if (i?.[h] && (clearTimeout(i[h]), i[h] = void 0), r && r !== 0 && i) {
+                    let a = setTimeout(()=>{
+                        this.#p(h) && this.#E(this.#i[h], "expire");
+                    }, r + 1);
+                    a.unref && a.unref(), i[h] = a;
+                }
+            } : ()=>{};
+            this.#z = (h, r)=>{
+                if (t[r]) {
+                    let a = t[r], w = e[r];
+                    if (!a || !w) return;
+                    h.ttl = a, h.start = w, h.now = n || o();
+                    let f = h.now - w;
+                    h.remainingTTL = a - f;
                 }
             };
-            // debounce calls to perf.now() to 1s so we're not hitting
-            // that costly call repeatedly.
-            let cachedNow = 0;
-            const getNow = ()=>{
-                const n = this.#perf.now();
+            let n = 0, o = ()=>{
+                let h = this.#m.now();
                 if (this.ttlResolution > 0) {
-                    cachedNow = n;
-                    const t = setTimeout(()=>cachedNow = 0, this.ttlResolution);
-                    // not available on all platforms
-                    /* c8 ignore start */ if (t.unref) {
-                        t.unref();
-                    }
-                /* c8 ignore stop */ }
-                return n;
-            };
-            this.getRemainingTTL = (key)=>{
-                const index = this.#keyMap.get(key);
-                if (index === undefined) {
-                    return 0;
-                }
-                const ttl = ttls[index];
-                const start = starts[index];
-                if (!ttl || !start) {
-                    return Infinity;
+                    n = h;
+                    let r = setTimeout(()=>n = 0, this.ttlResolution);
+                    r.unref && r.unref();
                 }
-                const age = (cachedNow || getNow()) - start;
-                return ttl - age;
+                return h;
             };
-            this.#isStale = (index)=>{
-                const s = starts[index];
-                const t = ttls[index];
-                return !!t && !!s && (cachedNow || getNow()) - s > t;
+            this.getRemainingTTL = (h)=>{
+                let r = this.#s.get(h);
+                if (r === void 0) return 0;
+                let a = t[r], w = e[r];
+                if (!a || !w) return 1 / 0;
+                let f = (n || o()) - w;
+                return a - f;
+            }, this.#p = (h)=>{
+                let r = e[h], a = t[h];
+                return !!a && !!r && (n || o()) - r > a;
             };
         }
-        // conditionally set private methods related to TTL
-        #updateItemAge = ()=>{};
-        #statusTTL = ()=>{};
-        #setItemTTL = ()=>{};
-        /* c8 ignore stop */ #isStale = ()=>false;
-        #initializeSizeTracking() {
-            const sizes = new ZeroArray(this.#max);
-            this.#calculatedSize = 0;
-            this.#sizes = sizes;
-            this.#removeItemSize = (index)=>{
-                this.#calculatedSize -= sizes[index];
-                sizes[index] = 0;
-            };
-            this.#requireSize = (k, v, size, sizeCalculation)=>{
-                // provisionally accept background fetches.
-                // actual value size will be checked when they return.
-                if (this.#isBackgroundFetch(v)) {
-                    return 0;
-                }
-                if (!isPosInt(size)) {
-                    if (sizeCalculation) {
-                        if (typeof sizeCalculation !== 'function') {
-                            throw new TypeError('sizeCalculation must be a function');
-                        }
-                        size = sizeCalculation(v, k);
-                        if (!isPosInt(size)) {
-                            throw new TypeError('sizeCalculation return invalid (expect positive integer)');
-                        }
-                    } else {
-                        throw new TypeError('invalid size value (must be positive integer). ' + 'When maxSize or maxEntrySize is used, sizeCalculation ' + 'or size must be set.');
-                    }
-                }
-                return size;
-            };
-            this.#addItemSize = (index, size, status)=>{
-                sizes[index] = size;
-                if (this.#maxSize) {
-                    const maxSize = this.#maxSize - sizes[index];
-                    while(this.#calculatedSize > maxSize){
-                        this.#evict(true);
-                    }
-                }
-                this.#calculatedSize += sizes[index];
-                if (status) {
-                    status.entrySize = size;
-                    status.totalCalculatedSize = this.#calculatedSize;
-                }
+        #R = ()=>{};
+        #z = ()=>{};
+        #N = ()=>{};
+        #p = ()=>false;
+        #B() {
+            let t = new z(this.#o);
+            this.#_ = 0, this.#y = t, this.#W = (e)=>{
+                this.#_ -= t[e], t[e] = 0;
+            }, this.#P = (e, i, s, n)=>{
+                if (this.#e(i)) return 0;
+                if (!y(s)) if (n) {
+                    if (typeof n != "function") throw new TypeError("sizeCalculation must be a function");
+                    if (s = n(i, e), !y(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+                } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+                return s;
+            }, this.#M = (e, i, s)=>{
+                if (t[e] = i, this.#c) {
+                    let n = this.#c - t[e];
+                    for(; this.#_ > n;)this.#G(true);
+                }
+                this.#_ += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
             };
         }
-        #removeItemSize = (_i)=>{};
-        #addItemSize = (_i, _s, _st)=>{};
-        #requireSize = (_k, _v, size, sizeCalculation)=>{
-            if (size || sizeCalculation) {
-                throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
-            }
+        #W = (t)=>{};
+        #M = (t, e, i)=>{};
+        #P = (t, e, i, s)=>{
+            if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
             return 0;
         };
-        *#indexes({ allowStale = this.allowStale } = {}) {
-            if (this.#size) {
-                for(let i = this.#tail; true;){
-                    if (!this.#isValidIndex(i)) {
-                        break;
-                    }
-                    if (allowStale || !this.#isStale(i)) {
-                        yield i;
-                    }
-                    if (i === this.#head) {
-                        break;
-                    } else {
-                        i = this.#prev[i];
-                    }
-                }
-            }
+        *#F({ allowStale: t = this.allowStale } = {}) {
+            if (this.#n) for(let e = this.#h; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l));)e = this.#u[e];
         }
-        *#rindexes({ allowStale = this.allowStale } = {}) {
-            if (this.#size) {
-                for(let i = this.#head; true;){
-                    if (!this.#isValidIndex(i)) {
-                        break;
-                    }
-                    if (allowStale || !this.#isStale(i)) {
-                        yield i;
-                    }
-                    if (i === this.#tail) {
-                        break;
-                    } else {
-                        i = this.#next[i];
-                    }
-                }
-            }
+        *#O({ allowStale: t = this.allowStale } = {}) {
+            if (this.#n) for(let e = this.#l; !(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h));)e = this.#a[e];
         }
-        #isValidIndex(index) {
-            return index !== undefined && this.#keyMap.get(this.#keyList[index]) === index;
+        #H(t) {
+            return t !== void 0 && this.#s.get(this.#i[t]) === t;
         }
-        /**
-	     * Return a generator yielding `[key, value]` pairs,
-	     * in order from most recently used to least recently used.
-	     */ *entries() {
-            for (const i of this.#indexes()){
-                if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield [
-                        this.#keyList[i],
-                        this.#valList[i]
-                    ];
-                }
-            }
+        *entries() {
+            for (let t of this.#F())this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [
+                this.#i[t],
+                this.#t[t]
+            ]);
         }
-        /**
-	     * Inverse order version of {@link LRUCache.entries}
-	     *
-	     * Return a generator yielding `[key, value]` pairs,
-	     * in order from least recently used to most recently used.
-	     */ *rentries() {
-            for (const i of this.#rindexes()){
-                if (this.#valList[i] !== undefined && this.#keyList[i] !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield [
-                        this.#keyList[i],
-                        this.#valList[i]
-                    ];
-                }
-            }
+        *rentries() {
+            for (let t of this.#O())this.#t[t] !== void 0 && this.#i[t] !== void 0 && !this.#e(this.#t[t]) && (yield [
+                this.#i[t],
+                this.#t[t]
+            ]);
         }
-        /**
-	     * Return a generator yielding the keys in the cache,
-	     * in order from most recently used to least recently used.
-	     */ *keys() {
-            for (const i of this.#indexes()){
-                const k = this.#keyList[i];
-                if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield k;
-                }
+        *keys() {
+            for (let t of this.#F()){
+                let e = this.#i[t];
+                e !== void 0 && !this.#e(this.#t[t]) && (yield e);
             }
         }
-        /**
-	     * Inverse order version of {@link LRUCache.keys}
-	     *
-	     * Return a generator yielding the keys in the cache,
-	     * in order from least recently used to most recently used.
-	     */ *rkeys() {
-            for (const i of this.#rindexes()){
-                const k = this.#keyList[i];
-                if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield k;
-                }
+        *rkeys() {
+            for (let t of this.#O()){
+                let e = this.#i[t];
+                e !== void 0 && !this.#e(this.#t[t]) && (yield e);
             }
         }
-        /**
-	     * Return a generator yielding the values in the cache,
-	     * in order from most recently used to least recently used.
-	     */ *values() {
-            for (const i of this.#indexes()){
-                const v = this.#valList[i];
-                if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield this.#valList[i];
-                }
-            }
+        *values() {
+            for (let t of this.#F())this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
         }
-        /**
-	     * Inverse order version of {@link LRUCache.values}
-	     *
-	     * Return a generator yielding the values in the cache,
-	     * in order from least recently used to most recently used.
-	     */ *rvalues() {
-            for (const i of this.#rindexes()){
-                const v = this.#valList[i];
-                if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
-                    yield this.#valList[i];
-                }
-            }
+        *rvalues() {
+            for (let t of this.#O())this.#t[t] !== void 0 && !this.#e(this.#t[t]) && (yield this.#t[t]);
         }
-        /**
-	     * Iterating over the cache itself yields the same results as
-	     * {@link LRUCache.entries}
-	     */ [_computedKey]() {
+        [_computedKey]() {
             return this.entries();
         }
-        /**
-	     * A String value that is used in the creation of the default string
-	     * description of an object. Called by the built-in method
-	     * `Object.prototype.toString`.
-	     */ [_computedKey1] = 'LRUCache';
-        /**
-	     * Find a value for which the supplied fn method returns a truthy value,
-	     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
-	     */ find(fn, getOptions = {}) {
-            for (const i of this.#indexes()){
-                const v = this.#valList[i];
-                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                if (value === undefined) continue;
-                if (fn(value, this.#keyList[i], this)) {
-                    return this.get(this.#keyList[i], getOptions);
-                }
+        [_computedKey1] = "LRUCache";
+        find(t, e = {}) {
+            for (let i of this.#F()){
+                let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                if (n !== void 0 && t(n, this.#i[i], this)) return this.get(this.#i[i], e);
             }
         }
-        /**
-	     * Call the supplied function on each item in the cache, in order from most
-	     * recently used to least recently used.
-	     *
-	     * `fn` is called as `fn(value, key, cache)`.
-	     *
-	     * If `thisp` is provided, function will be called in the `this`-context of
-	     * the provided object, or the cache if no `thisp` object is provided.
-	     *
-	     * Does not update age or recenty of use, or iterate over stale values.
-	     */ forEach(fn, thisp = this) {
-            for (const i of this.#indexes()){
-                const v = this.#valList[i];
-                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                if (value === undefined) continue;
-                fn.call(thisp, value, this.#keyList[i], this);
+        forEach(t, e = this) {
+            for (let i of this.#F()){
+                let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                n !== void 0 && t.call(e, n, this.#i[i], this);
             }
         }
-        /**
-	     * The same as {@link LRUCache.forEach} but items are iterated over in
-	     * reverse order.  (ie, less recently used items are iterated over first.)
-	     */ rforEach(fn, thisp = this) {
-            for (const i of this.#rindexes()){
-                const v = this.#valList[i];
-                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                if (value === undefined) continue;
-                fn.call(thisp, value, this.#keyList[i], this);
+        rforEach(t, e = this) {
+            for (let i of this.#O()){
+                let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
+                n !== void 0 && t.call(e, n, this.#i[i], this);
             }
         }
-        /**
-	     * Delete any stale entries. Returns true if anything was removed,
-	     * false otherwise.
-	     */ purgeStale() {
-            let deleted = false;
-            for (const i of this.#rindexes({
+        purgeStale() {
+            let t = false;
+            for (let e of this.#O({
                 allowStale: true
-            })){
-                if (this.#isStale(i)) {
-                    this.#delete(this.#keyList[i], 'expire');
-                    deleted = true;
-                }
-            }
-            return deleted;
-        }
-        /**
-	     * Get the extended info about a given entry, to get its value, size, and
-	     * TTL info simultaneously. Returns `undefined` if the key is not present.
-	     *
-	     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
-	     * serialization, the `start` value is always the current timestamp, and the
-	     * `ttl` is a calculated remaining time to live (negative if expired).
-	     *
-	     * Always returns stale values, if their info is found in the cache, so be
-	     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
-	     * if relevant.
-	     */ info(key) {
-            const i = this.#keyMap.get(key);
-            if (i === undefined) return undefined;
-            const v = this.#valList[i];
-            /* c8 ignore start - this isn't tested for the info function,
-	         * but it's the same logic as found in other places. */ const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-            if (value === undefined) return undefined;
-            /* c8 ignore end */ const entry = {
-                value
+            }))this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+            return t;
+        }
+        info(t) {
+            let e = this.#s.get(t);
+            if (e === void 0) return;
+            let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+            if (s === void 0) return;
+            let n = {
+                value: s
             };
-            if (this.#ttls && this.#starts) {
-                const ttl = this.#ttls[i];
-                const start = this.#starts[i];
-                if (ttl && start) {
-                    const remain = ttl - (this.#perf.now() - start);
-                    entry.ttl = remain;
-                    entry.start = Date.now();
+            if (this.#d && this.#A) {
+                let o = this.#d[e], h = this.#A[e];
+                if (o && h) {
+                    let r = o - (this.#m.now() - h);
+                    n.ttl = r, n.start = Date.now();
                 }
             }
-            if (this.#sizes) {
-                entry.size = this.#sizes[i];
-            }
-            return entry;
+            return this.#y && (n.size = this.#y[e]), n;
         }
-        /**
-	     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-	     * passed to {@link LRUCache#load}.
-	     *
-	     * The `start` fields are calculated relative to a portable `Date.now()`
-	     * timestamp, even if `performance.now()` is available.
-	     *
-	     * Stale entries are always included in the `dump`, even if
-	     * {@link LRUCache.OptionsBase.allowStale} is false.
-	     *
-	     * Note: this returns an actual array, not a generator, so it can be more
-	     * easily passed around.
-	     */ dump() {
-            const arr = [];
-            for (const i of this.#indexes({
+        dump() {
+            let t = [];
+            for (let e of this.#F({
                 allowStale: true
             })){
-                const key = this.#keyList[i];
-                const v = this.#valList[i];
-                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-                if (value === undefined || key === undefined) continue;
-                const entry = {
-                    value
+                let i = this.#i[e], s = this.#t[e], n = this.#e(s) ? s.__staleWhileFetching : s;
+                if (n === void 0 || i === void 0) continue;
+                let o = {
+                    value: n
                 };
-                if (this.#ttls && this.#starts) {
-                    entry.ttl = this.#ttls[i];
-                    // always dump the start relative to a portable timestamp
-                    // it's ok for this to be a bit slow, it's a rare operation.
-                    const age = this.#perf.now() - this.#starts[i];
-                    entry.start = Math.floor(Date.now() - age);
-                }
-                if (this.#sizes) {
-                    entry.size = this.#sizes[i];
-                }
-                arr.unshift([
-                    key,
-                    entry
+                if (this.#d && this.#A) {
+                    o.ttl = this.#d[e];
+                    let h = this.#m.now() - this.#A[e];
+                    o.start = Math.floor(Date.now() - h);
+                }
+                this.#y && (o.size = this.#y[e]), t.unshift([
+                    i,
+                    o
                 ]);
             }
-            return arr;
+            return t;
         }
-        /**
-	     * Reset the cache and load in the items in entries in the order listed.
-	     *
-	     * The shape of the resulting cache may be different if the same options are
-	     * not used in both caches.
-	     *
-	     * The `start` fields are assumed to be calculated relative to a portable
-	     * `Date.now()` timestamp, even if `performance.now()` is available.
-	     */ load(arr) {
+        load(t) {
             this.clear();
-            for (const [key, entry] of arr){
-                if (entry.start) {
-                    // entry.start is a portable timestamp, but we may be using
-                    // node's performance.now(), so calculate the offset, so that
-                    // we get the intended remaining TTL, no matter how long it's
-                    // been on ice.
-                    //
-                    // it's ok for this to be a bit slow, it's a rare operation.
-                    const age = Date.now() - entry.start;
-                    entry.start = this.#perf.now() - age;
+            for (let [e, i] of t){
+                if (i.start) {
+                    let s = Date.now() - i.start;
+                    i.start = this.#m.now() - s;
                 }
-                this.set(key, entry.value, entry);
+                this.set(e, i.value, i);
             }
         }
-        /**
-	     * Add a value to the cache.
-	     *
-	     * Note: if `undefined` is specified as a value, this is an alias for
-	     * {@link LRUCache#delete}
-	     *
-	     * Fields on the {@link LRUCache.SetOptions} options param will override
-	     * their corresponding values in the constructor options for the scope
-	     * of this single `set()` operation.
-	     *
-	     * If `start` is provided, then that will set the effective start
-	     * time for the TTL calculation. Note that this must be a previous
-	     * value of `performance.now()` if supported, or a previous value of
-	     * `Date.now()` if not.
-	     *
-	     * Options object may also include `size`, which will prevent
-	     * calling the `sizeCalculation` function and just use the specified
-	     * number if it is a positive integer, and `noDisposeOnSet` which
-	     * will prevent calling a `dispose` function in the case of
-	     * overwrites.
-	     *
-	     * If the `size` (or return value of `sizeCalculation`) for a given
-	     * entry is greater than `maxEntrySize`, then the item will not be
-	     * added to the cache.
-	     *
-	     * Will update the recency of the entry.
-	     *
-	     * If the value is `undefined`, then this is an alias for
-	     * `cache.delete(key)`. `undefined` is never stored in the cache.
-	     */ set(k, v, setOptions = {}) {
-            if (v === undefined) {
-                this.delete(k);
-                return this;
-            }
-            const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
-            let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-            const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-            // if the item doesn't fit, don't do anything
-            // NB: maxEntrySize set to maxSize by default
-            if (this.maxEntrySize && size > this.maxEntrySize) {
-                if (status) {
-                    status.set = 'miss';
-                    status.maxEntrySizeExceeded = true;
-                }
-                // have to delete, in case something is there already.
-                this.#delete(k, 'set');
-                return this;
-            }
-            let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
-            if (index === undefined) {
-                // addition
-                index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-                this.#keyList[index] = k;
-                this.#valList[index] = v;
-                this.#keyMap.set(k, index);
-                this.#next[this.#tail] = index;
-                this.#prev[index] = this.#tail;
-                this.#tail = index;
-                this.#size++;
-                this.#addItemSize(index, size, status);
-                if (status) status.set = 'add';
-                noUpdateTTL = false;
-                if (this.#hasOnInsert) {
-                    this.#onInsert?.(v, k, 'add');
-                }
-            } else {
-                // update
-                this.#moveToTail(index);
-                const oldVal = this.#valList[index];
-                if (v !== oldVal) {
-                    if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                        oldVal.__abortController.abort(new Error('replaced'));
-                        const { __staleWhileFetching: s } = oldVal;
-                        if (s !== undefined && !noDisposeOnSet) {
-                            if (this.#hasDispose) {
-                                this.#dispose?.(s, k, 'set');
-                            }
-                            if (this.#hasDisposeAfter) {
-                                this.#disposed?.push([
-                                    s,
-                                    k,
-                                    'set'
-                                ]);
-                            }
-                        }
-                    } else if (!noDisposeOnSet) {
-                        if (this.#hasDispose) {
-                            this.#dispose?.(oldVal, k, 'set');
-                        }
-                        if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([
-                                oldVal,
-                                k,
-                                'set'
-                            ]);
-                        }
-                    }
-                    this.#removeItemSize(index);
-                    this.#addItemSize(index, size, status);
-                    this.#valList[index] = v;
-                    if (status) {
-                        status.set = 'replace';
-                        const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
-                        if (oldValue !== undefined) status.oldValue = oldValue;
+        set(t, e, i = {}) {
+            if (e === void 0) return this.delete(t), this;
+            let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: r } = i, { noUpdateTTL: a = this.noUpdateTTL } = i, w = this.#P(t, e, i.size || 0, h);
+            if (this.maxEntrySize && w > this.maxEntrySize) return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+            let f = this.#n === 0 ? void 0 : this.#s.get(t);
+            if (f === void 0) f = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#G(false) : this.#n, this.#i[f] = t, this.#t[f] = e, this.#s.set(t, f), this.#a[this.#h] = f, this.#u[f] = this.#h, this.#h = f, this.#n++, this.#M(f, w, r), r && (r.set = "add"), a = false, this.#I && this.#C?.(e, t, "add");
+            else {
+                this.#D(f);
+                let d = this.#t[f];
+                if (e !== d) {
+                    if (this.#v && this.#e(d)) {
+                        d.__abortController.abort(new Error("replaced"));
+                        let { __staleWhileFetching: g } = d;
+                        g !== void 0 && !o && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([
+                            g,
+                            t,
+                            "set"
+                        ]));
+                    } else o || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([
+                        d,
+                        t,
+                        "set"
+                    ]));
+                    if (this.#W(f), this.#M(f, w, r), this.#t[f] = e, r) {
+                        r.set = "replace";
+                        let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+                        g !== void 0 && (r.oldValue = g);
                     }
-                } else if (status) {
-                    status.set = 'update';
-                }
-                if (this.#hasOnInsert) {
-                    this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
-                }
-            }
-            if (ttl !== 0 && !this.#ttls) {
-                this.#initializeTTLTracking();
+                } else r && (r.set = "update");
+                this.#I && this.onInsert?.(e, t, e === d ? "update" : "replace");
             }
-            if (this.#ttls) {
-                if (!noUpdateTTL) {
-                    this.#setItemTTL(index, ttl, start);
-                }
-                if (status) this.#statusTTL(status, index);
-            }
-            if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-                const dt = this.#disposed;
-                let task;
-                while(task = dt?.shift()){
-                    this.#disposeAfter?.(...task);
-                }
+            if (s !== 0 && !this.#d && this.#j(), this.#d && (a || this.#N(f, s, n), r && this.#z(r, f)), !o && this.#f && this.#r) {
+                let d = this.#r, g;
+                for(; g = d?.shift();)this.#S?.(...g);
             }
             return this;
         }
-        /**
-	     * Evict the least recently used item, returning its value or
-	     * `undefined` if cache is empty.
-	     */ pop() {
+        pop() {
             try {
-                while(this.#size){
-                    const val = this.#valList[this.#head];
-                    this.#evict(true);
-                    if (this.#isBackgroundFetch(val)) {
-                        if (val.__staleWhileFetching) {
-                            return val.__staleWhileFetching;
-                        }
-                    } else if (val !== undefined) {
-                        return val;
-                    }
+                for(; this.#n;){
+                    let t = this.#t[this.#l];
+                    if (this.#G(!0), this.#e(t)) {
+                        if (t.__staleWhileFetching) return t.__staleWhileFetching;
+                    } else if (t !== void 0) return t;
                 }
             } finally{
-                if (this.#hasDisposeAfter && this.#disposed) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift()){
-                        this.#disposeAfter?.(...task);
-                    }
-                }
-            }
-        }
-        #evict(free) {
-            const head = this.#head;
-            const k = this.#keyList[head];
-            const v = this.#valList[head];
-            if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-                v.__abortController.abort(new Error('evicted'));
-            } else if (this.#hasDispose || this.#hasDisposeAfter) {
-                if (this.#hasDispose) {
-                    this.#dispose?.(v, k, 'evict');
-                }
-                if (this.#hasDisposeAfter) {
-                    this.#disposed?.push([
-                        v,
-                        k,
-                        'evict'
-                    ]);
+                if (this.#f && this.#r) {
+                    let t = this.#r, e;
+                    for(; e = t?.shift();)this.#S?.(...e);
                 }
             }
-            this.#removeItemSize(head);
-            // if we aren't about to use the index, then null these out
-            if (free) {
-                this.#keyList[head] = undefined;
-                this.#valList[head] = undefined;
-                this.#free.push(head);
-            }
-            if (this.#size === 1) {
-                this.#head = this.#tail = 0;
-                this.#free.length = 0;
-            } else {
-                this.#head = this.#next[head];
-            }
-            this.#keyMap.delete(k);
-            this.#size--;
-            return head;
         }
-        /**
-	     * Check if a key is in the cache, without updating the recency of use.
-	     * Will return false if the item is stale, even though it is technically
-	     * in the cache.
-	     *
-	     * Check if a key is in the cache, without updating the recency of
-	     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
-	     * to `true` in either the options or the constructor.
-	     *
-	     * Will return `false` if the item is stale, even though it is technically in
-	     * the cache. The difference can be determined (if it matters) by using a
-	     * `status` argument, and inspecting the `has` field.
-	     *
-	     * Will not update item age unless
-	     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-	     */ has(k, hasOptions = {}) {
-            const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-            const index = this.#keyMap.get(k);
-            if (index !== undefined) {
-                const v = this.#valList[index];
-                if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === undefined) {
-                    return false;
-                }
-                if (!this.#isStale(index)) {
-                    if (updateAgeOnHas) {
-                        this.#updateItemAge(index);
-                    }
-                    if (status) {
-                        status.has = 'hit';
-                        this.#statusTTL(status, index);
-                    }
-                    return true;
-                } else if (status) {
-                    status.has = 'stale';
-                    this.#statusTTL(status, index);
-                }
-            } else if (status) {
-                status.has = 'miss';
-            }
+        #G(t) {
+            let e = this.#l, i = this.#i[e], s = this.#t[e];
+            return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([
+                s,
+                i,
+                "evict"
+            ])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = void 0), t && (this.#i[e] = void 0, this.#t[e] = void 0, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i), this.#n--, e;
+        }
+        has(t, e = {}) {
+            let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, n = this.#s.get(t);
+            if (n !== void 0) {
+                let o = this.#t[n];
+                if (this.#e(o) && o.__staleWhileFetching === void 0) return false;
+                if (this.#p(n)) s && (s.has = "stale", this.#z(s, n));
+                else return i && this.#R(n), s && (s.has = "hit", this.#z(s, n)), true;
+            } else s && (s.has = "miss");
             return false;
         }
-        /**
-	     * Like {@link LRUCache#get} but doesn't update recency or delete stale
-	     * items.
-	     *
-	     * Returns `undefined` if the item is stale, unless
-	     * {@link LRUCache.OptionsBase.allowStale} is set.
-	     */ peek(k, peekOptions = {}) {
-            const { allowStale = this.allowStale } = peekOptions;
-            const index = this.#keyMap.get(k);
-            if (index === undefined || !allowStale && this.#isStale(index)) {
-                return;
-            }
-            const v = this.#valList[index];
-            // either stale and allowed, or forcing a refresh of non-stale value
-            return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-        }
-        #backgroundFetch(k, index, options, context) {
-            const v = index === undefined ? undefined : this.#valList[index];
-            if (this.#isBackgroundFetch(v)) {
-                return v;
-            }
-            const ac = new AC();
-            const { signal } = options;
-            // when/if our AC signals, then stop listening to theirs.
-            signal?.addEventListener('abort', ()=>ac.abort(signal.reason), {
-                signal: ac.signal
+        peek(t, e = {}) {
+            let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+            if (s === void 0 || !i && this.#p(s)) return;
+            let n = this.#t[s];
+            return this.#e(n) ? n.__staleWhileFetching : n;
+        }
+        #x(t, e, i, s) {
+            let n = e === void 0 ? void 0 : this.#t[e];
+            if (this.#e(n)) return n;
+            let o = new C, { signal: h } = i;
+            h?.addEventListener("abort", ()=>o.abort(h.reason), {
+                signal: o.signal
             });
-            const fetchOpts = {
-                signal: ac.signal,
-                options,
-                context
-            };
-            const cb = (v, updateCache = false)=>{
-                const { aborted } = ac.signal;
-                const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
-                if (options.status) {
-                    if (aborted && !updateCache) {
-                        options.status.fetchAborted = true;
-                        options.status.fetchError = ac.signal.reason;
-                        if (ignoreAbort) options.status.fetchAbortIgnored = true;
-                    } else {
-                        options.status.fetchResolved = true;
-                    }
-                }
-                if (aborted && !ignoreAbort && !updateCache) {
-                    return fetchFail(ac.signal.reason);
-                }
-                // either we didn't abort, and are still here, or we did, and ignored
-                const bf = p;
-                // if nothing else has been written there but we're set to update the
-                // cache and ignore the abort, or if it's still pending on this specific
-                // background request, then write it to the cache.
-                const vl = this.#valList[index];
-                if (vl === p || ignoreAbort && updateCache && vl === undefined) {
-                    if (v === undefined) {
-                        if (bf.__staleWhileFetching !== undefined) {
-                            this.#valList[index] = bf.__staleWhileFetching;
-                        } else {
-                            this.#delete(k, 'fetch');
-                        }
-                    } else {
-                        if (options.status) options.status.fetchUpdated = true;
-                        this.set(k, v, fetchOpts.options);
-                    }
-                }
-                return v;
-            };
-            const eb = (er)=>{
-                if (options.status) {
-                    options.status.fetchRejected = true;
-                    options.status.fetchError = er;
-                }
-                return fetchFail(er);
-            };
-            const fetchFail = (er)=>{
-                const { aborted } = ac.signal;
-                const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-                const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-                const noDelete = allowStale || options.noDeleteOnFetchRejection;
-                const bf = p;
-                if (this.#valList[index] === p) {
-                    // if we allow stale on fetch rejections, then we need to ensure that
-                    // the stale value is not removed from the cache when the fetch fails.
-                    const del = !noDelete || bf.__staleWhileFetching === undefined;
-                    if (del) {
-                        this.#delete(k, 'fetch');
-                    } else if (!allowStaleAborted) {
-                        // still replace the *promise* with the stale value,
-                        // since we are done with the promise at this point.
-                        // leave it untouched if we're still waiting for an
-                        // aborted background fetch that hasn't yet returned.
-                        this.#valList[index] = bf.__staleWhileFetching;
-                    }
-                }
-                if (allowStale) {
-                    if (options.status && bf.__staleWhileFetching !== undefined) {
-                        options.status.returnedStale = true;
-                    }
-                    return bf.__staleWhileFetching;
-                } else if (bf.__returned === bf) {
-                    throw er;
-                }
-            };
-            const pcall = (res, rej)=>{
-                const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-                if (fmp && fmp instanceof Promise) {
-                    fmp.then((v)=>res(v === undefined ? undefined : v), rej);
-                }
-                // ignored, we go until we finish, regardless.
-                // defer check until we are actually aborting,
-                // so fetchMethod can override.
-                ac.signal.addEventListener('abort', ()=>{
-                    if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-                        res(undefined);
-                        // when it eventually resolves, update the cache.
-                        if (options.allowStaleOnFetchAbort) {
-                            res = (v)=>cb(v, true);
-                        }
-                    }
+            let r = {
+                signal: o.signal,
+                options: i,
+                context: s
+            }, a = (p, _ = false)=>{
+                let { aborted: l } = o.signal, S = i.ignoreFetchAbort && p !== void 0, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== void 0);
+                if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = o.signal.reason, S && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !S && !_) return f(o.signal.reason, b);
+                let m = g, u = this.#t[e];
+                return (u === g || S && _ && u === void 0) && (p === void 0 ? m.__staleWhileFetching !== void 0 ? this.#t[e] = m.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+            }, w = (p)=>(i.status && (i.status.fetchRejected = true, i.status.fetchError = p), f(p, false)), f = (p, _)=>{
+                let { aborted: l } = o.signal, S = l && i.allowStaleOnFetchAbort, b = S || i.allowStaleOnFetchRejection, m = b || i.noDeleteOnFetchRejection, u = g;
+                if (this.#t[e] === g && (!m || !_ && u.__staleWhileFetching === void 0 ? this.#E(t, "fetch") : S || (this.#t[e] = u.__staleWhileFetching)), b) return i.status && u.__staleWhileFetching !== void 0 && (i.status.returnedStale = true), u.__staleWhileFetching;
+                if (u.__returned === u) throw p;
+            }, d = (p, _)=>{
+                let l = this.#L?.(t, n, r);
+                l && l instanceof Promise && l.then((S)=>p(S === void 0 ? void 0 : S), _), o.signal.addEventListener("abort", ()=>{
+                    (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(void 0), i.allowStaleOnFetchAbort && (p = (S)=>a(S, true)));
                 });
             };
-            if (options.status) options.status.fetchDispatched = true;
-            const p = new Promise(pcall).then(cb, eb);
-            const bf = Object.assign(p, {
-                __abortController: ac,
-                __staleWhileFetching: v,
-                __returned: undefined
+            i.status && (i.status.fetchDispatched = true);
+            let g = new Promise(d).then(a, w), A = Object.assign(g, {
+                __abortController: o,
+                __staleWhileFetching: n,
+                __returned: void 0
             });
-            if (index === undefined) {
-                // internal, don't expose status.
-                this.set(k, bf, {
-                    ...fetchOpts.options,
-                    status: undefined
-                });
-                index = this.#keyMap.get(k);
+            return e === void 0 ? (this.set(t, A, {
+                ...r.options,
+                status: void 0
+            }), e = this.#s.get(t)) : this.#t[e] = A, A;
+        }
+        #e(t) {
+            if (!this.#v) return false;
+            let e = t;
+            return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+        }
+        async fetch(t, e = {}) {
+            let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: r = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: w = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: S } = e;
+            if (!this.#v) return l && (l.fetch = "get"), this.get(t, {
+                allowStale: i,
+                updateAgeOnGet: s,
+                noDeleteOnStaleGet: n,
+                status: l
+            });
+            let b = {
+                allowStale: i,
+                updateAgeOnGet: s,
+                noDeleteOnStaleGet: n,
+                ttl: o,
+                noDisposeOnSet: h,
+                size: r,
+                sizeCalculation: a,
+                noUpdateTTL: w,
+                noDeleteOnFetchRejection: f,
+                allowStaleOnFetchRejection: d,
+                allowStaleOnFetchAbort: A,
+                ignoreFetchAbort: g,
+                status: l,
+                signal: S
+            }, m = this.#s.get(t);
+            if (m === void 0) {
+                l && (l.fetch = "miss");
+                let u = this.#x(t, m, b, p);
+                return u.__returned = u;
             } else {
-                this.#valList[index] = bf;
-            }
-            return bf;
-        }
-        #isBackgroundFetch(p) {
-            if (!this.#hasFetchMethod) return false;
-            const b = p;
-            return !!b && b instanceof Promise && b.hasOwnProperty('__staleWhileFetching') && b.__abortController instanceof AC;
-        }
-        async fetch(k, fetchOptions = {}) {
-            const { // get options
-            allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, // set options
-            ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, // fetch exclusive options
-            noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal } = fetchOptions;
-            if (!this.#hasFetchMethod) {
-                if (status) status.fetch = 'get';
-                return this.get(k, {
-                    allowStale,
-                    updateAgeOnGet,
-                    noDeleteOnStaleGet,
-                    status
-                });
+                let u = this.#t[m];
+                if (this.#e(u)) {
+                    let E = i && u.__staleWhileFetching !== void 0;
+                    return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
+                }
+                let T = this.#p(m);
+                if (!_ && !T) return l && (l.fetch = "hit"), this.#D(m), s && this.#R(m), l && this.#z(l, m), u;
+                let F = this.#x(t, m, b, p), O = F.__staleWhileFetching !== void 0 && i;
+                return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
             }
-            const options = {
-                allowStale,
-                updateAgeOnGet,
-                noDeleteOnStaleGet,
-                ttl,
-                noDisposeOnSet,
-                size,
-                sizeCalculation,
-                noUpdateTTL,
-                noDeleteOnFetchRejection,
-                allowStaleOnFetchRejection,
-                allowStaleOnFetchAbort,
-                ignoreFetchAbort,
-                status,
-                signal
-            };
-            let index = this.#keyMap.get(k);
-            if (index === undefined) {
-                if (status) status.fetch = 'miss';
-                const p = this.#backgroundFetch(k, index, options, context);
-                return p.__returned = p;
-            } else {
-                // in cache, maybe already fetching
-                const v = this.#valList[index];
-                if (this.#isBackgroundFetch(v)) {
-                    const stale = allowStale && v.__staleWhileFetching !== undefined;
-                    if (status) {
-                        status.fetch = 'inflight';
-                        if (stale) status.returnedStale = true;
-                    }
-                    return stale ? v.__staleWhileFetching : v.__returned = v;
-                }
-                // if we force a refresh, that means do NOT serve the cached value,
-                // unless we are already in the process of refreshing the cache.
-                const isStale = this.#isStale(index);
-                if (!forceRefresh && !isStale) {
-                    if (status) status.fetch = 'hit';
-                    this.#moveToTail(index);
-                    if (updateAgeOnGet) {
-                        this.#updateItemAge(index);
-                    }
-                    if (status) this.#statusTTL(status, index);
-                    return v;
-                }
-                // ok, it is stale or a forced refresh, and not already fetching.
-                // refresh the cache.
-                const p = this.#backgroundFetch(k, index, options, context);
-                const hasStale = p.__staleWhileFetching !== undefined;
-                const staleVal = hasStale && allowStale;
-                if (status) {
-                    status.fetch = isStale ? 'stale' : 'refresh';
-                    if (staleVal && isStale) status.returnedStale = true;
-                }
-                return staleVal ? p.__staleWhileFetching : p.__returned = p;
-            }
-        }
-        async forceFetch(k, fetchOptions = {}) {
-            const v = await this.fetch(k, fetchOptions);
-            if (v === undefined) throw new Error('fetch() returned undefined');
-            return v;
-        }
-        memo(k, memoOptions = {}) {
-            const memoMethod = this.#memoMethod;
-            if (!memoMethod) {
-                throw new Error('no memoMethod provided to constructor');
-            }
-            const { context, forceRefresh, ...options } = memoOptions;
-            const v = this.get(k, options);
-            if (!forceRefresh && v !== undefined) return v;
-            const vv = memoMethod(k, v, {
-                options,
-                context
+        }
+        async forceFetch(t, e = {}) {
+            let i = await this.fetch(t, e);
+            if (i === void 0) throw new Error("fetch() returned undefined");
+            return i;
+        }
+        memo(t, e = {}) {
+            let i = this.#U;
+            if (!i) throw new Error("no memoMethod provided to constructor");
+            let { context: s, forceRefresh: n, ...o } = e, h = this.get(t, o);
+            if (!n && h !== void 0) return h;
+            let r = i(t, h, {
+                options: o,
+                context: s
             });
-            this.set(k, vv, options);
-            return vv;
+            return this.set(t, r, o), r;
         }
-        /**
-	     * Return a value from the cache. Will update the recency of the cache
-	     * entry found.
-	     *
-	     * If the key is not found, get() will return `undefined`.
-	     */ get(k, getOptions = {}) {
-            const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-            const index = this.#keyMap.get(k);
-            if (index !== undefined) {
-                const value = this.#valList[index];
-                const fetching = this.#isBackgroundFetch(value);
-                if (status) this.#statusTTL(status, index);
-                if (this.#isStale(index)) {
-                    if (status) status.get = 'stale';
-                    // delete only if not an in-flight background fetch
-                    if (!fetching) {
-                        if (!noDeleteOnStaleGet) {
-                            this.#delete(k, 'expire');
-                        }
-                        if (status && allowStale) status.returnedStale = true;
-                        return allowStale ? value : undefined;
-                    } else {
-                        if (status && allowStale && value.__staleWhileFetching !== undefined) {
-                            status.returnedStale = true;
-                        }
-                        return allowStale ? value.__staleWhileFetching : undefined;
-                    }
-                } else {
-                    if (status) status.get = 'hit';
-                    // if we're currently fetching it, we don't actually have it yet
-                    // it's not stale, which means this isn't a staleWhileRefetching.
-                    // If it's not stale, and fetching, AND has a __staleWhileFetching
-                    // value, then that means the user fetched with {forceRefresh:true},
-                    // so it's safe to return that value.
-                    if (fetching) {
-                        return value.__staleWhileFetching;
-                    }
-                    this.#moveToTail(index);
-                    if (updateAgeOnGet) {
-                        this.#updateItemAge(index);
-                    }
-                    return value;
-                }
-            } else if (status) {
-                status.get = 'miss';
-            }
-        }
-        #connect(p, n) {
-            this.#prev[n] = p;
-            this.#next[p] = n;
-        }
-        #moveToTail(index) {
-            // if tail already, nothing to do
-            // if head, move head to next[index]
-            // else
-            //   move next[prev[index]] to next[index] (head has no prev)
-            //   move prev[next[index]] to prev[index]
-            // prev[index] = tail
-            // next[tail] = index
-            // tail = index
-            if (index !== this.#tail) {
-                if (index === this.#head) {
-                    this.#head = this.#next[index];
-                } else {
-                    this.#connect(this.#prev[index], this.#next[index]);
-                }
-                this.#connect(this.#tail, index);
-                this.#tail = index;
-            }
+        get(t, e = {}) {
+            let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = e, h = this.#s.get(t);
+            if (h !== void 0) {
+                let r = this.#t[h], a = this.#e(r);
+                return o && this.#z(o, h), this.#p(h) ? (o && (o.get = "stale"), a ? (o && i && r.__staleWhileFetching !== void 0 && (o.returnedStale = true), i ? r.__staleWhileFetching : void 0) : (n || this.#E(t, "expire"), o && i && (o.returnedStale = true), i ? r : void 0)) : (o && (o.get = "hit"), a ? r.__staleWhileFetching : (this.#D(h), s && this.#R(h), r));
+            } else o && (o.get = "miss");
         }
-        /**
-	     * Deletes a key out of the cache.
-	     *
-	     * Returns true if the key was deleted, false otherwise.
-	     */ delete(k) {
-            return this.#delete(k, 'delete');
-        }
-        #delete(k, reason) {
-            let deleted = false;
-            if (this.#size !== 0) {
-                const index = this.#keyMap.get(k);
-                if (index !== undefined) {
-                    deleted = true;
-                    if (this.#size === 1) {
-                        this.#clear(reason);
-                    } else {
-                        this.#removeItemSize(index);
-                        const v = this.#valList[index];
-                        if (this.#isBackgroundFetch(v)) {
-                            v.__abortController.abort(new Error('deleted'));
-                        } else if (this.#hasDispose || this.#hasDisposeAfter) {
-                            if (this.#hasDispose) {
-                                this.#dispose?.(v, k, reason);
-                            }
-                            if (this.#hasDisposeAfter) {
-                                this.#disposed?.push([
-                                    v,
-                                    k,
-                                    reason
-                                ]);
-                            }
-                        }
-                        this.#keyMap.delete(k);
-                        this.#keyList[index] = undefined;
-                        this.#valList[index] = undefined;
-                        if (index === this.#tail) {
-                            this.#tail = this.#prev[index];
-                        } else if (index === this.#head) {
-                            this.#head = this.#next[index];
-                        } else {
-                            const pi = this.#prev[index];
-                            this.#next[pi] = this.#next[index];
-                            const ni = this.#next[index];
-                            this.#prev[ni] = this.#prev[index];
-                        }
-                        this.#size--;
-                        this.#free.push(index);
+        #k(t, e) {
+            this.#u[e] = t, this.#a[t] = e;
+        }
+        #D(t) {
+            t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+        }
+        delete(t) {
+            return this.#E(t, "delete");
+        }
+        #E(t, e) {
+            let i = false;
+            if (this.#n !== 0) {
+                let s = this.#s.get(t);
+                if (s !== void 0) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = true, this.#n === 1) this.#V(e);
+                else {
+                    this.#W(s);
+                    let n = this.#t[s];
+                    if (this.#e(n) ? n.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(n, t, e), this.#f && this.#r?.push([
+                        n,
+                        t,
+                        e
+                    ])), this.#s.delete(t), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#u[s];
+                    else if (s === this.#l) this.#l = this.#a[s];
+                    else {
+                        let o = this.#u[s];
+                        this.#a[o] = this.#a[s];
+                        let h = this.#a[s];
+                        this.#u[h] = this.#u[s];
                     }
+                    this.#n--, this.#b.push(s);
                 }
             }
-            if (this.#hasDisposeAfter && this.#disposed?.length) {
-                const dt = this.#disposed;
-                let task;
-                while(task = dt?.shift()){
-                    this.#disposeAfter?.(...task);
-                }
+            if (this.#f && this.#r?.length) {
+                let s = this.#r, n;
+                for(; n = s?.shift();)this.#S?.(...n);
             }
-            return deleted;
+            return i;
         }
-        /**
-	     * Clear the cache entirely, throwing away all values.
-	     */ clear() {
-            return this.#clear('delete');
+        clear() {
+            return this.#V("delete");
         }
-        #clear(reason) {
-            for (const index of this.#rindexes({
+        #V(t) {
+            for (let e of this.#O({
                 allowStale: true
             })){
-                const v = this.#valList[index];
-                if (this.#isBackgroundFetch(v)) {
-                    v.__abortController.abort(new Error('deleted'));
-                } else {
-                    const k = this.#keyList[index];
-                    if (this.#hasDispose) {
-                        this.#dispose?.(v, k, reason);
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([
-                            v,
-                            k,
-                            reason
-                        ]);
-                    }
+                let i = this.#t[e];
+                if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+                else {
+                    let s = this.#i[e];
+                    this.#T && this.#w?.(i, s, t), this.#f && this.#r?.push([
+                        i,
+                        s,
+                        t
+                    ]);
                 }
             }
-            this.#keyMap.clear();
-            this.#valList.fill(undefined);
-            this.#keyList.fill(undefined);
-            if (this.#ttls && this.#starts) {
-                this.#ttls.fill(0);
-                this.#starts.fill(0);
-            }
-            if (this.#sizes) {
-                this.#sizes.fill(0);
+            if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#A) {
+                this.#d.fill(0), this.#A.fill(0);
+                for (let e of this.#g ?? [])e !== void 0 && clearTimeout(e);
+                this.#g?.fill(void 0);
             }
-            this.#head = 0;
-            this.#tail = 0;
-            this.#free.length = 0;
-            this.#calculatedSize = 0;
-            this.#size = 0;
-            if (this.#hasDisposeAfter && this.#disposed) {
-                const dt = this.#disposed;
-                let task;
-                while(task = dt?.shift()){
-                    this.#disposeAfter?.(...task);
-                }
+            if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+                let e = this.#r, i;
+                for(; i = e?.shift();)this.#S?.(...i);
             }
         }
-    }
-    commonjs.LRUCache = LRUCache;
+    };
+    index_min.LRUCache = D;
     
-    return commonjs;
+    return index_min;
 }
 
 /* eslint-disable max-len */ var hosts_1;
@@ -13718,7 +12142,7 @@ var hasRequiredLib$2;
 function requireLib$2() {
     if (hasRequiredLib$2) return lib$2;
     hasRequiredLib$2 = 1;
-    const { LRUCache } = /*@__PURE__*/ requireCommonjs();
+    const { LRUCache } = /*@__PURE__*/ requireIndex_min();
     const hosts = requireHosts();
     const fromUrl = requireFromUrl();
     const parseUrl = requireParseUrl();
@@ -19099,7 +17523,7 @@ const command$1 = {
     }
 };
 
-var version = "3.0.8";
+var version = "3.0.9";
 
 var ajv = {exports: {}};
 
@@ -28108,39 +26532,39 @@ function requireLib() {
     const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
     const BRACKET = /^[()[\]{}]$/;
     let tokenize;
-    {
-        const JSX_TAG = /^[a-z][\w-]*$/i;
-        const getTokenType = function(token, offset, text) {
-            if (token.type === "name") {
-                if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
-                    return "keyword";
-                }
-                if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
-                    return "jsxIdentifier";
-                }
-                if (token.value[0] !== token.value[0].toLowerCase()) {
-                    return "capitalized";
-                }
+    const JSX_TAG = /^[a-z][\w-]*$/i;
+    const getTokenType = function(token, offset, text) {
+        if (token.type === "name") {
+            const tokenValue = token.value;
+            if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+                return "keyword";
             }
-            if (token.type === "punctuator" && BRACKET.test(token.value)) {
-                return "bracket";
+            if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+                return "jsxIdentifier";
             }
-            if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-                return "punctuator";
-            }
-            return token.type;
-        };
-        tokenize = function*(text) {
-            let match;
-            while(match = jsTokens.default.exec(text)){
-                const token = jsTokens.matchToToken(match);
-                yield {
-                    type: getTokenType(token, match.index, text),
-                    value: token.value
-                };
+            const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+            if (firstChar !== firstChar.toLowerCase()) {
+                return "capitalized";
             }
-        };
-    }
+        }
+        if (token.type === "punctuator" && BRACKET.test(token.value)) {
+            return "bracket";
+        }
+        if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+            return "punctuator";
+        }
+        return token.type;
+    };
+    tokenize = function*(text) {
+        let match;
+        while(match = jsTokens.default.exec(text)){
+            const token = jsTokens.matchToToken(match);
+            yield {
+                type: getTokenType(token, match.index, text),
+                value: token.value
+            };
+        }
+    };
     function highlight(text) {
         if (text === "") return "";
         const defs = getDefs(true);
@@ -28156,16 +26580,16 @@ function requireLib() {
     }
     let deprecationWarningShown = false;
     const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-    function getMarkerLines(loc, source, opts) {
+    function getMarkerLines(loc, source, opts, startLineBaseZero) {
         const startLoc = Object.assign({
             column: 0,
             line: -1
         }, loc.start);
         const endLoc = Object.assign({}, startLoc, loc.end);
         const { linesAbove = 2, linesBelow = 3 } = opts || {};
-        const startLine = startLoc.line;
+        const startLine = startLoc.line - startLineBaseZero;
         const startColumn = startLoc.column;
-        const endLine = endLoc.line;
+        const endLine = endLoc.line - startLineBaseZero;
         const endColumn = endLoc.column;
         let start = Math.max(startLine - (linesAbove + 1), 0);
         let end = Math.min(source.length, endLine + linesBelow);
@@ -28226,15 +26650,16 @@ function requireLib() {
     }
     function codeFrameColumns(rawLines, loc, opts = {}) {
         const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+        const startLineBaseZero = (opts.startLine || 1) - 1;
         const defs = getDefs(shouldHighlight);
         const lines = rawLines.split(NEWLINE);
-        const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+        const { start, end, markerLines } = getMarkerLines(loc, lines, opts, startLineBaseZero);
         const hasColumns = loc.start && typeof loc.start.column === "number";
-        const numberMaxWidth = String(end).length;
+        const numberMaxWidth = String(end + startLineBaseZero).length;
         const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
         let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index)=>{
             const number = start + 1 + index;
-            const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+            const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
             const gutter = ` ${paddedNumber} |`;
             const hasMarker = markerLines[number];
             const lastMarkerLine = !markerLines[number + 1];