lakutata 2.0.80 → 2.0.82

package/src/lib/helpers/Glob.mjs

@@ -1,35 +1,263 @@
-import { e as t } from "../../../vendor/Package.63.mjs";
+import { fileURLToPath as t } from "node:url";
 
-import { fileURLToPath as e } from "node:url";
+import { win32 as e, posix as s } from "node:path";
 
-import { win32 as s, posix as i } from "node:path";
+import { realpathSync as i, readlinkSync as n, readdirSync as r, readdir as o, lstatSync as h } from "fs";
 
-import { realpathSync as n, readlinkSync as r, readdirSync as o, readdir as h, lstatSync as a } from "fs";
+import * as a from "node:fs";
 
-import * as l from "node:fs";
+import { realpath as l, readlink as c, readdir as f, lstat as u } from "node:fs/promises";
 
-import { realpath as c, readlink as f, readdir as u, lstat as d } from "node:fs/promises";
+import { EventEmitter as d } from "node:events";
 
-import { EventEmitter as p } from "node:events";
+import p from "node:stream";
 
-import g from "node:stream";
+import { StringDecoder as g } from "node:string_decoder";
 
-import { StringDecoder as m } from "node:string_decoder";
+const balanced = (t, e, s) => {
+    const i = t instanceof RegExp ? maybeMatch(t, s) : t;
+    const n = e instanceof RegExp ? maybeMatch(e, s) : e;
+    const r = i !== null && n != null && range(i, n, s);
+    return r && {
+        start: r[0],
+        end: r[1],
+        pre: s.slice(0, r[0]),
+        body: s.slice(r[0] + i.length, r[1]),
+        post: s.slice(r[1] + n.length)
+    };
+};
+
+const maybeMatch = (t, e) => {
+    const s = e.match(t);
+    return s ? s[0] : null;
+};
+
+const range = (t, e, s) => {
+    let i, n, r, o = undefined, h;
+    let a = s.indexOf(t);
+    let l = s.indexOf(e, a + 1);
+    let c = a;
+    if (a >= 0 && l > 0) {
+        if (t === e) {
+            return [ a, l ];
+        }
+        i = [];
+        r = s.length;
+        while (c >= 0 && !h) {
+            if (c === a) {
+                i.push(c);
+                a = s.indexOf(t, c + 1);
+            } else if (i.length === 1) {
+                const t = i.pop();
+                if (t !== undefined) h = [ t, l ];
+            } else {
+                n = i.pop();
+                if (n !== undefined && n < r) {
+                    r = n;
+                    o = l;
+                }
+                l = s.indexOf(e, c + 1);
+            }
+            c = a < l && a >= 0 ? a : l;
+        }
+        if (i.length && o !== undefined) {
+            h = [ r, o ];
+        }
+    }
+    return h;
+};
+
+const y = "\0SLASH" + Math.random() + "\0";
+
+const w = "\0OPEN" + Math.random() + "\0";
+
+const b = "\0CLOSE" + Math.random() + "\0";
+
+const S = "\0COMMA" + Math.random() + "\0";
+
+const k = "\0PERIOD" + Math.random() + "\0";
+
+const x = new RegExp(y, "g");
+
+const v = new RegExp(w, "g");
+
+const E = new RegExp(b, "g");
+
+const C = new RegExp(S, "g");
+
+const T = new RegExp(k, "g");
+
+const A = /\\\\/g;
+
+const L = /\\{/g;
+
+const M = /\\}/g;
+
+const P = /\\,/g;
+
+const F = /\\./g;
+
+function numeric(t) {
+    return !isNaN(t) ? parseInt(t, 10) : t.charCodeAt(0);
+}
+
+function escapeBraces(t) {
+    return t.replace(A, y).replace(L, w).replace(M, b).replace(P, S).replace(F, k);
+}
+
+function unescapeBraces(t) {
+    return t.replace(x, "\\").replace(v, "{").replace(E, "}").replace(C, ",").replace(T, ".");
+}
+
+function parseCommaParts(t) {
+    if (!t) {
+        return [ "" ];
+    }
+    const e = [];
+    const s = balanced("{", "}", t);
+    if (!s) {
+        return t.split(",");
+    }
+    const {pre: i, body: n, post: r} = s;
+    const o = i.split(",");
+    o[o.length - 1] += "{" + n + "}";
+    const h = parseCommaParts(r);
+    if (r.length) {
+        o[o.length - 1] += h.shift();
+        o.push.apply(o, h);
+    }
+    e.push.apply(e, o);
+    return e;
+}
+
+function expand(t) {
+    if (!t) {
+        return [];
+    }
+    if (t.slice(0, 2) === "{}") {
+        t = "\\{\\}" + t.slice(2);
+    }
+    return expand_(escapeBraces(t), true).map(unescapeBraces);
+}
+
+function embrace(t) {
+    return "{" + t + "}";
+}
+
+function isPadded(t) {
+    return /^-?0\d/.test(t);
+}
 
-import "../../../vendor/Package.5.mjs";
+function lte(t, e) {
+    return t <= e;
+}
 
-const w = 1024 * 64;
+function gte(t, e) {
+    return t >= e;
+}
 
