@midscene/cli 1.8.9 → 1.8.10-beta-20260604215059.0

package/dist/lib/index.js

@@ -3374,9 +3374,7 @@ 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 = {
-            rE: "1.8.9"
-        };
+        var package_namespaceObject = JSON.parse('{"rE":"1.8.10-beta-20260604215059.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;
@@ -4513,85 +4511,47 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
         minimatch.escape = escape_escape;
         minimatch.unescape = unescape_unescape;
         var external_node_url_ = __webpack_require__("node:url");
-        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 {
+        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 {
             heap;
             length;
-            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;
+            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;
             }
             pop() {
                 return this.heap[--this.length];
             }
-        }
-        class LRUCache {
-            #max;
-            #maxSize;
-            #dispose;
-            #disposeAfter;
-            #fetchMethod;
-            #memoMethod;
+        }, L = class u {
+            #o;
+            #u;
+            #w;
+            #D;
+            #S;
+            #M;
+            #U;
+            #m;
+            get perf() {
+                return this.#m;
+            }
             ttl;
             ttlResolution;
             ttlAutopurge;
@@ -4607,823 +4567,613 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             allowStaleOnFetchAbort;
             allowStaleOnFetchRejection;
             ignoreFetchAbort;
-            #size;
-            #calculatedSize;
-            #keyMap;
-            #keyList;
-            #valList;
-            #next;
-            #prev;
-            #head;
-            #tail;
-            #free;
-            #disposed;
-            #sizes;
-            #starts;
-            #ttls;
-            #hasDispose;
-            #hasFetchMethod;
-            #hasDisposeAfter;
-            static unsafeExposeInternals(c) {
+            #n;
+            #b;
+            #s;
+            #i;
+            #t;
+            #a;
+            #c;
+            #l;
+            #h;
+            #y;
+            #r;
+            #_;
+            #F;
+            #d;
+            #g;
+            #T;
+            #W;
+            #f;
+            #j;
+            static unsafeExposeInternals(e1) {
                 return {
-                    starts: c.#starts,
-                    ttls: c.#ttls,
-                    sizes: c.#sizes,
-                    keyMap: c.#keyMap,
-                    keyList: c.#keyList,
-                    valList: c.#valList,
-                    next: c.#next,
-                    prev: c.#prev,
+                    starts: 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,
                     get head () {
-                        return c.#head;
+                        return e1.#l;
                     },
                     get tail () {
-                        return c.#tail;
+                        return e1.#h;
                     },
-                    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)
+                    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)
                 };
             }
             get max() {
-                return this.#max;
+                return this.#o;
             }
             get maxSize() {
-                return this.#maxSize;
+                return this.#u;
             }
             get calculatedSize() {
-                return this.#calculatedSize;
+                return this.#b;
             }
             get size() {
-                return this.#size;
+                return this.#n;
             }
             get fetchMethod() {
-                return this.#fetchMethod;
+                return this.#M;
             }
             get memoMethod() {
-                return this.#memoMethod;
+                return this.#U;
             }
             get dispose() {
-                return this.#dispose;
+                return this.#w;
             }
-            get disposeAfter() {
-                return this.#disposeAfter;
+            get onInsert() {
+                return this.#D;
             }
-            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();
-                    }
-                };
-                this.#updateItemAge = (index)=>{
-                    starts[index] = 0 !== ttls[index] ? perf.now() : 0;
+            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]);
                 };
-                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 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;
                     }
                 };
-                let cachedNow = 0;
-                const getNow = ()=>{
-                    const n = perf.now();
+                let n = 0, o = ()=>{
+                    let r = this.#m.now();
                     if (this.ttlResolution > 0) {
-                        cachedNow = n;
-                        const t1 = setTimeout(()=>cachedNow = 0, this.ttlResolution);
-                        if (t1.unref) t1.unref();
+                        n = r;
+                        let h = setTimeout(()=>n = 0, this.ttlResolution);
+                        h.unref && h.unref();
                     }
-                    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;
+                    return r;
                 };
-                this.#isStale = (index)=>{
-                    const s = starts[index];
-                    const t1 = ttls[index];
-                    return !!t1 && !!s && (cachedNow || getNow()) - s > t1;
+                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;
                 };
             }
-            #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)');
+            #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)");
                     } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
-                    return size;
-                };
-                this.#addItemSize = (index, size, status)=>{
-                    sizes[index] = size;
-                    if (this.#maxSize) {
-                        const maxSize = this.#maxSize - sizes[index];
-                        while(this.#calculatedSize > maxSize)this.#evict(true);
-                    }
-                    this.#calculatedSize += sizes[index];
-                    if (status) {
-                        status.entrySize = size;
-                        status.totalCalculatedSize = this.#calculatedSize;
+                    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);
                     }
+                    this.#b += e1[t1], s && (s.entrySize = i, s.totalCalculatedSize = this.#b);
                 };
             }
