@midscene/cli 1.8.10-beta-20260604215059.0 → 1.9.0

package/dist/lib/index.js

@@ -3374,7 +3374,9 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
         const cli_namespaceObject = require("@midscene/shared/cli");
         var main = __webpack_require__("../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/lib/main.js");
         var main_default = /*#__PURE__*/ __webpack_require__.n(main);
-        var package_namespaceObject = JSON.parse('{"rE":"1.8.10-beta-20260604215059.0"}');
+        var package_namespaceObject = {
+            rE: "1.9.0"
+        };
         var logger_ = __webpack_require__("@midscene/shared/logger");
         var brace_expansion = __webpack_require__("../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js");
         const MAX_PATTERN_LENGTH = 65536;
@@ -4511,47 +4513,85 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
         minimatch.escape = escape_escape;
         minimatch.unescape = unescape_unescape;
         var external_node_url_ = __webpack_require__("node:url");
-        const external_node_diagnostics_channel_namespaceObject = require("node:diagnostics_channel");
-        var S = (0, external_node_diagnostics_channel_namespaceObject.channel)("lru-cache:metrics"), W = (0, external_node_diagnostics_channel_namespaceObject.tracingChannel)("lru-cache");
-        var D = ()=>S.hasSubscribers || W.hasSubscribers, G = "object" == typeof performance && performance && "function" == typeof performance.now ? performance : Date, M = new Set, C = "object" == typeof process && process ? process : {}, P = (u, e1, t1, i)=>{
-            "function" == typeof C.emitWarning ? C.emitWarning(u, e1, t1, i) : console.error(`[${t1}] ${e1}: ${u}`);
-        }, H = (u)=>!M.has(u), F = (Symbol("type"), (u)=>!!u && u === Math.floor(u) && u > 0 && isFinite(u)), U = (u)=>F(u) ? u <= Math.pow(2, 8) ? Uint8Array : u <= Math.pow(2, 16) ? Uint16Array : u <= Math.pow(2, 32) ? Uint32Array : u <= Number.MAX_SAFE_INTEGER ? O : null : null, O = class extends Array {
-            constructor(e1){
-                super(e1), this.fill(0);
-            }
-        }, R = class u {
+        const perf = 'object' == typeof performance && performance && 'function' == typeof performance.now ? performance : Date;
+        const warned = new Set();
+        const PROCESS = 'object' == typeof process && process ? process : {};
+        const emitWarning = (msg, type, code, fn)=>{
+            'function' == typeof PROCESS.emitWarning ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+        };
+        let AC = globalThis.AbortController;
+        let AS = globalThis.AbortSignal;
+        if (void 0 === AC) {
+            AS = class {
+                onabort;
+                _onabort = [];
+                reason;
+                aborted = false;
+                addEventListener(_, fn) {
+                    this._onabort.push(fn);
+                }
+            };
+            AC = class {
+                constructor(){
+                    warnACPolyfill();
+                }
+                signal = new AS();
+                abort(reason) {
+                    if (this.signal.aborted) return;
+                    this.signal.reason = reason;
+                    this.signal.aborted = true;
+                    for (const fn of this.signal._onabort)fn(reason);
+                    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);
+            };
+        }
+        const shouldWarn = (code)=>!warned.has(code);
+        Symbol('type');
+        const isPosInt = (n)=>n && n === Math.floor(n) && n > 0 && isFinite(n);
+        const getUintArray = (max)=>isPosInt(max) ? 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 : null;
+        class ZeroArray extends Array {
+            constructor(size){
+                super(size);
+                this.fill(0);
+            }
+        }
+        class Stack {
             heap;
             length;
-            static #o = !1;
-            static create(e1) {
-                let t1 = U(e1);
-                if (!t1) return [];
-                u.#o = !0;
-                let i = new u(e1, t1);
-                return u.#o = !1, i;
-            }
-            constructor(e1, t1){
-                if (!u.#o) throw new TypeError("instantiate Stack using Stack.create(n)");
-                this.heap = new t1(e1), this.length = 0;
-            }
-            push(e1) {
-                this.heap[this.length++] = e1;
+            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){
+                if (!Stack.#constructing) throw new TypeError('instantiate Stack using Stack.create(n)');
+                this.heap = new HeapCls(max);
+                this.length = 0;
+            }
+            push(n) {
+                this.heap[this.length++] = n;
             }
             pop() {
                 return this.heap[--this.length];
             }
-        }, L = class u {
-            #o;
-            #u;
-            #w;
-            #D;
-            #S;
-            #M;
-            #U;
-            #m;
-            get perf() {
-                return this.#m;
-            }
+        }
+        class LRUCache {
+            #max;
+            #maxSize;
+            #dispose;
+            #disposeAfter;
+            #fetchMethod;
+            #memoMethod;
             ttl;
             ttlResolution;
             ttlAutopurge;
@@ -4567,613 +4607,823 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             allowStaleOnFetchAbort;
             allowStaleOnFetchRejection;
             ignoreFetchAbort;
-            #n;
-            #b;
-            #s;
-            #i;
-            #t;
-            #a;
-            #c;
-            #l;
-            #h;
-            #y;
-            #r;
-            #_;
-            #F;
-            #d;
-            #g;
-            #T;
-            #W;
-            #f;
-            #j;
-            static unsafeExposeInternals(e1) {
+            #size;
+            #calculatedSize;
+            #keyMap;
+            #keyList;
+            #valList;
+            #next;
+            #prev;
+            #head;
+            #tail;
+            #free;
+            #disposed;
+            #sizes;
+            #starts;
+            #ttls;
+            #hasDispose;
+            #hasFetchMethod;
+            #hasDisposeAfter;
+            static unsafeExposeInternals(c) {
                 return {
-                    starts: e1.#F,
-                    ttls: e1.#d,
-                    autopurgeTimers: e1.#g,
-                    sizes: e1.#_,
-                    keyMap: e1.#s,
-                    keyList: e1.#i,
-                    valList: e1.#t,
-                    next: e1.#a,
-                    prev: e1.#c,
+                    starts: c.#starts,
+                    ttls: c.#ttls,
+                    sizes: c.#sizes,
+                    keyMap: c.#keyMap,
+                    keyList: c.#keyList,
+                    valList: c.#valList,
+                    next: c.#next,
+                    prev: c.#prev,
                     get head () {
-                        return e1.#l;
+                        return c.#head;
                     },
                     get tail () {
-                        return e1.#h;
+                        return c.#tail;
                     },
-                    free: e1.#y,
-                    isBackgroundFetch: (t1)=>e1.#e(t1),
-                    backgroundFetch: (t1, i, s, n)=>e1.#P(t1, i, s, n),
-                    moveToTail: (t1)=>e1.#L(t1),
-                    indexes: (t1)=>e1.#A(t1),
-                    rindexes: (t1)=>e1.#z(t1),
-                    isStale: (t1)=>e1.#p(t1)
+                    free: c.#free,
+                    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)
                 };
             }
             get max() {
-                return this.#o;
+                return this.#max;
             }
             get maxSize() {
-                return this.#u;
+                return this.#maxSize;
             }
             get calculatedSize() {
-                return this.#b;
+                return this.#calculatedSize;
             }
             get size() {
-                return this.#n;
+                return this.#size;
             }
             get fetchMethod() {
-                return this.#M;
+                return this.#fetchMethod;
             }
             get memoMethod() {
-                return this.#U;
+                return this.#memoMethod;
             }
             get dispose() {
-                return this.#w;
-            }
-            get onInsert() {
-                return this.#D;
+                return this.#dispose;
             }
             get disposeAfter() {
-                return this.#S;
-            }
-            constructor(e1){
-                let { max: t1 = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: o, updateAgeOnHas: r, allowStale: h, dispose: l, onInsert: c, disposeAfter: f, noDisposeOnSet: g, noUpdateTTL: p, maxSize: T = 0, maxEntrySize: w = 0, sizeCalculation: y, fetchMethod: a, memoMethod: m, noDeleteOnFetchRejection: _, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: z, perf: x } = e1;
-                if (void 0 !== x && "function" != typeof x?.now) throw new TypeError("perf option must have a now() method if specified");
-                if (this.#m = x ?? G, 0 !== t1 && !F(t1)) throw new TypeError("max option must be a nonnegative integer");
-                let v = t1 ? U(t1) : Array;
-                if (!v) throw new Error("invalid max value: " + t1);
-                if (this.#o = t1, this.#u = T, this.maxEntrySize = w || this.#u, this.sizeCalculation = y, this.sizeCalculation) {
-                    if (!this.#u && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
-                    if ("function" != typeof this.sizeCalculation) throw new TypeError("sizeCalculation set to non-function");
-                }
-                if (void 0 !== m && "function" != typeof m) throw new TypeError("memoMethod must be a function if defined");
-                if (this.#U = m, void 0 !== a && "function" != typeof a) throw new TypeError("fetchMethod must be a function if specified");
-                if (this.#M = a, this.#W = !!a, this.#s = new Map, this.#i = Array.from({
-                    length: t1
-                }).fill(void 0), this.#t = Array.from({
-                    length: t1
-                }).fill(void 0), this.#a = new v(t1), this.#c = new v(t1), this.#l = 0, this.#h = 0, this.#y = R.create(t1), this.#n = 0, this.#b = 0, "function" == typeof l && (this.#w = l), "function" == typeof c && (this.#D = c), "function" == typeof f ? (this.#S = f, this.#r = []) : (this.#S = void 0, this.#r = void 0), this.#T = !!this.#w, this.#j = !!this.#D, this.#f = !!this.#S, this.noDisposeOnSet = !!g, this.noUpdateTTL = !!p, this.noDeleteOnFetchRejection = !!_, this.allowStaleOnFetchRejection = !!d, this.allowStaleOnFetchAbort = !!A, this.ignoreFetchAbort = !!z, 0 !== this.maxEntrySize) {
-                    if (0 !== this.#u && !F(this.#u)) throw new TypeError("maxSize must be a positive integer if specified");
-                    if (!F(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
-                    this.#X();
-                }
-                if (this.allowStale = !!h, this.noDeleteOnStaleGet = !!b, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!r, this.ttlResolution = F(s) || 0 === s ? s : 1, this.ttlAutopurge = !!n, this.ttl = i || 0, this.ttl) {
-                    if (!F(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
-                    this.#H();
-                }
-                if (0 === this.#o && 0 === this.ttl && 0 === this.#u) throw new TypeError("At least one of max, maxSize, or ttl is required");
-                if (!this.ttlAutopurge && !this.#o && !this.#u) {
-                    let E = "LRU_CACHE_UNBOUNDED";
-                    H(E) && (M.add(E), P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, u));
-                }
-            }
-            getRemainingTTL(e1) {
-                return this.#s.has(e1) ? 1 / 0 : 0;
-            }
-            #H() {
-                let e1 = new O(this.#o), t1 = new O(this.#o);
-                this.#d = e1, this.#F = t1;
-                let i = this.ttlAutopurge ? Array.from({
-                    length: this.#o
-                }) : void 0;
-                this.#g = i, this.#N = (r, h, l = this.#m.now())=>{
-                    t1[r] = 0 !== h ? l : 0, e1[r] = h, s(r, h);
-                }, this.#x = (r)=>{
-                    t1[r] = 0 !== e1[r] ? this.#m.now() : 0, s(r, e1[r]);
+                return this.#disposeAfter;
+            }
+            constructor(options){
+                const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+                if (0 !== max && !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 ('function' != typeof this.sizeCalculation) throw new TypeError('sizeCalculation set to non-function');
+                }
+                if (void 0 !== memoMethod && 'function' != typeof memoMethod) throw new TypeError('memoMethod must be a function if defined');
+                this.#memoMethod = memoMethod;
+                if (void 0 !== fetchMethod && 'function' != typeof fetchMethod) 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(void 0);
+                this.#valList = new Array(max).fill(void 0);
+                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 ('function' == typeof dispose) this.#dispose = dispose;
+                if ('function' == typeof disposeAfter) {
+                    this.#disposeAfter = disposeAfter;
+                    this.#disposed = [];
+                } else {
+                    this.#disposeAfter = void 0;
+                    this.#disposed = void 0;
+                }
+                this.#hasDispose = !!this.#dispose;
+                this.#hasDisposeAfter = !!this.#disposeAfter;
+                this.noDisposeOnSet = !!noDisposeOnSet;
+                this.noUpdateTTL = !!noUpdateTTL;
+                this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+                this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+                this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+                this.ignoreFetchAbort = !!ignoreFetchAbort;
+                if (0 !== this.maxEntrySize) {
+                    if (0 !== this.#maxSize) {
+                        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) || 0 === ttlResolution ? 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();
+                }
+                if (0 === this.#max && 0 === this.ttl && 0 === this.#maxSize) 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);
+                    }
+                }
+            }
+            getRemainingTTL(key) {
+                return this.#keyMap.has(key) ? 1 / 0 : 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 = perf.now())=>{
+                    starts[index] = 0 !== ttl ? start : 0;
+                    ttls[index] = ttl;
+                    if (0 !== ttl && this.ttlAutopurge) {
+                        const t1 = setTimeout(()=>{
+                            if (this.#isStale(index)) this.#delete(this.#keyList[index], 'expire');
+                        }, ttl + 1);
+                        if (t1.unref) t1.unref();
+                    }
                 };
-                let s = this.ttlAutopurge ? (r, h)=>{
-                    if (i?.[r] && (clearTimeout(i[r]), i[r] = void 0), h && 0 !== h && i) {
-                        let l = setTimeout(()=>{
-                            this.#p(r) && this.#v(this.#i[r], "expire");
-                        }, h + 1);
-                        l.unref && l.unref(), i[r] = l;
-                    }
-                } : ()=>{};
-                this.#E = (r, h)=>{
-                    if (e1[h]) {
-                        let l = e1[h], c = t1[h];
-                        if (!l || !c) return;
-                        r.ttl = l, r.start = c, r.now = n || o();
-                        let f = r.now - c;
-                        r.remainingTTL = l - f;
+                this.#updateItemAge = (index)=>{
+                    starts[index] = 0 !== ttls[index] ? perf.now() : 0;
+                };
+                this.#statusTTL = (status, index)=>{
+                    if (ttls[index]) {
+                        const ttl = ttls[index];
+                        const start = starts[index];
+                        if (!ttl || !start) return;
+                        status.ttl = ttl;
+                        status.start = start;
+                        status.now = cachedNow || getNow();
+                        const age = status.now - start;
+                        status.remainingTTL = ttl - age;
                     }
                 };
-                let n = 0, o = ()=>{
-                    let r = this.#m.now();
+                let cachedNow = 0;
+                const getNow = ()=>{
+                    const n = perf.now();
                     if (this.ttlResolution > 0) {
-                        n = r;
-                        let h = setTimeout(()=>n = 0, this.ttlResolution);
-                        h.unref && h.unref();
+                        cachedNow = n;
+                        const t1 = setTimeout(()=>cachedNow = 0, this.ttlResolution);
+                        if (t1.unref) t1.unref();
                     }
-                    return r;
+                    return n;
+                };
+                this.getRemainingTTL = (key)=>{
+                    const index = this.#keyMap.get(key);
+                    if (void 0 === index) return 0;
+                    const ttl = ttls[index];
+                    const start = starts[index];
+                    if (!ttl || !start) return 1 / 0;
+                    const age = (cachedNow || getNow()) - start;
+                    return ttl - age;
                 };
-                this.getRemainingTTL = (r)=>{
-                    let h = this.#s.get(r);
-                    if (void 0 === h) return 0;
-                    let l = e1[h], c = t1[h];
-                    if (!l || !c) return 1 / 0;
-                    let f = (n || o()) - c;
-                    return l - f;
-                }, this.#p = (r)=>{
-                    let h = t1[r], l = e1[r];
-                    return !!l && !!h && (n || o()) - h > l;
+                this.#isStale = (index)=>{
+                    const s = starts[index];
+                    const t1 = ttls[index];
+                    return !!t1 && !!s && (cachedNow || getNow()) - s > t1;
                 };
             }
-            #x = ()=>{};
-            #E = ()=>{};
-            #N = ()=>{};
-            #p = ()=>!1;
-            #X() {
-                let e1 = new O(this.#o);
-                this.#b = 0, this.#_ = e1, this.#R = (t1)=>{
-                    this.#b -= e1[t1], e1[t1] = 0;
-                }, this.#k = (t1, i, s, n)=>{
-                    if (this.#e(i)) return 0;
-                    if (!F(s)) if (n) {
-                        if ("function" != typeof n) throw new TypeError("sizeCalculation must be a function");
-                        if (s = n(i, t1), !F(s)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+            #updateItemAge = ()=>{};
+            #statusTTL = ()=>{};
+            #setItemTTL = ()=>{};
+            #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)=>{
+                    if (this.#isBackgroundFetch(v)) return 0;
+                    if (!isPosInt(size)) if (sizeCalculation) {
+                        if ('function' != typeof sizeCalculation) 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 s;
-                }, this.#I = (t1, i, s)=>{
-                    if (e1[t1] = i, this.#u) {
-                        let n = this.#u - e1[t1];
-                        for(; this.#b > n;)this.#G(!0);
+                    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;
                     }
-                    this.#b += e1[t1], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
                 };
             }
-            #R = (e1)=>{};
-            #I = (e1, t1, i)=>{};
-            #k = (e1, t1, i, s)=>{
-                if (i || s) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+            #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');
                 return 0;
             };
-            *#A({ allowStale: e1 = this.allowStale } = {}) {
-                if (this.#n) for(let t1 = this.#h; this.#V(t1) && ((e1 || !this.#p(t1)) && (yield t1), t1 !== this.#l);)t1 = this.#c[t1];
+            *#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;
+                    i = this.#prev[i];
+                }
             }
-            *#z({ allowStale: e1 = this.allowStale } = {}) {
-                if (this.#n) for(let t1 = this.#l; this.#V(t1) && ((e1 || !this.#p(t1)) && (yield t1), t1 !== this.#h);)t1 = this.#a[t1];
+            *#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;
+                    i = this.#next[i];
+                }
             }
-            #V(e1) {
-                return void 0 !== e1 && this.#s.get(this.#i[e1]) === e1;
+            #isValidIndex(index) {
+                return void 0 !== index && this.#keyMap.get(this.#keyList[index]) === index;
             }
             *entries() {
-                for (let e1 of this.#A())void 0 === this.#t[e1] || void 0 === this.#i[e1] || this.#e(this.#t[e1]) || (yield [
-                    this.#i[e1],
-                    this.#t[e1]
-                ]);
+                for (const i of this.#indexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
+                    this.#keyList[i],
+                    this.#valList[i]
+                ];
             }
             *rentries() {
-                for (let e1 of this.#z())void 0 === this.#t[e1] || void 0 === this.#i[e1] || this.#e(this.#t[e1]) || (yield [
-                    this.#i[e1],
-                    this.#t[e1]
-                ]);
+                for (const i of this.#rindexes())if (void 0 !== this.#valList[i] && void 0 !== this.#keyList[i] && !this.#isBackgroundFetch(this.#valList[i])) yield [
+                    this.#keyList[i],
+                    this.#valList[i]
+                ];
             }
             *keys() {
-                for (let e1 of this.#A()){
-                    let t1 = this.#i[e1];
-                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
+                for (const i of this.#indexes()){
+                    const k = this.#keyList[i];
+                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
                 }
             }
             *rkeys() {
-                for (let e1 of this.#z()){
-                    let t1 = this.#i[e1];
-                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
+                for (const i of this.#rindexes()){
+                    const k = this.#keyList[i];
+                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
                 }
             }
             *values() {
-                for (let e1 of this.#A())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
+                for (const i of this.#indexes()){
+                    const v = this.#valList[i];
+                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+                }
             }
             *rvalues() {
-                for (let e1 of this.#z())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
+                for (const i of this.#rindexes()){
+                    const v = this.#valList[i];
+                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
+                }
             }
             [Symbol.iterator]() {
                 return this.entries();
             }
-            [Symbol.toStringTag] = "LRUCache";
-            find(e1, t1 = {}) {
-                for (let i of this.#A()){
-                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
-                    if (void 0 !== n && e1(n, this.#i[i], this)) return this.#C(this.#i[i], t1);
+            [Symbol.toStringTag] = 'LRUCache';
+            find(fn, getOptions = {}) {
+                for (const i of this.#indexes()){
+                    const v = this.#valList[i];
+                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+                    if (void 0 !== value) {
+                        if (fn(value, this.#keyList[i], this)) return this.get(this.#keyList[i], getOptions);
+                    }
                 }
             }
-            forEach(e1, t1 = this) {
-                for (let i of this.#A()){
-                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
-                    void 0 !== n && e1.call(t1, n, this.#i[i], this);
+            forEach(fn, thisp = this) {
+                for (const i of this.#indexes()){
+                    const v = this.#valList[i];
+                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+                    if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
                 }
             }
-            rforEach(e1, t1 = this) {
-                for (let i of this.#z()){
-                    let s = this.#t[i], n = this.#e(s) ? s.__staleWhileFetching : s;
-                    void 0 !== n && e1.call(t1, n, this.#i[i], this);
+            rforEach(fn, thisp = this) {
+                for (const i of this.#rindexes()){
+                    const v = this.#valList[i];
+                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+                    if (void 0 !== value) fn.call(thisp, value, this.#keyList[i], this);
                 }
             }
             purgeStale() {
-                let e1 = !1;
-                for (let t1 of this.#z({
-                    allowStale: !0
-                }))this.#p(t1) && (this.#v(this.#i[t1], "expire"), e1 = !0);
-                return e1;
-            }
-            info(e1) {
-                let t1 = this.#s.get(e1);
-                if (void 0 === t1) return;
-                let i = this.#t[t1], s = this.#e(i) ? i.__staleWhileFetching : i;
-                if (void 0 === s) return;
-                let n = {
-                    value: s
+                let deleted = false;
+                for (const i of this.#rindexes({
+                    allowStale: true
+                }))if (this.#isStale(i)) {
+                    this.#delete(this.#keyList[i], 'expire');
+                    deleted = true;
+                }
+                return deleted;
+            }
+            info(key) {
+                const i = this.#keyMap.get(key);
+                if (void 0 === i) return;
+                const v = this.#valList[i];
+                const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+                if (void 0 === value) return;
+                const entry = {
+                    value
                 };
-                if (this.#d && this.#F) {
-                    let o = this.#d[t1], r = this.#F[t1];
-                    if (o && r) {
-                        let h = o - (this.#m.now() - r);
-                        n.ttl = h, n.start = Date.now();
+                if (this.#ttls && this.#starts) {
+                    const ttl = this.#ttls[i];
+                    const start = this.#starts[i];
+                    if (ttl && start) {
+                        const remain = ttl - (perf.now() - start);
+                        entry.ttl = remain;
+                        entry.start = Date.now();
                     }
                 }
-                return this.#_ && (n.size = this.#_[t1]), n;
+                if (this.#sizes) entry.size = this.#sizes[i];
+                return entry;
             }
             dump() {
-                let e1 = [];
-                for (let t1 of this.#A({
-                    allowStale: !0
+                const arr = [];
+                for (const i of this.#indexes({
+                    allowStale: true
                 })){
-                    let i = this.#i[t1], s = this.#t[t1], n = this.#e(s) ? s.__staleWhileFetching : s;
-                    if (void 0 === n || void 0 === i) continue;
-                    let o = {
-                        value: n
+                    const key = this.#keyList[i];
+                    const v = this.#valList[i];
+                    const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+                    if (void 0 === value || void 0 === key) continue;
+                    const entry = {
+                        value
                     };
-                    if (this.#d && this.#F) {
-                        o.ttl = this.#d[t1];
-                        let r = this.#m.now() - this.#F[t1];
-                        o.start = Math.floor(Date.now() - r);
-                    }
-                    this.#_ && (o.size = this.#_[t1]), e1.unshift([
-                        i,
-                        o
+                    if (this.#ttls && this.#starts) {
+                        entry.ttl = this.#ttls[i];
+                        const age = perf.now() - this.#starts[i];
+                        entry.start = Math.floor(Date.now() - age);
+                    }
+                    if (this.#sizes) entry.size = this.#sizes[i];
+                    arr.unshift([
+                        key,
+                        entry
                     ]);
                 }
-                return e1;
+                return arr;
             }
-            load(e1) {
+            load(arr) {
                 this.clear();
-                for (let [t1, i] of e1){
-                    if (i.start) {
-                        let s = Date.now() - i.start;
-                        i.start = this.#m.now() - s;
-                    }
-                    this.#O(t1, i.value, i);
-                }
-            }
-            set(e1, t1, i = {}) {
-                let { status: s = S.hasSubscribers ? {} : void 0 } = i;
-                i.status = s, s && (s.op = "set", s.key = e1, void 0 !== t1 && (s.value = t1));
-                let n = this.#O(e1, t1, i);
-                return s && S.hasSubscribers && S.publish(s), n;
-            }
-            #O(e1, t1, i = {}) {
-                let { ttl: s = this.ttl, start: n, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: r = this.sizeCalculation, status: h } = i;
-                if (void 0 === t1) return h && (h.set = "deleted"), this.delete(e1), this;
-                let { noUpdateTTL: l = this.noUpdateTTL } = i;
-                h && !this.#e(t1) && (h.value = t1);
-                let c = this.#k(e1, t1, i.size || 0, r, h);
-                if (this.maxEntrySize && c > this.maxEntrySize) return this.#v(e1, "set"), h && (h.set = "miss", h.maxEntrySizeExceeded = !0), this;
-                let f = 0 === this.#n ? void 0 : this.#s.get(e1);
-                if (void 0 === f) f = 0 === this.#n ? this.#h : 0 !== this.#y.length ? this.#y.pop() : this.#n === this.#o ? this.#G(!1) : this.#n, this.#i[f] = e1, this.#t[f] = t1, this.#s.set(e1, f), this.#a[this.#h] = f, this.#c[f] = this.#h, this.#h = f, this.#n++, this.#I(f, c, h), h && (h.set = "add"), l = !1, this.#j && this.#D?.(t1, e1, "add");
-                else {
-                    this.#L(f);
-                    let g = this.#t[f];
-                    if (t1 !== g) {
-                        if (this.#W && this.#e(g)) {
-                            g.__abortController.abort(new Error("replaced"));
-                            let { __staleWhileFetching: p } = g;
-                            void 0 !== p && !o && (this.#T && this.#w?.(p, e1, "set"), this.#f && this.#r?.push([
-                                p,
-                                e1,
-                                "set"
-                            ]));
-                        } else o || (this.#T && this.#w?.(g, e1, "set"), this.#f && this.#r?.push([
-                            g,
-                            e1,
-                            "set"
-                        ]));
-                        if (this.#R(f), this.#I(f, c, h), this.#t[f] = t1, h) {
-                            h.set = "replace";
-                            let p = g && this.#e(g) ? g.__staleWhileFetching : g;
-                            void 0 !== p && (h.oldValue = p);
+                for (const [key, entry] of arr){
+                    if (entry.start) {
+                        const age = Date.now() - entry.start;
+                        entry.start = perf.now() - age;
+                    }
+                    this.set(key, entry.value, entry);
+                }
+            }
+            set(k, v, setOptions = {}) {
+                if (void 0 === v) {
+                    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 (this.maxEntrySize && size > this.maxEntrySize) {
+                    if (status) {
+                        status.set = 'miss';
+                        status.maxEntrySizeExceeded = true;
+                    }
+                    this.#delete(k, 'set');
+                    return this;
+                }
+                let index = 0 === this.#size ? void 0 : this.#keyMap.get(k);
+                if (void 0 === index) {
+                    index = 0 === this.#size ? this.#tail : 0 !== this.#free.length ? 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;
+                } else {
+                    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 (void 0 !== s && !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 (void 0 !== oldValue) status.oldValue = oldValue;
                         }
-                    } else h && (h.set = "update");
-                    this.#j && this.onInsert?.(t1, e1, t1 === g ? "update" : "replace");
+                    } else if (status) status.set = 'update';
                 }
-                if (0 === s || this.#d || this.#H(), this.#d && (l || this.#N(f, s, n), h && this.#E(h, f)), !o && this.#f && this.#r) {
-                    let g = this.#r, p;
-                    for(; p = g?.shift();)this.#S?.(...p);
+                if (0 !== ttl && !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);
                 }
                 return this;
             }
             pop() {
                 try {
-                    for(; this.#n;){
-                        let e1 = this.#t[this.#l];
-                        if (this.#G(!0), this.#e(e1)) {
-                            if (e1.__staleWhileFetching) return e1.__staleWhileFetching;
-                        } else if (void 0 !== e1) return e1;
+                    while(this.#size){
+                        const val = this.#valList[this.#head];
+                        this.#evict(true);
+                        if (this.#isBackgroundFetch(val)) {
+                            if (val.__staleWhileFetching) return val.__staleWhileFetching;
+                        } else if (void 0 !== val) return val;
                     }
                 } finally{
-                    if (this.#f && this.#r) {
-                        let e1 = this.#r, t1;
-                        for(; t1 = e1?.shift();)this.#S?.(...t1);
+                    if (this.#hasDisposeAfter && this.#disposed) {
+                        const dt = this.#disposed;
+                        let task;
+                        while(task = dt?.shift())this.#disposeAfter?.(...task);
                     }
                 }
             }
-            #G(e1) {
-                let t1 = this.#l, i = this.#i[t1], s = this.#t[t1];
-                return this.#W && 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.#R(t1), this.#g?.[t1] && (clearTimeout(this.#g[t1]), this.#g[t1] = void 0), e1 && (this.#i[t1] = void 0, this.#t[t1] = void 0, this.#y.push(t1)), 1 === this.#n ? (this.#l = this.#h = 0, this.#y.length = 0) : this.#l = this.#a[t1], this.#s.delete(i), this.#n--, t1;
-            }
-            has(e1, t1 = {}) {
-                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
-                t1.status = i, i && (i.op = "has", i.key = e1);
-                let s = this.#Y(e1, t1);
-                return S.hasSubscribers && S.publish(i), s;
-            }
-            #Y(e1, t1 = {}) {
-                let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = t1, n = this.#s.get(e1);
-                if (void 0 !== n) {
-                    let o = this.#t[n];
-                    if (this.#e(o) && void 0 === o.__staleWhileFetching) return !1;
-                    if (!this.#p(n)) return i && this.#x(n), s && (s.has = "hit", this.#E(s, n)), !0;
-                    s && (s.has = "stale", this.#E(s, n));
-                } else s && (s.has = "miss");
-                return !1;
-            }
-            peek(e1, t1 = {}) {
-                let { status: i = D() ? {} : void 0 } = t1;
-                i && (i.op = "peek", i.key = e1), t1.status = i;
-                let s = this.#J(e1, t1);
-                return S.hasSubscribers && S.publish(i), s;
-            }
-            #J(e1, t1) {
-                let { status: i, allowStale: s = this.allowStale } = t1, n = this.#s.get(e1);
-                if (void 0 === n || !s && this.#p(n)) {
-                    i && (i.peek = void 0 === n ? "miss" : "stale");
-                    return;
+            #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'
+                    ]);
                 }
-                let o = this.#t[n], r = this.#e(o) ? o.__staleWhileFetching : o;
-                return i && (void 0 !== r ? (i.peek = "hit", i.value = r) : i.peek = "miss"), r;
+                this.#removeItemSize(head);
+                if (free) {
+                    this.#keyList[head] = void 0;
+                    this.#valList[head] = void 0;
+                    this.#free.push(head);
+                }
+                if (1 === this.#size) {
+                    this.#head = this.#tail = 0;
+                    this.#free.length = 0;
+                } else this.#head = this.#next[head];
+                this.#keyMap.delete(k);
+                this.#size--;
+                return head;
+            }
+            has(k, hasOptions = {}) {
+                const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+                const index = this.#keyMap.get(k);
+                if (void 0 !== index) {
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v) && void 0 === v.__staleWhileFetching) return false;
+                    if (this.#isStale(index)) {
+                        if (status) {
+                            status.has = 'stale';
+                            this.#statusTTL(status, index);
+                        }
+                    } else {
+                        if (updateAgeOnHas) this.#updateItemAge(index);
+                        if (status) {
+                            status.has = 'hit';
+                            this.#statusTTL(status, index);
+                        }
+                        return true;
+                    }
+                } else if (status) status.has = 'miss';
+                return false;
             }
-            #P(e1, t1, i, s) {
-                let n = void 0 === t1 ? void 0 : this.#t[t1];
-                if (this.#e(n)) return n;
-                let o = new AbortController, { signal: r } = i;
-                r?.addEventListener("abort", ()=>o.abort(r.reason), {
-                    signal: o.signal
+            peek(k, peekOptions = {}) {
+                const { allowStale = this.allowStale } = peekOptions;
+                const index = this.#keyMap.get(k);
+                if (void 0 === index || !allowStale && this.#isStale(index)) return;
+                const v = this.#valList[index];
+                return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            }
+            #backgroundFetch(k, index, options, context) {
+                const v = void 0 === index ? void 0 : this.#valList[index];
+                if (this.#isBackgroundFetch(v)) return v;
+                const ac = new AC();
+                const { signal } = options;
+                signal?.addEventListener('abort', ()=>ac.abort(signal.reason), {
+                    signal: ac.signal
                 });
-                let h = {
-                    signal: o.signal,
-                    options: i,
-                    context: s
-                }, l = (w, y = !1)=>{
-                    let { aborted: a } = o.signal, m = i.ignoreFetchAbort && void 0 !== w, _ = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && void 0 !== w);
-                    if (i.status && (a && !y ? (i.status.fetchAborted = !0, i.status.fetchError = o.signal.reason, m && (i.status.fetchAbortIgnored = !0)) : i.status.fetchResolved = !0), a && !m && !y) return f(o.signal.reason, _);
-                    let b = p, d = this.#t[t1];
-                    return (d === p || void 0 === d && m && y) && (void 0 === w ? void 0 !== b.__staleWhileFetching ? this.#t[t1] = b.__staleWhileFetching : this.#v(e1, "fetch") : (i.status && (i.status.fetchUpdated = !0), this.#O(e1, w, h.options))), w;
-                }, c = (w)=>(i.status && (i.status.fetchRejected = !0, i.status.fetchError = w), f(w, !1)), f = (w, y)=>{
-                    let { aborted: a } = o.signal, m = a && i.allowStaleOnFetchAbort, _ = m || i.allowStaleOnFetchRejection, b = _ || i.noDeleteOnFetchRejection, d = p;
-                    if (this.#t[t1] === p && (b && (y || void 0 !== d.__staleWhileFetching) ? m || (this.#t[t1] = d.__staleWhileFetching) : this.#v(e1, "fetch")), _) return i.status && void 0 !== d.__staleWhileFetching && (i.status.returnedStale = !0), d.__staleWhileFetching;
-                    if (d.__returned === d) throw w;
-                }, g = (w, y)=>{
-                    let a = this.#M?.(e1, n, h);
-                    a && a instanceof Promise && a.then((m)=>w(void 0 === m ? void 0 : m), y), o.signal.addEventListener("abort", ()=>{
-                        (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (w(void 0), i.allowStaleOnFetchAbort && (w = (m)=>l(m, !0)));
+                const fetchOpts = {
+                    signal: ac.signal,
+                    options,
+                    context
+                };
+                const cb = (v, updateCache = false)=>{
+                    const { aborted } = ac.signal;
+                    const ignoreAbort = options.ignoreFetchAbort && void 0 !== v;
+                    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);
+                    const bf = p;
+                    if (this.#valList[index] === p) if (void 0 === v) if (bf.__staleWhileFetching) 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) {
+                        const del = !noDelete || void 0 === bf.__staleWhileFetching;
+                        if (del) this.#delete(k, 'fetch');
+                        else if (!allowStaleAborted) this.#valList[index] = bf.__staleWhileFetching;
+                    }
+                    if (allowStale) {
+                        if (options.status && void 0 !== bf.__staleWhileFetching) options.status.returnedStale = true;
+                        return bf.__staleWhileFetching;
+                    }
+                    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(void 0 === v ? void 0 : v), rej);
+                    ac.signal.addEventListener('abort', ()=>{
+                        if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+                            res(void 0);
+                            if (options.allowStaleOnFetchAbort) res = (v)=>cb(v, true);
+                        }
                     });
                 };
-                i.status && (i.status.fetchDispatched = !0);
-                let p = new Promise(g).then(l, c), T = Object.assign(p, {
-                    __abortController: o,
-                    __staleWhileFetching: n,
+                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: void 0
                 });
-                return void 0 === t1 ? (this.#O(e1, T, {
-                    ...h.options,
-                    status: void 0
-                }), t1 = this.#s.get(e1)) : this.#t[t1] = T, T;
-            }
-            #e(e1) {
-                if (!this.#W) return !1;
-                let t1 = e1;
-                return !!t1 && t1 instanceof Promise && t1.hasOwnProperty("__staleWhileFetching") && t1.__abortController instanceof AbortController;
-            }
-            fetch(e1, t1 = {}) {
-                let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t1;
-                t1.status = s, s && t1.context && (s.context = t1.context);
-                let n = this.#B(e1, t1);
-                return s && D() && i && (s.trace = !0, W.tracePromise(()=>n, s).catch(()=>{})), n;
-            }
-            async #B(e1, t1 = {}) {
-                let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: r = this.noDisposeOnSet, size: h = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: c = this.noUpdateTTL, noDeleteOnFetchRejection: f = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: g = this.allowStaleOnFetchRejection, ignoreFetchAbort: p = this.ignoreFetchAbort, allowStaleOnFetchAbort: T = this.allowStaleOnFetchAbort, context: w, forceRefresh: y = !1, status: a, signal: m } = t1;
-                if (a && (a.op = "fetch", a.key = e1, y && (a.forceRefresh = !0)), !this.#W) return a && (a.fetch = "get"), this.#C(e1, {
-                    allowStale: i,
-                    updateAgeOnGet: s,
-                    noDeleteOnStaleGet: n,
-                    status: a
-                });
-                let _ = {
-                    allowStale: i,
-                    updateAgeOnGet: s,
-                    noDeleteOnStaleGet: n,
-                    ttl: o,
-                    noDisposeOnSet: r,
-                    size: h,
-                    sizeCalculation: l,
-                    noUpdateTTL: c,
-                    noDeleteOnFetchRejection: f,
-                    allowStaleOnFetchRejection: g,
-                    allowStaleOnFetchAbort: T,
-                    ignoreFetchAbort: p,
-                    status: a,
-                    signal: m
-                }, b = this.#s.get(e1);
-                if (void 0 === b) {
-                    a && (a.fetch = "miss");
-                    let d = this.#P(e1, b, _, w);
-                    return d.__returned = d;
+                if (void 0 === index) {
+                    this.set(k, bf, {
+                        ...fetchOpts.options,
+                        status: void 0
+                    });
+                    index = this.#keyMap.get(k);
+                } 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 { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, 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
+                    });
+                }
+                const options = {
+                    allowStale,
+                    updateAgeOnGet,
+                    noDeleteOnStaleGet,
+                    ttl,
+                    noDisposeOnSet,
+                    size,
+                    sizeCalculation,
+                    noUpdateTTL,
+                    noDeleteOnFetchRejection,
+                    allowStaleOnFetchRejection,
+                    allowStaleOnFetchAbort,
+                    ignoreFetchAbort,
+                    status,
+                    signal
+                };
+                let index = this.#keyMap.get(k);
+                if (void 0 === index) {
+                    if (status) status.fetch = 'miss';
+                    const p = this.#backgroundFetch(k, index, options, context);
+                    return p.__returned = p;
                 }
                 {
-                    let d = this.#t[b];
-                    if (this.#e(d)) {
-                        let E = i && void 0 !== d.__staleWhileFetching;
-                        return a && (a.fetch = "inflight", E && (a.returnedStale = !0)), E ? d.__staleWhileFetching : d.__returned = d;
-                    }
-                    let A = this.#p(b);
-                    if (!y && !A) return a && (a.fetch = "hit"), this.#L(b), s && this.#x(b), a && this.#E(a, b), d;
-                    let z = this.#P(e1, b, _, w), v = void 0 !== z.__staleWhileFetching && i;
-                    return a && (a.fetch = A ? "stale" : "refresh", v && A && (a.returnedStale = !0)), v ? z.__staleWhileFetching : z.__returned = z;
-                }
-            }
-            forceFetch(e1, t1 = {}) {
-                let i = W.hasSubscribers, { status: s = D() ? {} : void 0 } = t1;
-                t1.status = s, s && t1.context && (s.context = t1.context);
-                let n = this.#K(e1, t1);
-                return s && D() && i && (s.trace = !0, W.tracePromise(()=>n, s).catch(()=>{})), n;
-            }
-            async #K(e1, t1 = {}) {
-                let i = await this.#B(e1, t1);
-                if (void 0 === i) throw new Error("fetch() returned undefined");
-                return i;
-            }
-            memo(e1, t1 = {}) {
-                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
-                t1.status = i, i && (i.op = "memo", i.key = e1, t1.context && (i.context = t1.context));
-                let s = this.#Q(e1, t1);
-                return i && (i.value = s), S.hasSubscribers && S.publish(i), s;
-            }
-            #Q(e1, t1 = {}) {
-                let i = this.#U;
-                if (!i) throw new Error("no memoMethod provided to constructor");
-                let { context: s, status: n, forceRefresh: o, ...r } = t1;
-                n && o && (n.forceRefresh = !0);
-                let h = this.#C(e1, r), l = o || void 0 === h;
-                if (n && (n.memo = l ? "miss" : "hit", l || (n.value = h)), !l) return h;
-                let c = i(e1, h, {
-                    options: r,
-                    context: s
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) {
+                        const stale = allowStale && void 0 !== v.__staleWhileFetching;
+                        if (status) {
+                            status.fetch = 'inflight';
+                            if (stale) status.returnedStale = true;
+                        }
+                        return stale ? v.__staleWhileFetching : v.__returned = v;
+                    }
+                    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;
+                    }
+                    const p = this.#backgroundFetch(k, index, options, context);
+                    const hasStale = void 0 !== p.__staleWhileFetching;
+                    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 (void 0 === v) 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 && void 0 !== v) return v;
+                const vv = memoMethod(k, v, {
+                    options,
+                    context
                 });
-                return n && (n.value = c), this.#O(e1, c, r), c;
-            }
-            get(e1, t1 = {}) {
-                let { status: i = S.hasSubscribers ? {} : void 0 } = t1;
-                t1.status = i, i && (i.op = "get", i.key = e1);
-                let s = this.#C(e1, t1);
-                return i && (void 0 !== s && (i.value = s), S.hasSubscribers && S.publish(i)), s;
-            }
-            #C(e1, t1 = {}) {
-                let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: o } = t1, r = this.#s.get(e1);
-                if (void 0 === r) {
-                    o && (o.get = "miss");
-                    return;
+                this.set(k, vv, options);
+                return vv;
+            }
+            get(k, getOptions = {}) {
+                const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+                const index = this.#keyMap.get(k);
+                if (void 0 !== index) {
+                    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';
+                        if (fetching) {
+                            if (status && allowStale && void 0 !== value.__staleWhileFetching) status.returnedStale = true;
+                            return allowStale ? value.__staleWhileFetching : void 0;
+                        }
+                        if (!noDeleteOnStaleGet) this.#delete(k, 'expire');
+                        if (status && allowStale) status.returnedStale = true;
+                        return allowStale ? value : void 0;
+                    }
+                    if (status) status.get = 'hit';
+                    if (fetching) return value.__staleWhileFetching;
+                    this.#moveToTail(index);
+                    if (updateAgeOnGet) this.#updateItemAge(index);
+                    return value;
                 }
-                let h = this.#t[r], l = this.#e(h);
-                return o && this.#E(o, r), this.#p(r) ? l ? (o && (o.get = "stale-fetching"), i && void 0 !== h.__staleWhileFetching ? (o && (o.returnedStale = !0), h.__staleWhileFetching) : void 0) : (n || this.#v(e1, "expire"), o && (o.get = "stale"), i ? (o && (o.returnedStale = !0), h) : void 0) : (o && (o.get = l ? "fetching" : "hit"), this.#L(r), s && this.#x(r), l ? h.__staleWhileFetching : h);
+                if (status) status.get = 'miss';
             }
-            #$(e1, t1) {
-                this.#c[t1] = e1, this.#a[e1] = t1;
+            #connect(p, n) {
+                this.#prev[n] = p;
+                this.#next[p] = n;
             }
-            #L(e1) {
-                e1 !== this.#h && (e1 === this.#l ? this.#l = this.#a[e1] : this.#$(this.#c[e1], this.#a[e1]), this.#$(this.#h, e1), this.#h = e1);
+            #moveToTail(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;
+                }
             }
-            delete(e1) {
-                return this.#v(e1, "delete");
+            delete(k) {
+                return this.#delete(k, 'delete');
             }
-            #v(e1, t1) {
-                S.hasSubscribers && S.publish({
-                    op: "delete",
-                    delete: t1,
-                    key: e1
-                });
-                let i = !1;
-                if (0 !== this.#n) {
-                    let s = this.#s.get(e1);
-                    if (void 0 !== s) if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = void 0), i = !0, 1 === this.#n) this.#q(t1);
-                    else {
-                        this.#R(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, e1, t1), this.#f && this.#r?.push([
-                            n,
-                            e1,
-                            t1
-                        ])), this.#s.delete(e1), this.#i[s] = void 0, this.#t[s] = void 0, s === this.#h) this.#h = this.#c[s];
-                        else if (s === this.#l) this.#l = this.#a[s];
+            #delete(k, reason) {
+                let deleted = false;
+                if (0 !== this.#size) {
+                    const index = this.#keyMap.get(k);
+                    if (void 0 !== index) {
+                        deleted = true;
+                        if (1 === this.#size) this.#clear(reason);
                         else {
-                            let o = this.#c[s];
-                            this.#a[o] = this.#a[s];
-                            let r = this.#a[s];
-                            this.#c[r] = this.#c[s];
+                            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] = void 0;
+                            this.#valList[index] = void 0;
+                            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);
                         }
-                        this.#n--, this.#y.push(s);
                     }
                 }
-                if (this.#f && this.#r?.length) {
-                    let s = this.#r, n;
-                    for(; n = s?.shift();)this.#S?.(...n);
+                if (this.#hasDisposeAfter && this.#disposed?.length) {
+                    const dt = this.#disposed;
+                    let task;
+                    while(task = dt?.shift())this.#disposeAfter?.(...task);
                 }
-                return i;
+                return deleted;
             }
             clear() {
-                return this.#q("delete");
+                return this.#clear('delete');
             }
-            #q(e1) {
-                for (let t1 of this.#z({
-                    allowStale: !0
+            #clear(reason) {
+                for (const index of this.#rindexes({
+                    allowStale: true
                 })){
-                    let i = this.#t[t1];
-                    if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
                     else {
-                        let s = this.#i[t1];
-                        this.#T && this.#w?.(i, s, e1), this.#f && this.#r?.push([
-                            i,
-                            s,
-                            e1
+                        const k = this.#keyList[index];
+                        if (this.#hasDispose) this.#dispose?.(v, k, reason);
+                        if (this.#hasDisposeAfter) this.#disposed?.push([
+                            v,
+                            k,
+                            reason
                         ]);
                     }
                 }
-                if (this.#s.clear(), this.#t.fill(void 0), this.#i.fill(void 0), this.#d && this.#F) {
-                    this.#d.fill(0), this.#F.fill(0);
-                    for (let t1 of this.#g ?? [])void 0 !== t1 && clearTimeout(t1);
-                    this.#g?.fill(void 0);
+                this.#keyMap.clear();
+                this.#valList.fill(void 0);
+                this.#keyList.fill(void 0);
+                if (this.#ttls && this.#starts) {
+                    this.#ttls.fill(0);
+                    this.#starts.fill(0);
                 }
-                if (this.#_ && this.#_.fill(0), this.#l = 0, this.#h = 0, this.#y.length = 0, this.#b = 0, this.#n = 0, this.#f && this.#r) {
-                    let t1 = this.#r, i;
-                    for(; i = t1?.shift();)this.#S?.(...i);
+                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);
                 }
             }
-        };
+        }
         var external_fs_ = __webpack_require__("fs");
         const promises_namespaceObject = require("node:fs/promises");
         const external_node_events_namespaceObject = require("node:events");
@@ -5250,7 +5500,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             }
             constructor(src, dest, opts){
                 super(src, dest, opts);
-                this.proxyErrors = (er)=>this.dest.emit('error', er);
+                this.proxyErrors = (er)=>dest.emit('error', er);
                 src.on('error', this.proxyErrors);
             }
         }
@@ -5702,8 +5952,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
                     return: stop,
                     [Symbol.asyncIterator] () {
                         return this;
-                    },
-                    [Symbol.asyncDispose]: async ()=>{}
+                    }
                 };
             }
             [Symbol.iterator]() {
@@ -5737,8 +5986,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
                     return: stop,
                     [Symbol.iterator] () {
                         return this;
-                    },
-                    [Symbol.dispose]: ()=>{}
+                    }
                 };
             }
             destroy(er) {
@@ -5821,14 +6069,14 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             normalizeNocaseCache.set(s, n);
             return n;
         };
