lakutata 2.0.80 → 2.0.82

package/src/lib/helpers/Glob.cjs

@@ -4,31 +4,27 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const t = require("../../../vendor/Package.63.cjs");
+const t = require("node:url");
 
-const e = require("node:url");
+const e = require("node:path");
 
-const s = require("node:path");
+const s = require("fs");
 
-const i = require("fs");
+const i = require("node:fs");
 
-const n = require("node:fs");
+const n = require("node:fs/promises");
 
-const r = require("node:fs/promises");
+const r = require("node:events");
 
-const o = require("node:events");
+const o = require("node:stream");
 
-const h = require("node:stream");
+const h = require("node:string_decoder");
 
-const a = require("node:string_decoder");
-
-require("../../../vendor/Package.5.cjs");
-
-const l = t => t && t.__esModule ? t : {
+const _interopDefault = t => t && t.__esModule ? t : {
     default: t
 };
 
-function c(t) {
+function _interopNamespace(t) {
     if (t && t.__esModule) return t;
     const e = Object.create(null, {
         [Symbol.toStringTag]: {
@@ -50,22 +46,254 @@ function c(t) {
     return Object.freeze(e);
 }
 
-const f = c(n);
+const a = _interopNamespace(i);
+
+const l = _interopDefault(o);
+
+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 c = "\0SLASH" + Math.random() + "\0";
+
+const f = "\0OPEN" + Math.random() + "\0";
+
+const u = "\0CLOSE" + Math.random() + "\0";
+
+const d = "\0COMMA" + Math.random() + "\0";
+
+const p = "\0PERIOD" + Math.random() + "\0";
+
+const g = new RegExp(c, "g");
+
+const y = new RegExp(f, "g");
+
+const w = new RegExp(u, "g");
+
+const b = new RegExp(d, "g");
+
+const S = new RegExp(p, "g");
+
+const k = /\\\\/g;
+
+const x = /\\{/g;
+
+const v = /\\}/g;
+
+const E = /\\,/g;
+
+const C = /\\./g;
+
+function numeric(t) {
+    return !isNaN(t) ? parseInt(t, 10) : t.charCodeAt(0);
+}
+
+function escapeBraces(t) {
+    return t.replace(k, c).replace(x, f).replace(v, u).replace(E, d).replace(C, p);
+}
 
-const u = l(h);
+function unescapeBraces(t) {
+    return t.replace(g, "\\").replace(y, "{").replace(w, "}").replace(b, ",").replace(S, ".");
+}
 
-const d = 1024 * 64;
+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;
+}
 
-const p = t => {
+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);
+}
+
+function lte(t, e) {
+    return t <= e;
+}
+
+function gte(t, e) {
+    return t >= e;
+}
+
+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 + u + 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 T = 1024 * 64;
+
+const assertValidPattern = t => {
     if (typeof t !== "string") {
         throw new TypeError("invalid pattern");
     }
-    if (t.length > d) {
+    if (t.length > T) {
         throw new TypeError("pattern is too long");
     }
 };
 
-const g = {
+const L = {
     "[:alnum:]": [ "\\p{L}\\p{Nl}\\p{Nd}", true ],
     "[:alpha:]": [ "\\p{L}\\p{Nl}", true ],
     "[:ascii:]": [ "\\x" + "00-\\x" + "7f", false ],
@@ -82,13 +310,13 @@ const g = {
     "[:xdigit:]": [ "A-Fa-f0-9", false ]
 };
 
-const m = t => t.replace(/[[\]\\-]/g, "\\$&");
+const braceEscape = t => t.replace(/[[\]\\-]/g, "\\$&");
 
-const w = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regexpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const y = t => t.join("");
+const rangesToString = t => t.join("");
 
-const b = (t, e) => {
+const parseClass = (t, e) => {
     const s = e;
     if (t.charAt(s) !== "[") {
         throw new Error("not in a brace expression");
@@ -122,7 +350,7 @@ const b = (t, e) => {
             }
         }
         if (e === "[" && !a) {
-            for (const [e, [o, a, l]] of Object.entries(g)) {
+            for (const [e, [o, a, l]] of Object.entries(L)) {
                 if (t.startsWith(e, r)) {
                     if (f) {
                         return [ "$.", false, t.length - s, true ];
@@ -137,16 +365,16 @@ const b = (t, e) => {
         a = false;
         if (f) {
             if (e > f) {
-                i.push(m(f) + "-" + m(e));
+                i.push(braceEscape(f) + "-" + braceEscape(e));
             } else if (e === f) {
-                i.push(m(e));
+                i.push(braceEscape(e));
             }
             f = "";
             r++;
             continue;
         }
         if (t.startsWith("-]", r + 1)) {
-            i.push(m(e + "-"));
+            i.push(braceEscape(e + "-"));
             r += 2;
             continue;
         }
@@ -155,7 +383,7 @@ const b = (t, e) => {
             r += 2;
             continue;
         }
-        i.push(m(e));
+        i.push(braceEscape(e));
         r++;
     }
     if (c < r) {
@@ -166,37 +394,42 @@ const b = (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 [ w(t), false, c - s, false ];
+        return [ regexpEscape(t), false, c - s, false ];
     }
-    const u = "[" + (l ? "^" : "") + y(i) + "]";
-    const d = "[" + (l ? "" : "^") + y(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 S = (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 k = new Set([ "!", "?", "+", "*", "@" ]);
+const A = new Set([ "!", "?", "+", "*", "@" ]);
 
-const v = t => k.has(t);
+const isExtglobType = t => A.has(t);
 
-const x = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const M = "(?!(?:^|/)\\.\\.?(?:$|/))";
 
-const E = "(?!\\.)";
+const P = "(?!\\.)";
 
-const T = new Set([ "[", "." ]);
+const F = new Set([ "[", "." ]);
 
-const C = new Set([ "..", "." ]);
+const R = new Set([ "..", "." ]);
 
-const L = new Set("().*{}+?[]^$\\!");
+const O = new Set("().*{}+?[]^$\\!");
 
-const A = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regExpEscape$1 = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const M = "[^/]";
+const z = "[^/]";
 
-const P = M + "*?";
+const D = z + "*?";
 
-const F = M + "+?";
+const N = z + "+?";
 
 class AST {
     type;
@@ -342,7 +575,7 @@ class AST {
                     l += s;
                     continue;
                 }
-                if (!i.noext && v(s) && t.charAt(a) === "(") {
+                if (!i.noext && isExtglobType(s) && t.charAt(a) === "(") {
                     e.push(l);
                     l = "";
                     const n = new AST(s, e);
@@ -383,7 +616,7 @@ class AST {
                 f += s;
                 continue;
             }
-            if (v(s) && t.charAt(a) === "(") {
+            if (isExtglobType(s) && t.charAt(a) === "(") {
                 l.push(f);
                 f = "";
                 const e = new AST(s, l);
@@ -440,7 +673,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;
@@ -450,12 +683,12 @@ class AST {
             let n = "";
             if (this.isStart()) {
                 if (typeof this.#i[0] === "string") {
-                    const s = this.#i.length === 1 && C.has(this.#i[0]);
+                    const s = this.#i.length === 1 && R.has(this.#i[0]);
                     if (!s) {
-                        const s = T;
+                        const s = F;
                         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 ? x : o ? E : "";
+                        n = r ? M : o ? P : "";
                     }
                 }
             }
@@ -464,7 +697,7 @@ class AST {
                 r = "(?:$|\\/)";
             }
             const o = n + i + r;
-            return [ o, S(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 === "!" ? "(?:(?!(?:" : "(?:";
@@ -474,9 +707,9 @@ class AST {
             this.#i = [ t ];
             this.type = null;
             this.#e = undefined;
-            return [ t, S(this.toString()), false, false ];
+            return [ t, unescape(this.toString()), false, false ];
         }
-        let r = !s || t || e || !E ? "" : this.#p(true);
+        let r = !s || t || e || !P ? "" : this.#p(true);
         if (r === n) {
             r = "";
         }
@@ -485,12 +718,12 @@ class AST {
         }
         let o = "";
         if (this.type === "!" && this.#c) {
-            o = (this.isStart() && !e ? E : "") + F;
+            o = (this.isStart() && !e ? P : "") + N;
         } else {
-            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? E : "") + P + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
+            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? P : "") + D + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
             o = i + n + s;
         }
-        return [ o, S(n), this.#e = !!this.#e, this.#s ];
+        return [ o, unescape(n), this.#e = !!this.#e, this.#s ];
     }
     #p(t) {
         return this.#i.map((e => {
@@ -510,7 +743,7 @@ class AST {
             const h = t.charAt(o);
             if (i) {
                 i = false;
-                n += (L.has(h) ? "\\" : "") + h;
+                n += (O.has(h) ? "\\" : "") + h;
                 continue;
             }
             if (h === "\\") {
@@ -522,7 +755,7 @@ class AST {
                 continue;
             }
             if (h === "[") {
-                const [s, i, h, a] = b(t, o);
+                const [s, i, h, a] = parseClass(t, o);
                 if (h) {
                     n += s;
                     r = r || i;
@@ -532,102 +765,107 @@ class AST {
                 }
             }
             if (h === "*") {
-                if (s && t === "*") n += F; else n += P;
+                n += s && t === "*" ? N : D;
                 e = true;
                 continue;
             }
             if (h === "?") {
-                n += M;
+                n += z;
                 e = true;
                 continue;
             }
-            n += A(h);
+            n += regExpEscape$1(h);
         }
-        return [ n, S(t), !!e, r ];
+        return [ n, unescape(t), !!e, r ];
     }
 }
 
-const R = (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 O = (t, e, s = {}) => {
-    p(e);
+const minimatch = (t, e, s = {}) => {
+    assertValidPattern(e);
     if (!s.nocomment && e.charAt(0) === "#") {
         return false;
     }
     return new Minimatch(e, s).match(t);
 };
 
-const z = /^\*+([^+@!?\*\[\(]*)$/;
+const B = /^\*+([^+@!?\*\[\(]*)$/;
 
-const D = t => e => !e.startsWith(".") && e.endsWith(t);
+const starDotExtTest = t => e => !e.startsWith(".") && e.endsWith(t);
 
-const N = t => e => e.endsWith(t);
+const starDotExtTestDot = t => e => e.endsWith(t);
 
-const B = t => {
+const starDotExtTestNocase = t => {
     t = t.toLowerCase();
     return e => !e.startsWith(".") && e.toLowerCase().endsWith(t);
 };
 
-const W = t => {
+const starDotExtTestNocaseDot = t => {
     t = t.toLowerCase();
     return e => e.toLowerCase().endsWith(t);
 };
 
 const _ = /^\*+\.\*+$/;
 
-const I = t => !t.startsWith(".") && t.includes(".");
+const starDotStarTest = t => !t.startsWith(".") && t.includes(".");
 
-const j = t => t !== "." && t !== ".." && t.includes(".");
+const starDotStarTestDot = t => t !== "." && t !== ".." && t.includes(".");
 
-const U = /^\.\*+$/;
+const I = /^\.\*+$/;
 
-const G = t => t !== "." && t !== ".." && t.startsWith(".");
+const dotStarTest = t => t !== "." && t !== ".." && t.startsWith(".");
 
-const $ = /^\*+$/;
+const W = /^\*+$/;
 
-const q = t => t.length !== 0 && !t.startsWith(".");
+const starTest = t => t.length !== 0 && !t.startsWith(".");
 
-const H = t => t.length !== 0 && t !== "." && t !== "..";
+const starTestDot = t => t.length !== 0 && t !== "." && t !== "..";
 
-const Z = /^\?+([^+@!?\*\[\(]*)?$/;
+const j = /^\?+([^+@!?\*\[\(]*)?$/;
 
-const V = ([t, e = ""]) => {
-    const s = X([ 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 J = ([t, e = ""]) => {
-    const s = Q([ 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 K = ([t, e = ""]) => {
-    const s = Q([ t ]);
+const qmarksTestDot = ([t, e = ""]) => {
+    const s = qmarksTestNoExtDot([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const Y = ([t, e = ""]) => {
-    const s = X([ t ]);
+const qmarksTest = ([t, e = ""]) => {
+    const s = qmarksTestNoExt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const X = ([t]) => {
+const qmarksTestNoExt = ([t]) => {
     const e = t.length;
     return t => t.length === e && !t.startsWith(".");
 };
 
-const Q = ([t]) => {
+const qmarksTestNoExtDot = ([t]) => {
     const e = t.length;
     return t => t.length === e && t !== "." && t !== "..";
 };
 
-const tt = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+const $ = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
 
-const et = {
+const G = {
     win32: {
         sep: "\\"
     },
@@ -636,80 +874,80 @@ const et = {
     }
 };
 
-const st = tt === "win32" ? et.win32.sep : et.posix.sep;
+const U = $ === "win32" ? G.win32.sep : G.posix.sep;
 
-O.sep = st;
+minimatch.sep = U;
 
-const it = Symbol("globstar **");
+const q = Symbol("globstar **");
 
-O.GLOBSTAR = it;
+minimatch.GLOBSTAR = q;
 
-const nt = "[^/]";
+const H = "[^/]";
 
-const rt = nt + "*?";
+const Z = H + "*?";
 
-const ot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const V = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 
-const ht = "(?:(?!(?:\\/|^)\\.).)*?";
+const J = "(?:(?!(?:\\/|^)\\.).)*?";
 
-const at = (t, e = {}) => s => O(s, t, e);
+const filter = (t, e = {}) => s => minimatch(s, t, e);
 
-O.filter = at;
+minimatch.filter = filter;
 
-const lt = (t, e = {}) => Object.assign({}, t, e);
+const ext = (t, e = {}) => Object.assign({}, t, e);
 
-const ct = t => {
+const defaults = t => {
     if (!t || typeof t !== "object" || !Object.keys(t).length) {
-        return O;
+        return minimatch;
     }
-    const e = O;
-    const s = (s, i, n = {}) => e(s, i, lt(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, lt(t, s));
+                super(e, ext(t, s));
             }
             static defaults(s) {
-                return e.defaults(lt(t, s)).Minimatch;
+                return e.defaults(ext(t, s)).Minimatch;
             }
         },
         AST: class AST extends e.AST {
             constructor(e, s, i = {}) {
-                super(e, s, lt(t, i));
+                super(e, s, ext(t, i));
             }
             static fromGlob(s, i = {}) {
-                return e.AST.fromGlob(s, lt(t, i));
+                return e.AST.fromGlob(s, ext(t, i));
             }
         },
-        unescape: (s, i = {}) => e.unescape(s, lt(t, i)),
-        escape: (s, i = {}) => e.escape(s, lt(t, i)),
-        filter: (s, i = {}) => e.filter(s, lt(t, i)),
-        defaults: s => e.defaults(lt(t, s)),
-        makeRe: (s, i = {}) => e.makeRe(s, lt(t, i)),
-        braceExpand: (s, i = {}) => e.braceExpand(s, lt(t, i)),
-        match: (s, i, n = {}) => e.match(s, i, lt(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: it
+        GLOBSTAR: q
     });
 };
 
-O.defaults = ct;
+minimatch.defaults = defaults;
 
-const ft = (e, s = {}) => {
-    p(e);
-    if (s.nobrace || !/\{(?:(?!\{).)*\}/.test(e)) {
-        return [ e ];
+const braceExpand = (t, e = {}) => {
+    assertValidPattern(t);
+    if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(t)) {
+        return [ t ];
     }
-    return t.expand(e);
+    return expand(t);
 };
 
-O.braceExpand = ft;
+minimatch.braceExpand = braceExpand;
 
-const ut = (t, e = {}) => new Minimatch(t, e).makeRe();
+const makeRe = (t, e = {}) => new Minimatch(t, e).makeRe();
 
-O.makeRe = ut;
+minimatch.makeRe = makeRe;
 
-const dt = (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) {
@@ -718,11 +956,11 @@ const dt = (t, e, s = {}) => {
     return t;
 };
 
-O.match = dt;
+minimatch.match = match;
 
-const pt = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const K = /[?*]|[+@!]\(.*?\)|\[|\]/;
 
-const gt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const regExpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
 class Minimatch {
     options;
@@ -743,11 +981,11 @@ class Minimatch {
     windowsNoMagicRoot;
     regexp;
     constructor(t, e = {}) {
-        p(t);
+        assertValidPattern(t);
         e = e || {};
         this.options = e;
         this.pattern = t;
-        this.platform = e.platform || tt;
+        this.platform = e.platform || $;
         this.isWindows = this.platform === "win32";
         this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
@@ -801,7 +1039,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] === "?" || !pt.test(t[2])) && !pt.test(t[3]);
+                const e = t[0] === "" && t[1] === "" && (t[2] === "?" || !K.test(t[2])) && !K.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))) ];
@@ -1068,7 +1306,7 @@ class Minimatch {
             if (l === false) {
                 return false;
             }
-            if (l === it) {
+            if (l === q) {
                 this.debug("GLOBSTAR", [ e, l, c ]);
                 var f = r;
                 var u = o + 1;
@@ -1123,25 +1361,25 @@ class Minimatch {
         }
     }
     braceExpand() {
-        return ft(this.pattern, this.options);
+        return braceExpand(this.pattern, this.options);
     }
     parse(t) {
-        p(t);
+        assertValidPattern(t);
         const e = this.options;
-        if (t === "**") return it;
+        if (t === "**") return q;
         if (t === "") return "";
         let s;
         let i = null;
-        if (s = t.match($)) {
-            i = e.dot ? H : q;
-        } else if (s = t.match(z)) {
-            i = (e.nocase ? e.dot ? W : B : e.dot ? N : D)(s[1]);
-        } else if (s = t.match(Z)) {
-            i = (e.nocase ? e.dot ? J : V : e.dot ? K : Y)(s);
+        if (s = t.match(W)) {
+            i = e.dot ? starTestDot : starTest;
+        } else if (s = t.match(B)) {
+            i = (e.nocase ? e.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : e.dot ? starDotExtTestDot : starDotExtTest)(s[1]);
+        } else if (s = t.match(j)) {
+            i = (e.nocase ? e.dot ? qmarksTestNocaseDot : qmarksTestNocase : e.dot ? qmarksTestDot : qmarksTest)(s);
         } else if (s = t.match(_)) {
-            i = e.dot ? j : I;
-        } else if (s = t.match(U)) {
-            i = G;
+            i = e.dot ? starDotStarTestDot : starDotStarTest;
+        } else if (s = t.match(I)) {
+            i = dotStarTest;
         }
         const n = AST.fromGlob(t, this.options).toMMPattern();
         if (i && typeof n === "object") {
@@ -1159,38 +1397,49 @@ class Minimatch {
             return this.regexp;
         }
         const e = this.options;
-        const s = e.noglobstar ? rt : e.dot ? ot : ht;
+        const s = e.noglobstar ? Z : e.dot ? V : J;
         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" ? gt(t) : t === it ? it : t._src;
+                return typeof t === "string" ? regExpEscape(t) : t === q ? q : t._src;
             }));
             e.forEach(((t, i) => {
                 const n = e[i + 1];
                 const r = e[i - 1];
-                if (t !== it || r === it) {
+                if (t !== q || r === q) {
                     return;
                 }
                 if (r === undefined) {
-                    if (n !== undefined && n !== it) {
+                    if (n !== undefined && n !== q) {
                         e[i + 1] = "(?:\\/|" + s + "\\/)?" + n;
                     } else {
                         e[i] = s;
                     }
                 } else if (n === undefined) {
-                    e[i - 1] = r + "(?:\\/|" + s + ")?";
-                } else if (n !== it) {
+                    e[i - 1] = r + "(?:\\/|\\/" + s + ")?";
+                } else if (n !== q) {
                     e[i - 1] = r + "(?:\\/|\\/" + s + "\\/)" + n;
-                    e[i + 1] = it;
+                    e[i + 1] = q;
                 }
             }));
-            return e.filter((t => t !== it)).join("/");
+            const n = e.filter((t => t !== q));
+            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(""));
@@ -1253,34 +1502,34 @@ class Minimatch {
         return this.negate;
     }
     static defaults(t) {
-        return O.defaults(t).Minimatch;
+        return minimatch.defaults(t).Minimatch;
     }
 }
 
-O.AST = AST;
+minimatch.AST = AST;
 
-O.Minimatch = Minimatch;
+minimatch.Minimatch = Minimatch;
 
-O.escape = R;
+minimatch.escape = escape;
 
-O.unescape = S;
+minimatch.unescape = unescape;
 
-const mt = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const Y = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 
-const wt = new Set;
+const X = new Set;
 
-const yt = typeof process === "object" && !!process ? process : {};
+const Q = typeof process === "object" && !!process ? process : {};
 
-const bt = (t, e, s, i) => {
-    typeof yt.emitWarning === "function" ? yt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
+const emitWarning = (t, e, s, i) => {
+    typeof Q.emitWarning === "function" ? Q.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
 };
 
-let St = globalThis.AbortController;
+let tt = globalThis.AbortController;
 
-let kt = globalThis.AbortSignal;
+let et = globalThis.AbortSignal;
 
-if (typeof St === "undefined") {
-    kt = class AbortSignal {
+if (typeof tt === "undefined") {
+    et = class AbortSignal {
         onabort;
         _onabort=[];
         reason;
@@ -1289,11 +1538,11 @@ if (typeof St === "undefined") {
             this._onabort.push(e);
         }
     };
-    St = class AbortController {
+    tt = class AbortController {
         constructor() {
-            e();
+            warnACPolyfill();
         }
-        signal=new kt;
+        signal=new et;
         abort(t) {
             if (this.signal.aborted) return;
             this.signal.reason = t;
@@ -1304,21 +1553,21 @@ if (typeof St === "undefined") {
             this.signal.onabort?.(t);
         }
     };
-    let t = yt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
-    const e = () => {
+    let t = Q.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const warnACPolyfill = () => {
         if (!t) return;
         t = false;
-        bt("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 vt = t => !wt.has(t);
+const shouldWarn = t => !X.has(t);
 
-const xt = Symbol("type");
+const st = Symbol("type");
 
-const Et = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+const isPosInt = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
 
-const Tt = t => !Et(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) {
@@ -1332,7 +1581,7 @@ class Stack {
     length;
     static #g=false;
     static create(t) {
-        const e = Tt(t);
+        const e = getUintArray(t);
         if (!e) return [];
         Stack.#g = true;
         const s = new Stack(t, e);
@@ -1356,12 +1605,12 @@ class Stack {
 
 class LRUCache {
     #m;
-    #w;
     #y;
+    #w;
     #b;
     #S;
     #k;
-    #v;
+    #x;
     ttl;
     ttlResolution;
     ttlAutopurge;
@@ -1377,10 +1626,10 @@ class LRUCache {
     allowStaleOnFetchAbort;
     allowStaleOnFetchRejection;
     ignoreFetchAbort;
-    #x;
+    #v;
     #E;
-    #T;
     #C;
+    #T;
     #L;
     #A;
     #M;
@@ -1392,16 +1641,16 @@ class LRUCache {
     #D;
     #N;
     #B;
-    #W;
     #_;
     #I;
+    #W;
     static unsafeExposeInternals(t) {
         return {
             starts: t.#D,
             ttls: t.#N,
             sizes: t.#z,
-            keyMap: t.#T,
-            keyList: t.#C,
+            keyMap: t.#C,
+            keyList: t.#T,
             valList: t.#L,
             next: t.#A,
             prev: t.#M,
@@ -1413,9 +1662,9 @@ 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.#q(e),
             isStale: e => t.#H(e)
         };
@@ -1424,22 +1673,22 @@ class LRUCache {
         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;
@@ -1448,20 +1697,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 && !Et(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 ? Tt(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") {
@@ -1471,24 +1720,24 @@ 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.#T = new Map;
-        this.#C = new Array(e).fill(undefined);
+        this.#k = y;
+        this.#_ = !!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 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;
@@ -1500,66 +1749,66 @@ class LRUCache {
             this.#S = undefined;
             this.#O = undefined;
         }
-        this.#B = !!this.#y;
-        this.#I = !!this.#b;
-        this.#_ = !!this.#S;
+        this.#B = !!this.#w;
+        this.#W = !!this.#b;
+        this.#I = !!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 (!Et(this.#w)) {
+            if (this.#y !== 0) {
+                if (!isPosInt(this.#y)) {
                     throw new TypeError("maxSize must be a positive integer if specified");
                 }
             }
-            if (!Et(this.maxEntrySize)) {
+            if (!isPosInt(this.maxEntrySize)) {
                 throw new TypeError("maxEntrySize must be a positive integer if specified");
             }
             this.#Z();
         }
         this.allowStale = !!h;
-        this.noDeleteOnStaleGet = !!b;
+        this.noDeleteOnStaleGet = !!S;
         this.updateAgeOnGet = !!r;
         this.updateAgeOnHas = !!o;
-        this.ttlResolution = Et(i) || i === 0 ? i : 1;
+        this.ttlResolution = isPosInt(i) || i === 0 ? i : 1;
         this.ttlAutopurge = !!n;
         this.ttl = s || 0;
         if (this.ttl) {
-            if (!Et(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 (vt(t)) {
-                wt.add(t);
+            if (shouldWarn(t)) {
+                X.add(t);
                 const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
-                bt(e, "UnboundedCacheWarning", t, LRUCache);
+                emitWarning(e, "UnboundedCacheWarning", t, LRUCache);
             }
         }
     }
     getRemainingTTL(t) {
-        return this.#T.has(t) ? Infinity : 0;
+        return this.#C.has(t) ? Infinity : 0;
     }
     #V() {
         const t = new ZeroArray(this.#m);
         const e = new ZeroArray(this.#m);
         this.#N = t;
         this.#D = e;
-        this.#J = (s, i, n = mt.now()) => {
+        this.#J = (s, i, n = Y.now()) => {
             e[s] = i !== 0 ? n : 0;
             t[s] = i;
             if (i !== 0 && this.ttlAutopurge) {
                 const t = setTimeout((() => {
                     if (this.#H(s)) {
-                        this.#K(this.#C[s], "expire");
+                        this.#K(this.#T[s], "expire");
                     }
                 }), i + 1);
                 if (t.unref) {
@@ -1568,23 +1817,23 @@ class LRUCache {
             }
         };
         this.#Y = s => {
-            e[s] = t[s] !== 0 ? mt.now() : 0;
+            e[s] = t[s] !== 0 ? Y.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 = mt.now();
+        const getNow = () => {
+            const t = Y.now();
             if (this.ttlResolution > 0) {
                 s = t;
                 const e = setTimeout((() => s = 0), this.ttlResolution);
@@ -1594,23 +1843,23 @@ class LRUCache {
             }
             return t;
         };
-        this.getRemainingTTL = n => {
-            const r = this.#T.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.#H = n => {
-            const r = e[n];
-            const o = t[n];
-            return !!o && !!r && (s || i()) - r > o;
+        this.#H = i => {
+            const n = e[i];
+            const r = t[i];
+            return !!r && !!n && (s || getNow()) - n > r;
         };
     }
     #Y=() => {};
@@ -1629,13 +1878,13 @@ class LRUCache {
             if (this.#j(e)) {
                 return 0;
             }
-            if (!Et(s)) {
+            if (!isPosInt(s)) {
                 if (i) {
                     if (typeof i !== "function") {
                         throw new TypeError("sizeCalculation must be a function");
                     }
                     s = i(e, t);
-                    if (!Et(s)) {
+                    if (!isPosInt(s)) {
                         throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     }
                 } else {
@@ -1646,8 +1895,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);
                 }
@@ -1667,8 +1916,8 @@ 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;
@@ -1685,7 +1934,7 @@ class LRUCache {
         }
     }
     * #q({allowStale: t = this.allowStale} = {}) {
-        if (this.#x) {
+        if (this.#v) {
             for (let e = this.#P; true; ) {
                 if (!this.#it(e)) {
                     break;
@@ -1702,25 +1951,25 @@ class LRUCache {
         }
     }
     #it(t) {
-        return t !== undefined && this.#T.get(this.#C[t]) === t;
+        return t !== undefined && this.#C.get(this.#T[t]) === t;
     }
     * entries() {
-        for (const t of this.#$()) {
-            if (this.#L[t] !== undefined && this.#C[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#C[t], this.#L[t] ];
+        for (const t of this.#U()) {
+            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
+                yield [ this.#T[t], this.#L[t] ];
             }
         }
     }
     * rentries() {
         for (const t of this.#q()) {
-            if (this.#L[t] !== undefined && this.#C[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#C[t], this.#L[t] ];
+            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
+                yield [ this.#T[t], this.#L[t] ];
             }
         }
     }
     * keys() {
-        for (const t of this.#$()) {
-            const e = this.#C[t];
+        for (const t of this.#U()) {
+            const e = this.#T[t];
             if (e !== undefined && !this.#j(this.#L[t])) {
                 yield e;
             }
@@ -1728,14 +1977,14 @@ class LRUCache {
     }
     * rkeys() {
         for (const t of this.#q()) {
-            const e = this.#C[t];
+            const e = this.#T[t];
             if (e !== undefined && !this.#j(this.#L[t])) {
                 yield e;
             }
         }
     }
     * values() {
-        for (const t of this.#$()) {
+        for (const t of this.#U()) {
             const e = this.#L[t];
             if (e !== undefined && !this.#j(this.#L[t])) {
                 yield this.#L[t];
@@ -1755,21 +2004,21 @@ class LRUCache {
     }
     [Symbol.toStringTag]="LRUCache";
     find(t, e = {}) {
-        for (const s of this.#$()) {
+        for (const s of this.#U()) {
             const i = this.#L[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
-            if (t(n, this.#C[s], this)) {
-                return this.get(this.#C[s], e);
+            if (t(n, this.#T[s], this)) {
+                return this.get(this.#T[s], e);
             }
         }
     }
     forEach(t, e = this) {
-        for (const s of this.#$()) {
+        for (const s of this.#U()) {
             const i = this.#L[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
-            t.call(e, n, this.#C[s], this);
+            t.call(e, n, this.#T[s], this);
         }
     }
     rforEach(t, e = this) {
@@ -1777,7 +2026,7 @@ class LRUCache {
             const i = this.#L[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
-            t.call(e, n, this.#C[s], this);
+            t.call(e, n, this.#T[s], this);
         }
     }
     purgeStale() {
@@ -1786,14 +2035,14 @@ class LRUCache {
             allowStale: true
         })) {
             if (this.#H(e)) {
-                this.#K(this.#C[e], "expire");
+                this.#K(this.#T[e], "expire");
                 t = true;
             }
         }
         return t;
     }
     info(t) {
-        const e = this.#T.get(t);
+        const e = this.#C.get(t);
         if (e === undefined) return undefined;
         const s = this.#L[e];
         const i = this.#j(s) ? s.__staleWhileFetching : s;
@@ -1805,7 +2054,7 @@ class LRUCache {
             const t = this.#N[e];
             const s = this.#D[e];
             if (t && s) {
-                const e = t - (mt.now() - s);
+                const e = t - (Y.now() - s);
                 n.ttl = e;
                 n.start = Date.now();
             }
@@ -1817,10 +2066,10 @@ class LRUCache {
     }
     dump() {
         const t = [];
-        for (const e of this.#$({
+        for (const e of this.#U({
             allowStale: true
         })) {
-            const s = this.#C[e];
+            const s = this.#T[e];
             const i = this.#L[e];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined || s === undefined) continue;
@@ -1829,7 +2078,7 @@ class LRUCache {
             };
             if (this.#N && this.#D) {
                 r.ttl = this.#N[e];
-                const t = mt.now() - this.#D[e];
+                const t = Y.now() - this.#D[e];
                 r.start = Math.floor(Date.now() - t);
             }
             if (this.#z) {
@@ -1844,7 +2093,7 @@ class LRUCache {
         for (const [e, s] of t) {
             if (s.start) {
                 const t = Date.now() - s.start;
-                s.start = mt.now() - t;
+                s.start = Y.now() - t;
             }
             this.set(e, s.value, s);
         }
@@ -1865,42 +2114,42 @@ class LRUCache {
             this.#K(t, "set");
             return this;
         }
-        let c = this.#x === 0 ? undefined : this.#T.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;
-            this.#C[c] = t;
+            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.#T.set(t, c);
+            this.#C.set(t, c);
             this.#A[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;
-            if (this.#I) {
+            if (this.#W) {
                 this.#b?.(e, t, "add");
             }
         } else {
             this.#G(c);
             const s = this.#L[c];
             if (e !== s) {
-                if (this.#W && this.#j(s)) {
+                if (this.#_ && 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");
+                            this.#w?.(e, t, "set");
                         }
-                        if (this.#_) {
+                        if (this.#I) {
                             this.#O?.push([ e, t, "set" ]);
                         }
                     }
                 } else if (!r) {
                     if (this.#B) {
-                        this.#y?.(s, t, "set");
+                        this.#w?.(s, t, "set");
                     }
-                    if (this.#_) {
+                    if (this.#I) {
                         this.#O?.push([ s, t, "set" ]);
                     }
                 }
@@ -1915,7 +2164,7 @@ class LRUCache {
             } else if (h) {
                 h.set = "update";
             }
-            if (this.#I) {
+            if (this.#W) {
                 this.onInsert?.(e, t, e === s ? "update" : "replace");
             }
         }
@@ -1928,7 +2177,7 @@ class LRUCache {
             }
             if (h) this.#X(h, c);
         }
-        if (!r && this.#_ && this.#O) {
+        if (!r && this.#I && this.#O) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -1939,7 +2188,7 @@ class LRUCache {
     }
     pop() {
         try {
-            while (this.#x) {
+            while (this.#v) {
                 const t = this.#L[this.#P];
                 this.#st(true);
                 if (this.#j(t)) {
@@ -1951,7 +2200,7 @@ class LRUCache {
                 }
             }
         } finally {
-            if (this.#_ && this.#O) {
+            if (this.#I && this.#O) {
                 const t = this.#O;
                 let e;
                 while (e = t?.shift()) {
@@ -1962,37 +2211,37 @@ class LRUCache {
     }
     #st(t) {
         const e = this.#P;
-        const s = this.#C[e];
+        const s = this.#T[e];
         const i = this.#L[e];
-        if (this.#W && this.#j(i)) {
+        if (this.#_ && this.#j(i)) {
             i.__abortController.abort(new Error("evicted"));
-        } else if (this.#B || this.#_) {
+        } else if (this.#B || this.#I) {
             if (this.#B) {
-                this.#y?.(i, s, "evict");
+                this.#w?.(i, s, "evict");
             }
-            if (this.#_) {
+            if (this.#I) {
                 this.#O?.push([ i, s, "evict" ]);
             }
         }
         this.#Q(e);
         if (t) {
-            this.#C[e] = undefined;
+            this.#T[e] = undefined;
             this.#L[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.#T.delete(s);
-        this.#x--;
+        this.#C.delete(s);
+        this.#v--;
         return e;
     }
     has(t, e = {}) {
         const {updateAgeOnHas: s = this.updateAgeOnHas, status: i} = e;
-        const n = this.#T.get(t);
+        const n = this.#C.get(t);
         if (n !== undefined) {
             const t = this.#L[n];
             if (this.#j(t) && t.__staleWhileFetching === undefined) {
@@ -2018,19 +2267,19 @@ class LRUCache {
     }
     peek(t, e = {}) {
         const {allowStale: s = this.allowStale} = e;
-        const i = this.#T.get(t);
+        const i = this.#C.get(t);
         if (i === undefined || !s && this.#H(i)) {
             return;
         }
         const n = this.#L[i];
         return this.#j(n) ? n.__staleWhileFetching : n;
     }
-    #U(t, e, s, i) {
+    #$(t, e, s, i) {
         const n = e === undefined ? undefined : this.#L[e];
         if (this.#j(n)) {
             return n;
         }
-        const r = new St;
+        const r = new tt;
         const {signal: o} = s;
         o?.addEventListener("abort", (() => r.abort(o.reason)), {
             signal: r.signal
@@ -2040,26 +2289,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.#L[e] === a) {
                 if (i === undefined) {
-                    if (l.__staleWhileFetching) {
-                        this.#L[e] = l.__staleWhileFetching;
+                    if (c.__staleWhileFetching) {
+                        this.#L[e] = c.__staleWhileFetching;
                     } else {
                         this.#K(t, "fetch");
                     }
@@ -2070,37 +2319,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.#L[e] === a) {
+                const s = !l || c.__staleWhileFetching === undefined;
                 if (s) {
                     this.#K(t, "fetch");
                 } else if (!o) {
-                    this.#L[e] = l.__staleWhileFetching;
+                    this.#L[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);
@@ -2109,46 +2358,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.#T.get(t);
+            e = this.#C.get(t);
         } else {
-            this.#L[e] = d;
+            this.#L[e] = l;
         }
-        return d;
+        return l;
     }
     #j(t) {
-        if (!this.#W) return false;
+        if (!this.#_) return false;
         const e = t;
-        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof St;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof tt;
     }
     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.#_) {
+            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,
@@ -2161,40 +2410,40 @@ class LRUCache {
             allowStaleOnFetchRejection: f,
             allowStaleOnFetchAbort: d,
             ignoreFetchAbort: u,
-            status: m,
+            status: y,
             signal: w
         };
-        let b = this.#T.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.#L[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.#H(b);
+            const n = this.#H(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;
         }
@@ -2205,7 +2454,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");
         }
@@ -2221,7 +2470,7 @@ class LRUCache {
     }
     get(t, e = {}) {
         const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r} = e;
-        const o = this.#T.get(t);
+        const o = this.#C.get(t);
         if (o !== undefined) {
             const e = this.#L[o];
             const h = this.#j(e);
@@ -2275,27 +2524,27 @@ class LRUCache {
     }
     #K(t, e) {
         let s = false;
-        if (this.#x !== 0) {
-            const i = this.#T.get(t);
+        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];
                     if (this.#j(s)) {
                         s.__abortController.abort(new Error("deleted"));
-                    } else if (this.#B || this.#_) {
+                    } else if (this.#B || this.#I) {
                         if (this.#B) {
-                            this.#y?.(s, t, e);
+                            this.#w?.(s, t, e);
                         }
-                        if (this.#_) {
+                        if (this.#I) {
                             this.#O?.push([ s, t, e ]);
                         }
                     }
-                    this.#T.delete(t);
-                    this.#C[i] = undefined;
+                    this.#C.delete(t);
+                    this.#T[i] = undefined;
                     this.#L[i] = undefined;
                     if (i === this.#F) {
                         this.#F = this.#M[i];
@@ -2307,12 +2556,12 @@ class LRUCache {
                         const e = this.#A[i];
                         this.#M[e] = this.#M[i];
                     }
-                    this.#x--;
+                    this.#v--;
                     this.#R.push(i);
                 }
             }
         }
-        if (this.#_ && this.#O?.length) {
+        if (this.#I && this.#O?.length) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -2332,18 +2581,18 @@ class LRUCache {
             if (this.#j(s)) {
                 s.__abortController.abort(new Error("deleted"));
             } else {
-                const i = this.#C[e];
+                const i = this.#T[e];
                 if (this.#B) {
-                    this.#y?.(s, i, t);
+                    this.#w?.(s, i, t);
                 }
-                if (this.#_) {
+                if (this.#I) {
                     this.#O?.push([ s, i, t ]);
                 }
             }
         }
-        this.#T.clear();
+        this.#C.clear();
         this.#L.fill(undefined);
-        this.#C.fill(undefined);
+        this.#T.fill(undefined);
         if (this.#N && this.#D) {
             this.#N.fill(0);
             this.#D.fill(0);
@@ -2355,8 +2604,8 @@ class LRUCache {
         this.#F = 0;
         this.#R.length = 0;
         this.#E = 0;
-        this.#x = 0;
-        if (this.#_ && this.#O) {
+        this.#v = 0;
+        if (this.#I && this.#O) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -2366,88 +2615,88 @@ class LRUCache {
     }
 }
 
-const Ct = typeof process === "object" && process ? process : {
+const it = typeof process === "object" && process ? process : {
     stdout: null,
     stderr: null
 };
 
-const Lt = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof u.default || At(t) || Mt(t));
+const isStream = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof l.default || isReadable(t) || isWritable(t));
 
-const At = t => !!t && typeof t === "object" && t instanceof o.EventEmitter && typeof t.pipe === "function" && t.pipe !== u.default.Writable.prototype.pipe;
+const isReadable = t => !!t && typeof t === "object" && t instanceof r.EventEmitter && typeof t.pipe === "function" && t.pipe !== l.default.Writable.prototype.pipe;
 
-const Mt = t => !!t && typeof t === "object" && t instanceof o.EventEmitter && typeof t.write === "function" && typeof t.end === "function";
+const isWritable = t => !!t && typeof t === "object" && t instanceof r.EventEmitter && typeof t.write === "function" && typeof t.end === "function";
 
-const Pt = Symbol("EOF");
+const nt = Symbol("EOF");
 
-const Ft = Symbol("maybeEmitEnd");
+const rt = Symbol("maybeEmitEnd");
 
-const Rt = Symbol("emittedEnd");
+const ot = Symbol("emittedEnd");
 
-const Ot = Symbol("emittingEnd");
+const ht = Symbol("emittingEnd");
 
-const zt = Symbol("emittedError");
+const at = Symbol("emittedError");
 
-const Dt = Symbol("closed");
+const lt = Symbol("closed");
 
-const Nt = Symbol("read");
+const ct = Symbol("read");
 
-const Bt = Symbol("flush");
+const ft = Symbol("flush");
 
-const Wt = Symbol("flushChunk");
+const ut = Symbol("flushChunk");
 
-const _t = Symbol("encoding");
+const dt = Symbol("encoding");
 
-const It = Symbol("decoder");
+const pt = Symbol("decoder");
 
-const jt = Symbol("flowing");
+const gt = Symbol("flowing");
 
-const Ut = Symbol("paused");
+const mt = Symbol("paused");
 
-const Gt = Symbol("resume");
+const yt = Symbol("resume");
 
-const $t = Symbol("buffer");
+const wt = Symbol("buffer");
 
-const qt = Symbol("pipes");
+const bt = Symbol("pipes");
 
-const Ht = Symbol("bufferLength");
+const St = Symbol("bufferLength");
 
-const Zt = Symbol("bufferPush");
+const kt = Symbol("bufferPush");
 
-const Vt = Symbol("bufferShift");
+const xt = Symbol("bufferShift");
 
-const Jt = Symbol("objectMode");
+const vt = Symbol("objectMode");
 
-const Kt = Symbol("destroyed");
+const Et = Symbol("destroyed");
 
-const Yt = Symbol("error");
+const Ct = Symbol("error");
 
-const Xt = Symbol("emitData");
+const Tt = Symbol("emitData");
 
-const Qt = Symbol("emitEnd");
+const Lt = Symbol("emitEnd");
 
-const te = Symbol("emitEnd2");
+const At = Symbol("emitEnd2");
 
-const ee = Symbol("async");
+const Mt = Symbol("async");
 
-const se = Symbol("abort");
+const Pt = Symbol("abort");
 
-const ie = Symbol("aborted");
+const Ft = Symbol("aborted");
 
-const ne = Symbol("signal");
+const Rt = Symbol("signal");
 
-const re = Symbol("dataListeners");
+const Ot = Symbol("dataListeners");
 
-const oe = Symbol("discarded");
+const zt = Symbol("discarded");
 
-const he = t => Promise.resolve().then(t);
+const defer = t => Promise.resolve().then(t);
 
-const ae = t => t();
+const nodefer = t => t();
 
-const le = t => t === "end" || t === "finish" || t === "prefinish";
+const isEndish = t => t === "end" || t === "finish" || t === "prefinish";
 
-const ce = 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 fe = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
+const isArrayBufferView = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
 
 class Pipe {
     src;
@@ -2458,7 +2707,7 @@ class Pipe {
         this.src = t;
         this.dest = e;
         this.opts = s;
-        this.ondrain = () => t[Gt]();
+        this.ondrain = () => t[yt]();
         this.dest.on("drain", this.ondrain);
     }
     unpipe() {
@@ -2483,30 +2732,30 @@ class PipeProxyErrors extends Pipe {
     }
 }
 
-const ue = t => !!t.objectMode;
-
-const de = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
-
-class Minipass extends o.EventEmitter {
-    [jt]=false;
-    [Ut]=false;
-    [qt]=[];
-    [$t]=[];
-    [Jt];
-    [_t];
-    [ee];
-    [It];
-    [Pt]=false;
-    [Rt]=false;
-    [Ot]=false;
-    [Dt]=false;
-    [zt]=null;
-    [Ht]=0;
-    [Kt]=false;
-    [ne];
-    [ie]=false;
-    [re]=0;
-    [oe]=false;
+const isObjectModeOptions = t => !!t.objectMode;
+
+const isEncodingOptions = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+
+class Minipass extends r.EventEmitter {
+    [gt]=false;
+    [mt]=false;
+    [bt]=[];
+    [wt]=[];
+    [vt];
+    [dt];
+    [Mt];
+    [pt];
+    [nt]=false;
+    [ot]=false;
+    [ht]=false;
+    [lt]=false;
+    [at]=null;
+    [St]=0;
+    [Et]=false;
+    [Rt];
+    [Ft]=false;
+    [Ot]=0;
+    [zt]=false;
     writable=true;
     readable=true;
     constructor(...t) {
@@ -2515,43 +2764,43 @@ class Minipass extends o.EventEmitter {
         if (e.objectMode && typeof e.encoding === "string") {
             throw new TypeError("Encoding and objectMode may not be used together");
         }
-        if (ue(e)) {
-            this[Jt] = true;
-            this[_t] = null;
-        } else if (de(e)) {
-            this[_t] = e.encoding;
-            this[Jt] = false;
+        if (isObjectModeOptions(e)) {
+            this[vt] = true;
+            this[dt] = null;
+        } else if (isEncodingOptions(e)) {
+            this[dt] = e.encoding;
+            this[vt] = false;
         } else {
-            this[Jt] = false;
-            this[_t] = null;
+            this[vt] = false;
+            this[dt] = null;
         }
-        this[ee] = !!e.async;
-        this[It] = this[_t] ? new a.StringDecoder(this[_t]) : null;
+        this[Mt] = !!e.async;
+        this[pt] = this[dt] ? new h.StringDecoder(this[dt]) : null;
         if (e && e.debugExposeBuffer === true) {
             Object.defineProperty(this, "buffer", {
-                get: () => this[$t]
+                get: () => this[wt]
             });
         }
         if (e && e.debugExposePipes === true) {
             Object.defineProperty(this, "pipes", {
-                get: () => this[qt]
+                get: () => this[bt]
             });
         }
         const {signal: s} = e;
         if (s) {
-            this[ne] = s;
+            this[Rt] = s;
             if (s.aborted) {
-                this[se]();
+                this[Pt]();
             } else {
-                s.addEventListener("abort", (() => this[se]()));
+                s.addEventListener("abort", (() => this[Pt]()));
             }
         }
     }
     get bufferLength() {
-        return this[Ht];
+        return this[St];
     }
     get encoding() {
-        return this[_t];
+        return this[dt];
     }
     set encoding(t) {
         throw new Error("Encoding must be set at instantiation time");
@@ -2560,30 +2809,30 @@ class Minipass extends o.EventEmitter {
         throw new Error("Encoding must be set at instantiation time");
     }
     get objectMode() {
-        return this[Jt];
+        return this[vt];
     }
     set objectMode(t) {
         throw new Error("objectMode must be set at instantiation time");
     }
     get ["async"]() {
-        return this[ee];
+        return this[Mt];
     }
     set ["async"](t) {
-        this[ee] = this[ee] || !!t;
+        this[Mt] = this[Mt] || !!t;
     }
-    [se]() {
-        this[ie] = true;
-        this.emit("abort", this[ne]?.reason);
-        this.destroy(this[ne]?.reason);
+    [Pt]() {
+        this[Ft] = true;
+        this.emit("abort", this[Rt]?.reason);
+        this.destroy(this[Rt]?.reason);
     }
     get aborted() {
-        return this[ie];
+        return this[Ft];
     }
     set aborted(t) {}
     write(t, e, s) {
-        if (this[ie]) return false;
-        if (this[Pt]) throw new Error("write after end");
-        if (this[Kt]) {
+        if (this[Ft]) return false;
+        if (this[nt]) throw new Error("write after end");
+        if (this[Et]) {
             this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
                 code: "ERR_STREAM_DESTROYED"
             }));
@@ -2594,70 +2843,70 @@ class Minipass extends o.EventEmitter {
             e = "utf8";
         }
         if (!e) e = "utf8";
-        const i = this[ee] ? he : ae;
-        if (!this[Jt] && !Buffer.isBuffer(t)) {
-            if (fe(t)) {
+        const i = this[Mt] ? defer : nodefer;
+        if (!this[vt] && !Buffer.isBuffer(t)) {
+            if (isArrayBufferView(t)) {
                 t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
-            } else if (ce(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[Jt]) {
-            if (this[jt] && this[Ht] !== 0) this[Bt](true);
-            if (this[jt]) this.emit("data", t); else this[Zt](t);
-            if (this[Ht] !== 0) this.emit("readable");
+        if (this[vt]) {
+            if (this[gt] && this[St] !== 0) this[ft](true);
+            if (this[gt]) this.emit("data", t); else this[kt](t);
+            if (this[St] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[jt];
+            return this[gt];
         }
         if (!t.length) {
-            if (this[Ht] !== 0) this.emit("readable");
+            if (this[St] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[jt];
+            return this[gt];
         }
-        if (typeof t === "string" && !(e === this[_t] && !this[It]?.lastNeed)) {
+        if (typeof t === "string" && !(e === this[dt] && !this[pt]?.lastNeed)) {
             t = Buffer.from(t, e);
         }
-        if (Buffer.isBuffer(t) && this[_t]) {
-            t = this[It].write(t);
+        if (Buffer.isBuffer(t) && this[dt]) {
+            t = this[pt].write(t);
         }
-        if (this[jt] && this[Ht] !== 0) this[Bt](true);
-        if (this[jt]) this.emit("data", t); else this[Zt](t);
-        if (this[Ht] !== 0) this.emit("readable");
+        if (this[gt] && this[St] !== 0) this[ft](true);
+        if (this[gt]) this.emit("data", t); else this[kt](t);
+        if (this[St] !== 0) this.emit("readable");
         if (s) i(s);
-        return this[jt];
+        return this[gt];
     }
     read(t) {
-        if (this[Kt]) return null;
-        this[oe] = false;
-        if (this[Ht] === 0 || t === 0 || t && t > this[Ht]) {
-            this[Ft]();
+        if (this[Et]) return null;
+        this[zt] = false;
+        if (this[St] === 0 || t === 0 || t && t > this[St]) {
+            this[rt]();
             return null;
         }
-        if (this[Jt]) t = null;
-        if (this[$t].length > 1 && !this[Jt]) {
-            this[$t] = [ this[_t] ? this[$t].join("") : Buffer.concat(this[$t], this[Ht]) ];
+        if (this[vt]) t = null;
+        if (this[wt].length > 1 && !this[vt]) {
+            this[wt] = [ this[dt] ? this[wt].join("") : Buffer.concat(this[wt], this[St]) ];
         }
-        const e = this[Nt](t || null, this[$t][0]);
-        this[Ft]();
+        const e = this[ct](t || null, this[wt][0]);
+        this[rt]();
         return e;
     }
-    [Nt](t, e) {
-        if (this[Jt]) this[Vt](); else {
+    [ct](t, e) {
+        if (this[vt]) this[xt](); else {
             const s = e;
-            if (t === s.length || t === null) this[Vt](); else if (typeof s === "string") {
-                this[$t][0] = s.slice(t);
+            if (t === s.length || t === null) this[xt](); else if (typeof s === "string") {
+                this[wt][0] = s.slice(t);
                 e = s.slice(0, t);
-                this[Ht] -= t;
+                this[St] -= t;
             } else {
-                this[$t][0] = s.subarray(t);
+                this[wt][0] = s.subarray(t);
                 e = s.subarray(0, t);
-                this[Ht] -= t;
+                this[St] -= t;
             }
         }
         this.emit("data", e);
-        if (!this[$t].length && !this[Pt]) this.emit("drain");
+        if (!this[wt].length && !this[nt]) this.emit("drain");
         return e;
     }
     end(t, e, s) {
@@ -2671,78 +2920,78 @@ class Minipass extends o.EventEmitter {
         }
         if (t !== undefined) this.write(t, e);
         if (s) this.once("end", s);
-        this[Pt] = true;
+        this[nt] = true;
         this.writable = false;
-        if (this[jt] || !this[Ut]) this[Ft]();
+        if (this[gt] || !this[mt]) this[rt]();
         return this;
     }
-    [Gt]() {
-        if (this[Kt]) return;
-        if (!this[re] && !this[qt].length) {
-            this[oe] = true;
+    [yt]() {
+        if (this[Et]) return;
+        if (!this[Ot] && !this[bt].length) {
+            this[zt] = true;
         }
-        this[Ut] = false;
-        this[jt] = true;
+        this[mt] = false;
+        this[gt] = true;
         this.emit("resume");
-        if (this[$t].length) this[Bt](); else if (this[Pt]) this[Ft](); else this.emit("drain");
+        if (this[wt].length) this[ft](); else if (this[nt]) this[rt](); else this.emit("drain");
     }
     resume() {
-        return this[Gt]();
+        return this[yt]();
     }
     pause() {
-        this[jt] = false;
-        this[Ut] = true;
-        this[oe] = false;
+        this[gt] = false;
+        this[mt] = true;
+        this[zt] = false;
     }
     get destroyed() {
-        return this[Kt];
+        return this[Et];
     }
     get flowing() {
-        return this[jt];
+        return this[gt];
     }
     get paused() {
-        return this[Ut];
+        return this[mt];
     }
-    [Zt](t) {
-        if (this[Jt]) this[Ht] += 1; else this[Ht] += t.length;
-        this[$t].push(t);
+    [kt](t) {
+        if (this[vt]) this[St] += 1; else this[St] += t.length;
+        this[wt].push(t);
     }
-    [Vt]() {
-        if (this[Jt]) this[Ht] -= 1; else this[Ht] -= this[$t][0].length;
-        return this[$t].shift();
+    [xt]() {
+        if (this[vt]) this[St] -= 1; else this[St] -= this[wt][0].length;
+        return this[wt].shift();
     }
-    [Bt](t = false) {
-        do {} while (this[Wt](this[Vt]()) && this[$t].length);
-        if (!t && !this[$t].length && !this[Pt]) this.emit("drain");
+    [ft](t = false) {
+        do {} while (this[ut](this[xt]()) && this[wt].length);
+        if (!t && !this[wt].length && !this[nt]) this.emit("drain");
     }
-    [Wt](t) {
+    [ut](t) {
         this.emit("data", t);
-        return this[jt];
+        return this[gt];
     }
     pipe(t, e) {
-        if (this[Kt]) return t;
-        this[oe] = false;
-        const s = this[Rt];
+        if (this[Et]) return t;
+        this[zt] = false;
+        const s = this[ot];
         e = e || {};
-        if (t === Ct.stdout || t === Ct.stderr) e.end = false; else e.end = e.end !== false;
+        if (t === it.stdout || t === it.stderr) e.end = false; else e.end = e.end !== false;
         e.proxyErrors = !!e.proxyErrors;
         if (s) {
             if (e.end) t.end();
         } else {
-            this[qt].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
-            if (this[ee]) he((() => this[Gt]())); else this[Gt]();
+            this[bt].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+            if (this[Mt]) defer((() => this[yt]())); else this[yt]();
         }
         return t;
     }
     unpipe(t) {
-        const e = this[qt].find((e => e.dest === t));
+        const e = this[bt].find((e => e.dest === t));
         if (e) {
-            if (this[qt].length === 1) {
-                if (this[jt] && this[re] === 0) {
-                    this[jt] = false;
+            if (this[bt].length === 1) {
+                if (this[gt] && this[Ot] === 0) {
+                    this[gt] = false;
                 }
-                this[qt] = [];
-            } else this[qt].splice(this[qt].indexOf(e), 1);
+                this[bt] = [];
+            } else this[bt].splice(this[bt].indexOf(e), 1);
             e.unpipe();
         }
     }
@@ -2752,19 +3001,19 @@ class Minipass extends o.EventEmitter {
     on(t, e) {
         const s = super.on(t, e);
         if (t === "data") {
-            this[oe] = false;
-            this[re]++;
-            if (!this[qt].length && !this[jt]) {
-                this[Gt]();
+            this[zt] = false;
+            this[Ot]++;
+            if (!this[bt].length && !this[gt]) {
+                this[yt]();
             }
-        } else if (t === "readable" && this[Ht] !== 0) {
+        } else if (t === "readable" && this[St] !== 0) {
             super.emit("readable");
-        } else if (le(t) && this[Rt]) {
+        } else if (isEndish(t) && this[ot]) {
             super.emit(t);
             this.removeAllListeners(t);
-        } else if (t === "error" && this[zt]) {
+        } else if (t === "error" && this[at]) {
             const t = e;
-            if (this[ee]) he((() => t.call(this, this[zt]))); else t.call(this, this[zt]);
+            if (this[Mt]) defer((() => t.call(this, this[at]))); else t.call(this, this[at]);
         }
         return s;
     }
@@ -2774,9 +3023,9 @@ class Minipass extends o.EventEmitter {
     off(t, e) {
         const s = super.off(t, e);
         if (t === "data") {
-            this[re] = this.listeners("data").length;
-            if (this[re] === 0 && !this[oe] && !this[qt].length) {
-                this[jt] = false;
+            this[Ot] = this.listeners("data").length;
+            if (this[Ot] === 0 && !this[zt] && !this[bt].length) {
+                this[gt] = false;
             }
         }
         return s;
@@ -2784,49 +3033,49 @@ class Minipass extends o.EventEmitter {
     removeAllListeners(t) {
         const e = super.removeAllListeners(t);
         if (t === "data" || t === undefined) {
-            this[re] = 0;
-            if (!this[oe] && !this[qt].length) {
-                this[jt] = false;
+            this[Ot] = 0;
+            if (!this[zt] && !this[bt].length) {
+                this[gt] = false;
             }
         }
         return e;
     }
     get emittedEnd() {
-        return this[Rt];
+        return this[ot];
     }
-    [Ft]() {
-        if (!this[Ot] && !this[Rt] && !this[Kt] && this[$t].length === 0 && this[Pt]) {
-            this[Ot] = true;
+    [rt]() {
+        if (!this[ht] && !this[ot] && !this[Et] && this[wt].length === 0 && this[nt]) {
+            this[ht] = true;
             this.emit("end");
             this.emit("prefinish");
             this.emit("finish");
-            if (this[Dt]) this.emit("close");
-            this[Ot] = false;
+            if (this[lt]) this.emit("close");
+            this[ht] = false;
         }
     }
     emit(t, ...e) {
         const s = e[0];
-        if (t !== "error" && t !== "close" && t !== Kt && this[Kt]) {
+        if (t !== "error" && t !== "close" && t !== Et && this[Et]) {
             return false;
         } else if (t === "data") {
-            return !this[Jt] && !s ? false : this[ee] ? (he((() => this[Xt](s))), true) : this[Xt](s);
+            return !this[vt] && !s ? false : this[Mt] ? (defer((() => this[Tt](s))), true) : this[Tt](s);
         } else if (t === "end") {
-            return this[Qt]();
+            return this[Lt]();
         } else if (t === "close") {
-            this[Dt] = true;
-            if (!this[Rt] && !this[Kt]) return false;
+            this[lt] = true;
+            if (!this[ot] && !this[Et]) return false;
             const t = super.emit("close");
             this.removeAllListeners("close");
             return t;
         } else if (t === "error") {
-            this[zt] = s;
-            super.emit(Yt, s);
-            const t = !this[ne] || this.listeners("error").length ? super.emit("error", s) : false;
-            this[Ft]();
+            this[at] = s;
+            super.emit(Ct, s);
+            const t = !this[Rt] || this.listeners("error").length ? super.emit("error", s) : false;
+            this[rt]();
             return t;
         } else if (t === "resume") {
             const t = super.emit("resume");
-            this[Ft]();
+            this[rt]();
             return t;
         } else if (t === "finish" || t === "prefinish") {
             const e = super.emit(t);
@@ -2834,34 +3083,34 @@ class Minipass extends o.EventEmitter {
             return e;
         }
         const i = super.emit(t, ...e);
-        this[Ft]();
+        this[rt]();
         return i;
     }
-    [Xt](t) {
-        for (const e of this[qt]) {
+    [Tt](t) {
+        for (const e of this[bt]) {
             if (e.dest.write(t) === false) this.pause();
         }
-        const e = this[oe] ? false : super.emit("data", t);
-        this[Ft]();
+        const e = this[zt] ? false : super.emit("data", t);
+        this[rt]();
         return e;
     }
-    [Qt]() {
-        if (this[Rt]) return false;
-        this[Rt] = true;
+    [Lt]() {
+        if (this[ot]) return false;
+        this[ot] = true;
         this.readable = false;
-        return this[ee] ? (he((() => this[te]())), true) : this[te]();
+        return this[Mt] ? (defer((() => this[At]())), true) : this[At]();
     }
-    [te]() {
-        if (this[It]) {
-            const t = this[It].end();
+    [At]() {
+        if (this[pt]) {
+            const t = this[pt].end();
             if (t) {
-                for (const e of this[qt]) {
+                for (const e of this[bt]) {
                     e.dest.write(t);
                 }
-                if (!this[oe]) super.emit("data", t);
+                if (!this[zt]) super.emit("data", t);
             }
         }
-        for (const t of this[qt]) {
+        for (const t of this[bt]) {
             t.end();
         }
         const t = super.emit("end");
@@ -2872,33 +3121,33 @@ class Minipass extends o.EventEmitter {
         const t = Object.assign([], {
             dataLength: 0
         });
-        if (!this[Jt]) t.dataLength = 0;
+        if (!this[vt]) t.dataLength = 0;
         const e = this.promise();
         this.on("data", (e => {
             t.push(e);
-            if (!this[Jt]) t.dataLength += e.length;
+            if (!this[vt]) t.dataLength += e.length;
         }));
         await e;
         return t;
     }
     async concat() {
-        if (this[Jt]) {
+        if (this[vt]) {
             throw new Error("cannot concat in objectMode");
         }
         const t = await this.collect();
-        return this[_t] ? t.join("") : Buffer.concat(t, t.dataLength);
+        return this[dt] ? t.join("") : Buffer.concat(t, t.dataLength);
     }
     async promise() {
         return new Promise(((t, e) => {
-            this.on(Kt, (() => e(new Error("stream destroyed"))));
+            this.on(Et, (() => e(new Error("stream destroyed"))));
             this.on("error", (t => e(t)));
             this.on("end", (() => t()));
         }));
     }
     [Symbol.asyncIterator]() {
-        this[oe] = false;
+        this[zt] = false;
         let t = false;
-        const e = async () => {
+        const stop = async () => {
             this.pause();
             t = true;
             return {
@@ -2906,201 +3155,201 @@ class Minipass extends o.EventEmitter {
                 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[Pt]) return e();
+            if (this[nt]) return stop();
+            let s;
             let i;
-            let n;
-            const r = t => {
-                this.off("data", o);
-                this.off("end", h);
-                this.off(Kt, a);
-                e();
-                n(t);
+            const onerr = t => {
+                this.off("data", ondata);
+                this.off("end", onend);
+                this.off(Et, ondestroy);
+                stop();
+                i(t);
             };
-            const o = t => {
-                this.off("error", r);
-                this.off("end", h);
-                this.off(Kt, a);
+            const ondata = t => {
+                this.off("error", onerr);
+                this.off("end", onend);
+                this.off(Et, ondestroy);
                 this.pause();
-                i({
+                s({
                     value: t,
-                    done: !!this[Pt]
+                    done: !!this[nt]
                 });
             };
-            const h = () => {
-                this.off("error", r);
-                this.off("data", o);
-                this.off(Kt, a);
-                e();
-                i({
+            const onend = () => {
+                this.off("error", onerr);
+                this.off("data", ondata);
+                this.off(Et, 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(Kt, a);
-                this.once("error", r);
-                this.once("end", h);
-                this.once("data", o);
+                i = e;
+                s = t;
+                this.once(Et, 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[oe] = false;
+        this[zt] = false;
         let t = false;
-        const e = () => {
+        const stop = () => {
             this.pause();
-            this.off(Yt, e);
-            this.off(Kt, e);
-            this.off("end", e);
+            this.off(Ct, stop);
+            this.off(Et, 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(Yt, e);
-        this.once(Kt, e);
+        this.once("end", stop);
+        this.once(Ct, stop);
+        this.once(Et, stop);
         return {
-            next: s,
-            throw: e,
-            return: e,
+            next,
+            throw: stop,
+            return: stop,
             [Symbol.iterator]() {
                 return this;
             }
         };
     }
     destroy(t) {
-        if (this[Kt]) {
-            if (t) this.emit("error", t); else this.emit(Kt);
+        if (this[Et]) {
+            if (t) this.emit("error", t); else this.emit(Et);
             return this;
         }
-        this[Kt] = true;
-        this[oe] = true;
-        this[$t].length = 0;
-        this[Ht] = 0;
+        this[Et] = true;
+        this[zt] = true;
+        this[wt].length = 0;
+        this[St] = 0;
         const e = this;
-        if (typeof e.close === "function" && !this[Dt]) e.close();
-        if (t) this.emit("error", t); else this.emit(Kt);
+        if (typeof e.close === "function" && !this[lt]) e.close();
+        if (t) this.emit("error", t); else this.emit(Et);
         return this;
     }
     static get isStream() {
-        return Lt;
+        return isStream;
     }
 }
 
-const pe = i.realpathSync.native;
+const Dt = s.realpathSync.native;
 
-const ge = {
-    lstatSync: i.lstatSync,
-    readdir: i.readdir,
-    readdirSync: i.readdirSync,
-    readlinkSync: i.readlinkSync,
-    realpathSync: pe,
+const Nt = {
+    lstatSync: s.lstatSync,
+    readdir: s.readdir,
+    readdirSync: s.readdirSync,
+    readlinkSync: s.readlinkSync,
+    realpathSync: Dt,
     promises: {
-        lstat: r.lstat,
-        readdir: r.readdir,
-        readlink: r.readlink,
-        realpath: r.realpath
+        lstat: n.lstat,
+        readdir: n.readdir,
+        readlink: n.readlink,
+        realpath: n.realpath
     }
 };
 
-const me = t => !t || t === ge || t === f ? ge : {
-    ...ge,
+const fsFromOption = t => !t || t === Nt || t === a ? Nt : {
+    ...Nt,
     ...t,
     promises: {
-        ...ge.promises,
+        ...Nt.promises,
         ...t.promises || {}
     }
 };
 
-const we = /^\\\\\?\\([a-z]:)\\?$/i;
+const Bt = /^\\\\\?\\([a-z]:)\\?$/i;
 
-const ye = t => t.replace(/\//g, "\\").replace(we, "$1\\");
+const uncToDrive = t => t.replace(/\//g, "\\").replace(Bt, "$1\\");
 
-const be = /[\\\/]/;
+const _t = /[\\\/]/;
 
-const Se = 0;
+const It = 0;
 
-const ke = 1;
+const Wt = 1;
 
-const ve = 2;
+const jt = 2;
 
-const xe = 4;
+const $t = 4;
 
-const Ee = 6;
+const Gt = 6;
 
-const Te = 8;
+const Ut = 8;
 
-const Ce = 10;
+const qt = 10;
 
-const Le = 12;
+const Ht = 12;
 
-const Ae = 15;
+const Zt = 15;
 
-const Me = ~Ae;
+const Vt = ~Zt;
 
-const Pe = 16;
+const Jt = 16;
 
-const Fe = 32;
+const Kt = 32;
 
-const Re = 64;
+const Yt = 64;
 
-const Oe = 128;
+const Xt = 128;
 
-const ze = 256;
+const Qt = 256;
 
-const De = 512;
+const te = 512;
 
-const Ne = Re | Oe | De;
+const ee = Yt | Xt | te;
 
-const Be = 1023;
+const se = 1023;
 
-const We = t => t.isFile() ? Te : t.isDirectory() ? xe : t.isSymbolicLink() ? Ce : t.isCharacterDevice() ? ve : t.isBlockDevice() ? Ee : t.isSocket() ? Le : t.isFIFO() ? ke : Se;
+const entToType = t => t.isFile() ? Ut : t.isDirectory() ? $t : t.isSymbolicLink() ? qt : t.isCharacterDevice() ? jt : t.isBlockDevice() ? Gt : t.isSocket() ? Ht : t.isFIFO() ? Wt : It;
 
-const _e = new Map;
+const ie = new Map;
 
-const Ie = t => {
-    const e = _e.get(t);
+const normalize = t => {
+    const e = ie.get(t);
     if (e) return e;
     const s = t.normalize("NFKD");
-    _e.set(t, s);
+    ie.set(t, s);
     return s;
 };
 
-const je = new Map;
+const ne = new Map;
 
-const Ue = t => {
-    const e = je.get(t);
+const normalizeNocase = t => {
+    const e = ne.get(t);
     if (e) return e;
-    const s = Ie(t.toLowerCase());
-    je.set(t, s);
+    const s = normalize(t.toLowerCase());
+    ne.set(t, s);
     return s;
 };
 
@@ -3121,7 +3370,7 @@ class ChildrenCache extends LRUCache {
     }
 }
 
-const Ge = Symbol("PathScurry setAsCwd");
+const re = Symbol("PathScurry setAsCwd");
 
 class PathBase {
     name;
@@ -3163,9 +3412,9 @@ class PathBase {
     get ino() {
         return this.#pt;
     }
-    #x;
+    #v;
     get size() {
-        return this.#x;
+        return this.#v;
     }
     #gt;
     get blocks() {
@@ -3175,13 +3424,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() {
@@ -3195,17 +3444,17 @@ 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;
-    #Tt;
     #Ct;
+    #Tt;
     #Lt;
     #At;
     #Mt;
@@ -3219,28 +3468,28 @@ class PathBase {
     get path() {
         return this.parentPath;
     }
-    constructor(t, e = Se, s, i, n, r, o) {
+    constructor(t, e = It, s, i, n, r, o) {
         this.name = t;
-        this.#Et = n ? Ue(t) : Ie(t);
-        this.#Pt = e & Be;
+        this.#Et = n ? normalizeNocase(t) : normalize(t);
+        this.#Pt = e & se;
         this.nocase = n;
         this.roots = i;
         this.root = s || this;
         this.#Ft = r;
-        this.#Ct = o.fullpath;
+        this.#Tt = o.fullpath;
         this.#At = o.relative;
         this.#Mt = o.relativePosix;
         this.parent = o.parent;
         if (this.parent) {
             this.#ot = this.parent.#ot;
         } else {
-            this.#ot = me(o.fs);
+            this.#ot = fsFromOption(o.fs);
         }
     }
     depth() {
-        if (this.#Tt !== undefined) return this.#Tt;
-        if (!this.parent) return this.#Tt = 0;
-        return this.#Tt = this.parent.depth() + 1;
+        if (this.#Ct !== undefined) return this.#Ct;
+        if (!this.parent) return this.#Ct = 0;
+        return this.#Ct = this.parent.depth() + 1;
     }
     childrenCache() {
         return this.#Ft;
@@ -3271,7 +3520,7 @@ class PathBase {
             provisional: 0
         });
         this.#Ft.set(this, e);
-        this.#Pt &= ~Pe;
+        this.#Pt &= ~Jt;
         return e;
     }
     child(t, e) {
@@ -3282,21 +3531,21 @@ class PathBase {
             return this.parent || this;
         }
         const s = this.children();
-        const i = this.nocase ? Ue(t) : Ie(t);
+        const i = this.nocase ? normalizeNocase(t) : normalize(t);
         for (const t of s) {
             if (t.#Et === i) {
                 return t;
             }
         }
         const n = this.parent ? this.sep : "";
-        const r = this.#Ct ? this.#Ct + n + t : undefined;
-        const o = this.newChild(t, Se, {
+        const r = this.#Tt ? this.#Tt + n + t : undefined;
+        const o = this.newChild(t, It, {
             ...e,
             parent: this,
             fullpath: r
         });
         if (!this.canReaddir()) {
-            o.#Pt |= Oe;
+            o.#Pt |= Xt;
         }
         s.push(o);
         return o;
@@ -3327,17 +3576,17 @@ class PathBase {
         return s + (!s || !e.parent ? "" : "/") + t;
     }
     fullpath() {
-        if (this.#Ct !== undefined) {
-            return this.#Ct;
+        if (this.#Tt !== undefined) {
+            return this.#Tt;
         }
         const t = this.name;
         const e = this.parent;
         if (!e) {
-            return this.#Ct = this.name;
+            return this.#Tt = this.name;
         }
         const s = e.fullpath();
         const i = s + (!e.parent ? "" : this.sep) + t;
-        return this.#Ct = i;
+        return this.#Tt = i;
     }
     fullpathPosix() {
         if (this.#Lt !== undefined) return this.#Lt;
@@ -3356,7 +3605,7 @@ class PathBase {
         return this.#Lt = s;
     }
     isUnknown() {
-        return (this.#Pt & Ae) === Se;
+        return (this.#Pt & Zt) === It;
     }
     isType(t) {
         return this[`is${t}`]();
@@ -3365,28 +3614,28 @@ 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 & Ae) === Te;
+        return (this.#Pt & Zt) === Ut;
     }
     isDirectory() {
-        return (this.#Pt & Ae) === xe;
+        return (this.#Pt & Zt) === $t;
     }
     isCharacterDevice() {
-        return (this.#Pt & Ae) === ve;
+        return (this.#Pt & Zt) === jt;
     }
     isBlockDevice() {
-        return (this.#Pt & Ae) === Ee;
+        return (this.#Pt & Zt) === Gt;
     }
     isFIFO() {
-        return (this.#Pt & Ae) === ke;
+        return (this.#Pt & Zt) === Wt;
     }
     isSocket() {
-        return (this.#Pt & Ae) === Le;
+        return (this.#Pt & Zt) === Ht;
     }
     isSymbolicLink() {
-        return (this.#Pt & Ce) === Ce;
+        return (this.#Pt & qt) === qt;
     }
     lstatCached() {
-        return this.#Pt & Fe ? this : undefined;
+        return this.#Pt & Kt ? this : undefined;
     }
     readlinkCached() {
         return this.#Rt;
@@ -3401,17 +3650,17 @@ class PathBase {
     canReadlink() {
         if (this.#Rt) return true;
         if (!this.parent) return false;
-        const t = this.#Pt & Ae;
-        return !(t !== Se && t !== Ce || this.#Pt & ze || this.#Pt & Oe);
+        const t = this.#Pt & Zt;
+        return !(t !== It && t !== qt || this.#Pt & Qt || this.#Pt & Xt);
     }
     calledReaddir() {
-        return !!(this.#Pt & Pe);
+        return !!(this.#Pt & Jt);
     }
     isENOENT() {
-        return !!(this.#Pt & Oe);
+        return !!(this.#Pt & Xt);
     }
     isNamed(t) {
-        return !this.nocase ? this.#Et === Ie(t) : this.#Et === Ue(t);
+        return !this.nocase ? this.#Et === normalize(t) : this.#Et === normalizeNocase(t);
     }
     async readlink() {
         const t = this.#Rt;
@@ -3458,84 +3707,84 @@ class PathBase {
         }
     }
     #Nt(t) {
-        this.#Pt |= Pe;
+        this.#Pt |= Jt;
         for (let e = t.provisional; e < t.length; e++) {
             const s = t[e];
             if (s) s.#Bt();
         }
     }
     #Bt() {
-        if (this.#Pt & Oe) return;
-        this.#Pt = (this.#Pt | Oe) & Me;
-        this.#Wt();
+        if (this.#Pt & Xt) return;
+        this.#Pt = (this.#Pt | Xt) & Vt;
+        this.#_t();
     }
-    #Wt() {
+    #_t() {
         const t = this.children();
         t.provisional = 0;
         for (const e of t) {
             e.#Bt();
         }
     }
-    #_t() {
-        this.#Pt |= De;
-        this.#It();
-    }
     #It() {
-        if (this.#Pt & Re) return;
-        let t = this.#Pt;
-        if ((t & Ae) === xe) t &= Me;
-        this.#Pt = t | Re;
+        this.#Pt |= te;
         this.#Wt();
     }
+    #Wt() {
+        if (this.#Pt & Yt) return;
+        let t = this.#Pt;
+        if ((t & Zt) === $t) t &= Vt;
+        this.#Pt = t | Yt;
+        this.#_t();
+    }
     #jt(t = "") {
         if (t === "ENOTDIR" || t === "EPERM") {
-            this.#It();
+            this.#Wt();
         } else if (t === "ENOENT") {
             this.#Bt();
         } else {
             this.children().provisional = 0;
         }
     }
-    #Ut(t = "") {
+    #$t(t = "") {
         if (t === "ENOTDIR") {
             const t = this.parent;
-            t.#It();
+            t.#Wt();
         } else if (t === "ENOENT") {
             this.#Bt();
         }
     }
     #Dt(t = "") {
         let e = this.#Pt;
-        e |= ze;
-        if (t === "ENOENT") e |= Oe;
+        e |= Qt;
+        if (t === "ENOENT") e |= Xt;
         if (t === "EINVAL" || t === "UNKNOWN") {
-            e &= Me;
+            e &= Vt;
         }
         this.#Pt = e;
         if (t === "ENOTDIR" && this.parent) {
-            this.parent.#It();
+            this.parent.#Wt();
         }
     }
     #Gt(t, e) {
-        return this.#$t(t, e) || this.#qt(t, e);
+        return this.#Ut(t, e) || this.#qt(t, e);
     }
     #qt(t, e) {
-        const s = We(t);
+        const s = entToType(t);
         const i = this.newChild(t.name, s, {
             parent: this
         });
-        const n = i.#Pt & Ae;
-        if (n !== xe && n !== Ce && n !== Se) {
-            i.#Pt |= Re;
+        const n = i.#Pt & Zt;
+        if (n !== $t && n !== qt && n !== It) {
+            i.#Pt |= Yt;
         }
         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 ? Ue(t.name) : Ie(t.name);
+            const n = this.nocase ? normalizeNocase(t.name) : normalize(t.name);
             if (n !== i.#Et) {
                 continue;
             }
@@ -3544,7 +3793,7 @@ class PathBase {
     }
     #Ht(t, e, s, i) {
         const n = e.name;
-        e.#Pt = e.#Pt & Me | We(t);
+        e.#Pt = e.#Pt & Vt | 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);
@@ -3554,49 +3803,49 @@ class PathBase {
         return e;
     }
     async lstat() {
-        if ((this.#Pt & Oe) === 0) {
+        if ((this.#Pt & Xt) === 0) {
             try {
                 this.#Zt(await this.#ot.promises.lstat(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
     lstatSync() {
-        if ((this.#Pt & Oe) === 0) {
+        if ((this.#Pt & Xt) === 0) {
             try {
                 this.#Zt(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;
+        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 = We(t);
-        this.#Pt = this.#Pt & Me | b | Fe;
-        if (b !== Se && b !== xe && b !== Ce) {
-            this.#Pt |= Re;
+        this.#ut = y;
+        this.#v = w;
+        this.#ct = b;
+        const S = entToType(t);
+        this.#Pt = this.#Pt & Vt | S | Kt;
+        if (S !== It && S !== $t && S !== qt) {
+            this.#Pt |= Yt;
         }
     }
     #Vt=[];
@@ -3653,8 +3902,8 @@ 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
@@ -3667,7 +3916,7 @@ class PathBase {
                 t.provisional = 0;
             }
             this.#Yt = undefined;
-            s();
+            resolve();
         }
         return t.slice(0, t.provisional);
     }
@@ -3694,37 +3943,37 @@ class PathBase {
         return t.slice(0, t.provisional);
     }
     canReaddir() {
-        if (this.#Pt & Ne) return false;
-        const t = Ae & this.#Pt;
-        if (!(t === Se || t === xe || t === Ce)) {
+        if (this.#Pt & ee) return false;
+        const t = Zt & this.#Pt;
+        if (!(t === It || t === $t || t === qt)) {
             return false;
         }
         return true;
     }
     shouldWalk(t, e) {
-        return (this.#Pt & xe) === xe && !(this.#Pt & Ne) && !t.has(this) && (!e || e(this));
+        return (this.#Pt & $t) === $t && !(this.#Pt & ee) && !t.has(this) && (!e || e(this));
     }
     async realpath() {
         if (this.#Ot) return this.#Ot;
-        if ((De | ze | Oe) & this.#Pt) return undefined;
+        if ((te | Qt | Xt) & this.#Pt) return undefined;
         try {
             const t = await this.#ot.promises.realpath(this.fullpath());
             return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#_t();
+            this.#It();
         }
     }
     realpathSync() {
         if (this.#Ot) return this.#Ot;
-        if ((De | ze | Oe) & this.#Pt) return undefined;
+        if ((te | Qt | Xt) & this.#Pt) return undefined;
         try {
             const t = this.#ot.realpathSync(this.fullpath());
             return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#_t();
+            this.#It();
         }
     }
-    [Ge](t) {
+    [re](t) {
         if (t === this) return;
         t.isCWD = false;
         this.isCWD = true;
@@ -3749,18 +3998,18 @@ class PathBase {
 
 class PathWin32 extends PathBase {
     sep="\\";
-    splitSep=be;
-    constructor(t, e = Se, s, i, n, r, o) {
+    splitSep=_t;
+    constructor(t, e = It, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
-    newChild(t, e = Se, s = {}) {
+    newChild(t, e = It, s = {}) {
         return new PathWin32(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
     getRootString(t) {
-        return s.win32.parse(t).root;
+        return e.win32.parse(t).root;
     }
     getRoot(t) {
-        t = ye(t.toUpperCase());
+        t = uncToDrive(t.toUpperCase());
         if (t === this.root.name) {
             return this.root;
         }
@@ -3772,7 +4021,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(we, "$1\\");
+        t = t.toUpperCase().replace(/\//g, "\\").replace(Bt, "$1\\");
         return t === e;
     }
 }
@@ -3780,7 +4029,7 @@ class PathWin32 extends PathBase {
 class PathPosix extends PathBase {
     splitSep="/";
     sep="/";
-    constructor(t, e = Se, s, i, n, r, o) {
+    constructor(t, e = It, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
     getRootString(t) {
@@ -3789,7 +4038,7 @@ class PathPosix extends PathBase {
     getRoot(t) {
         return this.root;
     }
-    newChild(t, e = Se, s = {}) {
+    newChild(t, e = It, s = {}) {
         return new PathPosix(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
 }
@@ -3804,12 +4053,12 @@ class PathScurryBase {
     #Ft;
     nocase;
     #ot;
-    constructor(t = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = ge} = {}) {
-        this.#ot = me(o);
-        if (t instanceof URL || t.startsWith("file://")) {
-            t = e.fileURLToPath(t);
+    constructor(e = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = Nt} = {}) {
+        this.#ot = fsFromOption(o);
+        if (e instanceof URL || e.startsWith("file://")) {
+            e = t.fileURLToPath(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;
@@ -4018,38 +4267,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);
             }));
@@ -4147,7 +4396,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();
@@ -4157,21 +4406,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;
@@ -4179,24 +4428,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 = {}) {
@@ -4216,7 +4465,7 @@ class PathScurryBase {
         }
         const a = [ t ];
         let l = 0;
-        const c = () => {
+        const process = () => {
             let t = false;
             while (!t) {
                 const e = a.shift();
@@ -4246,24 +4495,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[Ge](e);
+        this.cwd[re](e);
     }
 }
 
 class PathScurryWin32 extends PathScurryBase {
     sep="\\";
-    constructor(t = process.cwd(), e = {}) {
-        const {nocase: i = true} = e;
-        super(t, s.win32, "\\", {
-            ...e,
+    constructor(t = process.cwd(), s = {}) {
+        const {nocase: i = true} = s;
+        super(t, e.win32, "\\", {
+            ...s,
             nocase: i
         });
         this.nocase = i;
@@ -4272,10 +4521,10 @@ class PathScurryWin32 extends PathScurryBase {
         }
     }
     parseRootPath(t) {
-        return s.win32.parse(t).root.toUpperCase();
+        return e.win32.parse(t).root.toUpperCase();
     }
     newRoot(t) {
-        return new PathWin32(this.rootPath, xe, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathWin32(this.rootPath, $t, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4286,10 +4535,10 @@ class PathScurryWin32 extends PathScurryBase {
 
 class PathScurryPosix extends PathScurryBase {
     sep="/";
-    constructor(t = process.cwd(), e = {}) {
-        const {nocase: i = false} = e;
-        super(t, s.posix, "/", {
-            ...e,
+    constructor(t = process.cwd(), s = {}) {
+        const {nocase: i = false} = s;
+        super(t, e.posix, "/", {
+            ...s,
             nocase: i
         });
         this.nocase = i;
@@ -4298,7 +4547,7 @@ class PathScurryPosix extends PathScurryBase {
         return "/";
     }
     newRoot(t) {
-        return new PathPosix(this.rootPath, xe, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathPosix(this.rootPath, $t, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4317,13 +4566,13 @@ class PathScurryDarwin extends PathScurryPosix {
     }
 }
 
-const $e = process.platform === "win32" ? PathWin32 : PathPosix;
+const oe = process.platform === "win32" ? PathWin32 : PathPosix;
 
-const qe = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+const he = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-const He = t => t.length >= 1;
+const isPatternList = t => t.length >= 1;
 
-const Ze = t => t.length >= 1;
+const isGlobList = t => t.length >= 1;
 
 class Pattern {
     #te;
@@ -4338,10 +4587,10 @@ class Pattern {
     #ae;
     #le=true;
     constructor(t, e, s, i) {
-        if (!He(t)) {
+        if (!isPatternList(t)) {
             throw new TypeError("empty pattern list");
         }
-        if (!Ze(e)) {
+        if (!isGlobList(e)) {
             throw new TypeError("empty glob list");
         }
         if (e.length !== t.length) {
@@ -4390,7 +4639,7 @@ class Pattern {
         return typeof this.#te[this.#se] === "string";
     }
     isGlobstar() {
-        return this.#te[this.#se] === it;
+        return this.#te[this.#se] === q;
     }
     isRegExp() {
         return this.#te[this.#se] instanceof RegExp;
@@ -4436,7 +4685,7 @@ class Pattern {
     }
 }
 
-const Ve = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const ae = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
 class Ignore {
     relative;
@@ -4445,7 +4694,7 @@ class Ignore {
     absoluteChildren;
     platform;
     mmopts;
-    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = Ve}) {
+    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = ae}) {
         this.relative = [];
         this.absolute = [];
         this.relativeChildren = [];
@@ -4621,7 +4870,7 @@ class Processor {
                 const e = n === ".." || n === "" || n === ".";
                 this.matches.add(t.resolve(n), i, e);
                 continue;
-            } else if (n === it) {
+            } else if (n === q) {
                 if (!t.isSymbolicLink() || this.follow || e.checkFollowGlobstar()) {
                     this.subwalks.add(t, e);
                 }
@@ -4657,7 +4906,7 @@ class Processor {
                 const s = e.isAbsolute();
                 const n = e.pattern();
                 const r = e.rest();
-                if (n === it) {
+                if (n === q) {
                     i.testGlobstar(t, e, r, s);
                 } else if (n instanceof RegExp) {
                     i.testRegExp(t, n, r, s);
@@ -4715,7 +4964,7 @@ class Processor {
     }
 }
 
-const Je = (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;
@@ -4737,7 +4986,7 @@ class GlobUtil {
         this.#ue = !s.posix && s.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = s.includeChildMatches !== false;
         if (s.ignore || !this.includeChildMatches) {
-            this.#fe = Je(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);
@@ -4856,13 +5105,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) {
@@ -4870,28 +5119,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();
@@ -4906,7 +5155,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()) {
@@ -4919,14 +5168,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()) {
@@ -4935,9 +5184,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();
     }
 }
 
@@ -5012,9 +5261,9 @@ class GlobStream extends GlobUtil {
     }
 }
 
-const Ke = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const le = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
-let Ye = class Glob {
+let ce = class Glob {
     absolute;
     cwd;
     root;
@@ -5042,7 +5291,7 @@ let Ye = 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;
@@ -5054,7 +5303,7 @@ let Ye = class Glob {
         if (!s.cwd) {
             this.cwd = "";
         } else if (s.cwd instanceof URL || s.cwd.startsWith("file://")) {
-            s.cwd = e.fileURLToPath(s.cwd);
+            s.cwd = t.fileURLToPath(s.cwd);
         }
         this.cwd = s.cwd || "";
         this.root = s.root;
@@ -5072,21 +5321,21 @@ let Ye = 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 || Ke;
+        this.pattern = e;
+        this.platform = s.platform || le;
         this.opts = {
             ...s,
             platform: this.platform
@@ -5097,7 +5346,7 @@ let Ye = 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 : qe;
+            const t = s.platform === "win32" ? PathScurryWin32 : s.platform === "darwin" ? PathScurryDarwin : s.platform ? PathScurryPosix : he;
             this.scurry = new t(this.cwd, {
                 nocase: s.nocase,
                 fs: s.fs
@@ -5182,7 +5431,7 @@ let Ye = class Glob {
     }
 };
 
-const Xe = (t, e = {}) => {
+const hasMagic = (t, e = {}) => {
     if (!Array.isArray(t)) {
         t = [ t ];
     }
@@ -5192,69 +5441,69 @@ const Xe = (t, e = {}) => {
     return false;
 };
 
-function Qe(t, e = {}) {
-    return new Ye(t, e).streamSync();
+function globStreamSync(t, e = {}) {
+    return new ce(t, e).streamSync();
 }
 
-function ts(t, e = {}) {
-    return new Ye(t, e).stream();
+function globStream(t, e = {}) {
+    return new ce(t, e).stream();
 }
 
-function es(t, e = {}) {
-    return new Ye(t, e).walkSync();
+function globSync(t, e = {}) {
+    return new ce(t, e).walkSync();
 }
 
-async function ss(t, e = {}) {
-    return new Ye(t, e).walk();
+async function glob_(t, e = {}) {
+    return new ce(t, e).walk();
 }
 
-function is(t, e = {}) {
-    return new Ye(t, e).iterateSync();
+function globIterateSync(t, e = {}) {
+    return new ce(t, e).iterateSync();
 }
 
-function ns(t, e = {}) {
-    return new Ye(t, e).iterate();
+function globIterate(t, e = {}) {
+    return new ce(t, e).iterate();
 }
 
-const rs = Qe;
+const fe = globStreamSync;
 
-const os = Object.assign(ts, {
-    sync: Qe
+const ue = Object.assign(globStream, {
+    sync: globStreamSync
 });
 
-const hs = is;
+const de = globIterateSync;
 
-const as = Object.assign(ns, {
-    sync: is
+const pe = Object.assign(globIterate, {
+    sync: globIterateSync
 });
 
-const ls = Object.assign(es, {
-    stream: Qe,
-    iterate: is
+const ge = Object.assign(globSync, {
+    stream: globStreamSync,
+    iterate: globIterateSync
 });
 
-const cs = Object.assign(ss, {
-    glob: ss,
-    globSync: es,
-    sync: ls,
-    globStream: ts,
-    stream: os,
-    globStreamSync: Qe,
-    streamSync: rs,
-    globIterate: ns,
-    iterate: as,
-    globIterateSync: is,
-    iterateSync: hs,
-    Glob: Ye,
-    hasMagic: Xe,
-    escape: R,
-    unescape: S
+const me = Object.assign(glob_, {
+    glob: glob_,
+    globSync,
+    sync: ge,
+    globStream,
+    stream: ue,
+    globStreamSync,
+    streamSync: fe,
+    globIterate,
+    iterate: pe,
+    globIterateSync,
+    iterateSync: de,
+    Glob: ce,
+    hasMagic,
+    escape,
+    unescape
 });
 
-cs.glob = cs;
+me.glob = me;
 
-async function fs(t, e) {
-    return e ? await cs(t, e) : await cs(t);
+async function Glob(t, e) {
+    return e ? await me(t, e) : await me(t);
 }
 
-exports.Glob = fs;
+exports.Glob = Glob;