-            #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');
+            #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");
                 return 0;
             };
-            *#indexes({ allowStale = this.allowStale } = {}) {
-                if (this.#size) for(let i = this.#tail; true;){
-                    if (!this.#isValidIndex(i)) break;
-                    if (allowStale || !this.#isStale(i)) yield i;
-                    if (i === this.#head) break;
-                    i = this.#prev[i];
-                }
+            *#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];
             }
-            *#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];
-                }
+            *#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];
             }
-            #isValidIndex(index) {
-                return void 0 !== index && this.#keyMap.get(this.#keyList[index]) === index;
+            #V(e1) {
+                return void 0 !== e1 && this.#s.get(this.#i[e1]) === e1;
             }
             *entries() {
-                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]
-                ];
+                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]
+                ]);
             }
             *rentries() {
-                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]
-                ];
+                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]
+                ]);
             }
             *keys() {
-                for (const i of this.#indexes()){
-                    const k = this.#keyList[i];
-                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+                for (let e1 of this.#A()){
+                    let t1 = this.#i[e1];
+                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
                 }
             }
             *rkeys() {
-                for (const i of this.#rindexes()){
-                    const k = this.#keyList[i];
-                    if (void 0 !== k && !this.#isBackgroundFetch(this.#valList[i])) yield k;
+                for (let e1 of this.#z()){
+                    let t1 = this.#i[e1];
+                    void 0 === t1 || this.#e(this.#t[e1]) || (yield t1);
                 }
             }
             *values() {
-                for (const i of this.#indexes()){
-                    const v = this.#valList[i];
-                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
-                }
+                for (let e1 of this.#A())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
             }
             *rvalues() {
-                for (const i of this.#rindexes()){
-                    const v = this.#valList[i];
-                    if (void 0 !== v && !this.#isBackgroundFetch(this.#valList[i])) yield this.#valList[i];
-                }
+                for (let e1 of this.#z())void 0 === this.#t[e1] || this.#e(this.#t[e1]) || (yield this.#t[e1]);
             }
             [Symbol.iterator]() {
                 return this.entries();
             }
-            [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);
-                    }
+            [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);
                 }
             }
-            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);
+            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);
                 }
             }
-            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);
+            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);
                 }
             }
             purgeStale() {
-                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
+                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
                 };
-                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();
+                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.#sizes) entry.size = this.#sizes[i];
-                return entry;
+                return this.#_ && (n.size = this.#_[t1]), n;
             }
             dump() {
-                const arr = [];
-                for (const i of this.#indexes({
-                    allowStale: true
+                let e1 = [];
+                for (let t1 of this.#A({
+                    allowStale: !0
                 })){
-                    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
+                    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
                     };
-                    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
+                    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
                     ]);
                 }
-                return arr;
+                return e1;
             }
-            load(arr) {
+            load(e1) {
                 this.clear();
-                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;
+                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);
                         }
-                    } else if (status) status.set = 'update';
+                    } else h && (h.set = "update");
+                    this.#j && this.onInsert?.(t1, e1, t1 === g ? "update" : "replace");
                 }
-                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);
+                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);
                 }
                 return this;
             }
             pop() {
                 try {
-                    while(this.#size){
-                        const val = this.#valList[this.#head];
-                        this.#evict(true);
-                        if (this.#isBackgroundFetch(val)) {
-                            if (val.__staleWhileFetching) return val.__staleWhileFetching;
-                        } else if (void 0 !== val) return val;
+                    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;
                     }
                 } finally{
-                    if (this.#hasDisposeAfter && this.#disposed) {
-                        const dt = this.#disposed;
-                        let task;
-                        while(task = dt?.shift())this.#disposeAfter?.(...task);
+                    if (this.#f && this.#r) {
+                        let e1 = this.#r, t1;
+                        for(; t1 = e1?.shift();)this.#S?.(...t1);
                     }
                 }
             }
-            #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'
-                    ]);
+            #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;
                 }
-                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;
+                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;
             }
-            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
+            #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
                 });
-                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);
-                        }
+                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)));
                     });
                 };
-                if (options.status) options.status.fetchDispatched = true;
-                const p = new Promise(pcall).then(cb, eb);
-                const bf = Object.assign(p, {
-                    __abortController: ac,
-                    __staleWhileFetching: v,
+                i.status && (i.status.fetchDispatched = !0);
+                let p = new Promise(g).then(l, c), T = Object.assign(p, {
+                    __abortController: o,
+                    __staleWhileFetching: n,
                     __returned: void 0
                 });
-                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;
+                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;
                 }
                 {
-                    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
+                    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
                 });
-                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;
+                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;
                 }
-                if (status) status.get = 'miss';
+                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);
             }
