lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.112.mjs

@@ -1,21 +1,2434 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
-import { g as r } from "./Package.internal.105.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { win32 as t, posix as e } from "node:path";
 
-import { h as t } from "./Package.internal.113.mjs";
+import { fileURLToPath as i } from "node:url";
 
-const n = r;
+import { realpathSync as s, readlinkSync as n, readdirSync as r, readdir as h, lstatSync as a } from "fs";
 
-const a = t;
+import * as o from "node:fs";
 
-var o = function(r, t, o) {
-    if (e(r) && (typeof t === "string" || Array.isArray(t))) {
-        return a(n(r, t, o));
+import { realpath as l, readlink as c, readdir as d, lstat as f } from "node:fs/promises";
+
+import { M as u } from "./Package.internal.113.mjs";
+
+const p = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+
+const y = new Set;
+
+const m = typeof process === "object" && !!process ? process : {};
+
+const g = (t, e, i, s) => {
+    typeof m.emitWarning === "function" ? m.emitWarning(t, e, i, s) : console.error(`[${i}] ${e}: ${t}`);
+};
+
+let w = globalThis.AbortController;
+
+let S = globalThis.AbortSignal;
+
+if (typeof w === "undefined") {
+    S = class AbortSignal {
+        onabort;
+        _onabort=[];
+        reason;
+        aborted=false;
+        addEventListener(t, e) {
+            this._onabort.push(e);
+        }
+    };
+    w = class AbortController {
+        constructor() {
+            e();
+        }
+        signal=new S;
+        abort(t) {
+            if (this.signal.aborted) return;
+            this.signal.reason = t;
+            this.signal.aborted = true;
+            for (const e of this.signal._onabort) {
+                e(t);
+            }
+            this.signal.onabort?.(t);
+        }
+    };
+    let t = m.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const e = () => {
+        if (!t) return;
+        t = false;
+        g("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", e);
+    };
+}
+
+const v = t => !y.has(t);
+
+const k = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+
+const F = t => !k(t) ? null : t <= Math.pow(2, 8) ? Uint8Array : t <= Math.pow(2, 16) ? Uint16Array : t <= Math.pow(2, 32) ? Uint32Array : t <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+
+class ZeroArray extends Array {
+    constructor(t) {
+        super(t);
+        this.fill(0);
+    }
+}
+
+class Stack {
+    heap;
+    length;
+    static #t=false;
+    static create(t) {
+        const e = F(t);
+        if (!e) return [];
+        Stack.#t = true;
+        const i = new Stack(t, e);
+        Stack.#t = false;
+        return i;
+    }
+    constructor(t, e) {
+        if (!Stack.#t) {
+            throw new TypeError("instantiate Stack using Stack.create(n)");
+        }
+        this.heap = new e(t);
+        this.length = 0;
+    }
+    push(t) {
+        this.heap[this.length++] = t;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+
+class LRUCache {
+    #e;
+    #i;
+    #s;
+    #n;
+    #r;
+    #h;
+    #a;
+    #o;
+    get perf() {
+        return this.#o;
+    }
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #l;
+    #c;
+    #d;
+    #f;
+    #u;
+    #p;
+    #y;
+    #m;
+    #g;
+    #w;
+    #S;
+    #v;
+    #k;
+    #F;
+    #T;
+    #x;
+    #b;
+    #z;
+    static unsafeExposeInternals(t) {
+        return {
+            starts: t.#k,
+            ttls: t.#F,
+            sizes: t.#v,
+            keyMap: t.#d,
+            keyList: t.#f,
+            valList: t.#u,
+            next: t.#p,
+            prev: t.#y,
+            get head() {
+                return t.#m;
+            },
+            get tail() {
+                return t.#g;
+            },
+            free: t.#w,
+            isBackgroundFetch: e => t.#L(e),
+            backgroundFetch: (e, i, s, n) => t.#A(e, i, s, n),
+            moveToTail: e => t.#C(e),
+            indexes: e => t.#P(e),
+            rindexes: e => t.#O(e),
+            isStale: e => t.#R(e)
+        };
+    }
+    get max() {
+        return this.#e;
+    }
+    get maxSize() {
+        return this.#i;
+    }
+    get calculatedSize() {
+        return this.#c;
+    }
+    get size() {
+        return this.#l;
+    }
+    get fetchMethod() {
+        return this.#h;
+    }
+    get memoMethod() {
+        return this.#a;
+    }
+    get dispose() {
+        return this.#s;
+    }
+    get onInsert() {
+        return this.#n;
+    }
+    get disposeAfter() {
+        return this.#r;
+    }
+    constructor(t) {
+        const {max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: h, allowStale: a, dispose: o, onInsert: l, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: f, maxSize: u = 0, maxEntrySize: m = 0, sizeCalculation: w, fetchMethod: S, memoMethod: T, noDeleteOnFetchRejection: x, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: z, allowStaleOnFetchAbort: L, ignoreFetchAbort: A, perf: C} = t;
+        if (C !== undefined) {
+            if (typeof C?.now !== "function") {
+                throw new TypeError("perf option must have a now() method if specified");
+            }
+        }
+        this.#o = C ?? p;
+        if (e !== 0 && !k(e)) {
+            throw new TypeError("max option must be a nonnegative integer");
+        }
+        const P = e ? F(e) : Array;
+        if (!P) {
+            throw new Error("invalid max value: " + e);
+        }
+        this.#e = e;
+        this.#i = u;
+        this.maxEntrySize = m || this.#i;
+        this.sizeCalculation = w;
+        if (this.sizeCalculation) {
+            if (!this.#i && !this.maxEntrySize) {
+                throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+            }
+            if (typeof this.sizeCalculation !== "function") {
+                throw new TypeError("sizeCalculation set to non-function");
+            }
+        }
+        if (T !== undefined && typeof T !== "function") {
+            throw new TypeError("memoMethod must be a function if defined");
+        }
+        this.#a = T;
+        if (S !== undefined && typeof S !== "function") {
+            throw new TypeError("fetchMethod must be a function if specified");
+        }
+        this.#h = S;
+        this.#x = !!S;
+        this.#d = new Map;
+        this.#f = new Array(e).fill(undefined);
+        this.#u = new Array(e).fill(undefined);
+        this.#p = new P(e);
+        this.#y = new P(e);
+        this.#m = 0;
+        this.#g = 0;
+        this.#w = Stack.create(e);
+        this.#l = 0;
+        this.#c = 0;
+        if (typeof o === "function") {
+            this.#s = o;
+        }
+        if (typeof l === "function") {
+            this.#n = l;
+        }
+        if (typeof c === "function") {
+            this.#r = c;
+            this.#S = [];
+        } else {
+            this.#r = undefined;
+            this.#S = undefined;
+        }
+        this.#T = !!this.#s;
+        this.#z = !!this.#n;
+        this.#b = !!this.#r;
+        this.noDisposeOnSet = !!d;
+        this.noUpdateTTL = !!f;
+        this.noDeleteOnFetchRejection = !!x;
+        this.allowStaleOnFetchRejection = !!z;
+        this.allowStaleOnFetchAbort = !!L;
+        this.ignoreFetchAbort = !!A;
+        if (this.maxEntrySize !== 0) {
+            if (this.#i !== 0) {
+                if (!k(this.#i)) {
+                    throw new TypeError("maxSize must be a positive integer if specified");
+                }
+            }
+            if (!k(this.maxEntrySize)) {
+                throw new TypeError("maxEntrySize must be a positive integer if specified");
+            }
+            this.#E();
+        }
+        this.allowStale = !!a;
+        this.noDeleteOnStaleGet = !!b;
+        this.updateAgeOnGet = !!r;
+        this.updateAgeOnHas = !!h;
+        this.ttlResolution = k(s) || s === 0 ? s : 1;
+        this.ttlAutopurge = !!n;
+        this.ttl = i || 0;
+        if (this.ttl) {
+            if (!k(this.ttl)) {
+                throw new TypeError("ttl must be a positive integer if specified");
+            }
+            this.#_();
+        }
+        if (this.#e === 0 && this.ttl === 0 && this.#i === 0) {
+            throw new TypeError("At least one of max, maxSize, or ttl is required");
+        }
+        if (!this.ttlAutopurge && !this.#e && !this.#i) {
+            const t = "LRU_CACHE_UNBOUNDED";
+            if (v(t)) {
+                y.add(t);
+                const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
+                g(e, "UnboundedCacheWarning", t, LRUCache);
+            }
+        }
+    }
+    getRemainingTTL(t) {
+        return this.#d.has(t) ? Infinity : 0;
+    }
+    #_() {
+        const t = new ZeroArray(this.#e);
+        const e = new ZeroArray(this.#e);
+        this.#F = t;
+        this.#k = e;
+        this.#D = (i, s, n = this.#o.now()) => {
+            e[i] = s !== 0 ? n : 0;
+            t[i] = s;
+            if (s !== 0 && this.ttlAutopurge) {
+                const t = setTimeout(() => {
+                    if (this.#R(i)) {
+                        this.#M(this.#f[i], "expire");
+                    }
+                }, s + 1);
+                if (t.unref) {
+                    t.unref();
+                }
+            }
+        };
+        this.#I = i => {
+            e[i] = t[i] !== 0 ? this.#o.now() : 0;
+        };
+        this.#B = (n, r) => {
+            if (t[r]) {
+                const h = t[r];
+                const a = e[r];
+                if (!h || !a) return;
+                n.ttl = h;
+                n.start = a;
+                n.now = i || s();
+                const o = n.now - a;
+                n.remainingTTL = h - o;
+            }
+        };
+        let i = 0;
+        const s = () => {
+            const t = this.#o.now();
+            if (this.ttlResolution > 0) {
+                i = t;
+                const e = setTimeout(() => i = 0, this.ttlResolution);
+                if (e.unref) {
+                    e.unref();
+                }
+            }
+            return t;
+        };
+        this.getRemainingTTL = n => {
+            const r = this.#d.get(n);
+            if (r === undefined) {
+                return 0;
+            }
+            const h = t[r];
+            const a = e[r];
+            if (!h || !a) {
+                return Infinity;
+            }
+            const o = (i || s()) - a;
+            return h - o;
+        };
+        this.#R = n => {
+            const r = e[n];
+            const h = t[n];
+            return !!h && !!r && (i || s()) - r > h;
+        };
+    }
+    #I=() => {};
+    #B=() => {};
+    #D=() => {};
+    #R=() => false;
+    #E() {
+        const t = new ZeroArray(this.#e);
+        this.#c = 0;
+        this.#v = t;
+        this.#N = e => {
+            this.#c -= t[e];
+            t[e] = 0;
+        };
+        this.#W = (t, e, i, s) => {
+            if (this.#L(e)) {
+                return 0;
+            }
+            if (!k(i)) {
+                if (s) {
+                    if (typeof s !== "function") {
+                        throw new TypeError("sizeCalculation must be a function");
+                    }
+                    i = s(e, t);
+                    if (!k(i)) {
+                        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 i;
+        };
+        this.#U = (e, i, s) => {
+            t[e] = i;
+            if (this.#i) {
+                const i = this.#i - t[e];
+                while (this.#c > i) {
+                    this.#j(true);
+                }
+            }
+            this.#c += t[e];
+            if (s) {
+                s.entrySize = i;
+                s.totalCalculatedSize = this.#c;
+            }
+        };
+    }
+    #N=t => {};
+    #U=(t, e, i) => {};
+    #W=(t, e, i, s) => {
+        if (i || s) {
+            throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+        }
+        return 0;
+    };
+    * #P({allowStale: t = this.allowStale} = {}) {
+        if (this.#l) {
+            for (let e = this.#g; true; ) {
+                if (!this.#G(e)) {
+                    break;
+                }
+                if (t || !this.#R(e)) {
+                    yield e;
+                }
+                if (e === this.#m) {
+                    break;
+                } else {
+                    e = this.#y[e];
+                }
+            }
+        }
+    }
+    * #O({allowStale: t = this.allowStale} = {}) {
+        if (this.#l) {
+            for (let e = this.#m; true; ) {
+                if (!this.#G(e)) {
+                    break;
+                }
+                if (t || !this.#R(e)) {
+                    yield e;
+                }
+                if (e === this.#g) {
+                    break;
+                } else {
+                    e = this.#p[e];
+                }
+            }
+        }
+    }
+    #G(t) {
+        return t !== undefined && this.#d.get(this.#f[t]) === t;
+    }
+    * entries() {
+        for (const t of this.#P()) {
+            if (this.#u[t] !== undefined && this.#f[t] !== undefined && !this.#L(this.#u[t])) {
+                yield [ this.#f[t], this.#u[t] ];
+            }
+        }
+    }
+    * rentries() {
+        for (const t of this.#O()) {
+            if (this.#u[t] !== undefined && this.#f[t] !== undefined && !this.#L(this.#u[t])) {
+                yield [ this.#f[t], this.#u[t] ];
+            }
+        }
+    }
+    * keys() {
+        for (const t of this.#P()) {
+            const e = this.#f[t];
+            if (e !== undefined && !this.#L(this.#u[t])) {
+                yield e;
+            }
+        }
+    }
+    * rkeys() {
+        for (const t of this.#O()) {
+            const e = this.#f[t];
+            if (e !== undefined && !this.#L(this.#u[t])) {
+                yield e;
+            }
+        }
+    }
+    * values() {
+        for (const t of this.#P()) {
+            const e = this.#u[t];
+            if (e !== undefined && !this.#L(this.#u[t])) {
+                yield this.#u[t];
+            }
+        }
+    }
+    * rvalues() {
+        for (const t of this.#O()) {
+            const e = this.#u[t];
+            if (e !== undefined && !this.#L(this.#u[t])) {
+                yield this.#u[t];
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag]="LRUCache";
+    find(t, e = {}) {
+        for (const i of this.#P()) {
+            const s = this.#u[i];
+            const n = this.#L(s) ? s.__staleWhileFetching : s;
+            if (n === undefined) continue;
+            if (t(n, this.#f[i], this)) {
+                return this.get(this.#f[i], e);
+            }
+        }
+    }
+    forEach(t, e = this) {
+        for (const i of this.#P()) {
+            const s = this.#u[i];
+            const n = this.#L(s) ? s.__staleWhileFetching : s;
+            if (n === undefined) continue;
+            t.call(e, n, this.#f[i], this);
+        }
+    }
+    rforEach(t, e = this) {
+        for (const i of this.#O()) {
+            const s = this.#u[i];
+            const n = this.#L(s) ? s.__staleWhileFetching : s;
+            if (n === undefined) continue;
+            t.call(e, n, this.#f[i], this);
+        }
+    }
+    purgeStale() {
+        let t = false;
+        for (const e of this.#O({
+            allowStale: true
+        })) {
+            if (this.#R(e)) {
+                this.#M(this.#f[e], "expire");
+                t = true;
+            }
+        }
+        return t;
+    }
+    info(t) {
+        const e = this.#d.get(t);
+        if (e === undefined) return undefined;
+        const i = this.#u[e];
+        const s = this.#L(i) ? i.__staleWhileFetching : i;
+        if (s === undefined) return undefined;
+        const n = {
+            value: s
+        };
+        if (this.#F && this.#k) {
+            const t = this.#F[e];
+            const i = this.#k[e];
+            if (t && i) {
+                const e = t - (this.#o.now() - i);
+                n.ttl = e;
+                n.start = Date.now();
+            }
+        }
+        if (this.#v) {
+            n.size = this.#v[e];
+        }
+        return n;
+    }
+    dump() {
+        const t = [];
+        for (const e of this.#P({
+            allowStale: true
+        })) {
+            const i = this.#f[e];
+            const s = this.#u[e];
+            const n = this.#L(s) ? s.__staleWhileFetching : s;
+            if (n === undefined || i === undefined) continue;
+            const r = {
+                value: n
+            };
+            if (this.#F && this.#k) {
+                r.ttl = this.#F[e];
+                const t = this.#o.now() - this.#k[e];
+                r.start = Math.floor(Date.now() - t);
+            }
+            if (this.#v) {
+                r.size = this.#v[e];
+            }
+            t.unshift([ i, r ]);
+        }
+        return t;
+    }
+    load(t) {
+        this.clear();
+        for (const [e, i] of t) {
+            if (i.start) {
+                const t = Date.now() - i.start;
+                i.start = this.#o.now() - t;
+            }
+            this.set(e, i.value, i);
+        }
+    }
+    set(t, e, i = {}) {
+        if (e === undefined) {
+            this.delete(t);
+            return this;
+        }
+        const {ttl: s = this.ttl, start: n, noDisposeOnSet: r = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: a} = i;
+        let {noUpdateTTL: o = this.noUpdateTTL} = i;
+        const l = this.#W(t, e, i.size || 0, h);
+        if (this.maxEntrySize && l > this.maxEntrySize) {
+            if (a) {
+                a.set = "miss";
+                a.maxEntrySizeExceeded = true;
+            }
+            this.#M(t, "set");
+            return this;
+        }
+        let c = this.#l === 0 ? undefined : this.#d.get(t);
+        if (c === undefined) {
+            c = this.#l === 0 ? this.#g : this.#w.length !== 0 ? this.#w.pop() : this.#l === this.#e ? this.#j(false) : this.#l;
+            this.#f[c] = t;
+            this.#u[c] = e;
+            this.#d.set(t, c);
+            this.#p[this.#g] = c;
+            this.#y[c] = this.#g;
+            this.#g = c;
+            this.#l++;
+            this.#U(c, l, a);
+            if (a) a.set = "add";
+            o = false;
+            if (this.#z) {
+                this.#n?.(e, t, "add");
+            }
+        } else {
+            this.#C(c);
+            const i = this.#u[c];
+            if (e !== i) {
+                if (this.#x && this.#L(i)) {
+                    i.__abortController.abort(new Error("replaced"));
+                    const {__staleWhileFetching: e} = i;
+                    if (e !== undefined && !r) {
+                        if (this.#T) {
+                            this.#s?.(e, t, "set");
+                        }
+                        if (this.#b) {
+                            this.#S?.push([ e, t, "set" ]);
+                        }
+                    }
+                } else if (!r) {
+                    if (this.#T) {
+                        this.#s?.(i, t, "set");
+                    }
+                    if (this.#b) {
+                        this.#S?.push([ i, t, "set" ]);
+                    }
+                }
+                this.#N(c);
+                this.#U(c, l, a);
+                this.#u[c] = e;
+                if (a) {
+                    a.set = "replace";
+                    const t = i && this.#L(i) ? i.__staleWhileFetching : i;
+                    if (t !== undefined) a.oldValue = t;
+                }
+            } else if (a) {
+                a.set = "update";
+            }
+            if (this.#z) {
+                this.onInsert?.(e, t, e === i ? "update" : "replace");
+            }
+        }
+        if (s !== 0 && !this.#F) {
+            this.#_();
+        }
+        if (this.#F) {
+            if (!o) {
+                this.#D(c, s, n);
+            }
+            if (a) this.#B(a, c);
+        }
+        if (!r && this.#b && this.#S) {
+            const t = this.#S;
+            let e;
+            while (e = t?.shift()) {
+                this.#r?.(...e);
+            }
+        }
+        return this;
+    }
+    pop() {
+        try {
+            while (this.#l) {
+                const t = this.#u[this.#m];
+                this.#j(true);
+                if (this.#L(t)) {
+                    if (t.__staleWhileFetching) {
+                        return t.__staleWhileFetching;
+                    }
+                } else if (t !== undefined) {
+                    return t;
+                }
+            }
+        } finally {
+            if (this.#b && this.#S) {
+                const t = this.#S;
+                let e;
+                while (e = t?.shift()) {
+                    this.#r?.(...e);
+                }
+            }
+        }
+    }
+    #j(t) {
+        const e = this.#m;
+        const i = this.#f[e];
+        const s = this.#u[e];
+        if (this.#x && this.#L(s)) {
+            s.__abortController.abort(new Error("evicted"));
+        } else if (this.#T || this.#b) {
+            if (this.#T) {
+                this.#s?.(s, i, "evict");
+            }
+            if (this.#b) {
+                this.#S?.push([ s, i, "evict" ]);
+            }
+        }
+        this.#N(e);
+        if (t) {
+            this.#f[e] = undefined;
+            this.#u[e] = undefined;
+            this.#w.push(e);
+        }
+        if (this.#l === 1) {
+            this.#m = this.#g = 0;
+            this.#w.length = 0;
+        } else {
+            this.#m = this.#p[e];
+        }
+        this.#d.delete(i);
+        this.#l--;
+        return e;
+    }
+    has(t, e = {}) {
+        const {updateAgeOnHas: i = this.updateAgeOnHas, status: s} = e;
+        const n = this.#d.get(t);
+        if (n !== undefined) {
+            const t = this.#u[n];
+            if (this.#L(t) && t.__staleWhileFetching === undefined) {
+                return false;
+            }
+            if (!this.#R(n)) {
+                if (i) {
+                    this.#I(n);
+                }
+                if (s) {
+                    s.has = "hit";
+                    this.#B(s, n);
+                }
+                return true;
+            } else if (s) {
+                s.has = "stale";
+                this.#B(s, n);
+            }
+        } else if (s) {
+            s.has = "miss";
+        }
+        return false;
+    }
+    peek(t, e = {}) {
+        const {allowStale: i = this.allowStale} = e;
+        const s = this.#d.get(t);
+        if (s === undefined || !i && this.#R(s)) {
+            return;
+        }
+        const n = this.#u[s];
+        return this.#L(n) ? n.__staleWhileFetching : n;
+    }
+    #A(t, e, i, s) {
+        const n = e === undefined ? undefined : this.#u[e];
+        if (this.#L(n)) {
+            return n;
+        }
+        const r = new w;
+        const {signal: h} = i;
+        h?.addEventListener("abort", () => r.abort(h.reason), {
+            signal: r.signal
+        });
+        const a = {
+            signal: r.signal,
+            options: i,
+            context: s
+        };
+        const o = (s, n = false) => {
+            const {aborted: h} = r.signal;
+            const o = i.ignoreFetchAbort && s !== undefined;
+            if (i.status) {
+                if (h && !n) {
+                    i.status.fetchAborted = true;
+                    i.status.fetchError = r.signal.reason;
+                    if (o) i.status.fetchAbortIgnored = true;
+                } else {
+                    i.status.fetchResolved = true;
+                }
+            }
+            if (h && !o && !n) {
+                return c(r.signal.reason);
+            }
+            const l = f;
+            const d = this.#u[e];
+            if (d === f || o && n && d === undefined) {
+                if (s === undefined) {
+                    if (l.__staleWhileFetching !== undefined) {
+                        this.#u[e] = l.__staleWhileFetching;
+                    } else {
+                        this.#M(t, "fetch");
+                    }
+                } else {
+                    if (i.status) i.status.fetchUpdated = true;
+                    this.set(t, s, a.options);
+                }
+            }
+            return s;
+        };
+        const l = t => {
+            if (i.status) {
+                i.status.fetchRejected = true;
+                i.status.fetchError = t;
+            }
+            return c(t);
+        };
+        const c = s => {
+            const {aborted: n} = r.signal;
+            const h = n && i.allowStaleOnFetchAbort;
+            const a = h || i.allowStaleOnFetchRejection;
+            const o = a || i.noDeleteOnFetchRejection;
+            const l = f;
+            if (this.#u[e] === f) {
+                const i = !o || l.__staleWhileFetching === undefined;
+                if (i) {
+                    this.#M(t, "fetch");
+                } else if (!h) {
+                    this.#u[e] = l.__staleWhileFetching;
+                }
+            }
+            if (a) {
+                if (i.status && l.__staleWhileFetching !== undefined) {
+                    i.status.returnedStale = true;
+                }
+                return l.__staleWhileFetching;
+            } else if (l.__returned === l) {
+                throw s;
+            }
+        };
+        const d = (e, s) => {
+            const h = this.#h?.(t, n, a);
+            if (h && h instanceof Promise) {
+                h.then(t => e(t === undefined ? undefined : t), s);
+            }
+            r.signal.addEventListener("abort", () => {
+                if (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) {
+                    e(undefined);
+                    if (i.allowStaleOnFetchAbort) {
+                        e = t => o(t, true);
+                    }
+                }
+            });
+        };
+        if (i.status) i.status.fetchDispatched = true;
+        const f = new Promise(d).then(o, l);
+        const u = Object.assign(f, {
+            __abortController: r,
+            __staleWhileFetching: n,
+            __returned: undefined
+        });
+        if (e === undefined) {
+            this.set(t, u, {
+                ...a.options,
+                status: undefined
+            });
+            e = this.#d.get(t);
+        } else {
+            this.#u[e] = u;
+        }
+        return u;
+    }
+    #L(t) {
+        if (!this.#x) return false;
+        const e = t;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof w;
+    }
+    async fetch(t, e = {}) {
+        const {allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: o = this.sizeCalculation, noUpdateTTL: l = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: f = this.ignoreFetchAbort, allowStaleOnFetchAbort: u = this.allowStaleOnFetchAbort, context: p, forceRefresh: y = false, status: m, signal: g} = e;
+        if (!this.#x) {
+            if (m) m.fetch = "get";
+            return this.get(t, {
+                allowStale: i,
+                updateAgeOnGet: s,
+                noDeleteOnStaleGet: n,
+                status: m
+            });
+        }
+        const w = {
+            allowStale: i,
+            updateAgeOnGet: s,
+            noDeleteOnStaleGet: n,
+            ttl: r,
+            noDisposeOnSet: h,
+            size: a,
+            sizeCalculation: o,
+            noUpdateTTL: l,
+            noDeleteOnFetchRejection: c,
+            allowStaleOnFetchRejection: d,
+            allowStaleOnFetchAbort: u,
+            ignoreFetchAbort: f,
+            status: m,
+            signal: g
+        };
+        let S = this.#d.get(t);
+        if (S === undefined) {
+            if (m) m.fetch = "miss";
+            const e = this.#A(t, S, w, p);
+            return e.__returned = e;
+        } else {
+            const e = this.#u[S];
+            if (this.#L(e)) {
+                const t = i && e.__staleWhileFetching !== undefined;
+                if (m) {
+                    m.fetch = "inflight";
+                    if (t) m.returnedStale = true;
+                }
+                return t ? e.__staleWhileFetching : e.__returned = e;
+            }
+            const n = this.#R(S);
+            if (!y && !n) {
+                if (m) m.fetch = "hit";
+                this.#C(S);
+                if (s) {
+                    this.#I(S);
+                }
+                if (m) this.#B(m, S);
+                return e;
+            }
+            const r = this.#A(t, S, w, p);
+            const h = r.__staleWhileFetching !== undefined;
+            const a = h && i;
+            if (m) {
+                m.fetch = n ? "stale" : "refresh";
+                if (a && n) m.returnedStale = true;
+            }
+            return a ? r.__staleWhileFetching : r.__returned = r;
+        }
+    }
+    async forceFetch(t, e = {}) {
+        const i = await this.fetch(t, e);
+        if (i === undefined) throw new Error("fetch() returned undefined");
+        return i;
+    }
+    memo(t, e = {}) {
+        const i = this.#a;
+        if (!i) {
+            throw new Error("no memoMethod provided to constructor");
+        }
+        const {context: s, forceRefresh: n, ...r} = e;
+        const h = this.get(t, r);
+        if (!n && h !== undefined) return h;
+        const a = i(t, h, {
+            options: r,
+            context: s
+        });
+        this.set(t, a, r);
+        return a;
+    }
+    get(t, e = {}) {
+        const {allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r} = e;
+        const h = this.#d.get(t);
+        if (h !== undefined) {
+            const e = this.#u[h];
+            const a = this.#L(e);
+            if (r) this.#B(r, h);
+            if (this.#R(h)) {
+                if (r) r.get = "stale";
+                if (!a) {
+                    if (!n) {
+                        this.#M(t, "expire");
+                    }
+                    if (r && i) r.returnedStale = true;
+                    return i ? e : undefined;
+                } else {
+                    if (r && i && e.__staleWhileFetching !== undefined) {
+                        r.returnedStale = true;
+                    }
+                    return i ? e.__staleWhileFetching : undefined;
+                }
+            } else {
+                if (r) r.get = "hit";
+                if (a) {
+                    return e.__staleWhileFetching;
+                }
+                this.#C(h);
+                if (s) {
+                    this.#I(h);
+                }
+                return e;
+            }
+        } else if (r) {
+            r.get = "miss";
+        }
+    }
+    #$(t, e) {
+        this.#y[e] = t;
+        this.#p[t] = e;
+    }
+    #C(t) {
+        if (t !== this.#g) {
+            if (t === this.#m) {
+                this.#m = this.#p[t];
+            } else {
+                this.#$(this.#y[t], this.#p[t]);
+            }
+            this.#$(this.#g, t);
+            this.#g = t;
+        }
+    }
+    delete(t) {
+        return this.#M(t, "delete");
+    }
+    #M(t, e) {
+        let i = false;
+        if (this.#l !== 0) {
+            const s = this.#d.get(t);
+            if (s !== undefined) {
+                i = true;
+                if (this.#l === 1) {
+                    this.#H(e);
+                } else {
+                    this.#N(s);
+                    const i = this.#u[s];
+                    if (this.#L(i)) {
+                        i.__abortController.abort(new Error("deleted"));
+                    } else if (this.#T || this.#b) {
+                        if (this.#T) {
+                            this.#s?.(i, t, e);
+                        }
+                        if (this.#b) {
+                            this.#S?.push([ i, t, e ]);
+                        }
+                    }
+                    this.#d.delete(t);
+                    this.#f[s] = undefined;
+                    this.#u[s] = undefined;
+                    if (s === this.#g) {
+                        this.#g = this.#y[s];
+                    } else if (s === this.#m) {
+                        this.#m = this.#p[s];
+                    } else {
+                        const t = this.#y[s];
+                        this.#p[t] = this.#p[s];
+                        const e = this.#p[s];
+                        this.#y[e] = this.#y[s];
+                    }
+                    this.#l--;
+                    this.#w.push(s);
+                }
+            }
+        }
+        if (this.#b && this.#S?.length) {
+            const t = this.#S;
+            let e;
+            while (e = t?.shift()) {
+                this.#r?.(...e);
+            }
+        }
+        return i;
+    }
+    clear() {
+        return this.#H("delete");
+    }
+    #H(t) {
+        for (const e of this.#O({
+            allowStale: true
+        })) {
+            const i = this.#u[e];
+            if (this.#L(i)) {
+                i.__abortController.abort(new Error("deleted"));
+            } else {
+                const s = this.#f[e];
+                if (this.#T) {
+                    this.#s?.(i, s, t);
+                }
+                if (this.#b) {
+                    this.#S?.push([ i, s, t ]);
+                }
+            }
+        }
+        this.#d.clear();
+        this.#u.fill(undefined);
+        this.#f.fill(undefined);
+        if (this.#F && this.#k) {
+            this.#F.fill(0);
+            this.#k.fill(0);
+        }
+        if (this.#v) {
+            this.#v.fill(0);
+        }
+        this.#m = 0;
+        this.#g = 0;
+        this.#w.length = 0;
+        this.#c = 0;
+        this.#l = 0;
+        if (this.#b && this.#S) {
+            const t = this.#S;
+            let e;
+            while (e = t?.shift()) {
+                this.#r?.(...e);
+            }
+        }
+    }
+}
+
+const T = s.native;
+
+const x = {
+    lstatSync: a,
+    readdir: h,
+    readdirSync: r,
+    readlinkSync: n,
+    realpathSync: T,
+    promises: {
+        lstat: f,
+        readdir: d,
+        readlink: c,
+        realpath: l
+    }
+};
+
+const b = t => !t || t === x || t === o ? x : {
+    ...x,
+    ...t,
+    promises: {
+        ...x.promises,
+        ...t.promises || {}
     }
-    return false;
 };
 