-const y = t => {
+function expand_(t, e) {
+    const s = [];
+    const i = balanced("{", "}", t);
+    if (!i) return [ t ];
+    const n = i.pre;
+    const r = i.post.length ? expand_(i.post, false) : [ "" ];
+    if (/\$$/.test(i.pre)) {
+        for (let t = 0; t < r.length; t++) {
+            const e = n + "{" + i.body + "}" + r[t];
+            s.push(e);
+        }
+    } else {
+        const o = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body);
+        const h = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body);
+        const a = o || h;
+        const l = i.body.indexOf(",") >= 0;
+        if (!a && !l) {
+            if (i.post.match(/,(?!,).*\}/)) {
+                t = i.pre + "{" + i.body + b + i.post;
+                return expand_(t);
+            }
+            return [ t ];
+        }
+        let c;
+        if (a) {
+            c = i.body.split(/\.\./);
+        } else {
+            c = parseCommaParts(i.body);
+            if (c.length === 1 && c[0] !== undefined) {
+                c = expand_(c[0], false).map(embrace);
+                if (c.length === 1) {
+                    return r.map((t => i.pre + c[0] + t));
+                }
+            }
+        }
+        let f;
+        if (a && c[0] !== undefined && c[1] !== undefined) {
+            const t = numeric(c[0]);
+            const e = numeric(c[1]);
+            const s = Math.max(c[0].length, c[1].length);
+            let i = c.length === 3 && c[2] !== undefined ? Math.abs(numeric(c[2])) : 1;
+            let n = lte;
+            const r = e < t;
+            if (r) {
+                i *= -1;
+                n = gte;
+            }
+            const o = c.some(isPadded);
+            f = [];
+            for (let r = t; n(r, e); r += i) {
+                let t;
+                if (h) {
+                    t = String.fromCharCode(r);
+                    if (t === "\\") {
+                        t = "";
+                    }
+                } else {
+                    t = String(r);
+                    if (o) {
+                        const e = s - t.length;
+                        if (e > 0) {
+                            const s = new Array(e + 1).join("0");
+                            if (r < 0) {
+                                t = "-" + s + t.slice(1);
+                            } else {
+                                t = s + t;
+                            }
+                        }
+                    }
+                }
+                f.push(t);
+            }
+        } else {
+            f = [];
+            for (let t = 0; t < c.length; t++) {
+                f.push.apply(f, expand_(c[t], false));
+            }
+        }
+        for (let t = 0; t < f.length; t++) {
+            for (let i = 0; i < r.length; i++) {
+                const o = n + f[t] + r[i];
+                if (!e || a || o) {
+                    s.push(o);
+                }
+            }
+        }
+    }
+    return s;
+}
+
+const R = 1024 * 64;
+
+const assertValidPattern = t => {
     if (typeof t !== "string") {
         throw new TypeError("invalid pattern");
     }
-    if (t.length > w) {
+    if (t.length > R) {
         throw new TypeError("pattern is too long");
     }
 };
 
-const b = {
+const O = {
     "[:alnum:]": [ "\\p{L}\\p{Nl}\\p{Nd}", true ],
     "[:alpha:]": [ "\\p{L}\\p{Nl}", true ],
     "[:ascii:]": [ "\\x" + "00-\\x" + "7f", false ],
@@ -46,13 +274,13 @@ const b = {
     "[:xdigit:]": [ "A-Fa-f0-9", false ]
 };
 
-const S = t => t.replace(/[[\]\\-]/g, "\\$&");
+const braceEscape = t => t.replace(/[[\]\\-]/g, "\\$&");
 
-const k = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regexpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const v = t => t.join("");
+const rangesToString = t => t.join("");
 
-const x = (t, e) => {
+const parseClass = (t, e) => {
     const s = e;
     if (t.charAt(s) !== "[") {
         throw new Error("not in a brace expression");
@@ -86,7 +314,7 @@ const x = (t, e) => {
             }
         }
         if (e === "[" && !a) {
-            for (const [e, [o, a, l]] of Object.entries(b)) {
+            for (const [e, [o, a, l]] of Object.entries(O)) {
                 if (t.startsWith(e, r)) {
                     if (f) {
                         return [ "$.", false, t.length - s, true ];
@@ -101,16 +329,16 @@ const x = (t, e) => {
         a = false;
         if (f) {
             if (e > f) {
-                i.push(S(f) + "-" + S(e));
+                i.push(braceEscape(f) + "-" + braceEscape(e));
             } else if (e === f) {
-                i.push(S(e));
+                i.push(braceEscape(e));
             }
             f = "";
             r++;
             continue;
         }
         if (t.startsWith("-]", r + 1)) {
-            i.push(S(e + "-"));
+            i.push(braceEscape(e + "-"));
             r += 2;
             continue;
         }
@@ -119,7 +347,7 @@ const x = (t, e) => {
             r += 2;
             continue;
         }
-        i.push(S(e));
+        i.push(braceEscape(e));
         r++;
     }
     if (c < r) {
@@ -130,37 +358,42 @@ const x = (t, e) => {
     }
     if (n.length === 0 && i.length === 1 && /^\\?.$/.test(i[0]) && !l) {
         const t = i[0].length === 2 ? i[0].slice(-1) : i[0];
-        return [ k(t), false, c - s, false ];
+        return [ regexpEscape(t), false, c - s, false ];
     }
-    const u = "[" + (l ? "^" : "") + v(i) + "]";
-    const d = "[" + (l ? "" : "^") + v(n) + "]";
+    const u = "[" + (l ? "^" : "") + rangesToString(i) + "]";
+    const d = "[" + (l ? "" : "^") + rangesToString(n) + "]";
     const p = i.length && n.length ? "(" + u + "|" + d + ")" : i.length ? u : d;
     return [ p, h, c - s, true ];
 };
 
-const E = (t, {windowsPathsNoEscape: e = false} = {}) => e ? t.replace(/\[([^\/\\])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+const unescape = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = true} = {}) => {
+    if (s) {
+        return e ? t.replace(/\[([^\/\\])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+    }
+    return e ? t.replace(/\[([^\/\\{}])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+};
 
-const C = new Set([ "!", "?", "+", "*", "@" ]);
+const z = new Set([ "!", "?", "+", "*", "@" ]);
 
-const T = t => C.has(t);
+const isExtglobType = t => z.has(t);
 
-const L = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const D = "(?!(?:^|/)\\.\\.?(?:$|/))";
 
-const A = "(?!\\.)";
+const B = "(?!\\.)";
 
-const M = new Set([ "[", "." ]);
+const N = new Set([ "[", "." ]);
 
-const P = new Set([ "..", "." ]);
+const I = new Set([ "..", "." ]);
 
-const F = new Set("().*{}+?[]^$\\!");
+const W = new Set("().*{}+?[]^$\\!");
 
-const R = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regExpEscape$1 = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const z = "[^/]";
+const _ = "[^/]";
 
-const O = z + "*?";
+const j = _ + "*?";
 
-const D = z + "+?";
+const $ = _ + "+?";
 
 class AST {
     type;
@@ -306,7 +539,7 @@ class AST {
                     l += s;
                     continue;
                 }
-                if (!i.noext && T(s) && t.charAt(a) === "(") {
+                if (!i.noext && isExtglobType(s) && t.charAt(a) === "(") {
                     e.push(l);
                     l = "";
                     const n = new AST(s, e);
@@ -347,7 +580,7 @@ class AST {
                 f += s;
                 continue;
             }
-            if (T(s) && t.charAt(a) === "(") {
+            if (isExtglobType(s) && t.charAt(a) === "(") {
                 l.push(f);
                 f = "";
                 const e = new AST(s, l);
@@ -404,7 +637,7 @@ class AST {
         const e = t ?? !!this.#a.dot;
         if (this.#t === this) this.#f();
         if (!this.type) {
-            const s = this.isStart() && this.isEnd();
+            const s = this.isStart() && this.isEnd() && !this.#i.some((t => typeof t !== "string"));
             const i = this.#i.map((e => {
                 const [i, n, r, o] = typeof e === "string" ? AST.#d(e, this.#e, s) : e.toRegExpSource(t);
                 this.#e = this.#e || r;
@@ -414,12 +647,12 @@ class AST {
             let n = "";
             if (this.isStart()) {
                 if (typeof this.#i[0] === "string") {
-                    const s = this.#i.length === 1 && P.has(this.#i[0]);
+                    const s = this.#i.length === 1 && I.has(this.#i[0]);
                     if (!s) {
-                        const s = M;
+                        const s = N;
                         const r = e && s.has(i.charAt(0)) || i.startsWith("\\.") && s.has(i.charAt(2)) || i.startsWith("\\.\\.") && s.has(i.charAt(4));
                         const o = !e && !t && s.has(i.charAt(0));
-                        n = r ? L : o ? A : "";
+                        n = r ? D : o ? B : "";
                     }
                 }
             }
@@ -428,7 +661,7 @@ class AST {
                 r = "(?:$|\\/)";
             }
             const o = n + i + r;
-            return [ o, E(i), this.#e = !!this.#e, this.#s ];
+            return [ o, unescape(i), this.#e = !!this.#e, this.#s ];
         }
         const s = this.type === "*" || this.type === "+";
         const i = this.type === "!" ? "(?:(?!(?:" : "(?:";
@@ -438,9 +671,9 @@ class AST {
             this.#i = [ t ];
             this.type = null;
             this.#e = undefined;
-            return [ t, E(this.toString()), false, false ];
+            return [ t, unescape(this.toString()), false, false ];
         }
-        let r = !s || t || e || !A ? "" : this.#p(true);
+        let r = !s || t || e || !B ? "" : this.#p(true);
         if (r === n) {
             r = "";
         }
@@ -449,12 +682,12 @@ class AST {
         }
         let o = "";
         if (this.type === "!" && this.#c) {
-            o = (this.isStart() && !e ? A : "") + D;
+            o = (this.isStart() && !e ? B : "") + $;
         } else {
-            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? A : "") + O + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
+            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? B : "") + j + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
             o = i + n + s;
         }
-        return [ o, E(n), this.#e = !!this.#e, this.#s ];
+        return [ o, unescape(n), this.#e = !!this.#e, this.#s ];
     }
     #p(t) {
         return this.#i.map((e => {
@@ -474,7 +707,7 @@ class AST {
             const h = t.charAt(o);
             if (i) {
                 i = false;
-                n += (F.has(h) ? "\\" : "") + h;
+                n += (W.has(h) ? "\\" : "") + h;
                 continue;
             }
             if (h === "\\") {
@@ -486,7 +719,7 @@ class AST {
                 continue;
             }
             if (h === "[") {
-                const [s, i, h, a] = x(t, o);
+                const [s, i, h, a] = parseClass(t, o);
                 if (h) {
                     n += s;
                     r = r || i;
@@ -496,102 +729,107 @@ class AST {
                 }
             }
             if (h === "*") {
-                if (s && t === "*") n += D; else n += O;
+                n += s && t === "*" ? $ : j;
                 e = true;
                 continue;
             }
             if (h === "?") {
-                n += z;
+                n += _;
                 e = true;
                 continue;
             }
-            n += R(h);
+            n += regExpEscape$1(h);
         }
-        return [ n, E(t), !!e, r ];
+        return [ n, unescape(t), !!e, r ];
     }
 }
 
-const N = (t, {windowsPathsNoEscape: e = false} = {}) => e ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+const escape = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = false} = {}) => {
+    if (s) {
+        return e ? t.replace(/[?*()[\]{}]/g, "[$&]") : t.replace(/[?*()[\]\\{}]/g, "\\$&");
+    }
+    return e ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+};
 
-const B = (t, e, s = {}) => {
-    y(e);
+const minimatch = (t, e, s = {}) => {
+    assertValidPattern(e);
     if (!s.nocomment && e.charAt(0) === "#") {
         return false;
     }
     return new Minimatch(e, s).match(t);
 };
 
-const W = /^\*+([^+@!?\*\[\(]*)$/;
+const G = /^\*+([^+@!?\*\[\(]*)$/;
 
-const I = t => e => !e.startsWith(".") && e.endsWith(t);
+const starDotExtTest = t => e => !e.startsWith(".") && e.endsWith(t);
 
-const _ = t => e => e.endsWith(t);
+const starDotExtTestDot = t => e => e.endsWith(t);
 
-const j = t => {
+const starDotExtTestNocase = t => {
     t = t.toLowerCase();
     return e => !e.startsWith(".") && e.toLowerCase().endsWith(t);
 };
 
-const U = t => {
+const starDotExtTestNocaseDot = t => {
     t = t.toLowerCase();
     return e => e.toLowerCase().endsWith(t);
 };
 
-const G = /^\*+\.\*+$/;
+const U = /^\*+\.\*+$/;
 
-const $ = t => !t.startsWith(".") && t.includes(".");
+const starDotStarTest = t => !t.startsWith(".") && t.includes(".");
 
-const H = t => t !== "." && t !== ".." && t.includes(".");
+const starDotStarTestDot = t => t !== "." && t !== ".." && t.includes(".");
 
-const q = /^\.\*+$/;
+const H = /^\.\*+$/;
 
-const Z = t => t !== "." && t !== ".." && t.startsWith(".");
+const dotStarTest = t => t !== "." && t !== ".." && t.startsWith(".");
 
-const V = /^\*+$/;
+const Z = /^\*+$/;
 
-const J = t => t.length !== 0 && !t.startsWith(".");
+const starTest = t => t.length !== 0 && !t.startsWith(".");
 
-const K = t => t.length !== 0 && t !== "." && t !== "..";
+const starTestDot = t => t.length !== 0 && t !== "." && t !== "..";
 
-const Y = /^\?+([^+@!?\*\[\(]*)?$/;
+const q = /^\?+([^+@!?\*\[\(]*)?$/;
 
-const X = ([t, e = ""]) => {
-    const s = st([ t ]);
+const qmarksTestNocase = ([t, e = ""]) => {
+    const s = qmarksTestNoExt([ t ]);
     if (!e) return s;
     e = e.toLowerCase();
     return t => s(t) && t.toLowerCase().endsWith(e);
 };
 
-const Q = ([t, e = ""]) => {
-    const s = it([ t ]);
+const qmarksTestNocaseDot = ([t, e = ""]) => {
+    const s = qmarksTestNoExtDot([ t ]);
     if (!e) return s;
     e = e.toLowerCase();
     return t => s(t) && t.toLowerCase().endsWith(e);
 };
 
-const tt = ([t, e = ""]) => {
-    const s = it([ t ]);
+const qmarksTestDot = ([t, e = ""]) => {
+    const s = qmarksTestNoExtDot([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const et = ([t, e = ""]) => {
-    const s = st([ t ]);
+const qmarksTest = ([t, e = ""]) => {
+    const s = qmarksTestNoExt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const st = ([t]) => {
+const qmarksTestNoExt = ([t]) => {
     const e = t.length;
     return t => t.length === e && !t.startsWith(".");
 };
 
-const it = ([t]) => {
+const qmarksTestNoExtDot = ([t]) => {
     const e = t.length;
     return t => t.length === e && t !== "." && t !== "..";
 };
 
-const nt = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+const V = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
 
-const rt = {
+const J = {
     win32: {
         sep: "\\"
     },
@@ -600,80 +838,80 @@ const rt = {
     }
 };
 
-const ot = nt === "win32" ? rt.win32.sep : rt.posix.sep;
+const K = V === "win32" ? J.win32.sep : J.posix.sep;
 
-B.sep = ot;
+minimatch.sep = K;
 
-const ht = Symbol("globstar **");
+const Y = Symbol("globstar **");
 
-B.GLOBSTAR = ht;
+minimatch.GLOBSTAR = Y;
 
-const at = "[^/]";
+const X = "[^/]";
 
-const lt = at + "*?";
+const Q = X + "*?";
 
-const ct = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const tt = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 
-const ft = "(?:(?!(?:\\/|^)\\.).)*?";
+const et = "(?:(?!(?:\\/|^)\\.).)*?";
 
-const ut = (t, e = {}) => s => B(s, t, e);
+const filter = (t, e = {}) => s => minimatch(s, t, e);
 
-B.filter = ut;
+minimatch.filter = filter;
 
-const dt = (t, e = {}) => Object.assign({}, t, e);
+const ext = (t, e = {}) => Object.assign({}, t, e);
 
-const pt = t => {
+const defaults = t => {
     if (!t || typeof t !== "object" || !Object.keys(t).length) {
-        return B;
+        return minimatch;
     }
-    const e = B;
-    const s = (s, i, n = {}) => e(s, i, dt(t, n));
-    return Object.assign(s, {
+    const e = minimatch;
+    const m = (s, i, n = {}) => e(s, i, ext(t, n));
+    return Object.assign(m, {
         Minimatch: class Minimatch extends e.Minimatch {
             constructor(e, s = {}) {
-                super(e, dt(t, s));
+                super(e, ext(t, s));
             }
             static defaults(s) {
-                return e.defaults(dt(t, s)).Minimatch;
+                return e.defaults(ext(t, s)).Minimatch;
             }
         },
         AST: class AST extends e.AST {
             constructor(e, s, i = {}) {
-                super(e, s, dt(t, i));
+                super(e, s, ext(t, i));
             }
             static fromGlob(s, i = {}) {
-                return e.AST.fromGlob(s, dt(t, i));
+                return e.AST.fromGlob(s, ext(t, i));
             }
         },
-        unescape: (s, i = {}) => e.unescape(s, dt(t, i)),
-        escape: (s, i = {}) => e.escape(s, dt(t, i)),
-        filter: (s, i = {}) => e.filter(s, dt(t, i)),
-        defaults: s => e.defaults(dt(t, s)),
-        makeRe: (s, i = {}) => e.makeRe(s, dt(t, i)),
-        braceExpand: (s, i = {}) => e.braceExpand(s, dt(t, i)),
-        match: (s, i, n = {}) => e.match(s, i, dt(t, n)),
+        unescape: (s, i = {}) => e.unescape(s, ext(t, i)),
+        escape: (s, i = {}) => e.escape(s, ext(t, i)),
+        filter: (s, i = {}) => e.filter(s, ext(t, i)),
+        defaults: s => e.defaults(ext(t, s)),
+        makeRe: (s, i = {}) => e.makeRe(s, ext(t, i)),
+        braceExpand: (s, i = {}) => e.braceExpand(s, ext(t, i)),
+        match: (s, i, n = {}) => e.match(s, i, ext(t, n)),
         sep: e.sep,
-        GLOBSTAR: ht
+        GLOBSTAR: Y
     });
 };
 
-B.defaults = pt;
+minimatch.defaults = defaults;
 
-const gt = (e, s = {}) => {
-    y(e);
-    if (s.nobrace || !/\{(?:(?!\{).)*\}/.test(e)) {
-        return [ e ];
+const braceExpand = (t, e = {}) => {
+    assertValidPattern(t);
+    if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(t)) {
+        return [ t ];
     }
-    return t(e);
+    return expand(t);
 };
 
-B.braceExpand = gt;
+minimatch.braceExpand = braceExpand;
 
-const mt = (t, e = {}) => new Minimatch(t, e).makeRe();
+const makeRe = (t, e = {}) => new Minimatch(t, e).makeRe();
 
-B.makeRe = mt;
+minimatch.makeRe = makeRe;
 
-const wt = (t, e, s = {}) => {
+const match = (t, e, s = {}) => {
     const i = new Minimatch(e, s);
     t = t.filter((t => i.match(t)));
     if (i.options.nonull && !t.length) {
@@ -682,11 +920,11 @@ const wt = (t, e, s = {}) => {
     return t;
 };
 
-B.match = wt;
+minimatch.match = match;
 
-const yt = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const st = /[?*]|[+@!]\(.*?\)|\[|\]/;
 
-const bt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regExpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
 class Minimatch {
     options;
@@ -707,11 +945,11 @@ class Minimatch {
     windowsNoMagicRoot;
     regexp;
     constructor(t, e = {}) {
-        y(t);
+        assertValidPattern(t);
         e = e || {};
         this.options = e;
         this.pattern = t;
-        this.platform = e.platform || nt;
+        this.platform = e.platform || V;
         this.isWindows = this.platform === "win32";
         this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
@@ -765,7 +1003,7 @@ class Minimatch {
         this.debug(this.pattern, this.globParts);
         let i = this.globParts.map(((t, e, s) => {
             if (this.isWindows && this.windowsNoMagicRoot) {
-                const e = t[0] === "" && t[1] === "" && (t[2] === "?" || !yt.test(t[2])) && !yt.test(t[3]);
+                const e = t[0] === "" && t[1] === "" && (t[2] === "?" || !st.test(t[2])) && !st.test(t[3]);
                 const s = /^[a-z]:/i.test(t[0]);
                 if (e) {
                     return [ ...t.slice(0, 4), ...t.slice(4).map((t => this.parse(t))) ];
@@ -1032,7 +1270,7 @@ class Minimatch {
             if (l === false) {
                 return false;
             }
-            if (l === ht) {
+            if (l === Y) {
                 this.debug("GLOBSTAR", [ e, l, c ]);
                 var f = r;
                 var u = o + 1;
@@ -1087,25 +1325,25 @@ class Minimatch {
         }
     }
     braceExpand() {
-        return gt(this.pattern, this.options);
+        return braceExpand(this.pattern, this.options);
     }
     parse(t) {
-        y(t);
+        assertValidPattern(t);
         const e = this.options;
-        if (t === "**") return ht;
+        if (t === "**") return Y;
         if (t === "") return "";
         let s;
         let i = null;
-        if (s = t.match(V)) {
-            i = e.dot ? K : J;
-        } else if (s = t.match(W)) {
-            i = (e.nocase ? e.dot ? U : j : e.dot ? _ : I)(s[1]);
-        } else if (s = t.match(Y)) {
-            i = (e.nocase ? e.dot ? Q : X : e.dot ? tt : et)(s);
+        if (s = t.match(Z)) {
+            i = e.dot ? starTestDot : starTest;
         } else if (s = t.match(G)) {
-            i = e.dot ? H : $;
+            i = (e.nocase ? e.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : e.dot ? starDotExtTestDot : starDotExtTest)(s[1]);
         } else if (s = t.match(q)) {
-            i = Z;
+            i = (e.nocase ? e.dot ? qmarksTestNocaseDot : qmarksTestNocase : e.dot ? qmarksTestDot : qmarksTest)(s);
+        } else if (s = t.match(U)) {
+            i = e.dot ? starDotStarTestDot : starDotStarTest;
+        } else if (s = t.match(H)) {
+            i = dotStarTest;
         }
         const n = AST.fromGlob(t, this.options).toMMPattern();
         if (i && typeof n === "object") {
@@ -1123,38 +1361,49 @@ class Minimatch {
             return this.regexp;
         }
         const e = this.options;
-        const s = e.noglobstar ? lt : e.dot ? ct : ft;
+        const s = e.noglobstar ? Q : e.dot ? tt : et;
         const i = new Set(e.nocase ? [ "i" ] : []);
         let n = t.map((t => {
             const e = t.map((t => {
                 if (t instanceof RegExp) {
                     for (const e of t.flags.split("")) i.add(e);
                 }
-                return typeof t === "string" ? bt(t) : t === ht ? ht : t._src;
+                return typeof t === "string" ? regExpEscape(t) : t === Y ? Y : t._src;
             }));
             e.forEach(((t, i) => {
                 const n = e[i + 1];
                 const r = e[i - 1];
-                if (t !== ht || r === ht) {
+                if (t !== Y || r === Y) {
                     return;
                 }
                 if (r === undefined) {
-                    if (n !== undefined && n !== ht) {
+                    if (n !== undefined && n !== Y) {
                         e[i + 1] = "(?:\\/|" + s + "\\/)?" + n;
                     } else {
                         e[i] = s;
                     }
                 } else if (n === undefined) {
-                    e[i - 1] = r + "(?:\\/|" + s + ")?";
-                } else if (n !== ht) {
+                    e[i - 1] = r + "(?:\\/|\\/" + s + ")?";
+                } else if (n !== Y) {
                     e[i - 1] = r + "(?:\\/|\\/" + s + "\\/)" + n;
-                    e[i + 1] = ht;
+                    e[i + 1] = Y;
                 }
             }));
-            return e.filter((t => t !== ht)).join("/");
+            const n = e.filter((t => t !== Y));
+            if (this.partial && n.length >= 1) {
+                const t = [];
+                for (let e = 1; e <= n.length; e++) {
+                    t.push(n.slice(0, e).join("/"));
+                }
+                return "(?:" + t.join("|") + ")";
+            }
+            return n.join("/");
         })).join("|");
         const [r, o] = t.length > 1 ? [ "(?:", ")" ] : [ "", "" ];
         n = "^" + r + n + o + "$";
+        if (this.partial) {
+            n = "^(?:\\/|" + r + n.slice(1, -1) + o + ")$";
+        }
         if (this.negate) n = "^(?!" + n + ").+$";
         try {
             this.regexp = new RegExp(n, [ ...i ].join(""));
@@ -1217,34 +1466,34 @@ class Minimatch {
         return this.negate;
     }
     static defaults(t) {
-        return B.defaults(t).Minimatch;
+        return minimatch.defaults(t).Minimatch;
     }
 }
 
-B.AST = AST;
+minimatch.AST = AST;
 
-B.Minimatch = Minimatch;
+minimatch.Minimatch = Minimatch;
 
-B.escape = N;
+minimatch.escape = escape;
 
-B.unescape = E;
+minimatch.unescape = unescape;
 
-const St = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const it = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 
-const kt = new Set;
+const nt = new Set;
 
-const vt = typeof process === "object" && !!process ? process : {};
+const rt = typeof process === "object" && !!process ? process : {};
 
-const xt = (t, e, s, i) => {
-    typeof vt.emitWarning === "function" ? vt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
+const emitWarning = (t, e, s, i) => {
+    typeof rt.emitWarning === "function" ? rt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
 };
 
-let Et = globalThis.AbortController;
+let ot = globalThis.AbortController;
 
-let Ct = globalThis.AbortSignal;
+let ht = globalThis.AbortSignal;
 
-if (typeof Et === "undefined") {
-    Ct = class AbortSignal {
+if (typeof ot === "undefined") {
+    ht = class AbortSignal {
         onabort;
         _onabort=[];
         reason;
@@ -1253,11 +1502,11 @@ if (typeof Et === "undefined") {
             this._onabort.push(e);
         }
     };
-    Et = class AbortController {
+    ot = class AbortController {
         constructor() {
-            e();
+            warnACPolyfill();
         }
-        signal=new Ct;
+        signal=new ht;
         abort(t) {
             if (this.signal.aborted) return;
             this.signal.reason = t;
@@ -1268,21 +1517,21 @@ if (typeof Et === "undefined") {
             this.signal.onabort?.(t);
         }
     };
-    let t = vt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
-    const e = () => {
+    let t = rt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const warnACPolyfill = () => {
         if (!t) return;
         t = false;
-        xt("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);
+        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 Tt = t => !kt.has(t);
+const shouldWarn = t => !nt.has(t);
 
-const Lt = Symbol("type");
+const at = Symbol("type");
 
-const At = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+const isPosInt = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
 
-const Mt = t => !At(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;
+const getUintArray = t => !isPosInt(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) {
@@ -1296,7 +1545,7 @@ class Stack {
     length;
     static #g=false;
     static create(t) {
-        const e = Mt(t);
+        const e = getUintArray(t);
         if (!e) return [];
         Stack.#g = true;
         const s = new Stack(t, e);
@@ -1320,12 +1569,12 @@ class Stack {
 
 class LRUCache {
     #m;
-    #w;
     #y;
+    #w;
     #b;
     #S;
     #k;
-    #v;
+    #x;
     ttl;
     ttlResolution;
     ttlAutopurge;
@@ -1341,33 +1590,33 @@ class LRUCache {
     allowStaleOnFetchAbort;
     allowStaleOnFetchRejection;
     ignoreFetchAbort;
-    #x;
+    #v;
     #E;
     #C;
     #T;
-    #L;
     #A;
+    #L;
     #M;
     #P;
     #F;
     #R;
-    #z;
     #O;
+    #z;
     #D;
-    #N;
     #B;
-    #W;
+    #N;
     #I;
+    #W;
     #_;
     static unsafeExposeInternals(t) {
         return {
             starts: t.#D,
-            ttls: t.#N,
-            sizes: t.#O,
+            ttls: t.#B,
+            sizes: t.#z,
             keyMap: t.#C,
             keyList: t.#T,
-            valList: t.#L,
-            next: t.#A,
+            valList: t.#A,
+            next: t.#L,
             prev: t.#M,
             get head() {
                 return t.#P;
@@ -1377,33 +1626,33 @@ class LRUCache {
             },
             free: t.#R,
             isBackgroundFetch: e => t.#j(e),
-            backgroundFetch: (e, s, i, n) => t.#U(e, s, i, n),
+            backgroundFetch: (e, s, i, n) => t.#$(e, s, i, n),
             moveToTail: e => t.#G(e),
-            indexes: e => t.#$(e),
+            indexes: e => t.#U(e),
             rindexes: e => t.#H(e),
-            isStale: e => t.#q(e)
+            isStale: e => t.#Z(e)
         };
     }
     get max() {
         return this.#m;
     }
     get maxSize() {
-        return this.#w;
+        return this.#y;
     }
     get calculatedSize() {
         return this.#E;
     }
     get size() {
-        return this.#x;
+        return this.#v;
     }
     get fetchMethod() {
         return this.#k;
     }
     get memoMethod() {
-        return this.#v;
+        return this.#x;
     }
     get dispose() {
-        return this.#y;
+        return this.#w;
     }
     get onInsert() {
         return this.#b;
@@ -1412,20 +1661,20 @@ class LRUCache {
         return this.#S;
     }
     constructor(t) {
-        const {max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: o, allowStale: h, dispose: a, onInsert: l, disposeAfter: c, noDisposeOnSet: f, noUpdateTTL: u, maxSize: d = 0, maxEntrySize: p = 0, sizeCalculation: g, fetchMethod: m, memoMethod: w, noDeleteOnFetchRejection: y, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: S, allowStaleOnFetchAbort: k, ignoreFetchAbort: v} = t;
-        if (e !== 0 && !At(e)) {
+        const {max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: o, allowStale: h, dispose: a, onInsert: l, disposeAfter: c, noDisposeOnSet: f, noUpdateTTL: u, maxSize: d = 0, maxEntrySize: p = 0, sizeCalculation: g, fetchMethod: y, memoMethod: w, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: S, allowStaleOnFetchRejection: k, allowStaleOnFetchAbort: x, ignoreFetchAbort: v} = t;
+        if (e !== 0 && !isPosInt(e)) {
             throw new TypeError("max option must be a nonnegative integer");
         }
-        const x = e ? Mt(e) : Array;
-        if (!x) {
+        const E = e ? getUintArray(e) : Array;
+        if (!E) {
             throw new Error("invalid max value: " + e);
         }
         this.#m = e;
-        this.#w = d;
-        this.maxEntrySize = p || this.#w;
+        this.#y = d;
+        this.maxEntrySize = p || this.#y;
         this.sizeCalculation = g;
         if (this.sizeCalculation) {
-            if (!this.#w && !this.maxEntrySize) {
+            if (!this.#y && !this.maxEntrySize) {
                 throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
             }
             if (typeof this.sizeCalculation !== "function") {
@@ -1435,77 +1684,77 @@ class LRUCache {
         if (w !== undefined && typeof w !== "function") {
             throw new TypeError("memoMethod must be a function if defined");
         }
-        this.#v = w;
-        if (m !== undefined && typeof m !== "function") {
+        this.#x = w;
+        if (y !== undefined && typeof y !== "function") {
             throw new TypeError("fetchMethod must be a function if specified");
         }
-        this.#k = m;
-        this.#W = !!m;
+        this.#k = y;
+        this.#I = !!y;
         this.#C = new Map;
         this.#T = new Array(e).fill(undefined);
-        this.#L = new Array(e).fill(undefined);
-        this.#A = new x(e);
-        this.#M = new x(e);
+        this.#A = new Array(e).fill(undefined);
+        this.#L = new E(e);
+        this.#M = new E(e);
         this.#P = 0;
         this.#F = 0;
         this.#R = Stack.create(e);
-        this.#x = 0;
+        this.#v = 0;
         this.#E = 0;
         if (typeof a === "function") {
-            this.#y = a;
+            this.#w = a;
         }
         if (typeof l === "function") {
             this.#b = l;
         }
         if (typeof c === "function") {
             this.#S = c;
-            this.#z = [];
+            this.#O = [];
         } else {
             this.#S = undefined;
-            this.#z = undefined;
+            this.#O = undefined;
         }
-        this.#B = !!this.#y;
+        this.#N = !!this.#w;
         this.#_ = !!this.#b;
-        this.#I = !!this.#S;
+        this.#W = !!this.#S;
         this.noDisposeOnSet = !!f;
         this.noUpdateTTL = !!u;
-        this.noDeleteOnFetchRejection = !!y;
-        this.allowStaleOnFetchRejection = !!S;
-        this.allowStaleOnFetchAbort = !!k;
+        this.noDeleteOnFetchRejection = !!b;
+        this.allowStaleOnFetchRejection = !!k;
+        this.allowStaleOnFetchAbort = !!x;
         this.ignoreFetchAbort = !!v;
         if (this.maxEntrySize !== 0) {
-            if (this.#w !== 0) {
-                if (!At(this.#w)) {
+            if (this.#y !== 0) {
+                if (!isPosInt(this.#y)) {
                     throw new TypeError("maxSize must be a positive integer if specified");
                 }
             }
-            if (!At(this.maxEntrySize)) {
+            if (!isPosInt(this.maxEntrySize)) {
                 throw new TypeError("maxEntrySize must be a positive integer if specified");
             }
-            this.#Z();
+            this.#q();
         }
         this.allowStale = !!h;
-        this.noDeleteOnStaleGet = !!b;
+        this.noDeleteOnStaleGet = !!S;
         this.updateAgeOnGet = !!r;
         this.updateAgeOnHas = !!o;
-        this.ttlResolution = At(i) || i === 0 ? i : 1;
+        this.ttlResolution = isPosInt(i) || i === 0 ? i : 1;
         this.ttlAutopurge = !!n;
         this.ttl = s || 0;
         if (this.ttl) {
-            if (!At(this.ttl)) {
+            if (!isPosInt(this.ttl)) {
                 throw new TypeError("ttl must be a positive integer if specified");
             }
             this.#V();
         }
-        if (this.#m === 0 && this.ttl === 0 && this.#w === 0) {
+        if (this.#m === 0 && this.ttl === 0 && this.#y === 0) {
             throw new TypeError("At least one of max, maxSize, or ttl is required");
         }
-        if (!this.ttlAutopurge && !this.#m && !this.#w) {
+        if (!this.ttlAutopurge && !this.#m && !this.#y) {
             const t = "LRU_CACHE_UNBOUNDED";
-            if (Tt(t)) {
-                kt.add(t);
+            if (shouldWarn(t)) {
+                nt.add(t);
                 const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
-                xt(e, "UnboundedCacheWarning", t, LRUCache);
+                emitWarning(e, "UnboundedCacheWarning", t, LRUCache);
             }
         }
     }
@@ -1515,14 +1764,14 @@ class LRUCache {
     #V() {
         const t = new ZeroArray(this.#m);
         const e = new ZeroArray(this.#m);
-        this.#N = t;
+        this.#B = t;
         this.#D = e;
-        this.#J = (s, i, n = St.now()) => {
+        this.#J = (s, i, n = it.now()) => {
             e[s] = i !== 0 ? n : 0;
             t[s] = i;
             if (i !== 0 && this.ttlAutopurge) {
                 const t = setTimeout((() => {
-                    if (this.#q(s)) {
+                    if (this.#Z(s)) {
                         this.#K(this.#T[s], "expire");
                     }
                 }), i + 1);
@@ -1532,23 +1781,23 @@ class LRUCache {
             }
         };
         this.#Y = s => {
-            e[s] = t[s] !== 0 ? St.now() : 0;
+            e[s] = t[s] !== 0 ? it.now() : 0;
         };
-        this.#X = (n, r) => {
-            if (t[r]) {
-                const o = t[r];
-                const h = e[r];
-                if (!o || !h) return;
-                n.ttl = o;
-                n.start = h;
-                n.now = s || i();
-                const a = n.now - h;
-                n.remainingTTL = o - a;
+        this.#X = (i, n) => {
+            if (t[n]) {
+                const r = t[n];
+                const o = e[n];
+                if (!r || !o) return;
+                i.ttl = r;
+                i.start = o;
+                i.now = s || getNow();
+                const h = i.now - o;
+                i.remainingTTL = r - h;
             }
         };
         let s = 0;
-        const i = () => {
-            const t = St.now();
+        const getNow = () => {
+            const t = it.now();
             if (this.ttlResolution > 0) {
                 s = t;
                 const e = setTimeout((() => s = 0), this.ttlResolution);
@@ -1558,33 +1807,33 @@ class LRUCache {
             }
             return t;
         };
-        this.getRemainingTTL = n => {
-            const r = this.#C.get(n);
-            if (r === undefined) {
+        this.getRemainingTTL = i => {
+            const n = this.#C.get(i);
+            if (n === undefined) {
                 return 0;
             }
-            const o = t[r];
-            const h = e[r];
-            if (!o || !h) {
+            const r = t[n];
+            const o = e[n];
+            if (!r || !o) {
                 return Infinity;
             }
-            const a = (s || i()) - h;
-            return o - a;
+            const h = (s || getNow()) - o;
+            return r - h;
         };
-        this.#q = n => {
-            const r = e[n];
-            const o = t[n];
-            return !!o && !!r && (s || i()) - r > o;
+        this.#Z = i => {
+            const n = e[i];
+            const r = t[i];
+            return !!r && !!n && (s || getNow()) - n > r;
         };
     }
     #Y=() => {};
     #X=() => {};
     #J=() => {};
-    #q=() => false;
-    #Z() {
+    #Z=() => false;
+    #q() {
         const t = new ZeroArray(this.#m);
         this.#E = 0;
-        this.#O = t;
+        this.#z = t;
         this.#Q = e => {
             this.#E -= t[e];
             t[e] = 0;
@@ -1593,13 +1842,13 @@ class LRUCache {
             if (this.#j(e)) {
                 return 0;
             }
-            if (!At(s)) {
+            if (!isPosInt(s)) {
                 if (i) {
                     if (typeof i !== "function") {
                         throw new TypeError("sizeCalculation must be a function");
                     }
                     s = i(e, t);
-                    if (!At(s)) {
+                    if (!isPosInt(s)) {
                         throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     }
                 } else {
@@ -1610,8 +1859,8 @@ class LRUCache {
         };
         this.#et = (e, s, i) => {
             t[e] = s;
-            if (this.#w) {
-                const s = this.#w - t[e];
+            if (this.#y) {
+                const s = this.#y - t[e];
                 while (this.#E > s) {
                     this.#st(true);
                 }
@@ -1631,13 +1880,13 @@ class LRUCache {
         }
         return 0;
     };
-    * #$({allowStale: t = this.allowStale} = {}) {
-        if (this.#x) {
+    * #U({allowStale: t = this.allowStale} = {}) {
+        if (this.#v) {
             for (let e = this.#F; true; ) {
                 if (!this.#it(e)) {
                     break;
                 }
-                if (t || !this.#q(e)) {
+                if (t || !this.#Z(e)) {
                     yield e;
                 }
                 if (e === this.#P) {
@@ -1649,18 +1898,18 @@ class LRUCache {
         }
     }
     * #H({allowStale: t = this.allowStale} = {}) {
-        if (this.#x) {
+        if (this.#v) {
             for (let e = this.#P; true; ) {
                 if (!this.#it(e)) {
                     break;
                 }
-                if (t || !this.#q(e)) {
+                if (t || !this.#Z(e)) {
                     yield e;
                 }
                 if (e === this.#F) {
                     break;
                 } else {
-                    e = this.#A[e];
+                    e = this.#L[e];
                 }
             }
         }
@@ -1669,23 +1918,23 @@ class LRUCache {
         return t !== undefined && this.#C.get(this.#T[t]) === t;
     }
     * entries() {
-        for (const t of this.#$()) {
-            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#T[t], this.#L[t] ];
+        for (const t of this.#U()) {
+            if (this.#A[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#A[t])) {
+                yield [ this.#T[t], this.#A[t] ];
             }
         }
     }
     * rentries() {
         for (const t of this.#H()) {
-            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#T[t], this.#L[t] ];
+            if (this.#A[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#A[t])) {
+                yield [ this.#T[t], this.#A[t] ];
             }
         }
     }
     * keys() {
-        for (const t of this.#$()) {
+        for (const t of this.#U()) {
             const e = this.#T[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
+            if (e !== undefined && !this.#j(this.#A[t])) {
                 yield e;
             }
         }
@@ -1693,24 +1942,24 @@ class LRUCache {
     * rkeys() {
         for (const t of this.#H()) {
             const e = this.#T[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
+            if (e !== undefined && !this.#j(this.#A[t])) {
                 yield e;
             }
         }
     }
     * values() {
-        for (const t of this.#$()) {
-            const e = this.#L[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
-                yield this.#L[t];
+        for (const t of this.#U()) {
+            const e = this.#A[t];
+            if (e !== undefined && !this.#j(this.#A[t])) {
+                yield this.#A[t];
             }
         }
     }
     * rvalues() {
         for (const t of this.#H()) {
-            const e = this.#L[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
-                yield this.#L[t];
+            const e = this.#A[t];
+            if (e !== undefined && !this.#j(this.#A[t])) {
+                yield this.#A[t];
             }
         }
     }
@@ -1719,8 +1968,8 @@ class LRUCache {
     }
     [Symbol.toStringTag]="LRUCache";
     find(t, e = {}) {
-        for (const s of this.#$()) {
-            const i = this.#L[s];
+        for (const s of this.#U()) {
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             if (t(n, this.#T[s], this)) {
@@ -1729,8 +1978,8 @@ class LRUCache {
         }
     }
     forEach(t, e = this) {
-        for (const s of this.#$()) {
-            const i = this.#L[s];
+        for (const s of this.#U()) {
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             t.call(e, n, this.#T[s], this);
@@ -1738,7 +1987,7 @@ class LRUCache {
     }
     rforEach(t, e = this) {
         for (const s of this.#H()) {
-            const i = this.#L[s];
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             t.call(e, n, this.#T[s], this);
@@ -1749,7 +1998,7 @@ class LRUCache {
         for (const e of this.#H({
             allowStale: true
         })) {
-            if (this.#q(e)) {
+            if (this.#Z(e)) {
                 this.#K(this.#T[e], "expire");
                 t = true;
             }
@@ -1759,45 +2008,45 @@ class LRUCache {
     info(t) {
         const e = this.#C.get(t);
         if (e === undefined) return undefined;
-        const s = this.#L[e];
+        const s = this.#A[e];
         const i = this.#j(s) ? s.__staleWhileFetching : s;
         if (i === undefined) return undefined;
         const n = {
             value: i
         };
-        if (this.#N && this.#D) {
-            const t = this.#N[e];
+        if (this.#B && this.#D) {
+            const t = this.#B[e];
             const s = this.#D[e];
             if (t && s) {
-                const e = t - (St.now() - s);
+                const e = t - (it.now() - s);
                 n.ttl = e;
                 n.start = Date.now();
             }
         }
-        if (this.#O) {
-            n.size = this.#O[e];
+        if (this.#z) {
+            n.size = this.#z[e];
         }
         return n;
     }
     dump() {
         const t = [];
-        for (const e of this.#$({
+        for (const e of this.#U({
             allowStale: true
         })) {
             const s = this.#T[e];
-            const i = this.#L[e];
+            const i = this.#A[e];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined || s === undefined) continue;
             const r = {
                 value: n
             };
-            if (this.#N && this.#D) {
-                r.ttl = this.#N[e];
-                const t = St.now() - this.#D[e];
+            if (this.#B && this.#D) {
+                r.ttl = this.#B[e];
+                const t = it.now() - this.#D[e];
                 r.start = Math.floor(Date.now() - t);
             }
-            if (this.#O) {
-                r.size = this.#O[e];
+            if (this.#z) {
+                r.size = this.#z[e];
             }
             t.unshift([ s, r ]);
         }
@@ -1808,7 +2057,7 @@ class LRUCache {
         for (const [e, s] of t) {
             if (s.start) {
                 const t = Date.now() - s.start;
-                s.start = St.now() - t;
+                s.start = it.now() - t;
             }
             this.set(e, s.value, s);
         }
@@ -1829,16 +2078,16 @@ class LRUCache {
             this.#K(t, "set");
             return this;
         }
-        let c = this.#x === 0 ? undefined : this.#C.get(t);
+        let c = this.#v === 0 ? undefined : this.#C.get(t);
         if (c === undefined) {
-            c = this.#x === 0 ? this.#F : this.#R.length !== 0 ? this.#R.pop() : this.#x === this.#m ? this.#st(false) : this.#x;
+            c = this.#v === 0 ? this.#F : this.#R.length !== 0 ? this.#R.pop() : this.#v === this.#m ? this.#st(false) : this.#v;
             this.#T[c] = t;
-            this.#L[c] = e;
+            this.#A[c] = e;
             this.#C.set(t, c);
-            this.#A[this.#F] = c;
+            this.#L[this.#F] = c;
             this.#M[c] = this.#F;
             this.#F = c;
-            this.#x++;
+            this.#v++;
             this.#et(c, l, h);
             if (h) h.set = "add";
             a = false;
@@ -1847,30 +2096,30 @@ class LRUCache {
             }
         } else {
             this.#G(c);
-            const s = this.#L[c];
+            const s = this.#A[c];
             if (e !== s) {
-                if (this.#W && this.#j(s)) {
+                if (this.#I && this.#j(s)) {
                     s.__abortController.abort(new Error("replaced"));
                     const {__staleWhileFetching: e} = s;
                     if (e !== undefined && !r) {
-                        if (this.#B) {
-                            this.#y?.(e, t, "set");
+                        if (this.#N) {
+                            this.#w?.(e, t, "set");
                         }
-                        if (this.#I) {
-                            this.#z?.push([ e, t, "set" ]);
+                        if (this.#W) {
+                            this.#O?.push([ e, t, "set" ]);
                         }
                     }
                 } else if (!r) {
-                    if (this.#B) {
-                        this.#y?.(s, t, "set");
+                    if (this.#N) {
+                        this.#w?.(s, t, "set");
                     }
-                    if (this.#I) {
-                        this.#z?.push([ s, t, "set" ]);
+                    if (this.#W) {
+                        this.#O?.push([ s, t, "set" ]);
                     }
                 }
                 this.#Q(c);
                 this.#et(c, l, h);
-                this.#L[c] = e;
+                this.#A[c] = e;
                 if (h) {
                     h.set = "replace";
                     const t = s && this.#j(s) ? s.__staleWhileFetching : s;
@@ -1883,17 +2132,17 @@ class LRUCache {
                 this.onInsert?.(e, t, e === s ? "update" : "replace");
             }
         }
-        if (i !== 0 && !this.#N) {
+        if (i !== 0 && !this.#B) {
             this.#V();
         }
-        if (this.#N) {
+        if (this.#B) {
             if (!a) {
                 this.#J(c, i, n);
             }
             if (h) this.#X(h, c);
         }
-        if (!r && this.#I && this.#z) {
-            const t = this.#z;
+        if (!r && this.#W && this.#O) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -1903,8 +2152,8 @@ class LRUCache {
     }
     pop() {
         try {
-            while (this.#x) {
-                const t = this.#L[this.#P];
+            while (this.#v) {
+                const t = this.#A[this.#P];
                 this.#st(true);
                 if (this.#j(t)) {
                     if (t.__staleWhileFetching) {
@@ -1915,8 +2164,8 @@ class LRUCache {
                 }
             }
         } finally {
-            if (this.#I && this.#z) {
-                const t = this.#z;
+            if (this.#W && this.#O) {
+                const t = this.#O;
                 let e;
                 while (e = t?.shift()) {
                     this.#S?.(...e);
@@ -1927,42 +2176,42 @@ class LRUCache {
     #st(t) {
         const e = this.#P;
         const s = this.#T[e];
-        const i = this.#L[e];
-        if (this.#W && this.#j(i)) {
+        const i = this.#A[e];
+        if (this.#I && this.#j(i)) {
             i.__abortController.abort(new Error("evicted"));
-        } else if (this.#B || this.#I) {
-            if (this.#B) {
-                this.#y?.(i, s, "evict");
+        } else if (this.#N || this.#W) {
+            if (this.#N) {
+                this.#w?.(i, s, "evict");
             }
-            if (this.#I) {
-                this.#z?.push([ i, s, "evict" ]);
+            if (this.#W) {
+                this.#O?.push([ i, s, "evict" ]);
             }
         }
         this.#Q(e);
         if (t) {
             this.#T[e] = undefined;
-            this.#L[e] = undefined;
+            this.#A[e] = undefined;
             this.#R.push(e);
         }
-        if (this.#x === 1) {
+        if (this.#v === 1) {
             this.#P = this.#F = 0;
             this.#R.length = 0;
         } else {
-            this.#P = this.#A[e];
+            this.#P = this.#L[e];
         }
         this.#C.delete(s);
-        this.#x--;
+        this.#v--;
         return e;
     }
     has(t, e = {}) {
         const {updateAgeOnHas: s = this.updateAgeOnHas, status: i} = e;
         const n = this.#C.get(t);
         if (n !== undefined) {
-            const t = this.#L[n];
+            const t = this.#A[n];
             if (this.#j(t) && t.__staleWhileFetching === undefined) {
                 return false;
             }
-            if (!this.#q(n)) {
+            if (!this.#Z(n)) {
                 if (s) {
                     this.#Y(n);
                 }
@@ -1983,18 +2232,18 @@ class LRUCache {
     peek(t, e = {}) {
         const {allowStale: s = this.allowStale} = e;
         const i = this.#C.get(t);
-        if (i === undefined || !s && this.#q(i)) {
+        if (i === undefined || !s && this.#Z(i)) {
             return;
         }
-        const n = this.#L[i];
+        const n = this.#A[i];
         return this.#j(n) ? n.__staleWhileFetching : n;
     }
-    #U(t, e, s, i) {
-        const n = e === undefined ? undefined : this.#L[e];
+    #$(t, e, s, i) {
+        const n = e === undefined ? undefined : this.#A[e];
         if (this.#j(n)) {
             return n;
         }
-        const r = new Et;
+        const r = new ot;
         const {signal: o} = s;
         o?.addEventListener("abort", (() => r.abort(o.reason)), {
             signal: r.signal
@@ -2004,26 +2253,26 @@ class LRUCache {
             options: s,
             context: i
         };
-        const a = (i, n = false) => {
+        const cb = (i, n = false) => {
             const {aborted: o} = r.signal;
-            const a = s.ignoreFetchAbort && i !== undefined;
+            const l = s.ignoreFetchAbort && i !== undefined;
             if (s.status) {
                 if (o && !n) {
                     s.status.fetchAborted = true;
                     s.status.fetchError = r.signal.reason;
-                    if (a) s.status.fetchAbortIgnored = true;
+                    if (l) s.status.fetchAbortIgnored = true;
                 } else {
                     s.status.fetchResolved = true;
                 }
             }
-            if (o && !a && !n) {
-                return c(r.signal.reason);
+            if (o && !l && !n) {
+                return fetchFail(r.signal.reason);
             }
-            const l = u;
-            if (this.#L[e] === u) {
+            const c = a;
+            if (this.#A[e] === a) {
                 if (i === undefined) {
-                    if (l.__staleWhileFetching) {
-                        this.#L[e] = l.__staleWhileFetching;
+                    if (c.__staleWhileFetching) {
+                        this.#A[e] = c.__staleWhileFetching;
                     } else {
                         this.#K(t, "fetch");
                     }
@@ -2034,37 +2283,37 @@ class LRUCache {
             }
             return i;
         };
-        const l = t => {
+        const eb = t => {
             if (s.status) {
                 s.status.fetchRejected = true;
                 s.status.fetchError = t;
             }
-            return c(t);
+            return fetchFail(t);
         };
-        const c = i => {
+        const fetchFail = i => {
             const {aborted: n} = r.signal;
             const o = n && s.allowStaleOnFetchAbort;
             const h = o || s.allowStaleOnFetchRejection;
-            const a = h || s.noDeleteOnFetchRejection;
-            const l = u;
-            if (this.#L[e] === u) {
-                const s = !a || l.__staleWhileFetching === undefined;
+            const l = h || s.noDeleteOnFetchRejection;
+            const c = a;
+            if (this.#A[e] === a) {
+                const s = !l || c.__staleWhileFetching === undefined;
                 if (s) {
                     this.#K(t, "fetch");
                 } else if (!o) {
-                    this.#L[e] = l.__staleWhileFetching;
+                    this.#A[e] = c.__staleWhileFetching;
                 }
             }
             if (h) {
-                if (s.status && l.__staleWhileFetching !== undefined) {
+                if (s.status && c.__staleWhileFetching !== undefined) {
                     s.status.returnedStale = true;
                 }
-                return l.__staleWhileFetching;
-            } else if (l.__returned === l) {
+                return c.__staleWhileFetching;
+            } else if (c.__returned === c) {
                 throw i;
             }
         };
-        const f = (e, i) => {
+        const pcall = (e, i) => {
             const o = this.#k?.(t, n, h);
             if (o && o instanceof Promise) {
                 o.then((t => e(t === undefined ? undefined : t)), i);
@@ -2073,46 +2322,46 @@ class LRUCache {
                 if (!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) {
                     e(undefined);
                     if (s.allowStaleOnFetchAbort) {
-                        e = t => a(t, true);
+                        e = t => cb(t, true);
                     }
                 }
             }));
         };
         if (s.status) s.status.fetchDispatched = true;
-        const u = new Promise(f).then(a, l);
-        const d = Object.assign(u, {
+        const a = new Promise(pcall).then(cb, eb);
+        const l = Object.assign(a, {
             __abortController: r,
             __staleWhileFetching: n,
             __returned: undefined
         });
         if (e === undefined) {
-            this.set(t, d, {
+            this.set(t, l, {
                 ...h.options,
                 status: undefined
             });
             e = this.#C.get(t);
         } else {
-            this.#L[e] = d;
+            this.#A[e] = l;
         }
-        return d;
+        return l;
     }
     #j(t) {
-        if (!this.#W) return false;
+        if (!this.#I) return false;
         const e = t;
-        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof Et;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof ot;
     }
     async fetch(t, e = {}) {
-        const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: h = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: l = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: f = this.allowStaleOnFetchRejection, ignoreFetchAbort: u = this.ignoreFetchAbort, allowStaleOnFetchAbort: d = this.allowStaleOnFetchAbort, context: p, forceRefresh: g = false, status: m, signal: w} = e;
-        if (!this.#W) {
-            if (m) m.fetch = "get";
+        const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: h = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: l = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: f = this.allowStaleOnFetchRejection, ignoreFetchAbort: u = this.ignoreFetchAbort, allowStaleOnFetchAbort: d = this.allowStaleOnFetchAbort, context: p, forceRefresh: g = false, status: y, signal: w} = e;
+        if (!this.#I) {
+            if (y) y.fetch = "get";
             return this.get(t, {
                 allowStale: s,
                 updateAgeOnGet: i,
                 noDeleteOnStaleGet: n,
-                status: m
+                status: y
             });
         }
-        const y = {
+        const b = {
             allowStale: s,
             updateAgeOnGet: i,
             noDeleteOnStaleGet: n,
@@ -2125,40 +2374,40 @@ class LRUCache {
             allowStaleOnFetchRejection: f,
             allowStaleOnFetchAbort: d,
             ignoreFetchAbort: u,
-            status: m,
+            status: y,
             signal: w
         };
-        let b = this.#C.get(t);
-        if (b === undefined) {
-            if (m) m.fetch = "miss";
-            const e = this.#U(t, b, y, p);
+        let S = this.#C.get(t);
+        if (S === undefined) {
+            if (y) y.fetch = "miss";
+            const e = this.#$(t, S, b, p);
             return e.__returned = e;
         } else {
-            const e = this.#L[b];
+            const e = this.#A[S];
             if (this.#j(e)) {
                 const t = s && e.__staleWhileFetching !== undefined;
-                if (m) {
-                    m.fetch = "inflight";
-                    if (t) m.returnedStale = true;
+                if (y) {
+                    y.fetch = "inflight";
+                    if (t) y.returnedStale = true;
                 }
                 return t ? e.__staleWhileFetching : e.__returned = e;
             }
-            const n = this.#q(b);
+            const n = this.#Z(S);
             if (!g && !n) {
-                if (m) m.fetch = "hit";
-                this.#G(b);
+                if (y) y.fetch = "hit";
+                this.#G(S);
                 if (i) {
-                    this.#Y(b);
+                    this.#Y(S);
                 }
-                if (m) this.#X(m, b);
+                if (y) this.#X(y, S);
                 return e;
             }
-            const r = this.#U(t, b, y, p);
+            const r = this.#$(t, S, b, p);
             const o = r.__staleWhileFetching !== undefined;
             const h = o && s;
-            if (m) {
-                m.fetch = n ? "stale" : "refresh";
-                if (h && n) m.returnedStale = true;
+            if (y) {
+                y.fetch = n ? "stale" : "refresh";
+                if (h && n) y.returnedStale = true;
             }
             return h ? r.__staleWhileFetching : r.__returned = r;
         }
@@ -2169,7 +2418,7 @@ class LRUCache {
         return s;
     }
     memo(t, e = {}) {
-        const s = this.#v;
+        const s = this.#x;
         if (!s) {
             throw new Error("no memoMethod provided to constructor");
         }
@@ -2187,10 +2436,10 @@ class LRUCache {
         const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r} = e;
         const o = this.#C.get(t);
         if (o !== undefined) {
-            const e = this.#L[o];
+            const e = this.#A[o];
             const h = this.#j(e);
             if (r) this.#X(r, o);
-            if (this.#q(o)) {
+            if (this.#Z(o)) {
                 if (r) r.get = "stale";
                 if (!h) {
                     if (!n) {
@@ -2221,14 +2470,14 @@ class LRUCache {
     }
     #nt(t, e) {
         this.#M[e] = t;
-        this.#A[t] = e;
+        this.#L[t] = e;
     }
     #G(t) {
         if (t !== this.#F) {
             if (t === this.#P) {
-                this.#P = this.#A[t];
+                this.#P = this.#L[t];
             } else {
-                this.#nt(this.#M[t], this.#A[t]);
+                this.#nt(this.#M[t], this.#L[t]);
             }
             this.#nt(this.#F, t);
             this.#F = t;
@@ -2239,45 +2488,45 @@ class LRUCache {
     }
     #K(t, e) {
         let s = false;
-        if (this.#x !== 0) {
+        if (this.#v !== 0) {
             const i = this.#C.get(t);
             if (i !== undefined) {
                 s = true;
-                if (this.#x === 1) {
+                if (this.#v === 1) {
                     this.#rt(e);
                 } else {
                     this.#Q(i);
-                    const s = this.#L[i];
+                    const s = this.#A[i];
                     if (this.#j(s)) {
                         s.__abortController.abort(new Error("deleted"));
-                    } else if (this.#B || this.#I) {
-                        if (this.#B) {
-                            this.#y?.(s, t, e);
+                    } else if (this.#N || this.#W) {
+                        if (this.#N) {
+                            this.#w?.(s, t, e);
                         }
-                        if (this.#I) {
-                            this.#z?.push([ s, t, e ]);
+                        if (this.#W) {
+                            this.#O?.push([ s, t, e ]);
                         }
                     }
                     this.#C.delete(t);
                     this.#T[i] = undefined;
-                    this.#L[i] = undefined;
+                    this.#A[i] = undefined;
                     if (i === this.#F) {
                         this.#F = this.#M[i];
                     } else if (i === this.#P) {
-                        this.#P = this.#A[i];
+                        this.#P = this.#L[i];
                     } else {
                         const t = this.#M[i];
-                        this.#A[t] = this.#A[i];
-                        const e = this.#A[i];
+                        this.#L[t] = this.#L[i];
+                        const e = this.#L[i];
                         this.#M[e] = this.#M[i];
                     }
-                    this.#x--;
+                    this.#v--;
                     this.#R.push(i);
                 }
             }
         }
-        if (this.#I && this.#z?.length) {
-            const t = this.#z;
+        if (this.#W && this.#O?.length) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -2292,36 +2541,36 @@ class LRUCache {
         for (const e of this.#H({
             allowStale: true
         })) {
-            const s = this.#L[e];
+            const s = this.#A[e];
             if (this.#j(s)) {
                 s.__abortController.abort(new Error("deleted"));
             } else {
                 const i = this.#T[e];
-                if (this.#B) {
-                    this.#y?.(s, i, t);
+                if (this.#N) {
+                    this.#w?.(s, i, t);
                 }
-                if (this.#I) {
-                    this.#z?.push([ s, i, t ]);
+                if (this.#W) {
+                    this.#O?.push([ s, i, t ]);
                 }
             }
         }
         this.#C.clear();
-        this.#L.fill(undefined);
+        this.#A.fill(undefined);
         this.#T.fill(undefined);
-        if (this.#N && this.#D) {
-            this.#N.fill(0);
+        if (this.#B && this.#D) {
+            this.#B.fill(0);
             this.#D.fill(0);
         }
-        if (this.#O) {
-            this.#O.fill(0);
+        if (this.#z) {
+            this.#z.fill(0);
         }
         this.#P = 0;
         this.#F = 0;
         this.#R.length = 0;
         this.#E = 0;
-        this.#x = 0;
-        if (this.#I && this.#z) {
-            const t = this.#z;
+        this.#v = 0;
+        if (this.#W && this.#O) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -2330,88 +2579,88 @@ class LRUCache {
     }
 }
 
-const Pt = typeof process === "object" && process ? process : {
+const lt = typeof process === "object" && process ? process : {
     stdout: null,
     stderr: null
 };
 
-const Ft = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof g || Rt(t) || zt(t));
+const isStream = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof p || isReadable(t) || isWritable(t));
 
-const Rt = t => !!t && typeof t === "object" && t instanceof p && typeof t.pipe === "function" && t.pipe !== g.Writable.prototype.pipe;
+const isReadable = t => !!t && typeof t === "object" && t instanceof d && typeof t.pipe === "function" && t.pipe !== p.Writable.prototype.pipe;
 
-const zt = t => !!t && typeof t === "object" && t instanceof p && typeof t.write === "function" && typeof t.end === "function";
+const isWritable = t => !!t && typeof t === "object" && t instanceof d && typeof t.write === "function" && typeof t.end === "function";
 
-const Ot = Symbol("EOF");
+const ct = Symbol("EOF");
 
-const Dt = Symbol("maybeEmitEnd");
+const ft = Symbol("maybeEmitEnd");
 
-const Nt = Symbol("emittedEnd");
+const ut = Symbol("emittedEnd");
 
-const Bt = Symbol("emittingEnd");
+const dt = Symbol("emittingEnd");
 
-const Wt = Symbol("emittedError");
+const pt = Symbol("emittedError");
 
-const It = Symbol("closed");
+const gt = Symbol("closed");
 
-const _t = Symbol("read");
+const mt = Symbol("read");
 
-const jt = Symbol("flush");
+const yt = Symbol("flush");
 
-const Ut = Symbol("flushChunk");
+const wt = Symbol("flushChunk");
 
-const Gt = Symbol("encoding");
+const bt = Symbol("encoding");
 
-const $t = Symbol("decoder");
+const St = Symbol("decoder");
 
-const Ht = Symbol("flowing");
+const kt = Symbol("flowing");
 
-const qt = Symbol("paused");
+const xt = Symbol("paused");
 
-const Zt = Symbol("resume");
+const vt = Symbol("resume");
 
-const Vt = Symbol("buffer");
+const Et = Symbol("buffer");
 
-const Jt = Symbol("pipes");
+const Ct = Symbol("pipes");
 
-const Kt = Symbol("bufferLength");
+const Tt = Symbol("bufferLength");
 
-const Yt = Symbol("bufferPush");
+const At = Symbol("bufferPush");
 
-const Xt = Symbol("bufferShift");
+const Lt = Symbol("bufferShift");
 
-const Qt = Symbol("objectMode");
+const Mt = Symbol("objectMode");
 
-const te = Symbol("destroyed");
+const Pt = Symbol("destroyed");
 
-const ee = Symbol("error");
+const Ft = Symbol("error");
 
-const se = Symbol("emitData");
+const Rt = Symbol("emitData");
 
-const ie = Symbol("emitEnd");
+const Ot = Symbol("emitEnd");
 
-const ne = Symbol("emitEnd2");
+const zt = Symbol("emitEnd2");
 
-const re = Symbol("async");
+const Dt = Symbol("async");
 
-const oe = Symbol("abort");
+const Bt = Symbol("abort");
 
-const he = Symbol("aborted");
+const Nt = Symbol("aborted");
 
-const ae = Symbol("signal");
+const It = Symbol("signal");
 
-const le = Symbol("dataListeners");
+const Wt = Symbol("dataListeners");
 
-const ce = Symbol("discarded");
+const _t = Symbol("discarded");
 
-const fe = t => Promise.resolve().then(t);
+const defer = t => Promise.resolve().then(t);
 
-const ue = t => t();
+const nodefer = t => t();
 
-const de = t => t === "end" || t === "finish" || t === "prefinish";
+const isEndish = t => t === "end" || t === "finish" || t === "prefinish";
 
-const pe = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
+const isArrayBufferLike = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
 
-const ge = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
+const isArrayBufferView = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
 
 class Pipe {
     src;
@@ -2422,7 +2671,7 @@ class Pipe {
         this.src = t;
         this.dest = e;
         this.opts = s;
-        this.ondrain = () => t[Zt]();
+        this.ondrain = () => t[vt]();
         this.dest.on("drain", this.ondrain);
     }
     unpipe() {
@@ -2447,30 +2696,30 @@ class PipeProxyErrors extends Pipe {
     }
 }
 
-const me = t => !!t.objectMode;
-
-const we = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
-
-class Minipass extends p {
-    [Ht]=false;
-    [qt]=false;
-    [Jt]=[];
-    [Vt]=[];
-    [Qt];
-    [Gt];
-    [re];
-    [$t];
-    [Ot]=false;
+const isObjectModeOptions = t => !!t.objectMode;
+
+const isEncodingOptions = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+
+class Minipass extends d {
+    [kt]=false;
+    [xt]=false;
+    [Ct]=[];
+    [Et]=[];
+    [Mt];
+    [bt];
+    [Dt];
+    [St];
+    [ct]=false;
+    [ut]=false;
+    [dt]=false;
+    [gt]=false;
+    [pt]=null;
+    [Tt]=0;
+    [Pt]=false;
+    [It];
     [Nt]=false;
-    [Bt]=false;
-    [It]=false;
-    [Wt]=null;
-    [Kt]=0;
-    [te]=false;
-    [ae];
-    [he]=false;
-    [le]=0;
-    [ce]=false;
+    [Wt]=0;
+    [_t]=false;
     writable=true;
     readable=true;
     constructor(...t) {
@@ -2479,43 +2728,43 @@ class Minipass extends p {
         if (e.objectMode && typeof e.encoding === "string") {
             throw new TypeError("Encoding and objectMode may not be used together");
         }
-        if (me(e)) {
-            this[Qt] = true;
-            this[Gt] = null;
-        } else if (we(e)) {
-            this[Gt] = e.encoding;
-            this[Qt] = false;
+        if (isObjectModeOptions(e)) {
+            this[Mt] = true;
+            this[bt] = null;
+        } else if (isEncodingOptions(e)) {
+            this[bt] = e.encoding;
+            this[Mt] = false;
         } else {
-            this[Qt] = false;
-            this[Gt] = null;
+            this[Mt] = false;
+            this[bt] = null;
         }
-        this[re] = !!e.async;
-        this[$t] = this[Gt] ? new m(this[Gt]) : null;
+        this[Dt] = !!e.async;
+        this[St] = this[bt] ? new g(this[bt]) : null;
         if (e && e.debugExposeBuffer === true) {
             Object.defineProperty(this, "buffer", {
-                get: () => this[Vt]
+                get: () => this[Et]
             });
         }
         if (e && e.debugExposePipes === true) {
             Object.defineProperty(this, "pipes", {
-                get: () => this[Jt]
+                get: () => this[Ct]
             });
         }
         const {signal: s} = e;
         if (s) {
-            this[ae] = s;
+            this[It] = s;
             if (s.aborted) {
-                this[oe]();
+                this[Bt]();
             } else {
-                s.addEventListener("abort", (() => this[oe]()));
+                s.addEventListener("abort", (() => this[Bt]()));
             }
         }
     }
     get bufferLength() {
-        return this[Kt];
+        return this[Tt];
     }
     get encoding() {
-        return this[Gt];
+        return this[bt];
     }
     set encoding(t) {
         throw new Error("Encoding must be set at instantiation time");
@@ -2524,30 +2773,30 @@ class Minipass extends p {
         throw new Error("Encoding must be set at instantiation time");
     }
     get objectMode() {
-        return this[Qt];
+        return this[Mt];
     }
     set objectMode(t) {
         throw new Error("objectMode must be set at instantiation time");
     }
     get ["async"]() {
-        return this[re];
+        return this[Dt];
     }
     set ["async"](t) {
-        this[re] = this[re] || !!t;
+        this[Dt] = this[Dt] || !!t;
     }
-    [oe]() {
-        this[he] = true;
-        this.emit("abort", this[ae]?.reason);
-        this.destroy(this[ae]?.reason);
+    [Bt]() {
+        this[Nt] = true;
+        this.emit("abort", this[It]?.reason);
+        this.destroy(this[It]?.reason);
     }
     get aborted() {
-        return this[he];
+        return this[Nt];
     }
     set aborted(t) {}
     write(t, e, s) {
-        if (this[he]) return false;
-        if (this[Ot]) throw new Error("write after end");
-        if (this[te]) {
+        if (this[Nt]) return false;
+        if (this[ct]) throw new Error("write after end");
+        if (this[Pt]) {
             this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
                 code: "ERR_STREAM_DESTROYED"
             }));
@@ -2558,70 +2807,70 @@ class Minipass extends p {
             e = "utf8";
         }
         if (!e) e = "utf8";
-        const i = this[re] ? fe : ue;
-        if (!this[Qt] && !Buffer.isBuffer(t)) {
-            if (ge(t)) {
+        const i = this[Dt] ? defer : nodefer;
+        if (!this[Mt] && !Buffer.isBuffer(t)) {
+            if (isArrayBufferView(t)) {
                 t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
-            } else if (pe(t)) {
+            } else if (isArrayBufferLike(t)) {
                 t = Buffer.from(t);
             } else if (typeof t !== "string") {
                 throw new Error("Non-contiguous data written to non-objectMode stream");
             }
         }
-        if (this[Qt]) {
-            if (this[Ht] && this[Kt] !== 0) this[jt](true);
-            if (this[Ht]) this.emit("data", t); else this[Yt](t);
-            if (this[Kt] !== 0) this.emit("readable");
+        if (this[Mt]) {
+            if (this[kt] && this[Tt] !== 0) this[yt](true);
+            if (this[kt]) this.emit("data", t); else this[At](t);
+            if (this[Tt] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[Ht];
+            return this[kt];
         }
         if (!t.length) {
-            if (this[Kt] !== 0) this.emit("readable");
+            if (this[Tt] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[Ht];
+            return this[kt];
         }
-        if (typeof t === "string" && !(e === this[Gt] && !this[$t]?.lastNeed)) {
+        if (typeof t === "string" && !(e === this[bt] && !this[St]?.lastNeed)) {
             t = Buffer.from(t, e);
         }
-        if (Buffer.isBuffer(t) && this[Gt]) {
-            t = this[$t].write(t);
+        if (Buffer.isBuffer(t) && this[bt]) {
+            t = this[St].write(t);
         }
-        if (this[Ht] && this[Kt] !== 0) this[jt](true);
-        if (this[Ht]) this.emit("data", t); else this[Yt](t);
-        if (this[Kt] !== 0) this.emit("readable");
+        if (this[kt] && this[Tt] !== 0) this[yt](true);
+        if (this[kt]) this.emit("data", t); else this[At](t);
+        if (this[Tt] !== 0) this.emit("readable");
         if (s) i(s);
-        return this[Ht];
+        return this[kt];
     }
     read(t) {
-        if (this[te]) return null;
-        this[ce] = false;
-        if (this[Kt] === 0 || t === 0 || t && t > this[Kt]) {
-            this[Dt]();
+        if (this[Pt]) return null;
+        this[_t] = false;
+        if (this[Tt] === 0 || t === 0 || t && t > this[Tt]) {
+            this[ft]();
             return null;
         }
-        if (this[Qt]) t = null;
-        if (this[Vt].length > 1 && !this[Qt]) {
-            this[Vt] = [ this[Gt] ? this[Vt].join("") : Buffer.concat(this[Vt], this[Kt]) ];
+        if (this[Mt]) t = null;
+        if (this[Et].length > 1 && !this[Mt]) {
+            this[Et] = [ this[bt] ? this[Et].join("") : Buffer.concat(this[Et], this[Tt]) ];
         }
-        const e = this[_t](t || null, this[Vt][0]);
-        this[Dt]();
+        const e = this[mt](t || null, this[Et][0]);
+        this[ft]();
         return e;
     }
-    [_t](t, e) {
-        if (this[Qt]) this[Xt](); else {
+    [mt](t, e) {
+        if (this[Mt]) this[Lt](); else {
             const s = e;
-            if (t === s.length || t === null) this[Xt](); else if (typeof s === "string") {
-                this[Vt][0] = s.slice(t);
+            if (t === s.length || t === null) this[Lt](); else if (typeof s === "string") {
+                this[Et][0] = s.slice(t);
                 e = s.slice(0, t);
-                this[Kt] -= t;
+                this[Tt] -= t;
             } else {
-                this[Vt][0] = s.subarray(t);
+                this[Et][0] = s.subarray(t);
                 e = s.subarray(0, t);
-                this[Kt] -= t;
+                this[Tt] -= t;
             }
         }
         this.emit("data", e);
-        if (!this[Vt].length && !this[Ot]) this.emit("drain");
+        if (!this[Et].length && !this[ct]) this.emit("drain");
         return e;
     }
     end(t, e, s) {
@@ -2635,78 +2884,78 @@ class Minipass extends p {
         }
         if (t !== undefined) this.write(t, e);
         if (s) this.once("end", s);
-        this[Ot] = true;
+        this[ct] = true;
         this.writable = false;
-        if (this[Ht] || !this[qt]) this[Dt]();
+        if (this[kt] || !this[xt]) this[ft]();
         return this;
     }
-    [Zt]() {
-        if (this[te]) return;
-        if (!this[le] && !this[Jt].length) {
-            this[ce] = true;
+    [vt]() {
+        if (this[Pt]) return;
+        if (!this[Wt] && !this[Ct].length) {
+            this[_t] = true;
         }
-        this[qt] = false;
-        this[Ht] = true;
+        this[xt] = false;
+        this[kt] = true;
         this.emit("resume");
-        if (this[Vt].length) this[jt](); else if (this[Ot]) this[Dt](); else this.emit("drain");
+        if (this[Et].length) this[yt](); else if (this[ct]) this[ft](); else this.emit("drain");
     }
     resume() {
-        return this[Zt]();
+        return this[vt]();
     }
     pause() {
-        this[Ht] = false;
-        this[qt] = true;
-        this[ce] = false;
+        this[kt] = false;
+        this[xt] = true;
+        this[_t] = false;
     }
     get destroyed() {
-        return this[te];
+        return this[Pt];
     }
     get flowing() {
-        return this[Ht];
+        return this[kt];
     }
     get paused() {
-        return this[qt];
+        return this[xt];
     }
-    [Yt](t) {
-        if (this[Qt]) this[Kt] += 1; else this[Kt] += t.length;
-        this[Vt].push(t);
+    [At](t) {
+        if (this[Mt]) this[Tt] += 1; else this[Tt] += t.length;
+        this[Et].push(t);
     }
-    [Xt]() {
-        if (this[Qt]) this[Kt] -= 1; else this[Kt] -= this[Vt][0].length;
-        return this[Vt].shift();
+    [Lt]() {
+        if (this[Mt]) this[Tt] -= 1; else this[Tt] -= this[Et][0].length;
+        return this[Et].shift();
     }
-    [jt](t = false) {
-        do {} while (this[Ut](this[Xt]()) && this[Vt].length);
-        if (!t && !this[Vt].length && !this[Ot]) this.emit("drain");
+    [yt](t = false) {
+        do {} while (this[wt](this[Lt]()) && this[Et].length);
+        if (!t && !this[Et].length && !this[ct]) this.emit("drain");
     }
-    [Ut](t) {
+    [wt](t) {
         this.emit("data", t);
-        return this[Ht];
+        return this[kt];
     }
     pipe(t, e) {
-        if (this[te]) return t;
-        this[ce] = false;
-        const s = this[Nt];
+        if (this[Pt]) return t;
+        this[_t] = false;
+        const s = this[ut];
         e = e || {};
-        if (t === Pt.stdout || t === Pt.stderr) e.end = false; else e.end = e.end !== false;
+        if (t === lt.stdout || t === lt.stderr) e.end = false; else e.end = e.end !== false;
         e.proxyErrors = !!e.proxyErrors;
         if (s) {
             if (e.end) t.end();
         } else {
-            this[Jt].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
-            if (this[re]) fe((() => this[Zt]())); else this[Zt]();
+            this[Ct].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+            if (this[Dt]) defer((() => this[vt]())); else this[vt]();
         }
         return t;
     }
     unpipe(t) {
-        const e = this[Jt].find((e => e.dest === t));
+        const e = this[Ct].find((e => e.dest === t));
         if (e) {
-            if (this[Jt].length === 1) {
-                if (this[Ht] && this[le] === 0) {
-                    this[Ht] = false;
+            if (this[Ct].length === 1) {
+                if (this[kt] && this[Wt] === 0) {
+                    this[kt] = false;
                 }
-                this[Jt] = [];
-            } else this[Jt].splice(this[Jt].indexOf(e), 1);
+                this[Ct] = [];
+            } else this[Ct].splice(this[Ct].indexOf(e), 1);
             e.unpipe();
         }
     }
@@ -2716,19 +2965,19 @@ class Minipass extends p {
     on(t, e) {
         const s = super.on(t, e);
         if (t === "data") {
-            this[ce] = false;
-            this[le]++;
-            if (!this[Jt].length && !this[Ht]) {
-                this[Zt]();
+            this[_t] = false;
+            this[Wt]++;
+            if (!this[Ct].length && !this[kt]) {
+                this[vt]();
             }
-        } else if (t === "readable" && this[Kt] !== 0) {
+        } else if (t === "readable" && this[Tt] !== 0) {
             super.emit("readable");
-        } else if (de(t) && this[Nt]) {
+        } else if (isEndish(t) && this[ut]) {
             super.emit(t);
             this.removeAllListeners(t);
-        } else if (t === "error" && this[Wt]) {
+        } else if (t === "error" && this[pt]) {
             const t = e;
-            if (this[re]) fe((() => t.call(this, this[Wt]))); else t.call(this, this[Wt]);
+            if (this[Dt]) defer((() => t.call(this, this[pt]))); else t.call(this, this[pt]);
         }
         return s;
     }
@@ -2738,9 +2987,9 @@ class Minipass extends p {
     off(t, e) {
         const s = super.off(t, e);
         if (t === "data") {
-            this[le] = this.listeners("data").length;
-            if (this[le] === 0 && !this[ce] && !this[Jt].length) {
-                this[Ht] = false;
+            this[Wt] = this.listeners("data").length;
+            if (this[Wt] === 0 && !this[_t] && !this[Ct].length) {
+                this[kt] = false;
             }
         }
         return s;
@@ -2748,49 +2997,49 @@ class Minipass extends p {
     removeAllListeners(t) {
         const e = super.removeAllListeners(t);
         if (t === "data" || t === undefined) {
-            this[le] = 0;
-            if (!this[ce] && !this[Jt].length) {
-                this[Ht] = false;
+            this[Wt] = 0;
+            if (!this[_t] && !this[Ct].length) {
+                this[kt] = false;
             }
         }
         return e;
     }
     get emittedEnd() {
-        return this[Nt];
+        return this[ut];
     }
-    [Dt]() {
-        if (!this[Bt] && !this[Nt] && !this[te] && this[Vt].length === 0 && this[Ot]) {
-            this[Bt] = true;
+    [ft]() {
+        if (!this[dt] && !this[ut] && !this[Pt] && this[Et].length === 0 && this[ct]) {
+            this[dt] = true;
             this.emit("end");
             this.emit("prefinish");
             this.emit("finish");
-            if (this[It]) this.emit("close");
-            this[Bt] = false;
+            if (this[gt]) this.emit("close");
+            this[dt] = false;
         }
     }
     emit(t, ...e) {
         const s = e[0];
-        if (t !== "error" && t !== "close" && t !== te && this[te]) {
+        if (t !== "error" && t !== "close" && t !== Pt && this[Pt]) {
             return false;
         } else if (t === "data") {
-            return !this[Qt] && !s ? false : this[re] ? (fe((() => this[se](s))), true) : this[se](s);
+            return !this[Mt] && !s ? false : this[Dt] ? (defer((() => this[Rt](s))), true) : this[Rt](s);
         } else if (t === "end") {
-            return this[ie]();
+            return this[Ot]();
         } else if (t === "close") {
-            this[It] = true;
-            if (!this[Nt] && !this[te]) return false;
+            this[gt] = true;
+            if (!this[ut] && !this[Pt]) return false;
             const t = super.emit("close");
             this.removeAllListeners("close");
             return t;
         } else if (t === "error") {
-            this[Wt] = s;
-            super.emit(ee, s);
-            const t = !this[ae] || this.listeners("error").length ? super.emit("error", s) : false;
-            this[Dt]();
+            this[pt] = s;
+            super.emit(Ft, s);
+            const t = !this[It] || this.listeners("error").length ? super.emit("error", s) : false;
+            this[ft]();
             return t;
         } else if (t === "resume") {
             const t = super.emit("resume");
-            this[Dt]();
+            this[ft]();
             return t;
         } else if (t === "finish" || t === "prefinish") {
             const e = super.emit(t);
@@ -2798,34 +3047,34 @@ class Minipass extends p {
             return e;
         }
         const i = super.emit(t, ...e);
-        this[Dt]();
+        this[ft]();
         return i;
     }
-    [se](t) {
-        for (const e of this[Jt]) {
+    [Rt](t) {
+        for (const e of this[Ct]) {
             if (e.dest.write(t) === false) this.pause();
         }
-        const e = this[ce] ? false : super.emit("data", t);
-        this[Dt]();
+        const e = this[_t] ? false : super.emit("data", t);
+        this[ft]();
         return e;
     }
-    [ie]() {
-        if (this[Nt]) return false;
-        this[Nt] = true;
+    [Ot]() {
+        if (this[ut]) return false;
+        this[ut] = true;
         this.readable = false;
-        return this[re] ? (fe((() => this[ne]())), true) : this[ne]();
+        return this[Dt] ? (defer((() => this[zt]())), true) : this[zt]();
     }
-    [ne]() {
-        if (this[$t]) {
-            const t = this[$t].end();
+    [zt]() {
+        if (this[St]) {
+            const t = this[St].end();
             if (t) {
-                for (const e of this[Jt]) {
+                for (const e of this[Ct]) {
                     e.dest.write(t);
                 }
-                if (!this[ce]) super.emit("data", t);
+                if (!this[_t]) super.emit("data", t);
             }
         }
-        for (const t of this[Jt]) {
+        for (const t of this[Ct]) {
             t.end();
         }
         const t = super.emit("end");
@@ -2836,33 +3085,33 @@ class Minipass extends p {
         const t = Object.assign([], {
             dataLength: 0
         });
-        if (!this[Qt]) t.dataLength = 0;
+        if (!this[Mt]) t.dataLength = 0;
         const e = this.promise();
         this.on("data", (e => {
             t.push(e);
-            if (!this[Qt]) t.dataLength += e.length;
+            if (!this[Mt]) t.dataLength += e.length;
         }));
         await e;
         return t;
     }
     async concat() {
-        if (this[Qt]) {
+        if (this[Mt]) {
             throw new Error("cannot concat in objectMode");
         }
         const t = await this.collect();
-        return this[Gt] ? t.join("") : Buffer.concat(t, t.dataLength);
+        return this[bt] ? t.join("") : Buffer.concat(t, t.dataLength);
     }
     async promise() {
         return new Promise(((t, e) => {
-            this.on(te, (() => e(new Error("stream destroyed"))));
+            this.on(Pt, (() => e(new Error("stream destroyed"))));
             this.on("error", (t => e(t)));
             this.on("end", (() => t()));
         }));
     }
     [Symbol.asyncIterator]() {
-        this[ce] = false;
+        this[_t] = false;
         let t = false;
-        const e = async () => {
+        const stop = async () => {
             this.pause();
             t = true;
             return {
@@ -2870,201 +3119,201 @@ class Minipass extends p {
                 done: true
             };
         };
-        const s = () => {
-            if (t) return e();
-            const s = this.read();
-            if (s !== null) return Promise.resolve({
+        const next = () => {
+            if (t) return stop();
+            const e = this.read();
+            if (e !== null) return Promise.resolve({
                 done: false,
-                value: s
+                value: e
             });
-            if (this[Ot]) return e();
+            if (this[ct]) return stop();
+            let s;
             let i;
-            let n;
-            const r = t => {
-                this.off("data", o);
-                this.off("end", h);
-                this.off(te, a);
-                e();
-                n(t);
+            const onerr = t => {
+                this.off("data", ondata);
+                this.off("end", onend);
+                this.off(Pt, ondestroy);
+                stop();
+                i(t);
             };
-            const o = t => {
-                this.off("error", r);
-                this.off("end", h);
-                this.off(te, a);
+            const ondata = t => {
+                this.off("error", onerr);
+                this.off("end", onend);
+                this.off(Pt, ondestroy);
                 this.pause();
-                i({
+                s({
                     value: t,
-                    done: !!this[Ot]
+                    done: !!this[ct]
                 });
             };
-            const h = () => {
-                this.off("error", r);
-                this.off("data", o);
-                this.off(te, a);
-                e();
-                i({
+            const onend = () => {
+                this.off("error", onerr);
+                this.off("data", ondata);
+                this.off(Pt, ondestroy);
+                stop();
+                s({
                     done: true,
                     value: undefined
                 });
             };
-            const a = () => r(new Error("stream destroyed"));
+            const ondestroy = () => onerr(new Error("stream destroyed"));
             return new Promise(((t, e) => {
-                n = e;
-                i = t;
-                this.once(te, a);
-                this.once("error", r);
-                this.once("end", h);
-                this.once("data", o);
+                i = e;
+                s = t;
+                this.once(Pt, ondestroy);
+                this.once("error", onerr);
+                this.once("end", onend);
+                this.once("data", ondata);
             }));
         };
         return {
-            next: s,
-            throw: e,
-            return: e,
+            next,
+            throw: stop,
+            return: stop,
             [Symbol.asyncIterator]() {
                 return this;
             }
         };
     }
     [Symbol.iterator]() {
-        this[ce] = false;
+        this[_t] = false;
         let t = false;
-        const e = () => {
+        const stop = () => {
             this.pause();
-            this.off(ee, e);
-            this.off(te, e);
-            this.off("end", e);
+            this.off(Ft, stop);
+            this.off(Pt, stop);
+            this.off("end", stop);
             t = true;
             return {
                 done: true,
                 value: undefined
             };
         };
-        const s = () => {
-            if (t) return e();
-            const s = this.read();
-            return s === null ? e() : {
+        const next = () => {
+            if (t) return stop();
+            const e = this.read();
+            return e === null ? stop() : {
                 done: false,
-                value: s
+                value: e
             };
         };
-        this.once("end", e);
-        this.once(ee, e);
-        this.once(te, e);
+        this.once("end", stop);
+        this.once(Ft, stop);
+        this.once(Pt, stop);
         return {
-            next: s,
-            throw: e,
-            return: e,
+            next,
+            throw: stop,
+            return: stop,
             [Symbol.iterator]() {
                 return this;
             }
         };
     }
     destroy(t) {
-        if (this[te]) {
-            if (t) this.emit("error", t); else this.emit(te);
+        if (this[Pt]) {
+            if (t) this.emit("error", t); else this.emit(Pt);
             return this;
         }
-        this[te] = true;
-        this[ce] = true;
-        this[Vt].length = 0;
-        this[Kt] = 0;
+        this[Pt] = true;
+        this[_t] = true;
+        this[Et].length = 0;
+        this[Tt] = 0;
         const e = this;
-        if (typeof e.close === "function" && !this[It]) e.close();
-        if (t) this.emit("error", t); else this.emit(te);
+        if (typeof e.close === "function" && !this[gt]) e.close();
+        if (t) this.emit("error", t); else this.emit(Pt);
         return this;
     }
     static get isStream() {
-        return Ft;
+        return isStream;
     }
 }
 
-const ye = n.native;
+const jt = i.native;
 
-const be = {
-    lstatSync: a,
-    readdir: h,
-    readdirSync: o,
-    readlinkSync: r,
-    realpathSync: ye,
+const $t = {
+    lstatSync: h,
+    readdir: o,
+    readdirSync: r,
+    readlinkSync: n,
+    realpathSync: jt,
     promises: {
-        lstat: d,
-        readdir: u,
-        readlink: f,
-        realpath: c
+        lstat: u,
+        readdir: f,
+        readlink: c,
+        realpath: l
     }
 };
 
-const Se = t => !t || t === be || t === l ? be : {
-    ...be,
+const fsFromOption = t => !t || t === $t || t === a ? $t : {
+    ...$t,
     ...t,
     promises: {
-        ...be.promises,
+        ...$t.promises,
         ...t.promises || {}
     }
 };
 
-const ke = /^\\\\\?\\([a-z]:)\\?$/i;
+const Gt = /^\\\\\?\\([a-z]:)\\?$/i;
 
-const ve = t => t.replace(/\//g, "\\").replace(ke, "$1\\");
+const uncToDrive = t => t.replace(/\//g, "\\").replace(Gt, "$1\\");
 
-const xe = /[\\\/]/;
+const Ut = /[\\\/]/;
 
-const Ee = 0;
+const Ht = 0;
 
-const Ce = 1;
+const Zt = 1;
 
-const Te = 2;
+const qt = 2;
 
-const Le = 4;
+const Vt = 4;
 
-const Ae = 6;
+const Jt = 6;
 
-const Me = 8;
+const Kt = 8;
 
-const Pe = 10;
+const Yt = 10;
 
-const Fe = 12;
+const Xt = 12;
 
-const Re = 15;
+const Qt = 15;
 
-const ze = ~Re;
+const te = ~Qt;
 
-const Oe = 16;
+const ee = 16;
 
-const De = 32;
+const se = 32;
 
-const Ne = 64;
+const ie = 64;
 
-const Be = 128;
+const ne = 128;
 
-const We = 256;
+const re = 256;
 
-const Ie = 512;
+const oe = 512;
 
-const _e = Ne | Be | Ie;
+const he = ie | ne | oe;
 
-const je = 1023;
+const ae = 1023;
 
-const Ue = t => t.isFile() ? Me : t.isDirectory() ? Le : t.isSymbolicLink() ? Pe : t.isCharacterDevice() ? Te : t.isBlockDevice() ? Ae : t.isSocket() ? Fe : t.isFIFO() ? Ce : Ee;
+const entToType = t => t.isFile() ? Kt : t.isDirectory() ? Vt : t.isSymbolicLink() ? Yt : t.isCharacterDevice() ? qt : t.isBlockDevice() ? Jt : t.isSocket() ? Xt : t.isFIFO() ? Zt : Ht;
 
-const Ge = new Map;
+const le = new Map;
 
-const $e = t => {
-    const e = Ge.get(t);
+const normalize = t => {
+    const e = le.get(t);
     if (e) return e;
     const s = t.normalize("NFKD");
-    Ge.set(t, s);
+    le.set(t, s);
     return s;
 };
 
-const He = new Map;
+const ce = new Map;
 
-const qe = t => {
-    const e = He.get(t);
+const normalizeNocase = t => {
+    const e = ce.get(t);
     if (e) return e;
-    const s = $e(t.toLowerCase());
-    He.set(t, s);
+    const s = normalize(t.toLowerCase());
+    ce.set(t, s);
     return s;
 };
 
@@ -3085,7 +3334,7 @@ class ChildrenCache extends LRUCache {
     }
 }
 
-const Ze = Symbol("PathScurry setAsCwd");
+const fe = Symbol("PathScurry setAsCwd");
 
 class PathBase {
     name;
@@ -3127,9 +3376,9 @@ class PathBase {
     get ino() {
         return this.#pt;
     }
-    #x;
+    #v;
     get size() {
-        return this.#x;
+        return this.#v;
     }
     #gt;
     get blocks() {
@@ -3139,13 +3388,13 @@ class PathBase {
     get atimeMs() {
         return this.#mt;
     }
-    #wt;
+    #yt;
     get mtimeMs() {
-        return this.#wt;
+        return this.#yt;
     }
-    #yt;
+    #wt;
     get ctimeMs() {
-        return this.#yt;
+        return this.#wt;
     }
     #bt;
     get birthtimeMs() {
@@ -3159,46 +3408,46 @@ class PathBase {
     get mtime() {
         return this.#kt;
     }
-    #vt;
+    #xt;
     get ctime() {
-        return this.#vt;
+        return this.#xt;
     }
-    #xt;
+    #vt;
     get birthtime() {
-        return this.#xt;
+        return this.#vt;
     }
     #Et;
     #Ct;
     #Tt;
-    #Lt;
     #At;
+    #Lt;
     #Mt;
     #Pt;
     #Ft;
     #Rt;
-    #zt;
+    #Ot;
     get parentPath() {
         return (this.parent || this).fullpath();
     }
     get path() {
         return this.parentPath;
     }
-    constructor(t, e = Ee, s, i, n, r, o) {
+    constructor(t, e = Ht, s, i, n, r, o) {
         this.name = t;
-        this.#Et = n ? qe(t) : $e(t);
-        this.#Pt = e & je;
+        this.#Et = n ? normalizeNocase(t) : normalize(t);
+        this.#Pt = e & ae;
         this.nocase = n;
         this.roots = i;
         this.root = s || this;
         this.#Ft = r;
         this.#Tt = o.fullpath;
-        this.#At = o.relative;
+        this.#Lt = o.relative;
         this.#Mt = o.relativePosix;
         this.parent = o.parent;
         if (this.parent) {
             this.#ot = this.parent.#ot;
         } else {
-            this.#ot = Se(o.fs);
+            this.#ot = fsFromOption(o.fs);
         }
     }
     depth() {
@@ -3216,10 +3465,10 @@ class PathBase {
         const e = this.getRootString(t);
         const s = t.substring(e.length);
         const i = s.split(this.splitSep);
-        const n = e ? this.getRoot(e).#Ot(i) : this.#Ot(i);
+        const n = e ? this.getRoot(e).#zt(i) : this.#zt(i);
         return n;
     }
-    #Ot(t) {
+    #zt(t) {
         let e = this;
         for (const s of t) {
             e = e.child(s);
@@ -3235,7 +3484,7 @@ class PathBase {
             provisional: 0
         });
         this.#Ft.set(this, e);
-        this.#Pt &= ~Oe;
+        this.#Pt &= ~ee;
         return e;
     }
     child(t, e) {
@@ -3246,7 +3495,7 @@ class PathBase {
             return this.parent || this;
         }
         const s = this.children();
-        const i = this.nocase ? qe(t) : $e(t);
+        const i = this.nocase ? normalizeNocase(t) : normalize(t);
         for (const t of s) {
             if (t.#Et === i) {
                 return t;
@@ -3254,26 +3503,26 @@ class PathBase {
         }
         const n = this.parent ? this.sep : "";
         const r = this.#Tt ? this.#Tt + n + t : undefined;
-        const o = this.newChild(t, Ee, {
+        const o = this.newChild(t, Ht, {
             ...e,
             parent: this,
             fullpath: r
         });
         if (!this.canReaddir()) {
-            o.#Pt |= Be;
+            o.#Pt |= ne;
         }
         s.push(o);
         return o;
     }
     relative() {
         if (this.isCWD) return "";
-        if (this.#At !== undefined) {
-            return this.#At;
+        if (this.#Lt !== undefined) {
+            return this.#Lt;
         }
         const t = this.name;
         const e = this.parent;
         if (!e) {
-            return this.#At = this.name;
+            return this.#Lt = this.name;
         }
         const s = e.relative();
         return s + (!s || !e.parent ? "" : this.sep) + t;
@@ -3304,23 +3553,23 @@ class PathBase {
         return this.#Tt = i;
     }
     fullpathPosix() {
-        if (this.#Lt !== undefined) return this.#Lt;
-        if (this.sep === "/") return this.#Lt = this.fullpath();
+        if (this.#At !== undefined) return this.#At;
+        if (this.sep === "/") return this.#At = this.fullpath();
         if (!this.parent) {
             const t = this.fullpath().replace(/\\/g, "/");
             if (/^[a-z]:\//i.test(t)) {
-                return this.#Lt = `//?/${t}`;
+                return this.#At = `//?/${t}`;
             } else {
-                return this.#Lt = t;
+                return this.#At = t;
             }
         }
         const t = this.parent;
         const e = t.fullpathPosix();
         const s = e + (!e || !t.parent ? "" : "/") + this.name;
-        return this.#Lt = s;
+        return this.#At = s;
     }
     isUnknown() {
-        return (this.#Pt & Re) === Ee;
+        return (this.#Pt & Qt) === Ht;
     }
     isType(t) {
         return this[`is${t}`]();
@@ -3329,34 +3578,34 @@ class PathBase {
         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.#Pt & Re) === Me;
+        return (this.#Pt & Qt) === Kt;
     }
     isDirectory() {
-        return (this.#Pt & Re) === Le;
+        return (this.#Pt & Qt) === Vt;
     }
     isCharacterDevice() {
-        return (this.#Pt & Re) === Te;
+        return (this.#Pt & Qt) === qt;
     }
     isBlockDevice() {
-        return (this.#Pt & Re) === Ae;
+        return (this.#Pt & Qt) === Jt;
     }
     isFIFO() {
-        return (this.#Pt & Re) === Ce;
+        return (this.#Pt & Qt) === Zt;
     }
     isSocket() {
-        return (this.#Pt & Re) === Fe;
+        return (this.#Pt & Qt) === Xt;
     }
     isSymbolicLink() {
-        return (this.#Pt & Pe) === Pe;
+        return (this.#Pt & Yt) === Yt;
     }
     lstatCached() {
-        return this.#Pt & De ? this : undefined;
+        return this.#Pt & se ? this : undefined;
     }
     readlinkCached() {
         return this.#Rt;
     }
     realpathCached() {
-        return this.#zt;
+        return this.#Ot;
     }
     readdirCached() {
         const t = this.children();
@@ -3365,17 +3614,17 @@ class PathBase {
     canReadlink() {
         if (this.#Rt) return true;
         if (!this.parent) return false;
-        const t = this.#Pt & Re;
-        return !(t !== Ee && t !== Pe || this.#Pt & We || this.#Pt & Be);
+        const t = this.#Pt & Qt;
+        return !(t !== Ht && t !== Yt || this.#Pt & re || this.#Pt & ne);
     }
     calledReaddir() {
-        return !!(this.#Pt & Oe);
+        return !!(this.#Pt & ee);
     }
     isENOENT() {
-        return !!(this.#Pt & Be);
+        return !!(this.#Pt & ne);
     }
     isNamed(t) {
-        return !this.nocase ? this.#Et === $e(t) : this.#Et === qe(t);
+        return !this.nocase ? this.#Et === normalize(t) : this.#Et === normalizeNocase(t);
     }
     async readlink() {
         const t = this.#Rt;
@@ -3421,59 +3670,59 @@ class PathBase {
             return undefined;
         }
     }
-    #Nt(t) {
-        this.#Pt |= Oe;
+    #Bt(t) {
+        this.#Pt |= ee;
         for (let e = t.provisional; e < t.length; e++) {
             const s = t[e];
-            if (s) s.#Bt();
+            if (s) s.#Nt();
         }
     }
-    #Bt() {
-        if (this.#Pt & Be) return;
-        this.#Pt = (this.#Pt | Be) & ze;
-        this.#Wt();
+    #Nt() {
+        if (this.#Pt & ne) return;
+        this.#Pt = (this.#Pt | ne) & te;
+        this.#It();
     }
-    #Wt() {
+    #It() {
         const t = this.children();
         t.provisional = 0;
         for (const e of t) {
-            e.#Bt();
+            e.#Nt();
         }
     }
-    #It() {
-        this.#Pt |= Ie;
+    #Wt() {
+        this.#Pt |= oe;
         this.#_t();
     }
     #_t() {
-        if (this.#Pt & Ne) return;
+        if (this.#Pt & ie) return;
         let t = this.#Pt;
-        if ((t & Re) === Le) t &= ze;
-        this.#Pt = t | Ne;
-        this.#Wt();
+        if ((t & Qt) === Vt) t &= te;
+        this.#Pt = t | ie;
+        this.#It();
     }
     #jt(t = "") {
         if (t === "ENOTDIR" || t === "EPERM") {
             this.#_t();
         } else if (t === "ENOENT") {
-            this.#Bt();
+            this.#Nt();
         } else {
             this.children().provisional = 0;
         }
     }
-    #Ut(t = "") {
+    #$t(t = "") {
         if (t === "ENOTDIR") {
             const t = this.parent;
             t.#_t();
         } else if (t === "ENOENT") {
-            this.#Bt();
+            this.#Nt();
         }
     }
     #Dt(t = "") {
         let e = this.#Pt;
-        e |= We;
-        if (t === "ENOENT") e |= Be;
+        e |= re;
+        if (t === "ENOENT") e |= ne;
         if (t === "EINVAL" || t === "UNKNOWN") {
-            e &= ze;
+            e &= te;
         }
         this.#Pt = e;
         if (t === "ENOTDIR" && this.parent) {
@@ -3481,34 +3730,34 @@ class PathBase {
         }
     }
     #Gt(t, e) {
-        return this.#$t(t, e) || this.#Ht(t, e);
+        return this.#Ut(t, e) || this.#Ht(t, e);
     }
     #Ht(t, e) {
-        const s = Ue(t);
+        const s = entToType(t);
         const i = this.newChild(t.name, s, {
             parent: this
         });
-        const n = i.#Pt & Re;
-        if (n !== Le && n !== Pe && n !== Ee) {
-            i.#Pt |= Ne;
+        const n = i.#Pt & Qt;
+        if (n !== Vt && n !== Yt && n !== Ht) {
+            i.#Pt |= ie;
         }
         e.unshift(i);
         e.provisional++;
         return i;
     }
-    #$t(t, e) {
+    #Ut(t, e) {
         for (let s = e.provisional; s < e.length; s++) {
             const i = e[s];
-            const n = this.nocase ? qe(t.name) : $e(t.name);
+            const n = this.nocase ? normalizeNocase(t.name) : normalize(t.name);
             if (n !== i.#Et) {
                 continue;
             }
-            return this.#qt(t, i, s, e);
+            return this.#Zt(t, i, s, e);
         }
     }
-    #qt(t, e, s, i) {
+    #Zt(t, e, s, i) {
         const n = e.name;
-        e.#Pt = e.#Pt & ze | Ue(t);
+        e.#Pt = e.#Pt & te | entToType(t);
         if (n !== t.name) e.name = t.name;
         if (s !== i.provisional) {
             if (s === i.length - 1) i.pop(); else i.splice(s, 1);
@@ -3518,49 +3767,49 @@ class PathBase {
         return e;
     }
     async lstat() {
-        if ((this.#Pt & Be) === 0) {
+        if ((this.#Pt & ne) === 0) {
             try {
-                this.#Zt(await this.#ot.promises.lstat(this.fullpath()));
+                this.#qt(await this.#ot.promises.lstat(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
     lstatSync() {
-        if ((this.#Pt & Be) === 0) {
+        if ((this.#Pt & ne) === 0) {
             try {
-                this.#Zt(this.#ot.lstatSync(this.fullpath()));
+                this.#qt(this.#ot.lstatSync(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
-    #Zt(t) {
-        const {atime: e, atimeMs: s, birthtime: i, birthtimeMs: n, blksize: r, blocks: o, ctime: h, ctimeMs: a, dev: l, gid: c, ino: f, mode: u, mtime: d, mtimeMs: p, nlink: g, rdev: m, size: w, uid: y} = t;
+    #qt(t) {
+        const {atime: e, atimeMs: s, birthtime: i, birthtimeMs: n, blksize: r, blocks: o, ctime: h, ctimeMs: a, dev: l, gid: c, ino: f, mode: u, mtime: d, mtimeMs: p, nlink: g, rdev: y, size: w, uid: b} = t;
         this.#St = e;
         this.#mt = s;
-        this.#xt = i;
+        this.#vt = i;
         this.#bt = n;
         this.#dt = r;
         this.#gt = o;
-        this.#vt = h;
-        this.#yt = a;
+        this.#xt = h;
+        this.#wt = a;
         this.#ht = l;
         this.#ft = c;
         this.#pt = f;
         this.#at = u;
         this.#kt = d;
-        this.#wt = p;
+        this.#yt = p;
         this.#lt = g;
-        this.#ut = m;
-        this.#x = w;
-        this.#ct = y;
-        const b = Ue(t);
-        this.#Pt = this.#Pt & ze | b | De;
-        if (b !== Ee && b !== Le && b !== Pe) {
-            this.#Pt |= Ne;
+        this.#ut = y;
+        this.#v = w;
+        this.#ct = b;
+        const S = entToType(t);
+        this.#Pt = this.#Pt & te | S | se;
+        if (S !== Ht && S !== Vt && S !== Yt) {
+            this.#Pt |= ie;
         }
     }
     #Vt=[];
@@ -3598,7 +3847,7 @@ class PathBase {
                 for (const t of e) {
                     this.#Gt(t, s);
                 }
-                this.#Nt(s);
+                this.#Bt(s);
             }
             this.#Kt(s.slice(0, s.provisional));
             return;
@@ -3617,21 +3866,21 @@ class PathBase {
         if (this.#Yt) {
             await this.#Yt;
         } else {
-            let s = () => {};
-            this.#Yt = new Promise((t => s = t));
+            let resolve = () => {};
+            this.#Yt = new Promise((t => resolve = t));
             try {
                 for (const s of await this.#ot.promises.readdir(e, {
                     withFileTypes: true
                 })) {
                     this.#Gt(s, t);
                 }
-                this.#Nt(t);
+                this.#Bt(t);
             } catch (e) {
                 this.#jt(e.code);
                 t.provisional = 0;
             }
             this.#Yt = undefined;
-            s();
+            resolve();
         }
         return t.slice(0, t.provisional);
     }
@@ -3650,7 +3899,7 @@ class PathBase {
             })) {
                 this.#Gt(s, t);
             }
-            this.#Nt(t);
+            this.#Bt(t);
         } catch (e) {
             this.#jt(e.code);
             t.provisional = 0;
@@ -3658,37 +3907,37 @@ class PathBase {
         return t.slice(0, t.provisional);
     }
     canReaddir() {
-        if (this.#Pt & _e) return false;
-        const t = Re & this.#Pt;
-        if (!(t === Ee || t === Le || t === Pe)) {
+        if (this.#Pt & he) return false;
+        const t = Qt & this.#Pt;
+        if (!(t === Ht || t === Vt || t === Yt)) {
             return false;
         }
         return true;
     }
     shouldWalk(t, e) {
-        return (this.#Pt & Le) === Le && !(this.#Pt & _e) && !t.has(this) && (!e || e(this));
+        return (this.#Pt & Vt) === Vt && !(this.#Pt & he) && !t.has(this) && (!e || e(this));
     }
     async realpath() {
-        if (this.#zt) return this.#zt;
-        if ((Ie | We | Be) & this.#Pt) return undefined;
+        if (this.#Ot) return this.#Ot;
+        if ((oe | re | ne) & this.#Pt) return undefined;
         try {
             const t = await this.#ot.promises.realpath(this.fullpath());
-            return this.#zt = this.resolve(t);
+            return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#It();
+            this.#Wt();
         }
     }
     realpathSync() {
-        if (this.#zt) return this.#zt;
-        if ((Ie | We | Be) & this.#Pt) return undefined;
+        if (this.#Ot) return this.#Ot;
+        if ((oe | re | ne) & this.#Pt) return undefined;
         try {
             const t = this.#ot.realpathSync(this.fullpath());
-            return this.#zt = this.resolve(t);
+            return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#It();
+            this.#Wt();
         }
     }
-    [Ze](t) {
+    [fe](t) {
         if (t === this) return;
         t.isCWD = false;
         this.isCWD = true;
@@ -3697,14 +3946,14 @@ class PathBase {
         let i = this;
         while (i && i.parent) {
             e.add(i);
-            i.#At = s.join(this.sep);
+            i.#Lt = s.join(this.sep);
             i.#Mt = s.join("/");
             i = i.parent;
             s.push("..");
         }
         i = t;
         while (i && i.parent && !e.has(i)) {
-            i.#At = undefined;
+            i.#Lt = undefined;
             i.#Mt = undefined;
             i = i.parent;
         }
@@ -3713,18 +3962,18 @@ class PathBase {
 
 class PathWin32 extends PathBase {
     sep="\\";
-    splitSep=xe;
-    constructor(t, e = Ee, s, i, n, r, o) {
+    splitSep=Ut;
+    constructor(t, e = Ht, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
-    newChild(t, e = Ee, s = {}) {
+    newChild(t, e = Ht, s = {}) {
         return new PathWin32(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
     getRootString(t) {
-        return s.parse(t).root;
+        return e.parse(t).root;
     }
     getRoot(t) {
-        t = ve(t.toUpperCase());
+        t = uncToDrive(t.toUpperCase());
         if (t === this.root.name) {
             return this.root;
         }
@@ -3736,7 +3985,7 @@ class PathWin32 extends PathBase {
         return this.roots[t] = new PathScurryWin32(t, this).root;
     }
     sameRoot(t, e = this.root.name) {
-        t = t.toUpperCase().replace(/\//g, "\\").replace(ke, "$1\\");
+        t = t.toUpperCase().replace(/\//g, "\\").replace(Gt, "$1\\");
         return t === e;
     }
 }
@@ -3744,7 +3993,7 @@ class PathWin32 extends PathBase {
 class PathPosix extends PathBase {
     splitSep="/";
     sep="/";
-    constructor(t, e = Ee, s, i, n, r, o) {
+    constructor(t, e = Ht, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
     getRootString(t) {
@@ -3753,7 +4002,7 @@ class PathPosix extends PathBase {
     getRoot(t) {
         return this.root;
     }
-    newChild(t, e = Ee, s = {}) {
+    newChild(t, e = Ht, s = {}) {
         return new PathPosix(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
 }
@@ -3768,12 +4017,12 @@ class PathScurryBase {
     #Ft;
     nocase;
     #ot;
-    constructor(t = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = be} = {}) {
-        this.#ot = Se(o);
-        if (t instanceof URL || t.startsWith("file://")) {
-            t = e(t);
+    constructor(e = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = $t} = {}) {
+        this.#ot = fsFromOption(o);
+        if (e instanceof URL || e.startsWith("file://")) {
+            e = t(e);
         }
-        const h = s.resolve(t);
+        const h = s.resolve(e);
         this.roots = Object.create(null);
         this.rootPath = this.parseRootPath(h);
         this.#Xt = new ResolveCache;
@@ -3982,38 +4231,38 @@ class PathScurryBase {
             o.push(s ? t : t.fullpath());
         }
         const h = new Set;
-        const a = (t, e) => {
+        const walk = (t, e) => {
             h.add(t);
-            t.readdirCB(((t, l) => {
+            t.readdirCB(((t, a) => {
                 if (t) {
                     return e(t);
                 }
-                let c = l.length;
-                if (!c) return e();
-                const f = () => {
-                    if (--c === 0) {
+                let l = a.length;
+                if (!l) return e();
+                const next = () => {
+                    if (--l === 0) {
                         e();
                     }
                 };
-                for (const t of l) {
+                for (const t of a) {
                     if (!n || n(t)) {
                         o.push(s ? t : t.fullpath());
                     }
                     if (i && t.isSymbolicLink()) {
-                        t.realpath().then((t => t?.isUnknown() ? t.lstat() : t)).then((t => t?.shouldWalk(h, r) ? a(t, f) : f()));
+                        t.realpath().then((t => t?.isUnknown() ? t.lstat() : t)).then((t => t?.shouldWalk(h, r) ? walk(t, next) : next()));
                     } else {
                         if (t.shouldWalk(h, r)) {
-                            a(t, f);
+                            walk(t, next);
                         } else {
-                            f();
+                            next();
                         }
                     }
                 }
             }), true);
         };
-        const l = t;
+        const a = t;
         return new Promise(((t, e) => {
-            a(l, (s => {
+            walk(a, (s => {
                 if (s) return e(s);
                 t(o);
             }));
@@ -4111,7 +4360,7 @@ class PathScurryBase {
         const h = new Set;
         const a = [ t ];
         let l = 0;
-        const c = () => {
+        const process = () => {
             let t = false;
             while (!t) {
                 const e = a.shift();
@@ -4121,21 +4370,21 @@ class PathScurryBase {
                 }
                 l++;
                 h.add(e);
-                const f = (e, d, p = false) => {
+                const onReaddir = (e, f, u = false) => {
                     if (e) return o.emit("error", e);
-                    if (i && !p) {
+                    if (i && !u) {
                         const t = [];
-                        for (const e of d) {
+                        for (const e of f) {
                             if (e.isSymbolicLink()) {
                                 t.push(e.realpath().then((t => t?.isUnknown() ? t.lstat() : t)));
                             }
                         }
                         if (t.length) {
-                            Promise.all(t).then((() => f(null, d, true)));
+                            Promise.all(t).then((() => onReaddir(null, f, true)));
                             return;
                         }
                     }
-                    for (const e of d) {
+                    for (const e of f) {
                         if (e && (!n || n(e))) {
                             if (!o.write(s ? e : e.fullpath())) {
                                 t = true;
@@ -4143,24 +4392,24 @@ class PathScurryBase {
                         }
                     }
                     l--;
-                    for (const t of d) {
+                    for (const t of f) {
                         const e = t.realpathCached() || t;
                         if (e.shouldWalk(h, r)) {
                             a.push(e);
                         }
                     }
                     if (t && !o.flowing) {
-                        o.once("drain", c);
-                    } else if (!u) {
-                        c();
+                        o.once("drain", process);
+                    } else if (!c) {
+                        process();
                     }
                 };
-                let u = true;
-                e.readdirCB(f, true);
-                u = false;
+                let c = true;
+                e.readdirCB(onReaddir, true);
+                c = false;
             }
         };
-        c();
+        process();
         return o;
     }
     streamSync(t = this.cwd, e = {}) {
@@ -4180,7 +4429,7 @@ class PathScurryBase {
         }
         const a = [ t ];
         let l = 0;
-        const c = () => {
+        const process = () => {
             let t = false;
             while (!t) {
                 const e = a.shift();
@@ -4210,24 +4459,24 @@ class PathScurryBase {
                     }
                 }
             }
-            if (t && !o.flowing) o.once("drain", c);
+            if (t && !o.flowing) o.once("drain", process);
         };
-        c();
+        process();
         return o;
     }
     chdir(t = this.cwd) {
         const e = this.cwd;
         this.cwd = typeof t === "string" ? this.cwd.resolve(t) : t;
-        this.cwd[Ze](e);
+        this.cwd[fe](e);
     }
 }
 
 class PathScurryWin32 extends PathScurryBase {
     sep="\\";
-    constructor(t = process.cwd(), e = {}) {
-        const {nocase: i = true} = e;
-        super(t, s, "\\", {
-            ...e,
+    constructor(t = process.cwd(), s = {}) {
+        const {nocase: i = true} = s;
+        super(t, e, "\\", {
+            ...s,
             nocase: i
         });
         this.nocase = i;
@@ -4236,10 +4485,10 @@ class PathScurryWin32 extends PathScurryBase {
         }
     }
     parseRootPath(t) {
-        return s.parse(t).root.toUpperCase();
+        return e.parse(t).root.toUpperCase();
     }
     newRoot(t) {
-        return new PathWin32(this.rootPath, Le, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathWin32(this.rootPath, Vt, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4251,18 +4500,18 @@ class PathScurryWin32 extends PathScurryBase {
 class PathScurryPosix extends PathScurryBase {
     sep="/";
     constructor(t = process.cwd(), e = {}) {
-        const {nocase: s = false} = e;
-        super(t, i, "/", {
+        const {nocase: i = false} = e;
+        super(t, s, "/", {
             ...e,
-            nocase: s
+            nocase: i
         });
-        this.nocase = s;
+        this.nocase = i;
     }
     parseRootPath(t) {
         return "/";
     }
     newRoot(t) {
-        return new PathPosix(this.rootPath, Le, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathPosix(this.rootPath, Vt, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4281,13 +4530,13 @@ class PathScurryDarwin extends PathScurryPosix {
     }
 }
 
-const Ve = process.platform === "win32" ? PathWin32 : PathPosix;
+const ue = process.platform === "win32" ? PathWin32 : PathPosix;
 
-const Je = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+const de = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-const Ke = t => t.length >= 1;
+const isPatternList = t => t.length >= 1;
 
-const Ye = t => t.length >= 1;
+const isGlobList = t => t.length >= 1;
 
 class Pattern {
     #te;
@@ -4302,10 +4551,10 @@ class Pattern {
     #ae;
     #le=true;
     constructor(t, e, s, i) {
-        if (!Ke(t)) {
+        if (!isPatternList(t)) {
             throw new TypeError("empty pattern list");
         }
-        if (!Ye(e)) {
+        if (!isGlobList(e)) {
             throw new TypeError("empty glob list");
         }
         if (e.length !== t.length) {
@@ -4354,7 +4603,7 @@ class Pattern {
         return typeof this.#te[this.#se] === "string";
     }
     isGlobstar() {
-        return this.#te[this.#se] === ht;
+        return this.#te[this.#se] === Y;
     }
     isRegExp() {
         return this.#te[this.#se] instanceof RegExp;
@@ -4400,7 +4649,7 @@ class Pattern {
     }
 }
 
-const Xe = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const pe = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
 class Ignore {
     relative;
@@ -4409,7 +4658,7 @@ class Ignore {
     absoluteChildren;
     platform;
     mmopts;
-    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = Xe}) {
+    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = pe}) {
         this.relative = [];
         this.absolute = [];
         this.relativeChildren = [];
@@ -4585,7 +4834,7 @@ class Processor {
                 const e = n === ".." || n === "" || n === ".";
                 this.matches.add(t.resolve(n), i, e);
                 continue;
-            } else if (n === ht) {
+            } else if (n === Y) {
                 if (!t.isSymbolicLink() || this.follow || e.checkFollowGlobstar()) {
                     this.subwalks.add(t, e);
                 }
@@ -4621,7 +4870,7 @@ class Processor {
                 const s = e.isAbsolute();
                 const n = e.pattern();
                 const r = e.rest();
-                if (n === ht) {
+                if (n === Y) {
                     i.testGlobstar(t, e, r, s);
                 } else if (n instanceof RegExp) {
                     i.testRegExp(t, n, r, s);
@@ -4679,7 +4928,7 @@ class Processor {
     }
 }
 
-const Qe = (t, e) => typeof t === "string" ? new Ignore([ t ], e) : Array.isArray(t) ? new Ignore(t, e) : t;
+const makeIgnore = (t, e) => typeof t === "string" ? new Ignore([ t ], e) : Array.isArray(t) ? new Ignore(t, e) : t;
 
 class GlobUtil {
     path;
@@ -4701,7 +4950,7 @@ class GlobUtil {
         this.#ue = !s.posix && s.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = s.includeChildMatches !== false;
         if (s.ignore || !this.includeChildMatches) {
-            this.#fe = Qe(s.ignore ?? [], s);
+            this.#fe = makeIgnore(s.ignore ?? [], s);
             if (!this.includeChildMatches && typeof this.#fe.add !== "function") {
                 const t = "cannot ignore child matches, ignore lacks add() method.";
                 throw new Error(t);
@@ -4820,13 +5069,13 @@ class GlobUtil {
         }
         s.processPatterns(t, e);
         let n = 1;
-        const r = () => {
+        const next = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
             if (this.#de(t)) continue;
             n++;
-            this.match(t, e, i).then((() => r()));
+            this.match(t, e, i).then((() => next()));
         }
         for (const t of s.subwalkTargets()) {
             if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
@@ -4834,28 +5083,28 @@ class GlobUtil {
             }
             n++;
             const e = t.readdirCached();
-            if (t.calledReaddir()) this.walkCB3(t, e, s, r); else {
-                t.readdirCB(((e, i) => this.walkCB3(t, i, s, r)), true);
+            if (t.calledReaddir()) this.walkCB3(t, e, s, next); else {
+                t.readdirCB(((e, i) => this.walkCB3(t, i, s, next)), true);
             }
         }
-        r();
+        next();
     }
     walkCB3(t, e, s, i) {
         s = s.filterEntries(t, e);
         let n = 1;
-        const r = () => {
+        const next = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
             if (this.#de(t)) continue;
             n++;
-            this.match(t, e, i).then((() => r()));
+            this.match(t, e, i).then((() => next()));
         }
         for (const [t, e] of s.subwalks.entries()) {
             n++;
-            this.walkCB2(t, e, s.child(), r);
+            this.walkCB2(t, e, s.child(), next);
         }
-        r();
+        next();
     }
     walkCBSync(t, e, s) {
         if (this.signal?.aborted) s();
@@ -4870,7 +5119,7 @@ class GlobUtil {
         }
         s.processPatterns(t, e);
         let n = 1;
-        const r = () => {
+        const next = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
@@ -4883,14 +5132,14 @@ class GlobUtil {
             }
             n++;
             const e = t.readdirSync();
-            this.walkCB3Sync(t, e, s, r);
+            this.walkCB3Sync(t, e, s, next);
         }
-        r();
+        next();
     }
     walkCB3Sync(t, e, s, i) {
         s = s.filterEntries(t, e);
         let n = 1;
-        const r = () => {
+        const next = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
@@ -4899,9 +5148,9 @@ class GlobUtil {
         }
         for (const [t, e] of s.subwalks.entries()) {
             n++;
-            this.walkCB2Sync(t, e, s.child(), r);
+            this.walkCB2Sync(t, e, s.child(), next);
         }
-        r();
+        next();
     }
 }
 
@@ -4976,9 +5225,9 @@ class GlobStream extends GlobUtil {
     }
 }
 
-const ts = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const ge = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
-let es = class Glob {
+let me = class Glob {
     absolute;
     cwd;
     root;
@@ -5006,7 +5255,7 @@ let es = class Glob {
     includeChildMatches;
     opts;
     patterns;
-    constructor(t, s) {
+    constructor(e, s) {
         if (!s) throw new TypeError("glob options required");
         this.withFileTypes = !!s.withFileTypes;
         this.signal = s.signal;
@@ -5018,7 +5267,7 @@ let es = class Glob {
         if (!s.cwd) {
             this.cwd = "";
         } else if (s.cwd instanceof URL || s.cwd.startsWith("file://")) {
-            s.cwd = e(s.cwd);
+            s.cwd = t(s.cwd);
         }
         this.cwd = s.cwd || "";
         this.root = s.root;
@@ -5036,21 +5285,21 @@ let es = class Glob {
         if (this.withFileTypes && this.absolute !== undefined) {
             throw new Error("cannot set absolute and withFileTypes:true");
         }
-        if (typeof t === "string") {
-            t = [ t ];
+        if (typeof e === "string") {
+            e = [ e ];
         }
         this.windowsPathsNoEscape = !!s.windowsPathsNoEscape || s.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
-            t = t.map((t => t.replace(/\\/g, "/")));
+            e = e.map((t => t.replace(/\\/g, "/")));
         }
         if (this.matchBase) {
             if (s.noglobstar) {
                 throw new TypeError("base matching requires globstar");
             }
-            t = t.map((t => t.includes("/") ? t : `./**/${t}`));
+            e = e.map((t => t.includes("/") ? t : `./**/${t}`));
         }
-        this.pattern = t;
-        this.platform = s.platform || ts;
+        this.pattern = e;
+        this.platform = s.platform || ge;
         this.opts = {
             ...s,
             platform: this.platform
@@ -5061,7 +5310,7 @@ let es = class Glob {
                 throw new Error("nocase option contradicts provided scurry option");
             }
         } else {
-            const t = s.platform === "win32" ? PathScurryWin32 : s.platform === "darwin" ? PathScurryDarwin : s.platform ? PathScurryPosix : Je;
+            const t = s.platform === "win32" ? PathScurryWin32 : s.platform === "darwin" ? PathScurryDarwin : s.platform ? PathScurryPosix : de;
             this.scurry = new t(this.cwd, {
                 nocase: s.nocase,
                 fs: s.fs
@@ -5146,7 +5395,7 @@ let es = class Glob {
     }
 };
 
-const ss = (t, e = {}) => {
+const hasMagic = (t, e = {}) => {
     if (!Array.isArray(t)) {
         t = [ t ];
     }
@@ -5156,69 +5405,69 @@ const ss = (t, e = {}) => {
     return false;
 };
 
-function is(t, e = {}) {
-    return new es(t, e).streamSync();
+function globStreamSync(t, e = {}) {
+    return new me(t, e).streamSync();
 }
 
-function ns(t, e = {}) {
-    return new es(t, e).stream();
+function globStream(t, e = {}) {
+    return new me(t, e).stream();
 }
 
-function rs(t, e = {}) {
-    return new es(t, e).walkSync();
+function globSync(t, e = {}) {
+    return new me(t, e).walkSync();
 }
 
-async function os(t, e = {}) {
-    return new es(t, e).walk();
+async function glob_(t, e = {}) {
+    return new me(t, e).walk();
 }
 
-function hs(t, e = {}) {
-    return new es(t, e).iterateSync();
+function globIterateSync(t, e = {}) {
+    return new me(t, e).iterateSync();
 }
 
-function as(t, e = {}) {
-    return new es(t, e).iterate();
+function globIterate(t, e = {}) {
+    return new me(t, e).iterate();
 }
 
-const ls = is;
+const ye = globStreamSync;
 
-const cs = Object.assign(ns, {
-    sync: is
+const we = Object.assign(globStream, {
+    sync: globStreamSync
 });
 
-const fs = hs;
+const be = globIterateSync;
 
-const us = Object.assign(as, {
-    sync: hs
+const Se = Object.assign(globIterate, {
+    sync: globIterateSync
 });
 
-const ds = Object.assign(rs, {
-    stream: is,
-    iterate: hs
+const ke = Object.assign(globSync, {
+    stream: globStreamSync,
+    iterate: globIterateSync
 });
 
-const ps = Object.assign(os, {
-    glob: os,
-    globSync: rs,
-    sync: ds,
-    globStream: ns,
-    stream: cs,
-    globStreamSync: is,
-    streamSync: ls,
-    globIterate: as,
-    iterate: us,
-    globIterateSync: hs,
-    iterateSync: fs,
-    Glob: es,
-    hasMagic: ss,
-    escape: N,
-    unescape: E
+const xe = Object.assign(glob_, {
+    glob: glob_,
+    globSync,
+    sync: ke,
+    globStream,
+    stream: we,
+    globStreamSync,
+    streamSync: ye,
+    globIterate,
+    iterate: Se,
+    globIterateSync,
+    iterateSync: be,
+    Glob: me,
+    hasMagic,
+    escape,
+    unescape
 });
 
-ps.glob = ps;
+xe.glob = xe;
 
-async function gs(t, e) {
-    return e ? await ps(t, e) : await ps(t);
+async function Glob(t, e) {
+    return e ? await xe(t, e) : await xe(t);
 }
 
-export { gs as Glob };
+export { Glob };