-            #connect(p, n) {
-                this.#prev[n] = p;
-                this.#next[p] = n;
+            #$(e1, t1) {
+                this.#c[t1] = e1, this.#a[e1] = t1;
             }
-            #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;
-                }
+            #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);
             }
-            delete(k) {
-                return this.#delete(k, 'delete');
+            delete(e1) {
+                return this.#v(e1, "delete");
             }
-            #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);
+            #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];
                         else {
-                            this.#removeItemSize(index);
-                            const v = this.#valList[index];
-                            if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
-                            else if (this.#hasDispose || this.#hasDisposeAfter) {
-                                if (this.#hasDispose) this.#dispose?.(v, k, reason);
-                                if (this.#hasDisposeAfter) this.#disposed?.push([
-                                    v,
-                                    k,
-                                    reason
-                                ]);
-                            }
-                            this.#keyMap.delete(k);
-                            this.#keyList[index] = 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);
+                            let o = this.#c[s];
+                            this.#a[o] = this.#a[s];
+                            let r = this.#a[s];
+                            this.#c[r] = this.#c[s];
                         }
+                        this.#n--, this.#y.push(s);
                     }
                 }
-                if (this.#hasDisposeAfter && this.#disposed?.length) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift())this.#disposeAfter?.(...task);
+                if (this.#f && this.#r?.length) {
+                    let s = this.#r, n;
+                    for(; n = s?.shift();)this.#S?.(...n);
                 }
-                return deleted;
+                return i;
             }
             clear() {
-                return this.#clear('delete');
+                return this.#q("delete");
             }
-            #clear(reason) {
-                for (const index of this.#rindexes({
-                    allowStale: true
+            #q(e1) {
+                for (let t1 of this.#z({
+                    allowStale: !0
                 })){
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v)) v.__abortController.abort(new Error('deleted'));
+                    let i = this.#t[t1];
+                    if (this.#e(i)) i.__abortController.abort(new Error("deleted"));
                     else {
-                        const k = this.#keyList[index];
-                        if (this.#hasDispose) this.#dispose?.(v, k, reason);
-                        if (this.#hasDisposeAfter) this.#disposed?.push([
-                            v,
-                            k,
-                            reason
+                        let s = this.#i[t1];
+                        this.#T && this.#w?.(i, s, e1), this.#f && this.#r?.push([
+                            i,
+                            s,
+                            e1
                         ]);
                     }
                 }
-                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.#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);
                 }
-                if (this.#sizes) this.#sizes.fill(0);
-                this.#head = 0;
-                this.#tail = 0;
-                this.#free.length = 0;
-                this.#calculatedSize = 0;
-                this.#size = 0;
-                if (this.#hasDisposeAfter && this.#disposed) {
-                    const dt = this.#disposed;
-                    let task;
-                    while(task = dt?.shift())this.#disposeAfter?.(...task);
+                if (this.#_ && 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);
                 }
             }
-        }
+        };
         var external_fs_ = __webpack_require__("fs");
         const promises_namespaceObject = require("node:fs/promises");
         const external_node_events_namespaceObject = require("node:events");
@@ -5500,7 +5250,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             }
             constructor(src, dest, opts){
                 super(src, dest, opts);
-                this.proxyErrors = (er)=>dest.emit('error', er);
+                this.proxyErrors = (er)=>this.dest.emit('error', er);
                 src.on('error', this.proxyErrors);
             }
         }
@@ -5952,7 +5702,8 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
                     return: stop,
                     [Symbol.asyncIterator] () {
                         return this;
-                    }
+                    },
+                    [Symbol.asyncDispose]: async ()=>{}
                 };
             }
             [Symbol.iterator]() {
@@ -5986,7 +5737,8 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
                     return: stop,
                     [Symbol.iterator] () {
                         return this;
-                    }
+                    },
+                    [Symbol.dispose]: ()=>{}
                 };
             }
             destroy(er) {
@@ -6069,14 +5821,14 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             normalizeNocaseCache.set(s, n);
             return n;
         };
-        class ResolveCache extends LRUCache {
+        class ResolveCache extends L {
             constructor(){
                 super({
                     max: 256
                 });
             }
         }
-        class ChildrenCache extends LRUCache {
+        class ChildrenCache extends L {
             constructor(maxSize = 16384){
                 super({
                     maxSize,
@@ -7219,6 +6971,586 @@ 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;
@@ -7697,7 +8029,7 @@ defineYamlBatchTest(${JSON.stringify(testOptions, null, 2)});
             results;
             constructor(patterns, path, opts){
                 super(patterns, path, opts);
-                this.results = new Minipass({
+                this.results = new esm_Minipass({
                     signal: this.signal,
                     objectMode: true
                 });
@@ -11210,7 +11542,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.9").help().epilogue(`For complete list of configuration options, please visit:
+            }).version('version', 'Show version number', "1.8.10-beta-20260604215059.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