-function e(r) {
-    return r != null && (typeof r === "object" || typeof r === "function" || Array.isArray(r));
+const z = /^\\\\\?\\([a-z]:)\\?$/i;
+
+const L = t => t.replace(/\//g, "\\").replace(z, "$1\\");
+
+const A = /[\\\/]/;
+
+const C = 0;
+
+const P = 1;
+
+const O = 2;
+
+const R = 4;
+
+const E = 6;
+
+const _ = 8;
+
+const D = 10;
+
+const M = 12;
+
+const I = 15;
+
+const B = ~I;
+
+const N = 16;
+
+const W = 32;
+
+const U = 64;
+
+const j = 128;
+
+const G = 256;
+
+const $ = 512;
+
+const H = U | j | $;
+
+const q = 1023;
+
+const V = t => t.isFile() ? _ : t.isDirectory() ? R : t.isSymbolicLink() ? D : t.isCharacterDevice() ? O : t.isBlockDevice() ? E : t.isSocket() ? M : t.isFIFO() ? P : C;
+
+const Z = new LRUCache({
+    max: 2 ** 12
+});
+
+const K = t => {
+    const e = Z.get(t);
+    if (e) return e;
+    const i = t.normalize("NFKD");
+    Z.set(t, i);
+    return i;
+};
+
+const X = new LRUCache({
+    max: 2 ** 12
+});
+
+const Y = t => {
+    const e = X.get(t);
+    if (e) return e;
+    const i = K(t.toLowerCase());
+    X.set(t, i);
+    return i;
+};
+
+class ResolveCache extends LRUCache {
+    constructor() {
+        super({
+            max: 256
+        });
+    }
+}
+
+class ChildrenCache extends LRUCache {
+    constructor(t = 16 * 1024) {
+        super({
+            maxSize: t,
+            sizeCalculation: t => t.length + 1
+        });
+    }
+}
+
+const J = Symbol("PathScurry setAsCwd");
+
+class PathBase {
+    name;
+    root;
+    roots;
+    parent;
+    nocase;
+    isCWD=false;
+    #q;
+    #V;
+    get dev() {
+        return this.#V;
+    }
+    #Z;
+    get mode() {
+        return this.#Z;
+    }
+    #K;
+    get nlink() {
+        return this.#K;
+    }
+    #X;
+    get uid() {
+        return this.#X;
+    }
+    #Y;
+    get gid() {
+        return this.#Y;
+    }
+    #J;
+    get rdev() {
+        return this.#J;
+    }
+    #Q;
+    get blksize() {
+        return this.#Q;
+    }
+    #tt;
+    get ino() {
+        return this.#tt;
+    }
+    #l;
+    get size() {
+        return this.#l;
+    }
+    #et;
+    get blocks() {
+        return this.#et;
+    }
+    #it;
+    get atimeMs() {
+        return this.#it;
+    }
+    #st;
+    get mtimeMs() {
+        return this.#st;
+    }
+    #nt;
+    get ctimeMs() {
+        return this.#nt;
+    }
+    #rt;
+    get birthtimeMs() {
+        return this.#rt;
+    }
+    #ht;
+    get atime() {
+        return this.#ht;
+    }
+    #at;
+    get mtime() {
+        return this.#at;
+    }
+    #ot;
+    get ctime() {
+        return this.#ot;
+    }
+    #lt;
+    get birthtime() {
+        return this.#lt;
+    }
+    #ct;
+    #dt;
+    #ft;
+    #ut;
+    #pt;
+    #yt;
+    #mt;
+    #gt;
+    #wt;
+    #St;
+    get parentPath() {
+        return (this.parent || this).fullpath();
+    }
+    get path() {
+        return this.parentPath;
+    }
+    constructor(t, e = C, i, s, n, r, h) {
+        this.name = t;
+        this.#ct = n ? Y(t) : K(t);
+        this.#mt = e & q;
+        this.nocase = n;
+        this.roots = s;
+        this.root = i || this;
+        this.#gt = r;
+        this.#ft = h.fullpath;
+        this.#pt = h.relative;
+        this.#yt = h.relativePosix;
+        this.parent = h.parent;
+        if (this.parent) {
+            this.#q = this.parent.#q;
+        } else {
+            this.#q = b(h.fs);
+        }
+    }
+    depth() {
+        if (this.#dt !== undefined) return this.#dt;
+        if (!this.parent) return this.#dt = 0;
+        return this.#dt = this.parent.depth() + 1;
+    }
+    childrenCache() {
+        return this.#gt;
+    }
+    resolve(t) {
+        if (!t) {
+            return this;
+        }
+        const e = this.getRootString(t);
+        const i = t.substring(e.length);
+        const s = i.split(this.splitSep);
+        const n = e ? this.getRoot(e).#vt(s) : this.#vt(s);
+        return n;
+    }
+    #vt(t) {
+        let e = this;
+        for (const i of t) {
+            e = e.child(i);
+        }
+        return e;
+    }
+    children() {
+        const t = this.#gt.get(this);
+        if (t) {
+            return t;
+        }
+        const e = Object.assign([], {
+            provisional: 0
+        });
+        this.#gt.set(this, e);
+        this.#mt &= ~N;
+        return e;
+    }
+    child(t, e) {
+        if (t === "" || t === ".") {
+            return this;
+        }
+        if (t === "..") {
+            return this.parent || this;
+        }
+        const i = this.children();
+        const s = this.nocase ? Y(t) : K(t);
+        for (const t of i) {
+            if (t.#ct === s) {
+                return t;
+            }
+        }
+        const n = this.parent ? this.sep : "";
+        const r = this.#ft ? this.#ft + n + t : undefined;
+        const h = this.newChild(t, C, {
+            ...e,
+            parent: this,
+            fullpath: r
+        });
+        if (!this.canReaddir()) {
+            h.#mt |= j;
+        }
+        i.push(h);
+        return h;
+    }
+    relative() {
+        if (this.isCWD) return "";
+        if (this.#pt !== undefined) {
+            return this.#pt;
+        }
+        const t = this.name;
+        const e = this.parent;
+        if (!e) {
+            return this.#pt = this.name;
+        }
+        const i = e.relative();
+        return i + (!i || !e.parent ? "" : this.sep) + t;
+    }
+    relativePosix() {
+        if (this.sep === "/") return this.relative();
+        if (this.isCWD) return "";
+        if (this.#yt !== undefined) return this.#yt;
+        const t = this.name;
+        const e = this.parent;
+        if (!e) {
+            return this.#yt = this.fullpathPosix();
+        }
+        const i = e.relativePosix();
+        return i + (!i || !e.parent ? "" : "/") + t;
+    }
+    fullpath() {
+        if (this.#ft !== undefined) {
+            return this.#ft;
+        }
+        const t = this.name;
+        const e = this.parent;
+        if (!e) {
+            return this.#ft = this.name;
+        }
+        const i = e.fullpath();
+        const s = i + (!e.parent ? "" : this.sep) + t;
+        return this.#ft = s;
+    }
+    fullpathPosix() {
+        if (this.#ut !== undefined) return this.#ut;
+        if (this.sep === "/") return this.#ut = this.fullpath();
+        if (!this.parent) {
+            const t = this.fullpath().replace(/\\/g, "/");
+            if (/^[a-z]:\//i.test(t)) {
+                return this.#ut = `//?/${t}`;
+            } else {
+                return this.#ut = t;
+            }
+        }
+        const t = this.parent;
+        const e = t.fullpathPosix();
+        const i = e + (!e || !t.parent ? "" : "/") + this.name;
+        return this.#ut = i;
+    }
+    isUnknown() {
+        return (this.#mt & I) === C;
+    }
+    isType(t) {
+        return this[`is${t}`]();
+    }
+    getType() {
+        return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+    }
+    isFile() {
+        return (this.#mt & I) === _;
+    }
+    isDirectory() {
+        return (this.#mt & I) === R;
+    }
+    isCharacterDevice() {
+        return (this.#mt & I) === O;
+    }
+    isBlockDevice() {
+        return (this.#mt & I) === E;
+    }
+    isFIFO() {
+        return (this.#mt & I) === P;
+    }
+    isSocket() {
+        return (this.#mt & I) === M;
+    }
+    isSymbolicLink() {
+        return (this.#mt & D) === D;
+    }
+    lstatCached() {
+        return this.#mt & W ? this : undefined;
+    }
+    readlinkCached() {
+        return this.#wt;
+    }
+    realpathCached() {
+        return this.#St;
+    }
+    readdirCached() {
+        const t = this.children();
+        return t.slice(0, t.provisional);
+    }
+    canReadlink() {
+        if (this.#wt) return true;
+        if (!this.parent) return false;
+        const t = this.#mt & I;
+        return !(t !== C && t !== D || this.#mt & G || this.#mt & j);
+    }
+    calledReaddir() {
+        return !!(this.#mt & N);
+    }
+    isENOENT() {
+        return !!(this.#mt & j);
+    }
+    isNamed(t) {
+        return !this.nocase ? this.#ct === K(t) : this.#ct === Y(t);
+    }
+    async readlink() {
+        const t = this.#wt;
+        if (t) {
+            return t;
+        }
+        if (!this.canReadlink()) {
+            return undefined;
+        }
+        if (!this.parent) {
+            return undefined;
+        }
+        try {
+            const t = await this.#q.promises.readlink(this.fullpath());
+            const e = (await this.parent.realpath())?.resolve(t);
+            if (e) {
+                return this.#wt = e;
+            }
+        } catch (t) {
+            this.#kt(t.code);
+            return undefined;
+        }
+    }
+    readlinkSync() {
+        const t = this.#wt;
+        if (t) {
+            return t;
+        }
+        if (!this.canReadlink()) {
+            return undefined;
+        }
+        if (!this.parent) {
+            return undefined;
+        }
+        try {
+            const t = this.#q.readlinkSync(this.fullpath());
+            const e = this.parent.realpathSync()?.resolve(t);
+            if (e) {
+                return this.#wt = e;
+            }
+        } catch (t) {
+            this.#kt(t.code);
+            return undefined;
+        }
+    }
+    #Ft(t) {
+        this.#mt |= N;
+        for (let e = t.provisional; e < t.length; e++) {
+            const i = t[e];
+            if (i) i.#Tt();
+        }
+    }
+    #Tt() {
+        if (this.#mt & j) return;
+        this.#mt = (this.#mt | j) & B;
+        this.#xt();
+    }
+    #xt() {
+        const t = this.children();
+        t.provisional = 0;
+        for (const e of t) {
+            e.#Tt();
+        }
+    }
+    #bt() {
+        this.#mt |= $;
+        this.#zt();
+    }
+    #zt() {
+        if (this.#mt & U) return;
+        let t = this.#mt;
+        if ((t & I) === R) t &= B;
+        this.#mt = t | U;
+        this.#xt();
+    }
+    #Lt(t = "") {
+        if (t === "ENOTDIR" || t === "EPERM") {
+            this.#zt();
+        } else if (t === "ENOENT") {
+            this.#Tt();
+        } else {
+            this.children().provisional = 0;
+        }
+    }
+    #At(t = "") {
+        if (t === "ENOTDIR") {
+            const t = this.parent;
+            t.#zt();
+        } else if (t === "ENOENT") {
+            this.#Tt();
+        }
+    }
+    #kt(t = "") {
+        let e = this.#mt;
+        e |= G;
+        if (t === "ENOENT") e |= j;
+        if (t === "EINVAL" || t === "UNKNOWN") {
+            e &= B;
+        }
+        this.#mt = e;
+        if (t === "ENOTDIR" && this.parent) {
+            this.parent.#zt();
+        }
+    }
+    #Ct(t, e) {
+        return this.#Pt(t, e) || this.#Ot(t, e);
+    }
+    #Ot(t, e) {
+        const i = V(t);
+        const s = this.newChild(t.name, i, {
+            parent: this
+        });
+        const n = s.#mt & I;
+        if (n !== R && n !== D && n !== C) {
+            s.#mt |= U;
+        }
+        e.unshift(s);
+        e.provisional++;
+        return s;
+    }
+    #Pt(t, e) {
+        for (let i = e.provisional; i < e.length; i++) {
+            const s = e[i];
+            const n = this.nocase ? Y(t.name) : K(t.name);
+            if (n !== s.#ct) {
+                continue;
+            }
+            return this.#Rt(t, s, i, e);
+        }
+    }
+    #Rt(t, e, i, s) {
+        const n = e.name;
+        e.#mt = e.#mt & B | V(t);
+        if (n !== t.name) e.name = t.name;
+        if (i !== s.provisional) {
+            if (i === s.length - 1) s.pop(); else s.splice(i, 1);
+            s.unshift(e);
+        }
+        s.provisional++;
+        return e;
+    }
+    async lstat() {
+        if ((this.#mt & j) === 0) {
+            try {
+                this.#Et(await this.#q.promises.lstat(this.fullpath()));
+                return this;
+            } catch (t) {
+                this.#At(t.code);
+            }
+        }
+    }
+    lstatSync() {
+        if ((this.#mt & j) === 0) {
+            try {
+                this.#Et(this.#q.lstatSync(this.fullpath()));
+                return this;
+            } catch (t) {
+                this.#At(t.code);
+            }
+        }
+    }
+    #Et(t) {
+        const {atime: e, atimeMs: i, birthtime: s, birthtimeMs: n, blksize: r, blocks: h, ctime: a, ctimeMs: o, dev: l, gid: c, ino: d, mode: f, mtime: u, mtimeMs: p, nlink: y, rdev: m, size: g, uid: w} = t;
+        this.#ht = e;
+        this.#it = i;
+        this.#lt = s;
+        this.#rt = n;
+        this.#Q = r;
+        this.#et = h;
+        this.#ot = a;
+        this.#nt = o;
+        this.#V = l;
+        this.#Y = c;
+        this.#tt = d;
+        this.#Z = f;
+        this.#at = u;
+        this.#st = p;
+        this.#K = y;
+        this.#J = m;
+        this.#l = g;
+        this.#X = w;
+        const S = V(t);
+        this.#mt = this.#mt & B | S | W;
+        if (S !== C && S !== R && S !== D) {
+            this.#mt |= U;
+        }
+    }
+    #_t=[];
+    #Dt=false;
+    #Mt(t) {
+        this.#Dt = false;
+        const e = this.#_t.slice();
+        this.#_t.length = 0;
+        e.forEach(e => e(null, t));
+    }
+    readdirCB(t, e = false) {
+        if (!this.canReaddir()) {
+            if (e) t(null, []); else queueMicrotask(() => t(null, []));
+            return;
+        }
+        const i = this.children();
+        if (this.calledReaddir()) {
+            const s = i.slice(0, i.provisional);
+            if (e) t(null, s); else queueMicrotask(() => t(null, s));
+            return;
+        }
+        this.#_t.push(t);
+        if (this.#Dt) {
+            return;
+        }
+        this.#Dt = true;
+        const s = this.fullpath();
+        this.#q.readdir(s, {
+            withFileTypes: true
+        }, (t, e) => {
+            if (t) {
+                this.#Lt(t.code);
+                i.provisional = 0;
+            } else {
+                for (const t of e) {
+                    this.#Ct(t, i);
+                }
+                this.#Ft(i);
+            }
+            this.#Mt(i.slice(0, i.provisional));
+            return;
+        });
+    }
+    #It;
+    async readdir() {
+        if (!this.canReaddir()) {
+            return [];
+        }
+        const t = this.children();
+        if (this.calledReaddir()) {
+            return t.slice(0, t.provisional);
+        }
+        const e = this.fullpath();
+        if (this.#It) {
+            await this.#It;
+        } else {
+            let i = () => {};
+            this.#It = new Promise(t => i = t);
+            try {
+                for (const i of await this.#q.promises.readdir(e, {
+                    withFileTypes: true
+                })) {
+                    this.#Ct(i, t);
+                }
+                this.#Ft(t);
+            } catch (e) {
+                this.#Lt(e.code);
+                t.provisional = 0;
+            }
+            this.#It = undefined;
+            i();
+        }
+        return t.slice(0, t.provisional);
+    }
+    readdirSync() {
+        if (!this.canReaddir()) {
+            return [];
+        }
+        const t = this.children();
+        if (this.calledReaddir()) {
+            return t.slice(0, t.provisional);
+        }
+        const e = this.fullpath();
+        try {
+            for (const i of this.#q.readdirSync(e, {
+                withFileTypes: true
+            })) {
+                this.#Ct(i, t);
+            }
+            this.#Ft(t);
+        } catch (e) {
+            this.#Lt(e.code);
+            t.provisional = 0;
+        }
+        return t.slice(0, t.provisional);
+    }
+    canReaddir() {
+        if (this.#mt & H) return false;
+        const t = I & this.#mt;
+        if (!(t === C || t === R || t === D)) {
+            return false;
+        }
+        return true;
+    }
+    shouldWalk(t, e) {
+        return (this.#mt & R) === R && !(this.#mt & H) && !t.has(this) && (!e || e(this));
+    }
+    async realpath() {
+        if (this.#St) return this.#St;
+        if (($ | G | j) & this.#mt) return undefined;
+        try {
+            const t = await this.#q.promises.realpath(this.fullpath());
+            return this.#St = this.resolve(t);
+        } catch (t) {
+            this.#bt();
+        }
+    }
+    realpathSync() {
+        if (this.#St) return this.#St;
+        if (($ | G | j) & this.#mt) return undefined;
+        try {
+            const t = this.#q.realpathSync(this.fullpath());
+            return this.#St = this.resolve(t);
+        } catch (t) {
+            this.#bt();
+        }
+    }
+    [J](t) {
+        if (t === this) return;
+        t.isCWD = false;
+        this.isCWD = true;
+        const e = new Set([]);
+        let i = [];
+        let s = this;
+        while (s && s.parent) {
+            e.add(s);
+            s.#pt = i.join(this.sep);
+            s.#yt = i.join("/");
+            s = s.parent;
+            i.push("..");
+        }
+        s = t;
+        while (s && s.parent && !e.has(s)) {
+            s.#pt = undefined;
+            s.#yt = undefined;
+            s = s.parent;
+        }
+    }
+}
+
+class PathWin32 extends PathBase {
+    sep="\\";
+    splitSep=A;
+    constructor(t, e = C, i, s, n, r, h) {
+        super(t, e, i, s, n, r, h);
+    }
+    newChild(t, e = C, i = {}) {
+        return new PathWin32(t, e, this.root, this.roots, this.nocase, this.childrenCache(), i);
+    }
+    getRootString(e) {
+        return t.parse(e).root;
+    }
+    getRoot(t) {
+        t = L(t.toUpperCase());
+        if (t === this.root.name) {
+            return this.root;
+        }
+        for (const [e, i] of Object.entries(this.roots)) {
+            if (this.sameRoot(t, e)) {
+                return this.roots[t] = i;
+            }
+        }
+        return this.roots[t] = new PathScurryWin32(t, this).root;
+    }
+    sameRoot(t, e = this.root.name) {
+        t = t.toUpperCase().replace(/\//g, "\\").replace(z, "$1\\");
+        return t === e;
+    }
+}
+
+class PathPosix extends PathBase {
+    splitSep="/";
+    sep="/";
+    constructor(t, e = C, i, s, n, r, h) {
+        super(t, e, i, s, n, r, h);
+    }
+    getRootString(t) {
+        return t.startsWith("/") ? "/" : "";
+    }
+    getRoot(t) {
+        return this.root;
+    }
+    newChild(t, e = C, i = {}) {
+        return new PathPosix(t, e, this.root, this.roots, this.nocase, this.childrenCache(), i);
+    }
 }
 
-export { o as h };
+class PathScurryBase {
+    root;
+    rootPath;
+    roots;
+    cwd;
+    #Bt;
+    #Nt;
+    #gt;
+    nocase;
+    #q;
+    constructor(t = process.cwd(), e, s, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: h = x} = {}) {
+        this.#q = b(h);
+        if (t instanceof URL || t.startsWith("file://")) {
+            t = i(t);
+        }
+        const a = e.resolve(t);
+        this.roots = Object.create(null);
+        this.rootPath = this.parseRootPath(a);
+        this.#Bt = new ResolveCache;
+        this.#Nt = new ResolveCache;
+        this.#gt = new ChildrenCache(r);
+        const o = a.substring(this.rootPath.length).split(s);
+        if (o.length === 1 && !o[0]) {
+            o.pop();
+        }
+        if (n === undefined) {
+            throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+        }
+        this.nocase = n;
+        this.root = this.newRoot(this.#q);
+        this.roots[this.rootPath] = this.root;
+        let l = this.root;
+        let c = o.length - 1;
+        const d = e.sep;
+        let f = this.rootPath;
+        let u = false;
+        for (const t of o) {
+            const e = c--;
+            l = l.child(t, {
+                relative: new Array(e).fill("..").join(d),
+                relativePosix: new Array(e).fill("..").join("/"),
+                fullpath: f += (u ? "" : d) + t
+            });
+            u = true;
+        }
+        this.cwd = l;
+    }
+    depth(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.depth();
+    }
+    childrenCache() {
+        return this.#gt;
+    }
+    resolve(...t) {
+        let e = "";
+        for (let i = t.length - 1; i >= 0; i--) {
+            const s = t[i];
+            if (!s || s === ".") continue;
+            e = e ? `${s}/${e}` : s;
+            if (this.isAbsolute(s)) {
+                break;
+            }
+        }
+        const i = this.#Bt.get(e);
+        if (i !== undefined) {
+            return i;
+        }
+        const s = this.cwd.resolve(e).fullpath();
+        this.#Bt.set(e, s);
+        return s;
+    }
+    resolvePosix(...t) {
+        let e = "";
+        for (let i = t.length - 1; i >= 0; i--) {
+            const s = t[i];
+            if (!s || s === ".") continue;
+            e = e ? `${s}/${e}` : s;
+            if (this.isAbsolute(s)) {
+                break;
+            }
+        }
+        const i = this.#Nt.get(e);
+        if (i !== undefined) {
+            return i;
+        }
+        const s = this.cwd.resolve(e).fullpathPosix();
+        this.#Nt.set(e, s);
+        return s;
+    }
+    relative(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.relative();
+    }
+    relativePosix(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.relativePosix();
+    }
+    basename(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.name;
+    }
+    dirname(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return (t.parent || t).fullpath();
+    }
+    async readdir(t = this.cwd, e = {
+        withFileTypes: true
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i} = e;
+        if (!t.canReaddir()) {
+            return [];
+        } else {
+            const e = await t.readdir();
+            return i ? e : e.map(t => t.name);
+        }
+    }
+    readdirSync(t = this.cwd, e = {
+        withFileTypes: true
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true} = e;
+        if (!t.canReaddir()) {
+            return [];
+        } else if (i) {
+            return t.readdirSync();
+        } else {
+            return t.readdirSync().map(t => t.name);
+        }
+    }
+    async lstat(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.lstat();
+    }
+    lstatSync(t = this.cwd) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        }
+        return t.lstatSync();
+    }
+    async readlink(t = this.cwd, {withFileTypes: e} = {
+        withFileTypes: false
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t.withFileTypes;
+            t = this.cwd;
+        }
+        const i = await t.readlink();
+        return e ? i : i?.fullpath();
+    }
+    readlinkSync(t = this.cwd, {withFileTypes: e} = {
+        withFileTypes: false
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t.withFileTypes;
+            t = this.cwd;
+        }
+        const i = t.readlinkSync();
+        return e ? i : i?.fullpath();
+    }
+    async realpath(t = this.cwd, {withFileTypes: e} = {
+        withFileTypes: false
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t.withFileTypes;
+            t = this.cwd;
+        }
+        const i = await t.realpath();
+        return e ? i : i?.fullpath();
+    }
+    realpathSync(t = this.cwd, {withFileTypes: e} = {
+        withFileTypes: false
+    }) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t.withFileTypes;
+            t = this.cwd;
+        }
+        const i = t.realpathSync();
+        return e ? i : i?.fullpath();
+    }
+    async walk(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true, follow: s = false, filter: n, walkFilter: r} = e;
+        const h = [];
+        if (!n || n(t)) {
+            h.push(i ? t : t.fullpath());
+        }
+        const a = new Set;
+        const o = (t, e) => {
+            a.add(t);
+            t.readdirCB((t, l) => {
+                if (t) {
+                    return e(t);
+                }
+                let c = l.length;
+                if (!c) return e();
+                const d = () => {
+                    if (--c === 0) {
+                        e();
+                    }
+                };
+                for (const t of l) {
+                    if (!n || n(t)) {
+                        h.push(i ? t : t.fullpath());
+                    }
+                    if (s && t.isSymbolicLink()) {
+                        t.realpath().then(t => t?.isUnknown() ? t.lstat() : t).then(t => t?.shouldWalk(a, r) ? o(t, d) : d());
+                    } else {
+                        if (t.shouldWalk(a, r)) {
+                            o(t, d);
+                        } else {
+                            d();
+                        }
+                    }
+                }
+            }, true);
+        };
+        const l = t;
+        return new Promise((t, e) => {
+            o(l, i => {
+                if (i) return e(i);
+                t(h);
+            });
+        });
+    }
+    walkSync(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true, follow: s = false, filter: n, walkFilter: r} = e;
+        const h = [];
+        if (!n || n(t)) {
+            h.push(i ? t : t.fullpath());
+        }
+        const a = new Set([ t ]);
+        for (const t of a) {
+            const e = t.readdirSync();
+            for (const t of e) {
+                if (!n || n(t)) {
+                    h.push(i ? t : t.fullpath());
+                }
+                let e = t;
+                if (t.isSymbolicLink()) {
+                    if (!(s && (e = t.realpathSync()))) continue;
+                    if (e.isUnknown()) e.lstatSync();
+                }
+                if (e.shouldWalk(a, r)) {
+                    a.add(e);
+                }
+            }
+        }
+        return h;
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+    iterate(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        return this.stream(t, e)[Symbol.asyncIterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    * iterateSync(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true, follow: s = false, filter: n, walkFilter: r} = e;
+        if (!n || n(t)) {
+            yield i ? t : t.fullpath();
+        }
+        const h = new Set([ t ]);
+        for (const t of h) {
+            const e = t.readdirSync();
+            for (const t of e) {
+                if (!n || n(t)) {
+                    yield i ? t : t.fullpath();
+                }
+                let e = t;
+                if (t.isSymbolicLink()) {
+                    if (!(s && (e = t.realpathSync()))) continue;
+                    if (e.isUnknown()) e.lstatSync();
+                }
+                if (e.shouldWalk(h, r)) {
+                    h.add(e);
+                }
+            }
+        }
+    }
+    stream(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true, follow: s = false, filter: n, walkFilter: r} = e;
+        const h = new u({
+            objectMode: true
+        });
+        if (!n || n(t)) {
+            h.write(i ? t : t.fullpath());
+        }
+        const a = new Set;
+        const o = [ t ];
+        let l = 0;
+        const c = () => {
+            let t = false;
+            while (!t) {
+                const e = o.shift();
+                if (!e) {
+                    if (l === 0) h.end();
+                    return;
+                }
+                l++;
+                a.add(e);
+                const d = (e, u, p = false) => {
+                    if (e) return h.emit("error", e);
+                    if (s && !p) {
+                        const t = [];
+                        for (const e of u) {
+                            if (e.isSymbolicLink()) {
+                                t.push(e.realpath().then(t => t?.isUnknown() ? t.lstat() : t));
+                            }
+                        }
+                        if (t.length) {
+                            Promise.all(t).then(() => d(null, u, true));
+                            return;
+                        }
+                    }
+                    for (const e of u) {
+                        if (e && (!n || n(e))) {
+                            if (!h.write(i ? e : e.fullpath())) {
+                                t = true;
+                            }
+                        }
+                    }
+                    l--;
+                    for (const t of u) {
+                        const e = t.realpathCached() || t;
+                        if (e.shouldWalk(a, r)) {
+                            o.push(e);
+                        }
+                    }
+                    if (t && !h.flowing) {
+                        h.once("drain", c);
+                    } else if (!f) {
+                        c();
+                    }
+                };
+                let f = true;
+                e.readdirCB(d, true);
+                f = false;
+            }
+        };
+        c();
+        return h;
+    }
+    streamSync(t = this.cwd, e = {}) {
+        if (typeof t === "string") {
+            t = this.cwd.resolve(t);
+        } else if (!(t instanceof PathBase)) {
+            e = t;
+            t = this.cwd;
+        }
+        const {withFileTypes: i = true, follow: s = false, filter: n, walkFilter: r} = e;
+        const h = new u({
+            objectMode: true
+        });
+        const a = new Set;
+        if (!n || n(t)) {
+            h.write(i ? t : t.fullpath());
+        }
+        const o = [ t ];
+        let l = 0;
+        const c = () => {
+            let t = false;
+            while (!t) {
+                const e = o.shift();
+                if (!e) {
+                    if (l === 0) h.end();
+                    return;
+                }
+                l++;
+                a.add(e);
+                const c = e.readdirSync();
+                for (const e of c) {
+                    if (!n || n(e)) {
+                        if (!h.write(i ? e : e.fullpath())) {
+                            t = true;
+                        }
+                    }
+                }
+                l--;
+                for (const t of c) {
+                    let e = t;
+                    if (t.isSymbolicLink()) {
+                        if (!(s && (e = t.realpathSync()))) continue;
+                        if (e.isUnknown()) e.lstatSync();
+                    }
+                    if (e.shouldWalk(a, r)) {
+                        o.push(e);
+                    }
+                }
+            }
+            if (t && !h.flowing) h.once("drain", c);
+        };
+        c();
+        return h;
+    }
+    chdir(t = this.cwd) {
+        const e = this.cwd;
+        this.cwd = typeof t === "string" ? this.cwd.resolve(t) : t;
+        this.cwd[J](e);
+    }
+}
+
+class PathScurryWin32 extends PathScurryBase {
+    sep="\\";
+    constructor(e = process.cwd(), i = {}) {
+        const {nocase: s = true} = i;
+        super(e, t, "\\", {
+            ...i,
+            nocase: s
+        });
+        this.nocase = s;
+        for (let t = this.cwd; t; t = t.parent) {
+            t.nocase = this.nocase;
+        }
+    }
+    parseRootPath(e) {
+        return t.parse(e).root.toUpperCase();
+    }
+    newRoot(t) {
+        return new PathWin32(this.rootPath, R, undefined, this.roots, this.nocase, this.childrenCache(), {
+            fs: t
+        });
+    }
+    isAbsolute(t) {
+        return t.startsWith("/") || t.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(t);
+    }
+}
+
+class PathScurryPosix extends PathScurryBase {
+    sep="/";
+    constructor(t = process.cwd(), i = {}) {
+        const {nocase: s = false} = i;
+        super(t, e, "/", {
+            ...i,
+            nocase: s
+        });
+        this.nocase = s;
+    }
+    parseRootPath(t) {
+        return "/";
+    }
+    newRoot(t) {
+        return new PathPosix(this.rootPath, R, undefined, this.roots, this.nocase, this.childrenCache(), {
+            fs: t
+        });
+    }
+    isAbsolute(t) {
+        return t.startsWith("/");
+    }
+}
+
+class PathScurryDarwin extends PathScurryPosix {
+    constructor(t = process.cwd(), e = {}) {
+        const {nocase: i = true} = e;
+        super(t, {
+            ...e,
+            nocase: i
+        });
+    }
+}
+
+process.platform === "win32" ? PathWin32 : PathPosix;
+
+const Q = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+
+export { PathScurryWin32 as P, PathScurryDarwin as a, PathScurryPosix as b, Q as c };