-        class ResolveCache extends L {
+        class ResolveCache extends LRUCache {
             constructor(){
                 super({
                     max: 256
                 });
             }
         }
-        class ChildrenCache extends L {
+        class ChildrenCache extends LRUCache {
             constructor(maxSize = 16384){
                 super({
                     maxSize,
@@ -6971,586 +7219,6 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
                 return true;
             }
         }
-        const esm_proc = 'object' == typeof process && process ? process : {
-            stdout: null,
-            stderr: null
-        };
-        const esm_isStream = (s)=>!!s && 'object' == typeof s && (s instanceof esm_Minipass || s instanceof external_node_stream_namespaceObject || esm_isReadable(s) || esm_isWritable(s));
-        const esm_isReadable = (s)=>!!s && 'object' == typeof s && s instanceof external_node_events_namespaceObject.EventEmitter && 'function' == typeof s.pipe && s.pipe !== external_node_stream_namespaceObject.Writable.prototype.pipe;
-        const esm_isWritable = (s)=>!!s && 'object' == typeof s && s instanceof external_node_events_namespaceObject.EventEmitter && 'function' == typeof s.write && 'function' == typeof s.end;
-        const esm_EOF = Symbol('EOF');
-        const esm_MAYBE_EMIT_END = Symbol('maybeEmitEnd');
-        const esm_EMITTED_END = Symbol('emittedEnd');
-        const esm_EMITTING_END = Symbol('emittingEnd');
-        const esm_EMITTED_ERROR = Symbol('emittedError');
-        const esm_CLOSED = Symbol('closed');
-        const esm_READ = Symbol('read');
-        const esm_FLUSH = Symbol('flush');
-        const esm_FLUSHCHUNK = Symbol('flushChunk');
-        const esm_ENCODING = Symbol('encoding');
-        const esm_DECODER = Symbol('decoder');
-        const esm_FLOWING = Symbol('flowing');
-        const esm_PAUSED = Symbol('paused');
-        const esm_RESUME = Symbol('resume');
-        const esm_BUFFER = Symbol('buffer');
-        const esm_PIPES = Symbol('pipes');
-        const esm_BUFFERLENGTH = Symbol('bufferLength');
-        const esm_BUFFERPUSH = Symbol('bufferPush');
-        const esm_BUFFERSHIFT = Symbol('bufferShift');
-        const esm_OBJECTMODE = Symbol('objectMode');
-        const esm_DESTROYED = Symbol('destroyed');
-        const esm_ERROR = Symbol('error');
-        const esm_EMITDATA = Symbol('emitData');
-        const esm_EMITEND = Symbol('emitEnd');
-        const esm_EMITEND2 = Symbol('emitEnd2');
-        const esm_ASYNC = Symbol('async');
-        const esm_ABORT = Symbol('abort');
-        const esm_ABORTED = Symbol('aborted');
-        const esm_SIGNAL = Symbol('signal');
-        const esm_DATALISTENERS = Symbol('dataListeners');
-        const esm_DISCARDED = Symbol('discarded');
-        const esm_defer = (fn)=>Promise.resolve().then(fn);
-        const esm_nodefer = (fn)=>fn();
-        const esm_isEndish = (ev)=>'end' === ev || 'finish' === ev || 'prefinish' === ev;
-        const esm_isArrayBufferLike = (b)=>b instanceof ArrayBuffer || !!b && 'object' == typeof b && b.constructor && 'ArrayBuffer' === b.constructor.name && b.byteLength >= 0;
-        const esm_isArrayBufferView = (b)=>!Buffer.isBuffer(b) && ArrayBuffer.isView(b);
-        class esm_Pipe {
-            src;
-            dest;
-            opts;
-            ondrain;
-            constructor(src, dest, opts){
-                this.src = src;
-                this.dest = dest;
-                this.opts = opts;
-                this.ondrain = ()=>src[esm_RESUME]();
-                this.dest.on('drain', this.ondrain);
-            }
-            unpipe() {
-                this.dest.removeListener('drain', this.ondrain);
-            }
-            proxyErrors(_er) {}
-            end() {
-                this.unpipe();
-                if (this.opts.end) this.dest.end();
-            }
-        }
-        class esm_PipeProxyErrors extends esm_Pipe {
-            unpipe() {
-                this.src.removeListener('error', this.proxyErrors);
-                super.unpipe();
-            }
-            constructor(src, dest, opts){
-                super(src, dest, opts);
-                this.proxyErrors = (er)=>dest.emit('error', er);
-                src.on('error', this.proxyErrors);
-            }
-        }
-        const esm_isObjectModeOptions = (o)=>!!o.objectMode;
-        const esm_isEncodingOptions = (o)=>!o.objectMode && !!o.encoding && 'buffer' !== o.encoding;
-        class esm_Minipass extends external_node_events_namespaceObject.EventEmitter {
-            [esm_FLOWING] = false;
-            [esm_PAUSED] = false;
-            [esm_PIPES] = [];
-            [esm_BUFFER] = [];
-            [esm_OBJECTMODE];
-            [esm_ENCODING];
-            [esm_ASYNC];
-            [esm_DECODER];
-            [esm_EOF] = false;
-            [esm_EMITTED_END] = false;
-            [esm_EMITTING_END] = false;
-            [esm_CLOSED] = false;
-            [esm_EMITTED_ERROR] = null;
-            [esm_BUFFERLENGTH] = 0;
-            [esm_DESTROYED] = false;
-            [esm_SIGNAL];
-            [esm_ABORTED] = false;
-            [esm_DATALISTENERS] = 0;
-            [esm_DISCARDED] = false;
-            writable = true;
-            readable = true;
-            constructor(...args){
-                const options = args[0] || {};
-                super();
-                if (options.objectMode && 'string' == typeof options.encoding) throw new TypeError('Encoding and objectMode may not be used together');
-                if (esm_isObjectModeOptions(options)) {
-                    this[esm_OBJECTMODE] = true;
-                    this[esm_ENCODING] = null;
-                } else if (esm_isEncodingOptions(options)) {
-                    this[esm_ENCODING] = options.encoding;
-                    this[esm_OBJECTMODE] = false;
-                } else {
-                    this[esm_OBJECTMODE] = false;
-                    this[esm_ENCODING] = null;
-                }
-                this[esm_ASYNC] = !!options.async;
-                this[esm_DECODER] = this[esm_ENCODING] ? new external_node_string_decoder_namespaceObject.StringDecoder(this[esm_ENCODING]) : null;
-                if (options && true === options.debugExposeBuffer) Object.defineProperty(this, 'buffer', {
-                    get: ()=>this[esm_BUFFER]
-                });
-                if (options && true === options.debugExposePipes) Object.defineProperty(this, 'pipes', {
-                    get: ()=>this[esm_PIPES]
-                });
-                const { signal } = options;
-                if (signal) {
-                    this[esm_SIGNAL] = signal;
-                    if (signal.aborted) this[esm_ABORT]();
-                    else signal.addEventListener('abort', ()=>this[esm_ABORT]());
-                }
-            }
-            get bufferLength() {
-                return this[esm_BUFFERLENGTH];
-            }
-            get encoding() {
-                return this[esm_ENCODING];
-            }
-            set encoding(_enc) {
-                throw new Error('Encoding must be set at instantiation time');
-            }
-            setEncoding(_enc) {
-                throw new Error('Encoding must be set at instantiation time');
-            }
-            get objectMode() {
-                return this[esm_OBJECTMODE];
-            }
-            set objectMode(_om) {
-                throw new Error('objectMode must be set at instantiation time');
-            }
-            get ['async']() {
-                return this[esm_ASYNC];
-            }
-            set ['async'](a) {
-                this[esm_ASYNC] = this[esm_ASYNC] || !!a;
-            }
-            [esm_ABORT]() {
-                this[esm_ABORTED] = true;
-                this.emit('abort', this[esm_SIGNAL]?.reason);
-                this.destroy(this[esm_SIGNAL]?.reason);
-            }
-            get aborted() {
-                return this[esm_ABORTED];
-            }
-            set aborted(_) {}
-            write(chunk, encoding, cb) {
-                if (this[esm_ABORTED]) return false;
-                if (this[esm_EOF]) throw new Error('write after end');
-                if (this[esm_DESTROYED]) {
-                    this.emit('error', Object.assign(new Error('Cannot call write after a stream was destroyed'), {
-                        code: 'ERR_STREAM_DESTROYED'
-                    }));
-                    return true;
-                }
-                if ('function' == typeof encoding) {
-                    cb = encoding;
-                    encoding = 'utf8';
-                }
-                if (!encoding) encoding = 'utf8';
-                const fn = this[esm_ASYNC] ? esm_defer : esm_nodefer;
-                if (!this[esm_OBJECTMODE] && !Buffer.isBuffer(chunk)) {
-                    if (esm_isArrayBufferView(chunk)) chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-                    else if (esm_isArrayBufferLike(chunk)) chunk = Buffer.from(chunk);
-                    else if ('string' != typeof chunk) throw new Error('Non-contiguous data written to non-objectMode stream');
-                }
-                if (this[esm_OBJECTMODE]) {
-                    if (this[esm_FLOWING] && 0 !== this[esm_BUFFERLENGTH]) this[esm_FLUSH](true);
-                    if (this[esm_FLOWING]) this.emit('data', chunk);
-                    else this[esm_BUFFERPUSH](chunk);
-                    if (0 !== this[esm_BUFFERLENGTH]) this.emit('readable');
-                    if (cb) fn(cb);
-                    return this[esm_FLOWING];
-                }
-                if (!chunk.length) {
-                    if (0 !== this[esm_BUFFERLENGTH]) this.emit('readable');
-                    if (cb) fn(cb);
-                    return this[esm_FLOWING];
-                }
-                if ('string' == typeof chunk && !(encoding === this[esm_ENCODING] && !this[esm_DECODER]?.lastNeed)) chunk = Buffer.from(chunk, encoding);
-                if (Buffer.isBuffer(chunk) && this[esm_ENCODING]) chunk = this[esm_DECODER].write(chunk);
-                if (this[esm_FLOWING] && 0 !== this[esm_BUFFERLENGTH]) this[esm_FLUSH](true);
-                if (this[esm_FLOWING]) this.emit('data', chunk);
-                else this[esm_BUFFERPUSH](chunk);
-                if (0 !== this[esm_BUFFERLENGTH]) this.emit('readable');
-                if (cb) fn(cb);
-                return this[esm_FLOWING];
-            }
-            read(n) {
-                if (this[esm_DESTROYED]) return null;
-                this[esm_DISCARDED] = false;
-                if (0 === this[esm_BUFFERLENGTH] || 0 === n || n && n > this[esm_BUFFERLENGTH]) {
-                    this[esm_MAYBE_EMIT_END]();
-                    return null;
-                }
-                if (this[esm_OBJECTMODE]) n = null;
-                if (this[esm_BUFFER].length > 1 && !this[esm_OBJECTMODE]) this[esm_BUFFER] = [
-                    this[esm_ENCODING] ? this[esm_BUFFER].join('') : Buffer.concat(this[esm_BUFFER], this[esm_BUFFERLENGTH])
-                ];
-                const ret = this[esm_READ](n || null, this[esm_BUFFER][0]);
-                this[esm_MAYBE_EMIT_END]();
-                return ret;
-            }
-            [esm_READ](n, chunk) {
-                if (this[esm_OBJECTMODE]) this[esm_BUFFERSHIFT]();
-                else {
-                    const c = chunk;
-                    if (n === c.length || null === n) this[esm_BUFFERSHIFT]();
-                    else if ('string' == typeof c) {
-                        this[esm_BUFFER][0] = c.slice(n);
-                        chunk = c.slice(0, n);
-                        this[esm_BUFFERLENGTH] -= n;
-                    } else {
-                        this[esm_BUFFER][0] = c.subarray(n);
-                        chunk = c.subarray(0, n);
-                        this[esm_BUFFERLENGTH] -= n;
-                    }
-                }
-                this.emit('data', chunk);
-                if (!this[esm_BUFFER].length && !this[esm_EOF]) this.emit('drain');
-                return chunk;
-            }
-            end(chunk, encoding, cb) {
-                if ('function' == typeof chunk) {
-                    cb = chunk;
-                    chunk = void 0;
-                }
-                if ('function' == typeof encoding) {
-                    cb = encoding;
-                    encoding = 'utf8';
-                }
-                if (void 0 !== chunk) this.write(chunk, encoding);
-                if (cb) this.once('end', cb);
-                this[esm_EOF] = true;
-                this.writable = false;
-                if (this[esm_FLOWING] || !this[esm_PAUSED]) this[esm_MAYBE_EMIT_END]();
-                return this;
-            }
-            [esm_RESUME]() {
-                if (this[esm_DESTROYED]) return;
-                if (!this[esm_DATALISTENERS] && !this[esm_PIPES].length) this[esm_DISCARDED] = true;
-                this[esm_PAUSED] = false;
-                this[esm_FLOWING] = true;
-                this.emit('resume');
-                if (this[esm_BUFFER].length) this[esm_FLUSH]();
-                else if (this[esm_EOF]) this[esm_MAYBE_EMIT_END]();
-                else this.emit('drain');
-            }
-            resume() {
-                return this[esm_RESUME]();
-            }
-            pause() {
-                this[esm_FLOWING] = false;
-                this[esm_PAUSED] = true;
-                this[esm_DISCARDED] = false;
-            }
-            get destroyed() {
-                return this[esm_DESTROYED];
-            }
-            get flowing() {
-                return this[esm_FLOWING];
-            }
-            get paused() {
-                return this[esm_PAUSED];
-            }
-            [esm_BUFFERPUSH](chunk) {
-                if (this[esm_OBJECTMODE]) this[esm_BUFFERLENGTH] += 1;
-                else this[esm_BUFFERLENGTH] += chunk.length;
-                this[esm_BUFFER].push(chunk);
-            }
-            [esm_BUFFERSHIFT]() {
-                if (this[esm_OBJECTMODE]) this[esm_BUFFERLENGTH] -= 1;
-                else this[esm_BUFFERLENGTH] -= this[esm_BUFFER][0].length;
-                return this[esm_BUFFER].shift();
-            }
-            [esm_FLUSH](noDrain = false) {
-                do ;
-                while (this[esm_FLUSHCHUNK](this[esm_BUFFERSHIFT]()) && this[esm_BUFFER].length);
-                if (!noDrain && !this[esm_BUFFER].length && !this[esm_EOF]) this.emit('drain');
-            }
-            [esm_FLUSHCHUNK](chunk) {
-                this.emit('data', chunk);
-                return this[esm_FLOWING];
-            }
-            pipe(dest, opts) {
-                if (this[esm_DESTROYED]) return dest;
-                this[esm_DISCARDED] = false;
-                const ended = this[esm_EMITTED_END];
-                opts = opts || {};
-                if (dest === esm_proc.stdout || dest === esm_proc.stderr) opts.end = false;
-                else opts.end = false !== opts.end;
-                opts.proxyErrors = !!opts.proxyErrors;
-                if (ended) {
-                    if (opts.end) dest.end();
-                } else {
-                    this[esm_PIPES].push(opts.proxyErrors ? new esm_PipeProxyErrors(this, dest, opts) : new esm_Pipe(this, dest, opts));
-                    if (this[esm_ASYNC]) esm_defer(()=>this[esm_RESUME]());
-                    else this[esm_RESUME]();
-                }
-                return dest;
-            }
-            unpipe(dest) {
-                const p = this[esm_PIPES].find((p)=>p.dest === dest);
-                if (p) {
-                    if (1 === this[esm_PIPES].length) {
-                        if (this[esm_FLOWING] && 0 === this[esm_DATALISTENERS]) this[esm_FLOWING] = false;
-                        this[esm_PIPES] = [];
-                    } else this[esm_PIPES].splice(this[esm_PIPES].indexOf(p), 1);
-                    p.unpipe();
-                }
-            }
-            addListener(ev, handler) {
-                return this.on(ev, handler);
-            }
-            on(ev, handler) {
-                const ret = super.on(ev, handler);
-                if ('data' === ev) {
-                    this[esm_DISCARDED] = false;
-                    this[esm_DATALISTENERS]++;
-                    if (!this[esm_PIPES].length && !this[esm_FLOWING]) this[esm_RESUME]();
-                } else if ('readable' === ev && 0 !== this[esm_BUFFERLENGTH]) super.emit('readable');
-                else if (esm_isEndish(ev) && this[esm_EMITTED_END]) {
-                    super.emit(ev);
-                    this.removeAllListeners(ev);
-                } else if ('error' === ev && this[esm_EMITTED_ERROR]) {
-                    const h = handler;
-                    if (this[esm_ASYNC]) esm_defer(()=>h.call(this, this[esm_EMITTED_ERROR]));
-                    else h.call(this, this[esm_EMITTED_ERROR]);
-                }
-                return ret;
-            }
-            removeListener(ev, handler) {
-                return this.off(ev, handler);
-            }
-            off(ev, handler) {
-                const ret = super.off(ev, handler);
-                if ('data' === ev) {
-                    this[esm_DATALISTENERS] = this.listeners('data').length;
-                    if (0 === this[esm_DATALISTENERS] && !this[esm_DISCARDED] && !this[esm_PIPES].length) this[esm_FLOWING] = false;
-                }
-                return ret;
-            }
-            removeAllListeners(ev) {
-                const ret = super.removeAllListeners(ev);
-                if ('data' === ev || void 0 === ev) {
-                    this[esm_DATALISTENERS] = 0;
-                    if (!this[esm_DISCARDED] && !this[esm_PIPES].length) this[esm_FLOWING] = false;
-                }
-                return ret;
-            }
-            get emittedEnd() {
-                return this[esm_EMITTED_END];
-            }
-            [esm_MAYBE_EMIT_END]() {
-                if (!this[esm_EMITTING_END] && !this[esm_EMITTED_END] && !this[esm_DESTROYED] && 0 === this[esm_BUFFER].length && this[esm_EOF]) {
-                    this[esm_EMITTING_END] = true;
-                    this.emit('end');
-                    this.emit('prefinish');
-                    this.emit('finish');
-                    if (this[esm_CLOSED]) this.emit('close');
-                    this[esm_EMITTING_END] = false;
-                }
-            }
-            emit(ev, ...args) {
-                const data = args[0];
-                if ('error' !== ev && 'close' !== ev && ev !== esm_DESTROYED && this[esm_DESTROYED]) return false;
-                if ('data' === ev) return this[esm_OBJECTMODE] || data ? this[esm_ASYNC] ? (esm_defer(()=>this[esm_EMITDATA](data)), true) : this[esm_EMITDATA](data) : false;
-                if ('end' === ev) return this[esm_EMITEND]();
-                if ('close' === ev) {
-                    this[esm_CLOSED] = true;
-                    if (!this[esm_EMITTED_END] && !this[esm_DESTROYED]) return false;
-                    const ret = super.emit('close');
-                    this.removeAllListeners('close');
-                    return ret;
-                }
-                if ('error' === ev) {
-                    this[esm_EMITTED_ERROR] = data;
-                    super.emit(esm_ERROR, data);
-                    const ret = !this[esm_SIGNAL] || this.listeners('error').length ? super.emit('error', data) : false;
-                    this[esm_MAYBE_EMIT_END]();
-                    return ret;
-                } else if ('resume' === ev) {
-                    const ret = super.emit('resume');
-                    this[esm_MAYBE_EMIT_END]();
-                    return ret;
-                } else if ('finish' === ev || 'prefinish' === ev) {
-                    const ret = super.emit(ev);
-                    this.removeAllListeners(ev);
-                    return ret;
-                }
-                const ret = super.emit(ev, ...args);
-                this[esm_MAYBE_EMIT_END]();
-                return ret;
-            }
-            [esm_EMITDATA](data) {
-                for (const p of this[esm_PIPES])if (false === p.dest.write(data)) this.pause();
-                const ret = this[esm_DISCARDED] ? false : super.emit('data', data);
-                this[esm_MAYBE_EMIT_END]();
-                return ret;
-            }
-            [esm_EMITEND]() {
-                if (this[esm_EMITTED_END]) return false;
-                this[esm_EMITTED_END] = true;
-                this.readable = false;
-                return this[esm_ASYNC] ? (esm_defer(()=>this[esm_EMITEND2]()), true) : this[esm_EMITEND2]();
-            }
-            [esm_EMITEND2]() {
-                if (this[esm_DECODER]) {
-                    const data = this[esm_DECODER].end();
-                    if (data) {
-                        for (const p of this[esm_PIPES])p.dest.write(data);
-                        if (!this[esm_DISCARDED]) super.emit('data', data);
-                    }
-                }
-                for (const p of this[esm_PIPES])p.end();
-                const ret = super.emit('end');
-                this.removeAllListeners('end');
-                return ret;
-            }
-            async collect() {
-                const buf = Object.assign([], {
-                    dataLength: 0
-                });
-                if (!this[esm_OBJECTMODE]) buf.dataLength = 0;
-                const p = this.promise();
-                this.on('data', (c)=>{
-                    buf.push(c);
-                    if (!this[esm_OBJECTMODE]) buf.dataLength += c.length;
-                });
-                await p;
-                return buf;
-            }
-            async concat() {
-                if (this[esm_OBJECTMODE]) throw new Error('cannot concat in objectMode');
-                const buf = await this.collect();
-                return this[esm_ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength);
-            }
-            async promise() {
-                return new Promise((resolve, reject)=>{
-                    this.on(esm_DESTROYED, ()=>reject(new Error('stream destroyed')));
-                    this.on('error', (er)=>reject(er));
-                    this.on('end', ()=>resolve());
-                });
-            }
-            [Symbol.asyncIterator]() {
-                this[esm_DISCARDED] = false;
-                let stopped = false;
-                const stop = async ()=>{
-                    this.pause();
-                    stopped = true;
-                    return {
-                        value: void 0,
-                        done: true
-                    };
-                };
-                const next = ()=>{
-                    if (stopped) return stop();
-                    const res = this.read();
-                    if (null !== res) return Promise.resolve({
-                        done: false,
-                        value: res
-                    });
-                    if (this[esm_EOF]) return stop();
-                    let resolve;
-                    let reject;
-                    const onerr = (er)=>{
-                        this.off('data', ondata);
-                        this.off('end', onend);
-                        this.off(esm_DESTROYED, ondestroy);
-                        stop();
-                        reject(er);
-                    };
-                    const ondata = (value)=>{
-                        this.off('error', onerr);
-                        this.off('end', onend);
-                        this.off(esm_DESTROYED, ondestroy);
-                        this.pause();
-                        resolve({
-                            value,
-                            done: !!this[esm_EOF]
-                        });
-                    };
-                    const onend = ()=>{
-                        this.off('error', onerr);
-                        this.off('data', ondata);
-                        this.off(esm_DESTROYED, ondestroy);
-                        stop();
-                        resolve({
-                            done: true,
-                            value: void 0
-                        });
-                    };
-                    const ondestroy = ()=>onerr(new Error('stream destroyed'));
-                    return new Promise((res, rej)=>{
-                        reject = rej;
-                        resolve = res;
-                        this.once(esm_DESTROYED, ondestroy);
-                        this.once('error', onerr);
-                        this.once('end', onend);
-                        this.once('data', ondata);
-                    });
-                };
-                return {
-                    next,
-                    throw: stop,
-                    return: stop,
-                    [Symbol.asyncIterator] () {
-                        return this;
-                    }
-                };
-            }
-            [Symbol.iterator]() {
-                this[esm_DISCARDED] = false;
-                let stopped = false;
-                const stop = ()=>{
-                    this.pause();
-                    this.off(esm_ERROR, stop);
-                    this.off(esm_DESTROYED, stop);
-                    this.off('end', stop);
-                    stopped = true;
-                    return {
-                        done: true,
-                        value: void 0
-                    };
-                };
-                const next = ()=>{
-                    if (stopped) return stop();
-                    const value = this.read();
-                    return null === value ? stop() : {
-                        done: false,
-                        value
-                    };
-                };
-                this.once('end', stop);
-                this.once(esm_ERROR, stop);
-                this.once(esm_DESTROYED, stop);
-                return {
-                    next,
-                    throw: stop,
-                    return: stop,
-                    [Symbol.iterator] () {
-                        return this;
-                    }
-                };
-            }
-            destroy(er) {
-                if (this[esm_DESTROYED]) {
-                    if (er) this.emit('error', er);
-                    else this.emit(esm_DESTROYED);
-                    return this;
-                }
-                this[esm_DESTROYED] = true;
-                this[esm_DISCARDED] = true;
-                this[esm_BUFFER].length = 0;
-                this[esm_BUFFERLENGTH] = 0;
-                const wc = this;
-                if ('function' == typeof wc.close && !this[esm_CLOSED]) wc.close();
-                if (er) this.emit('error', er);
-                else this.emit(esm_DESTROYED);
-                return this;
-            }
-            static get isStream() {
-                return esm_isStream;
-            }
-        }
         const ignore_defaultPlatform = 'object' == typeof process && process && 'string' == typeof process.platform ? process.platform : 'linux';
         class Ignore {
             relative;
@@ -8029,7 +7697,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             results;
             constructor(patterns, path, opts){
                 super(patterns, path, opts);
-                this.results = new esm_Minipass({
+                this.results = new Minipass({
                     signal: this.signal,
                     objectMode: true
                 });
@@ -11542,7 +11210,7 @@ Usage:
                     type: 'boolean',
                     description: `Turn on logging to help debug why certain keys or values are not being set as you expect, default is ${config_factory_defaultConfig.dotenvDebug}`
                 }
-            }).version('version', 'Show version number', "1.8.10-beta-20260604215059.0").help().epilogue(`For complete list of configuration options, please visit:
+            }).version('version', 'Show version number', "1.9.0").help().epilogue(`For complete list of configuration options, please visit:
   • Web options: https://midscenejs.com/automate-with-scripts-in-yaml#the-web-part
   • Android options: https://midscenejs.com/automate-with-scripts-in-yaml#the-android-part
   • iOS options: https://midscenejs.com/automate-with-scripts-in-yaml#the-ios-part