lakutata 2.0.80 → 2.0.81

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 a = t => t && t.__esModule ? t : {
     default: t
 };
 
-function c(t) {
+function l(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 c = l(i);
+
+const f = a(o);
+
+const u = (t, e, s) => {
+    const i = t instanceof RegExp ? d(t, s) : t;
+    const n = e instanceof RegExp ? d(e, s) : e;
+    const r = i !== null && n != null && p(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 d = (t, e) => {
+    const s = e.match(t);
+    return s ? s[0] : null;
+};
+
+const p = (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 g = "\0SLASH" + Math.random() + "\0";
+
+const m = "\0OPEN" + Math.random() + "\0";
+
+const w = "\0CLOSE" + Math.random() + "\0";
+
+const y = "\0COMMA" + Math.random() + "\0";
+
+const b = "\0PERIOD" + Math.random() + "\0";
+
+const S = new RegExp(g, "g");
+
+const k = new RegExp(m, "g");
+
+const v = new RegExp(w, "g");
+
+const x = new RegExp(y, "g");
+
+const E = new RegExp(b, "g");
+
+const C = /\\\\/g;
+
+const T = /\\{/g;
+
+const L = /\\}/g;
+
+const A = /\\,/g;
+
+const M = /\\./g;
+
+function P(t) {
+    return !isNaN(t) ? parseInt(t, 10) : t.charCodeAt(0);
+}
+
+function F(t) {
+    return t.replace(C, g).replace(T, m).replace(L, w).replace(A, y).replace(M, b);
+}
+
+function R(t) {
+    return t.replace(S, "\\").replace(k, "{").replace(v, "}").replace(x, ",").replace(E, ".");
+}
+
+function O(t) {
+    if (!t) {
+        return [ "" ];
+    }
+    const e = [];
+    const s = u("{", "}", 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 = O(r);
+    if (r.length) {
+        o[o.length - 1] += h.shift();
+        o.push.apply(o, h);
+    }
+    e.push.apply(e, o);
+    return e;
+}
+
+function z(t) {
+    if (!t) {
+        return [];
+    }
+    if (t.slice(0, 2) === "{}") {
+        t = "\\{\\}" + t.slice(2);
+    }
+    return I(F(t), true).map(R);
+}
+
+function D(t) {
+    return "{" + t + "}";
+}
 
-const u = l(h);
+function N(t) {
+    return /^-?0\d/.test(t);
+}
 
-const d = 1024 * 64;
+function B(t, e) {
+    return t <= e;
+}
 
-const p = t => {
+function W(t, e) {
+    return t >= e;
+}
+
+function I(t, e) {
+    const s = [];
+    const i = u("{", "}", t);
+    if (!i) return [ t ];
+    const n = i.pre;
+    const r = i.post.length ? I(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 + w + i.post;
+                return I(t);
+            }
+            return [ t ];
+        }
+        let c;
+        if (a) {
+            c = i.body.split(/\.\./);
+        } else {
+            c = O(i.body);
+            if (c.length === 1 && c[0] !== undefined) {
+                c = I(c[0], false).map(D);
+                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 = P(c[0]);
+            const e = P(c[1]);
+            const s = Math.max(c[0].length, c[1].length);
+            let i = c.length === 3 && c[2] !== undefined ? Math.abs(P(c[2])) : 1;
+            let n = B;
+            const r = e < t;
+            if (r) {
+                i *= -1;
+                n = W;
+            }
+            const o = c.some(N);
+            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, I(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 _ = 1024 * 64;
+
+const j = t => {
     if (typeof t !== "string") {
         throw new TypeError("invalid pattern");
     }
-    if (t.length > d) {
+    if (t.length > _) {
         throw new TypeError("pattern is too long");
     }
 };
 
-const g = {
+const $ = {
     "[: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 U = t => t.replace(/[[\]\\-]/g, "\\$&");
 
-const w = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const G = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const y = t => t.join("");
+const q = t => t.join("");
 
-const b = (t, e) => {
+const H = (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($)) {
                 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(U(f) + "-" + U(e));
             } else if (e === f) {
-                i.push(m(e));
+                i.push(U(e));
             }
             f = "";
             r++;
             continue;
         }
         if (t.startsWith("-]", r + 1)) {
-            i.push(m(e + "-"));
+            i.push(U(e + "-"));
             r += 2;
             continue;
         }
@@ -155,7 +383,7 @@ const b = (t, e) => {
             r += 2;
             continue;
         }
-        i.push(m(e));
+        i.push(U(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 [ G(t), false, c - s, false ];
     }
-    const u = "[" + (l ? "^" : "") + y(i) + "]";
-    const d = "[" + (l ? "" : "^") + y(n) + "]";
+    const u = "[" + (l ? "^" : "") + q(i) + "]";
+    const d = "[" + (l ? "" : "^") + q(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 Z = (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 V = new Set([ "!", "?", "+", "*", "@" ]);
 
-const v = t => k.has(t);
+const J = t => V.has(t);
 
-const x = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const K = "(?!(?:^|/)\\.\\.?(?:$|/))";
 
-const E = "(?!\\.)";
+const Y = "(?!\\.)";
 
-const T = new Set([ "[", "." ]);
+const X = new Set([ "[", "." ]);
 
-const C = new Set([ "..", "." ]);
+const Q = new Set([ "..", "." ]);
 
-const L = new Set("().*{}+?[]^$\\!");
+const tt = new Set("().*{}+?[]^$\\!");
 
-const A = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const et = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const M = "[^/]";
+const st = "[^/]";
 
-const P = M + "*?";
+const it = st + "*?";
 
-const F = M + "+?";
+const nt = st + "+?";
 
 class AST {
     type;
@@ -342,7 +575,7 @@ class AST {
                     l += s;
                     continue;
                 }
-                if (!i.noext && v(s) && t.charAt(a) === "(") {
+                if (!i.noext && J(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 (J(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 && Q.has(this.#i[0]);
                     if (!s) {
-                        const s = T;
+                        const s = X;
                         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 ? K : o ? Y : "";
                     }
                 }
             }
@@ -464,7 +697,7 @@ class AST {
                 r = "(?:$|\\/)";
             }
             const o = n + i + r;
-            return [ o, S(i), this.#e = !!this.#e, this.#s ];
+            return [ o, Z(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, Z(this.toString()), false, false ];
         }
-        let r = !s || t || e || !E ? "" : this.#p(true);
+        let r = !s || t || e || !Y ? "" : 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 ? Y : "") + nt;
         } 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 ? Y : "") + it + ")" : 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, Z(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 += (tt.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] = H(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 === "*" ? nt : it;
                 e = true;
                 continue;
             }
             if (h === "?") {
-                n += M;
+                n += st;
                 e = true;
                 continue;
             }
-            n += A(h);
+            n += et(h);
         }
-        return [ n, S(t), !!e, r ];
+        return [ n, Z(t), !!e, r ];
     }
 }
 
-const R = (t, {windowsPathsNoEscape: e = false} = {}) => e ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+const rt = (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 ot = (t, e, s = {}) => {
+    j(e);
     if (!s.nocomment && e.charAt(0) === "#") {
         return false;
     }
     return new Minimatch(e, s).match(t);
 };
 
-const z = /^\*+([^+@!?\*\[\(]*)$/;
+const ht = /^\*+([^+@!?\*\[\(]*)$/;
 
-const D = t => e => !e.startsWith(".") && e.endsWith(t);
+const at = t => e => !e.startsWith(".") && e.endsWith(t);
 
-const N = t => e => e.endsWith(t);
+const lt = t => e => e.endsWith(t);
 
-const B = t => {
+const ct = t => {
     t = t.toLowerCase();
     return e => !e.startsWith(".") && e.toLowerCase().endsWith(t);
 };
 
-const W = t => {
+const ft = t => {
     t = t.toLowerCase();
     return e => e.toLowerCase().endsWith(t);
 };
 
-const _ = /^\*+\.\*+$/;
+const ut = /^\*+\.\*+$/;
 
-const I = t => !t.startsWith(".") && t.includes(".");
+const dt = t => !t.startsWith(".") && t.includes(".");
 
-const j = t => t !== "." && t !== ".." && t.includes(".");
+const pt = t => t !== "." && t !== ".." && t.includes(".");
 
-const U = /^\.\*+$/;
+const gt = /^\.\*+$/;
 
-const G = t => t !== "." && t !== ".." && t.startsWith(".");
+const mt = t => t !== "." && t !== ".." && t.startsWith(".");
 
-const $ = /^\*+$/;
+const wt = /^\*+$/;
 
-const q = t => t.length !== 0 && !t.startsWith(".");
+const yt = t => t.length !== 0 && !t.startsWith(".");
 
-const H = t => t.length !== 0 && t !== "." && t !== "..";
+const bt = t => t.length !== 0 && t !== "." && t !== "..";
 
-const Z = /^\?+([^+@!?\*\[\(]*)?$/;
+const St = /^\?+([^+@!?\*\[\(]*)?$/;
 
-const V = ([t, e = ""]) => {
-    const s = X([ t ]);
+const kt = ([t, e = ""]) => {
+    const s = Ct([ 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 vt = ([t, e = ""]) => {
+    const s = Tt([ 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 xt = ([t, e = ""]) => {
+    const s = Tt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const Y = ([t, e = ""]) => {
-    const s = X([ t ]);
+const Et = ([t, e = ""]) => {
+    const s = Ct([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const X = ([t]) => {
+const Ct = ([t]) => {
     const e = t.length;
     return t => t.length === e && !t.startsWith(".");
 };
 
-const Q = ([t]) => {
+const Tt = ([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 Lt = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
 
-const et = {
+const At = {
     win32: {
         sep: "\\"
     },
@@ -636,80 +874,80 @@ const et = {
     }
 };
 
-const st = tt === "win32" ? et.win32.sep : et.posix.sep;
+const Mt = Lt === "win32" ? At.win32.sep : At.posix.sep;
 
-O.sep = st;
+ot.sep = Mt;
 
-const it = Symbol("globstar **");
+const Pt = Symbol("globstar **");
 
-O.GLOBSTAR = it;
+ot.GLOBSTAR = Pt;
 
-const nt = "[^/]";
+const Ft = "[^/]";
 
-const rt = nt + "*?";
+const Rt = Ft + "*?";
 
-const ot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const Ot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 
-const ht = "(?:(?!(?:\\/|^)\\.).)*?";
+const zt = "(?:(?!(?:\\/|^)\\.).)*?";
 
-const at = (t, e = {}) => s => O(s, t, e);
+const Dt = (t, e = {}) => s => ot(s, t, e);
 
-O.filter = at;
+ot.filter = Dt;
 
-const lt = (t, e = {}) => Object.assign({}, t, e);
+const Nt = (t, e = {}) => Object.assign({}, t, e);
 
-const ct = t => {
+const Bt = t => {
     if (!t || typeof t !== "object" || !Object.keys(t).length) {
-        return O;
+        return ot;
     }
-    const e = O;
-    const s = (s, i, n = {}) => e(s, i, lt(t, n));
+    const e = ot;
+    const s = (s, i, n = {}) => e(s, i, Nt(t, n));
     return Object.assign(s, {
         Minimatch: class Minimatch extends e.Minimatch {
             constructor(e, s = {}) {
-                super(e, lt(t, s));
+                super(e, Nt(t, s));
             }
             static defaults(s) {
-                return e.defaults(lt(t, s)).Minimatch;
+                return e.defaults(Nt(t, s)).Minimatch;
             }
         },
         AST: class AST extends e.AST {
             constructor(e, s, i = {}) {
-                super(e, s, lt(t, i));
+                super(e, s, Nt(t, i));
             }
             static fromGlob(s, i = {}) {
-                return e.AST.fromGlob(s, lt(t, i));
+                return e.AST.fromGlob(s, Nt(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, Nt(t, i)),
+        escape: (s, i = {}) => e.escape(s, Nt(t, i)),
+        filter: (s, i = {}) => e.filter(s, Nt(t, i)),
+        defaults: s => e.defaults(Nt(t, s)),
+        makeRe: (s, i = {}) => e.makeRe(s, Nt(t, i)),
+        braceExpand: (s, i = {}) => e.braceExpand(s, Nt(t, i)),
+        match: (s, i, n = {}) => e.match(s, i, Nt(t, n)),
         sep: e.sep,
-        GLOBSTAR: it
+        GLOBSTAR: Pt
     });
 };
 
-O.defaults = ct;
+ot.defaults = Bt;
 
-const ft = (e, s = {}) => {
-    p(e);
-    if (s.nobrace || !/\{(?:(?!\{).)*\}/.test(e)) {
-        return [ e ];
+const Wt = (t, e = {}) => {
+    j(t);
+    if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(t)) {
+        return [ t ];
     }
-    return t.expand(e);
+    return z(t);
 };
 
-O.braceExpand = ft;
+ot.braceExpand = Wt;
 
-const ut = (t, e = {}) => new Minimatch(t, e).makeRe();
+const It = (t, e = {}) => new Minimatch(t, e).makeRe();
 
-O.makeRe = ut;
+ot.makeRe = It;
 
-const dt = (t, e, s = {}) => {
+const _t = (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;
+ot.match = _t;
 
-const pt = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const jt = /[?*]|[+@!]\(.*?\)|\[|\]/;
 
-const gt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const $t = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
 class Minimatch {
     options;
@@ -743,11 +981,11 @@ class Minimatch {
     windowsNoMagicRoot;
     regexp;
     constructor(t, e = {}) {
-        p(t);
+        j(t);
         e = e || {};
         this.options = e;
         this.pattern = t;
-        this.platform = e.platform || tt;
+        this.platform = e.platform || Lt;
         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] === "?" || !jt.test(t[2])) && !jt.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 === Pt) {
                 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 Wt(this.pattern, this.options);
     }
     parse(t) {
-        p(t);
+        j(t);
         const e = this.options;
-        if (t === "**") return it;
+        if (t === "**") return Pt;
         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);
-        } else if (s = t.match(_)) {
-            i = e.dot ? j : I;
-        } else if (s = t.match(U)) {
-            i = G;
+        if (s = t.match(wt)) {
+            i = e.dot ? bt : yt;
+        } else if (s = t.match(ht)) {
+            i = (e.nocase ? e.dot ? ft : ct : e.dot ? lt : at)(s[1]);
+        } else if (s = t.match(St)) {
+            i = (e.nocase ? e.dot ? vt : kt : e.dot ? xt : Et)(s);
+        } else if (s = t.match(ut)) {
+            i = e.dot ? pt : dt;
+        } else if (s = t.match(gt)) {
+            i = mt;
         }
         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 ? Rt : e.dot ? Ot : zt;
         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" ? $t(t) : t === Pt ? Pt : t._src;
             }));
             e.forEach(((t, i) => {
                 const n = e[i + 1];
                 const r = e[i - 1];
-                if (t !== it || r === it) {
+                if (t !== Pt || r === Pt) {
                     return;
                 }
                 if (r === undefined) {
-                    if (n !== undefined && n !== it) {
+                    if (n !== undefined && n !== Pt) {
                         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 !== Pt) {
                     e[i - 1] = r + "(?:\\/|\\/" + s + "\\/)" + n;
-                    e[i + 1] = it;
+                    e[i + 1] = Pt;
                 }
             }));
-            return e.filter((t => t !== it)).join("/");
+            const n = e.filter((t => t !== Pt));
+            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 ot.defaults(t).Minimatch;
     }
 }
 
-O.AST = AST;
+ot.AST = AST;
 
-O.Minimatch = Minimatch;
+ot.Minimatch = Minimatch;
 
-O.escape = R;
+ot.escape = rt;
 
-O.unescape = S;
+ot.unescape = Z;
 
-const mt = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const Ut = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 
-const wt = new Set;
+const Gt = new Set;
 
-const yt = typeof process === "object" && !!process ? process : {};
+const qt = 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 Ht = (t, e, s, i) => {
+    typeof qt.emitWarning === "function" ? qt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
 };
 
-let St = globalThis.AbortController;
+let Zt = globalThis.AbortController;
 
-let kt = globalThis.AbortSignal;
+let Vt = globalThis.AbortSignal;
 
-if (typeof St === "undefined") {
-    kt = class AbortSignal {
+if (typeof Zt === "undefined") {
+    Vt = class AbortSignal {
         onabort;
         _onabort=[];
         reason;
@@ -1289,11 +1538,11 @@ if (typeof St === "undefined") {
             this._onabort.push(e);
         }
     };
-    St = class AbortController {
+    Zt = class AbortController {
         constructor() {
             e();
         }
-        signal=new kt;
+        signal=new Vt;
         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";
+    let t = qt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
     const e = () => {
         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);
+        Ht("AbortController is not defined. If using lru-cache in " + "node 14, load an AbortController polyfill from the " + "`node-abort-controller` package. A minimal polyfill is " + "provided for use by LRUCache.fetch(), but it should not be " + "relied upon in other contexts (eg, passing it to other APIs that " + "use AbortController/AbortSignal might have undesirable effects). " + "You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", e);
     };
 }
 
-const vt = t => !wt.has(t);
+const Jt = t => !Gt.has(t);
 
-const xt = Symbol("type");
+const Kt = Symbol("type");
 
-const Et = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+const Yt = 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 Xt = t => !Yt(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 = Xt(t);
         if (!e) return [];
         Stack.#g = true;
         const s = new Stack(t, e);
@@ -1379,8 +1628,8 @@ class LRUCache {
     ignoreFetchAbort;
     #x;
     #E;
-    #T;
     #C;
+    #T;
     #L;
     #A;
     #M;
@@ -1393,15 +1642,15 @@ class LRUCache {
     #N;
     #B;
     #W;
-    #_;
     #I;
+    #_;
     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),
-            moveToTail: e => t.#G(e),
-            indexes: e => t.#$(e),
+            backgroundFetch: (e, s, i, n) => t.#$(e, s, i, n),
+            moveToTail: e => t.#U(e),
+            indexes: e => t.#G(e),
             rindexes: e => t.#q(e),
             isStale: e => t.#H(e)
         };
@@ -1449,10 +1698,10 @@ class LRUCache {
     }
     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)) {
+        if (e !== 0 && !Yt(e)) {
             throw new TypeError("max option must be a nonnegative integer");
         }
-        const x = e ? Tt(e) : Array;
+        const x = e ? Xt(e) : Array;
         if (!x) {
             throw new Error("invalid max value: " + e);
         }
@@ -1477,8 +1726,8 @@ class LRUCache {
         }
         this.#k = m;
         this.#W = !!m;
-        this.#T = new Map;
-        this.#C = new Array(e).fill(undefined);
+        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);
@@ -1501,8 +1750,8 @@ class LRUCache {
             this.#O = undefined;
         }
         this.#B = !!this.#y;
-        this.#I = !!this.#b;
-        this.#_ = !!this.#S;
+        this.#_ = !!this.#b;
+        this.#I = !!this.#S;
         this.noDisposeOnSet = !!f;
         this.noUpdateTTL = !!u;
         this.noDeleteOnFetchRejection = !!y;
@@ -1511,11 +1760,11 @@ class LRUCache {
         this.ignoreFetchAbort = !!v;
         if (this.maxEntrySize !== 0) {
             if (this.#w !== 0) {
-                if (!Et(this.#w)) {
+                if (!Yt(this.#w)) {
                     throw new TypeError("maxSize must be a positive integer if specified");
                 }
             }
-            if (!Et(this.maxEntrySize)) {
+            if (!Yt(this.maxEntrySize)) {
                 throw new TypeError("maxEntrySize must be a positive integer if specified");
             }
             this.#Z();
@@ -1524,11 +1773,11 @@ class LRUCache {
         this.noDeleteOnStaleGet = !!b;
         this.updateAgeOnGet = !!r;
         this.updateAgeOnHas = !!o;
-        this.ttlResolution = Et(i) || i === 0 ? i : 1;
+        this.ttlResolution = Yt(i) || i === 0 ? i : 1;
         this.ttlAutopurge = !!n;
         this.ttl = s || 0;
         if (this.ttl) {
-            if (!Et(this.ttl)) {
+            if (!Yt(this.ttl)) {
                 throw new TypeError("ttl must be a positive integer if specified");
             }
             this.#V();
@@ -1538,28 +1787,28 @@ class LRUCache {
         }
         if (!this.ttlAutopurge && !this.#m && !this.#w) {
             const t = "LRU_CACHE_UNBOUNDED";
-            if (vt(t)) {
-                wt.add(t);
+            if (Jt(t)) {
+                Gt.add(t);
                 const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
-                bt(e, "UnboundedCacheWarning", t, LRUCache);
+                Ht(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 = Ut.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,7 +1817,7 @@ class LRUCache {
             }
         };
         this.#Y = s => {
-            e[s] = t[s] !== 0 ? mt.now() : 0;
+            e[s] = t[s] !== 0 ? Ut.now() : 0;
         };
         this.#X = (n, r) => {
             if (t[r]) {
@@ -1584,7 +1833,7 @@ class LRUCache {
         };
         let s = 0;
         const i = () => {
-            const t = mt.now();
+            const t = Ut.now();
             if (this.ttlResolution > 0) {
                 s = t;
                 const e = setTimeout((() => s = 0), this.ttlResolution);
@@ -1595,7 +1844,7 @@ class LRUCache {
             return t;
         };
         this.getRemainingTTL = n => {
-            const r = this.#T.get(n);
+            const r = this.#C.get(n);
             if (r === undefined) {
                 return 0;
             }
@@ -1629,13 +1878,13 @@ class LRUCache {
             if (this.#j(e)) {
                 return 0;
             }
-            if (!Et(s)) {
+            if (!Yt(s)) {
                 if (i) {
                     if (typeof i !== "function") {
                         throw new TypeError("sizeCalculation must be a function");
                     }
                     s = i(e, t);
-                    if (!Et(s)) {
+                    if (!Yt(s)) {
                         throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     }
                 } else {
@@ -1667,7 +1916,7 @@ class LRUCache {
         }
         return 0;
     };
-    * #$({allowStale: t = this.allowStale} = {}) {
+    * #G({allowStale: t = this.allowStale} = {}) {
         if (this.#x) {
             for (let e = this.#F; true; ) {
                 if (!this.#it(e)) {
@@ -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.#G()) {
+            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.#G()) {
+            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.#G()) {
             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.#G()) {
             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.#G()) {
             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 - (Ut.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.#G({
             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 = Ut.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 = Ut.now() - t;
             }
             this.set(e, s.value, s);
         }
@@ -1865,12 +2114,12 @@ class LRUCache {
             this.#K(t, "set");
             return this;
         }
-        let c = this.#x === 0 ? undefined : this.#T.get(t);
+        let c = this.#x === 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;
+            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;
@@ -1878,11 +2127,11 @@ class LRUCache {
             this.#et(c, l, h);
             if (h) h.set = "add";
             a = false;
-            if (this.#I) {
+            if (this.#_) {
                 this.#b?.(e, t, "add");
             }
         } else {
-            this.#G(c);
+            this.#U(c);
             const s = this.#L[c];
             if (e !== s) {
                 if (this.#W && this.#j(s)) {
@@ -1892,7 +2141,7 @@ class LRUCache {
                         if (this.#B) {
                             this.#y?.(e, t, "set");
                         }
-                        if (this.#_) {
+                        if (this.#I) {
                             this.#O?.push([ e, t, "set" ]);
                         }
                     }
@@ -1900,7 +2149,7 @@ class LRUCache {
                     if (this.#B) {
                         this.#y?.(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.#_) {
                 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()) {
@@ -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,21 +2211,21 @@ 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)) {
             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");
             }
-            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);
         }
@@ -1986,13 +2235,13 @@ class LRUCache {
         } else {
             this.#P = this.#A[e];
         }
-        this.#T.delete(s);
+        this.#C.delete(s);
         this.#x--;
         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 Zt;
         const {signal: o} = s;
         o?.addEventListener("abort", (() => r.abort(o.reason)), {
             signal: r.signal
@@ -2126,7 +2375,7 @@ class LRUCache {
                 ...h.options,
                 status: undefined
             });
-            e = this.#T.get(t);
+            e = this.#C.get(t);
         } else {
             this.#L[e] = d;
         }
@@ -2135,7 +2384,7 @@ class LRUCache {
     #j(t) {
         if (!this.#W) 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 Zt;
     }
     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;
@@ -2164,10 +2413,10 @@ class LRUCache {
             status: m,
             signal: w
         };
-        let b = this.#T.get(t);
+        let b = this.#C.get(t);
         if (b === undefined) {
             if (m) m.fetch = "miss";
-            const e = this.#U(t, b, y, p);
+            const e = this.#$(t, b, y, p);
             return e.__returned = e;
         } else {
             const e = this.#L[b];
@@ -2182,14 +2431,14 @@ class LRUCache {
             const n = this.#H(b);
             if (!g && !n) {
                 if (m) m.fetch = "hit";
-                this.#G(b);
+                this.#U(b);
                 if (i) {
                     this.#Y(b);
                 }
                 if (m) this.#X(m, b);
                 return e;
             }
-            const r = this.#U(t, b, y, p);
+            const r = this.#$(t, b, y, p);
             const o = r.__staleWhileFetching !== undefined;
             const h = o && s;
             if (m) {
@@ -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);
@@ -2245,7 +2494,7 @@ class LRUCache {
                 if (h) {
                     return e.__staleWhileFetching;
                 }
-                this.#G(o);
+                this.#U(o);
                 if (i) {
                     this.#Y(o);
                 }
@@ -2259,7 +2508,7 @@ class LRUCache {
         this.#M[e] = t;
         this.#A[t] = e;
     }
-    #G(t) {
+    #U(t) {
         if (t !== this.#F) {
             if (t === this.#P) {
                 this.#P = this.#A[t];
@@ -2276,7 +2525,7 @@ class LRUCache {
     #K(t, e) {
         let s = false;
         if (this.#x !== 0) {
-            const i = this.#T.get(t);
+            const i = this.#C.get(t);
             if (i !== undefined) {
                 s = true;
                 if (this.#x === 1) {
@@ -2286,16 +2535,16 @@ class LRUCache {
                     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);
                         }
-                        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];
@@ -2312,7 +2561,7 @@ class LRUCache {
                 }
             }
         }
-        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);
                 }
-                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);
@@ -2356,7 +2605,7 @@ class LRUCache {
         this.#R.length = 0;
         this.#E = 0;
         this.#x = 0;
-        if (this.#_ && this.#O) {
+        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 Qt = 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 te = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof f.default || ee(t) || se(t));
 
-const At = t => !!t && typeof t === "object" && t instanceof o.EventEmitter && typeof t.pipe === "function" && t.pipe !== u.default.Writable.prototype.pipe;
+const ee = t => !!t && typeof t === "object" && t instanceof r.EventEmitter && typeof t.pipe === "function" && t.pipe !== f.default.Writable.prototype.pipe;
 
-const Mt = t => !!t && typeof t === "object" && t instanceof o.EventEmitter && typeof t.write === "function" && typeof t.end === "function";
+const se = t => !!t && typeof t === "object" && t instanceof r.EventEmitter && typeof t.write === "function" && typeof t.end === "function";
 
-const Pt = Symbol("EOF");
+const ie = Symbol("EOF");
 
-const Ft = Symbol("maybeEmitEnd");
+const ne = Symbol("maybeEmitEnd");
 
-const Rt = Symbol("emittedEnd");
+const re = Symbol("emittedEnd");
 
-const Ot = Symbol("emittingEnd");
+const oe = Symbol("emittingEnd");
 
-const zt = Symbol("emittedError");
+const he = Symbol("emittedError");
 
-const Dt = Symbol("closed");
+const ae = Symbol("closed");
 
-const Nt = Symbol("read");
+const le = Symbol("read");
 
-const Bt = Symbol("flush");
+const ce = Symbol("flush");
 
-const Wt = Symbol("flushChunk");
+const fe = Symbol("flushChunk");
 
-const _t = Symbol("encoding");
+const ue = Symbol("encoding");
 
-const It = Symbol("decoder");
+const de = Symbol("decoder");
 
-const jt = Symbol("flowing");
+const pe = Symbol("flowing");
 
-const Ut = Symbol("paused");
+const ge = Symbol("paused");
 
-const Gt = Symbol("resume");
+const me = Symbol("resume");
 
-const $t = Symbol("buffer");
+const we = Symbol("buffer");
 
-const qt = Symbol("pipes");
+const ye = Symbol("pipes");
 
-const Ht = Symbol("bufferLength");
+const be = Symbol("bufferLength");
 
-const Zt = Symbol("bufferPush");
+const Se = Symbol("bufferPush");
 
-const Vt = Symbol("bufferShift");
+const ke = Symbol("bufferShift");
 
-const Jt = Symbol("objectMode");
+const ve = Symbol("objectMode");
 
-const Kt = Symbol("destroyed");
+const xe = Symbol("destroyed");
 
-const Yt = Symbol("error");
+const Ee = Symbol("error");
 
-const Xt = Symbol("emitData");
+const Ce = Symbol("emitData");
 
-const Qt = Symbol("emitEnd");
+const Te = Symbol("emitEnd");
 
-const te = Symbol("emitEnd2");
+const Le = Symbol("emitEnd2");
 
-const ee = Symbol("async");
+const Ae = Symbol("async");
 
-const se = Symbol("abort");
+const Me = Symbol("abort");
 
-const ie = Symbol("aborted");
+const Pe = Symbol("aborted");
 
-const ne = Symbol("signal");
+const Fe = Symbol("signal");
 
-const re = Symbol("dataListeners");
+const Re = Symbol("dataListeners");
 
-const oe = Symbol("discarded");
+const Oe = Symbol("discarded");
 
-const he = t => Promise.resolve().then(t);
+const ze = t => Promise.resolve().then(t);
 
-const ae = t => t();
+const De = t => t();
 
-const le = t => t === "end" || t === "finish" || t === "prefinish";
+const Ne = 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 Be = 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 We = 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[me]();
         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];
+const Ie = t => !!t.objectMode;
+
+const _e = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+
+class Minipass extends r.EventEmitter {
+    [pe]=false;
+    [ge]=false;
+    [ye]=[];
+    [we]=[];
+    [ve];
+    [ue];
+    [Ae];
+    [de];
     [ie]=false;
-    [re]=0;
+    [re]=false;
     [oe]=false;
+    [ae]=false;
+    [he]=null;
+    [be]=0;
+    [xe]=false;
+    [Fe];
+    [Pe]=false;
+    [Re]=0;
+    [Oe]=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 (Ie(e)) {
+            this[ve] = true;
+            this[ue] = null;
+        } else if (_e(e)) {
+            this[ue] = e.encoding;
+            this[ve] = false;
         } else {
-            this[Jt] = false;
-            this[_t] = null;
+            this[ve] = false;
+            this[ue] = null;
         }
-        this[ee] = !!e.async;
-        this[It] = this[_t] ? new a.StringDecoder(this[_t]) : null;
+        this[Ae] = !!e.async;
+        this[de] = this[ue] ? new h.StringDecoder(this[ue]) : null;
         if (e && e.debugExposeBuffer === true) {
             Object.defineProperty(this, "buffer", {
-                get: () => this[$t]
+                get: () => this[we]
             });
         }
         if (e && e.debugExposePipes === true) {
             Object.defineProperty(this, "pipes", {
-                get: () => this[qt]
+                get: () => this[ye]
             });
         }
         const {signal: s} = e;
         if (s) {
-            this[ne] = s;
+            this[Fe] = s;
             if (s.aborted) {
-                this[se]();
+                this[Me]();
             } else {
-                s.addEventListener("abort", (() => this[se]()));
+                s.addEventListener("abort", (() => this[Me]()));
             }
         }
     }
     get bufferLength() {
-        return this[Ht];
+        return this[be];
     }
     get encoding() {
-        return this[_t];
+        return this[ue];
     }
     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[ve];
     }
     set objectMode(t) {
         throw new Error("objectMode must be set at instantiation time");
     }
     get ["async"]() {
-        return this[ee];
+        return this[Ae];
     }
     set ["async"](t) {
-        this[ee] = this[ee] || !!t;
+        this[Ae] = this[Ae] || !!t;
     }
-    [se]() {
-        this[ie] = true;
-        this.emit("abort", this[ne]?.reason);
-        this.destroy(this[ne]?.reason);
+    [Me]() {
+        this[Pe] = true;
+        this.emit("abort", this[Fe]?.reason);
+        this.destroy(this[Fe]?.reason);
     }
     get aborted() {
-        return this[ie];
+        return this[Pe];
     }
     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[Pe]) return false;
+        if (this[ie]) throw new Error("write after end");
+        if (this[xe]) {
             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[Ae] ? ze : De;
+        if (!this[ve] && !Buffer.isBuffer(t)) {
+            if (We(t)) {
                 t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
-            } else if (ce(t)) {
+            } else if (Be(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[ve]) {
+            if (this[pe] && this[be] !== 0) this[ce](true);
+            if (this[pe]) this.emit("data", t); else this[Se](t);
+            if (this[be] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[jt];
+            return this[pe];
         }
         if (!t.length) {
-            if (this[Ht] !== 0) this.emit("readable");
+            if (this[be] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[jt];
+            return this[pe];
         }
-        if (typeof t === "string" && !(e === this[_t] && !this[It]?.lastNeed)) {
+        if (typeof t === "string" && !(e === this[ue] && !this[de]?.lastNeed)) {
             t = Buffer.from(t, e);
         }
-        if (Buffer.isBuffer(t) && this[_t]) {
-            t = this[It].write(t);
+        if (Buffer.isBuffer(t) && this[ue]) {
+            t = this[de].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[pe] && this[be] !== 0) this[ce](true);
+        if (this[pe]) this.emit("data", t); else this[Se](t);
+        if (this[be] !== 0) this.emit("readable");
         if (s) i(s);
-        return this[jt];
+        return this[pe];
     }
     read(t) {
-        if (this[Kt]) return null;
-        this[oe] = false;
-        if (this[Ht] === 0 || t === 0 || t && t > this[Ht]) {
-            this[Ft]();
+        if (this[xe]) return null;
+        this[Oe] = false;
+        if (this[be] === 0 || t === 0 || t && t > this[be]) {
+            this[ne]();
             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[ve]) t = null;
+        if (this[we].length > 1 && !this[ve]) {
+            this[we] = [ this[ue] ? this[we].join("") : Buffer.concat(this[we], this[be]) ];
         }
-        const e = this[Nt](t || null, this[$t][0]);
-        this[Ft]();
+        const e = this[le](t || null, this[we][0]);
+        this[ne]();
         return e;
     }
-    [Nt](t, e) {
-        if (this[Jt]) this[Vt](); else {
+    [le](t, e) {
+        if (this[ve]) this[ke](); 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[ke](); else if (typeof s === "string") {
+                this[we][0] = s.slice(t);
                 e = s.slice(0, t);
-                this[Ht] -= t;
+                this[be] -= t;
             } else {
-                this[$t][0] = s.subarray(t);
+                this[we][0] = s.subarray(t);
                 e = s.subarray(0, t);
-                this[Ht] -= t;
+                this[be] -= t;
             }
         }
         this.emit("data", e);
-        if (!this[$t].length && !this[Pt]) this.emit("drain");
+        if (!this[we].length && !this[ie]) 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[ie] = true;
         this.writable = false;
-        if (this[jt] || !this[Ut]) this[Ft]();
+        if (this[pe] || !this[ge]) this[ne]();
         return this;
     }
-    [Gt]() {
-        if (this[Kt]) return;
-        if (!this[re] && !this[qt].length) {
-            this[oe] = true;
+    [me]() {
+        if (this[xe]) return;
+        if (!this[Re] && !this[ye].length) {
+            this[Oe] = true;
         }
-        this[Ut] = false;
-        this[jt] = true;
+        this[ge] = false;
+        this[pe] = true;
         this.emit("resume");
-        if (this[$t].length) this[Bt](); else if (this[Pt]) this[Ft](); else this.emit("drain");
+        if (this[we].length) this[ce](); else if (this[ie]) this[ne](); else this.emit("drain");
     }
     resume() {
-        return this[Gt]();
+        return this[me]();
     }
     pause() {
-        this[jt] = false;
-        this[Ut] = true;
-        this[oe] = false;
+        this[pe] = false;
+        this[ge] = true;
+        this[Oe] = false;
     }
     get destroyed() {
-        return this[Kt];
+        return this[xe];
     }
     get flowing() {
-        return this[jt];
+        return this[pe];
     }
     get paused() {
-        return this[Ut];
+        return this[ge];
     }
-    [Zt](t) {
-        if (this[Jt]) this[Ht] += 1; else this[Ht] += t.length;
-        this[$t].push(t);
+    [Se](t) {
+        if (this[ve]) this[be] += 1; else this[be] += t.length;
+        this[we].push(t);
     }
-    [Vt]() {
-        if (this[Jt]) this[Ht] -= 1; else this[Ht] -= this[$t][0].length;
-        return this[$t].shift();
+    [ke]() {
+        if (this[ve]) this[be] -= 1; else this[be] -= this[we][0].length;
+        return this[we].shift();
     }
-    [Bt](t = false) {
-        do {} while (this[Wt](this[Vt]()) && this[$t].length);
-        if (!t && !this[$t].length && !this[Pt]) this.emit("drain");
+    [ce](t = false) {
+        do {} while (this[fe](this[ke]()) && this[we].length);
+        if (!t && !this[we].length && !this[ie]) this.emit("drain");
     }
-    [Wt](t) {
+    [fe](t) {
         this.emit("data", t);
-        return this[jt];
+        return this[pe];
     }
     pipe(t, e) {
-        if (this[Kt]) return t;
-        this[oe] = false;
-        const s = this[Rt];
+        if (this[xe]) return t;
+        this[Oe] = false;
+        const s = this[re];
         e = e || {};
-        if (t === Ct.stdout || t === Ct.stderr) e.end = false; else e.end = e.end !== false;
+        if (t === Qt.stdout || t === Qt.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[ye].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+            if (this[Ae]) ze((() => this[me]())); else this[me]();
         }
         return t;
     }
     unpipe(t) {
-        const e = this[qt].find((e => e.dest === t));
+        const e = this[ye].find((e => e.dest === t));
         if (e) {
-            if (this[qt].length === 1) {
-                if (this[jt] && this[re] === 0) {
-                    this[jt] = false;
+            if (this[ye].length === 1) {
+                if (this[pe] && this[Re] === 0) {
+                    this[pe] = false;
                 }
-                this[qt] = [];
-            } else this[qt].splice(this[qt].indexOf(e), 1);
+                this[ye] = [];
+            } else this[ye].splice(this[ye].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[Oe] = false;
+            this[Re]++;
+            if (!this[ye].length && !this[pe]) {
+                this[me]();
             }
-        } else if (t === "readable" && this[Ht] !== 0) {
+        } else if (t === "readable" && this[be] !== 0) {
             super.emit("readable");
-        } else if (le(t) && this[Rt]) {
+        } else if (Ne(t) && this[re]) {
             super.emit(t);
             this.removeAllListeners(t);
-        } else if (t === "error" && this[zt]) {
+        } else if (t === "error" && this[he]) {
             const t = e;
-            if (this[ee]) he((() => t.call(this, this[zt]))); else t.call(this, this[zt]);
+            if (this[Ae]) ze((() => t.call(this, this[he]))); else t.call(this, this[he]);
         }
         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[Re] = this.listeners("data").length;
+            if (this[Re] === 0 && !this[Oe] && !this[ye].length) {
+                this[pe] = 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[Re] = 0;
+            if (!this[Oe] && !this[ye].length) {
+                this[pe] = false;
             }
         }
         return e;
     }
     get emittedEnd() {
-        return this[Rt];
+        return this[re];
     }
-    [Ft]() {
-        if (!this[Ot] && !this[Rt] && !this[Kt] && this[$t].length === 0 && this[Pt]) {
-            this[Ot] = true;
+    [ne]() {
+        if (!this[oe] && !this[re] && !this[xe] && this[we].length === 0 && this[ie]) {
+            this[oe] = true;
             this.emit("end");
             this.emit("prefinish");
             this.emit("finish");
-            if (this[Dt]) this.emit("close");
-            this[Ot] = false;
+            if (this[ae]) this.emit("close");
+            this[oe] = false;
         }
     }
     emit(t, ...e) {
         const s = e[0];
-        if (t !== "error" && t !== "close" && t !== Kt && this[Kt]) {
+        if (t !== "error" && t !== "close" && t !== xe && this[xe]) {
             return false;
         } else if (t === "data") {
-            return !this[Jt] && !s ? false : this[ee] ? (he((() => this[Xt](s))), true) : this[Xt](s);
+            return !this[ve] && !s ? false : this[Ae] ? (ze((() => this[Ce](s))), true) : this[Ce](s);
         } else if (t === "end") {
-            return this[Qt]();
+            return this[Te]();
         } else if (t === "close") {
-            this[Dt] = true;
-            if (!this[Rt] && !this[Kt]) return false;
+            this[ae] = true;
+            if (!this[re] && !this[xe]) 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[he] = s;
+            super.emit(Ee, s);
+            const t = !this[Fe] || this.listeners("error").length ? super.emit("error", s) : false;
+            this[ne]();
             return t;
         } else if (t === "resume") {
             const t = super.emit("resume");
-            this[Ft]();
+            this[ne]();
             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[ne]();
         return i;
     }
-    [Xt](t) {
-        for (const e of this[qt]) {
+    [Ce](t) {
+        for (const e of this[ye]) {
             if (e.dest.write(t) === false) this.pause();
         }
-        const e = this[oe] ? false : super.emit("data", t);
-        this[Ft]();
+        const e = this[Oe] ? false : super.emit("data", t);
+        this[ne]();
         return e;
     }
-    [Qt]() {
-        if (this[Rt]) return false;
-        this[Rt] = true;
+    [Te]() {
+        if (this[re]) return false;
+        this[re] = true;
         this.readable = false;
-        return this[ee] ? (he((() => this[te]())), true) : this[te]();
+        return this[Ae] ? (ze((() => this[Le]())), true) : this[Le]();
     }
-    [te]() {
-        if (this[It]) {
-            const t = this[It].end();
+    [Le]() {
+        if (this[de]) {
+            const t = this[de].end();
             if (t) {
-                for (const e of this[qt]) {
+                for (const e of this[ye]) {
                     e.dest.write(t);
                 }
-                if (!this[oe]) super.emit("data", t);
+                if (!this[Oe]) super.emit("data", t);
             }
         }
-        for (const t of this[qt]) {
+        for (const t of this[ye]) {
             t.end();
         }
         const t = super.emit("end");
@@ -2872,31 +3121,31 @@ class Minipass extends o.EventEmitter {
         const t = Object.assign([], {
             dataLength: 0
         });
-        if (!this[Jt]) t.dataLength = 0;
+        if (!this[ve]) t.dataLength = 0;
         const e = this.promise();
         this.on("data", (e => {
             t.push(e);
-            if (!this[Jt]) t.dataLength += e.length;
+            if (!this[ve]) t.dataLength += e.length;
         }));
         await e;
         return t;
     }
     async concat() {
-        if (this[Jt]) {
+        if (this[ve]) {
             throw new Error("cannot concat in objectMode");
         }
         const t = await this.collect();
-        return this[_t] ? t.join("") : Buffer.concat(t, t.dataLength);
+        return this[ue] ? t.join("") : Buffer.concat(t, t.dataLength);
     }
     async promise() {
         return new Promise(((t, e) => {
-            this.on(Kt, (() => e(new Error("stream destroyed"))));
+            this.on(xe, (() => e(new Error("stream destroyed"))));
             this.on("error", (t => e(t)));
             this.on("end", (() => t()));
         }));
     }
     [Symbol.asyncIterator]() {
-        this[oe] = false;
+        this[Oe] = false;
         let t = false;
         const e = async () => {
             this.pause();
@@ -2913,30 +3162,30 @@ class Minipass extends o.EventEmitter {
                 done: false,
                 value: s
             });
-            if (this[Pt]) return e();
+            if (this[ie]) return e();
             let i;
             let n;
             const r = t => {
                 this.off("data", o);
                 this.off("end", h);
-                this.off(Kt, a);
+                this.off(xe, a);
                 e();
                 n(t);
             };
             const o = t => {
                 this.off("error", r);
                 this.off("end", h);
-                this.off(Kt, a);
+                this.off(xe, a);
                 this.pause();
                 i({
                     value: t,
-                    done: !!this[Pt]
+                    done: !!this[ie]
                 });
             };
             const h = () => {
                 this.off("error", r);
                 this.off("data", o);
-                this.off(Kt, a);
+                this.off(xe, a);
                 e();
                 i({
                     done: true,
@@ -2947,7 +3196,7 @@ class Minipass extends o.EventEmitter {
             return new Promise(((t, e) => {
                 n = e;
                 i = t;
-                this.once(Kt, a);
+                this.once(xe, a);
                 this.once("error", r);
                 this.once("end", h);
                 this.once("data", o);
@@ -2963,12 +3212,12 @@ class Minipass extends o.EventEmitter {
         };
     }
     [Symbol.iterator]() {
-        this[oe] = false;
+        this[Oe] = false;
         let t = false;
         const e = () => {
             this.pause();
-            this.off(Yt, e);
-            this.off(Kt, e);
+            this.off(Ee, e);
+            this.off(xe, e);
             this.off("end", e);
             t = true;
             return {
@@ -2985,8 +3234,8 @@ class Minipass extends o.EventEmitter {
             };
         };
         this.once("end", e);
-        this.once(Yt, e);
-        this.once(Kt, e);
+        this.once(Ee, e);
+        this.once(xe, e);
         return {
             next: s,
             throw: e,
@@ -2997,110 +3246,110 @@ class Minipass extends o.EventEmitter {
         };
     }
     destroy(t) {
-        if (this[Kt]) {
-            if (t) this.emit("error", t); else this.emit(Kt);
+        if (this[xe]) {
+            if (t) this.emit("error", t); else this.emit(xe);
             return this;
         }
-        this[Kt] = true;
-        this[oe] = true;
-        this[$t].length = 0;
-        this[Ht] = 0;
+        this[xe] = true;
+        this[Oe] = true;
+        this[we].length = 0;
+        this[be] = 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[ae]) e.close();
+        if (t) this.emit("error", t); else this.emit(xe);
         return this;
     }
     static get isStream() {
-        return Lt;
+        return te;
     }
 }
 
-const pe = i.realpathSync.native;
+const je = s.realpathSync.native;
 
-const ge = {
-    lstatSync: i.lstatSync,
-    readdir: i.readdir,
-    readdirSync: i.readdirSync,
-    readlinkSync: i.readlinkSync,
-    realpathSync: pe,
+const $e = {
+    lstatSync: s.lstatSync,
+    readdir: s.readdir,
+    readdirSync: s.readdirSync,
+    readlinkSync: s.readlinkSync,
+    realpathSync: je,
     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 Ue = t => !t || t === $e || t === c ? $e : {
+    ...$e,
     ...t,
     promises: {
-        ...ge.promises,
+        ...$e.promises,
         ...t.promises || {}
     }
 };
 
-const we = /^\\\\\?\\([a-z]:)\\?$/i;
+const Ge = /^\\\\\?\\([a-z]:)\\?$/i;
 
-const ye = t => t.replace(/\//g, "\\").replace(we, "$1\\");
+const qe = t => t.replace(/\//g, "\\").replace(Ge, "$1\\");
 
-const be = /[\\\/]/;
+const He = /[\\\/]/;
 
-const Se = 0;
+const Ze = 0;
 
-const ke = 1;
+const Ve = 1;
 
-const ve = 2;
+const Je = 2;
 
-const xe = 4;
+const Ke = 4;
 
-const Ee = 6;
+const Ye = 6;
 
-const Te = 8;
+const Xe = 8;
 
-const Ce = 10;
+const Qe = 10;
 
-const Le = 12;
+const ts = 12;
 
-const Ae = 15;
+const es = 15;
 
-const Me = ~Ae;
+const ss = ~es;
 
-const Pe = 16;
+const is = 16;
 
-const Fe = 32;
+const ns = 32;
 
-const Re = 64;
+const rs = 64;
 
-const Oe = 128;
+const os = 128;
 
-const ze = 256;
+const hs = 256;
 
-const De = 512;
+const as = 512;
 
-const Ne = Re | Oe | De;
+const ls = rs | os | as;
 
-const Be = 1023;
+const cs = 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 fs = t => t.isFile() ? Xe : t.isDirectory() ? Ke : t.isSymbolicLink() ? Qe : t.isCharacterDevice() ? Je : t.isBlockDevice() ? Ye : t.isSocket() ? ts : t.isFIFO() ? Ve : Ze;
 
-const _e = new Map;
+const us = new Map;
 
-const Ie = t => {
-    const e = _e.get(t);
+const ds = t => {
+    const e = us.get(t);
     if (e) return e;
     const s = t.normalize("NFKD");
-    _e.set(t, s);
+    us.set(t, s);
     return s;
 };
 
-const je = new Map;
+const ps = new Map;
 
-const Ue = t => {
-    const e = je.get(t);
+const gs = t => {
+    const e = ps.get(t);
     if (e) return e;
-    const s = Ie(t.toLowerCase());
-    je.set(t, s);
+    const s = ds(t.toLowerCase());
+    ps.set(t, s);
     return s;
 };
 
@@ -3121,7 +3370,7 @@ class ChildrenCache extends LRUCache {
     }
 }
 
-const Ge = Symbol("PathScurry setAsCwd");
+const ms = Symbol("PathScurry setAsCwd");
 
 class PathBase {
     name;
@@ -3204,8 +3453,8 @@ class PathBase {
         return this.#xt;
     }
     #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 = Ze, s, i, n, r, o) {
         this.name = t;
-        this.#Et = n ? Ue(t) : Ie(t);
-        this.#Pt = e & Be;
+        this.#Et = n ? gs(t) : ds(t);
+        this.#Pt = e & cs;
         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 = Ue(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 &= ~is;
         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 ? gs(t) : ds(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, Ze, {
             ...e,
             parent: this,
             fullpath: r
         });
         if (!this.canReaddir()) {
-            o.#Pt |= Oe;
+            o.#Pt |= os;
         }
         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 & es) === Ze;
     }
     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 & es) === Xe;
     }
     isDirectory() {
-        return (this.#Pt & Ae) === xe;
+        return (this.#Pt & es) === Ke;
     }
     isCharacterDevice() {
-        return (this.#Pt & Ae) === ve;
+        return (this.#Pt & es) === Je;
     }
     isBlockDevice() {
-        return (this.#Pt & Ae) === Ee;
+        return (this.#Pt & es) === Ye;
     }
     isFIFO() {
-        return (this.#Pt & Ae) === ke;
+        return (this.#Pt & es) === Ve;
     }
     isSocket() {
-        return (this.#Pt & Ae) === Le;
+        return (this.#Pt & es) === ts;
     }
     isSymbolicLink() {
-        return (this.#Pt & Ce) === Ce;
+        return (this.#Pt & Qe) === Qe;
     }
     lstatCached() {
-        return this.#Pt & Fe ? this : undefined;
+        return this.#Pt & ns ? 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 & es;
+        return !(t !== Ze && t !== Qe || this.#Pt & hs || this.#Pt & os);
     }
     calledReaddir() {
-        return !!(this.#Pt & Pe);
+        return !!(this.#Pt & is);
     }
     isENOENT() {
-        return !!(this.#Pt & Oe);
+        return !!(this.#Pt & os);
     }
     isNamed(t) {
-        return !this.nocase ? this.#Et === Ie(t) : this.#Et === Ue(t);
+        return !this.nocase ? this.#Et === ds(t) : this.#Et === gs(t);
     }
     async readlink() {
         const t = this.#Rt;
@@ -3458,15 +3707,15 @@ class PathBase {
         }
     }
     #Nt(t) {
-        this.#Pt |= Pe;
+        this.#Pt |= is;
         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;
+        if (this.#Pt & os) return;
+        this.#Pt = (this.#Pt | os) & ss;
         this.#Wt();
     }
     #Wt() {
@@ -3476,66 +3725,66 @@ class PathBase {
             e.#Bt();
         }
     }
-    #_t() {
-        this.#Pt |= De;
-        this.#It();
-    }
     #It() {
-        if (this.#Pt & Re) return;
+        this.#Pt |= as;
+        this.#_t();
+    }
+    #_t() {
+        if (this.#Pt & rs) return;
         let t = this.#Pt;
-        if ((t & Ae) === xe) t &= Me;
-        this.#Pt = t | Re;
+        if ((t & es) === Ke) t &= ss;
+        this.#Pt = t | rs;
         this.#Wt();
     }
     #jt(t = "") {
         if (t === "ENOTDIR" || t === "EPERM") {
-            this.#It();
+            this.#_t();
         } 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.#_t();
         } else if (t === "ENOENT") {
             this.#Bt();
         }
     }
     #Dt(t = "") {
         let e = this.#Pt;
-        e |= ze;
-        if (t === "ENOENT") e |= Oe;
+        e |= hs;
+        if (t === "ENOENT") e |= os;
         if (t === "EINVAL" || t === "UNKNOWN") {
-            e &= Me;
+            e &= ss;
         }
         this.#Pt = e;
         if (t === "ENOTDIR" && this.parent) {
-            this.parent.#It();
+            this.parent.#_t();
         }
     }
-    #Gt(t, e) {
-        return this.#$t(t, e) || this.#qt(t, e);
+    #Ut(t, e) {
+        return this.#Gt(t, e) || this.#qt(t, e);
     }
     #qt(t, e) {
-        const s = We(t);
+        const s = fs(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 & es;
+        if (n !== Ke && n !== Qe && n !== Ze) {
+            i.#Pt |= rs;
         }
         e.unshift(i);
         e.provisional++;
         return i;
     }
-    #$t(t, e) {
+    #Gt(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 ? gs(t.name) : ds(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 & ss | fs(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,22 +3803,22 @@ class PathBase {
         return e;
     }
     async lstat() {
-        if ((this.#Pt & Oe) === 0) {
+        if ((this.#Pt & os) === 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 & os) === 0) {
             try {
                 this.#Zt(this.#ot.lstatSync(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
@@ -3593,10 +3842,10 @@ class PathBase {
         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;
+        const b = fs(t);
+        this.#Pt = this.#Pt & ss | b | ns;
+        if (b !== Ze && b !== Ke && b !== Qe) {
+            this.#Pt |= rs;
         }
     }
     #Vt=[];
@@ -3632,7 +3881,7 @@ class PathBase {
                 s.provisional = 0;
             } else {
                 for (const t of e) {
-                    this.#Gt(t, s);
+                    this.#Ut(t, s);
                 }
                 this.#Nt(s);
             }
@@ -3659,7 +3908,7 @@ class PathBase {
                 for (const s of await this.#ot.promises.readdir(e, {
                     withFileTypes: true
                 })) {
-                    this.#Gt(s, t);
+                    this.#Ut(s, t);
                 }
                 this.#Nt(t);
             } catch (e) {
@@ -3684,7 +3933,7 @@ class PathBase {
             for (const s of this.#ot.readdirSync(e, {
                 withFileTypes: true
             })) {
-                this.#Gt(s, t);
+                this.#Ut(s, t);
             }
             this.#Nt(t);
         } catch (e) {
@@ -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 & ls) return false;
+        const t = es & this.#Pt;
+        if (!(t === Ze || t === Ke || t === Qe)) {
             return false;
         }
         return true;
     }
     shouldWalk(t, e) {
-        return (this.#Pt & xe) === xe && !(this.#Pt & Ne) && !t.has(this) && (!e || e(this));
+        return (this.#Pt & Ke) === Ke && !(this.#Pt & ls) && !t.has(this) && (!e || e(this));
     }
     async realpath() {
         if (this.#Ot) return this.#Ot;
-        if ((De | ze | Oe) & this.#Pt) return undefined;
+        if ((as | hs | os) & 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 ((as | hs | os) & 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) {
+    [ms](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=He;
+    constructor(t, e = Ze, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
-    newChild(t, e = Se, s = {}) {
+    newChild(t, e = Ze, 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 = qe(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(Ge, "$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 = Ze, 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 = Ze, 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 = $e} = {}) {
+        this.#ot = Ue(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;
@@ -4254,16 +4503,16 @@ class PathScurryBase {
     chdir(t = this.cwd) {
         const e = this.cwd;
         this.cwd = typeof t === "string" ? this.cwd.resolve(t) : t;
-        this.cwd[Ge](e);
+        this.cwd[ms](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, Ke, 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, Ke, 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 ws = process.platform === "win32" ? PathWin32 : PathPosix;
 
-const qe = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+const ys = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-const He = t => t.length >= 1;
+const bs = t => t.length >= 1;
 
-const Ze = t => t.length >= 1;
+const Ss = 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 (!bs(t)) {
             throw new TypeError("empty pattern list");
         }
-        if (!Ze(e)) {
+        if (!Ss(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] === Pt;
     }
     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 ks = 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 = ks}) {
         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 === Pt) {
                 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 === Pt) {
                     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 vs = (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 = vs(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);
@@ -5012,9 +5261,9 @@ class GlobStream extends GlobUtil {
     }
 }
 
-const Ke = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const xs = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
-let Ye = class Glob {
+let Es = 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 || xs;
         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 : ys;
             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 Cs = (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 Ts(t, e = {}) {
+    return new Es(t, e).streamSync();
 }
 
-function ts(t, e = {}) {
-    return new Ye(t, e).stream();
+function Ls(t, e = {}) {
+    return new Es(t, e).stream();
 }
 
-function es(t, e = {}) {
-    return new Ye(t, e).walkSync();
+function As(t, e = {}) {
+    return new Es(t, e).walkSync();
 }
 
-async function ss(t, e = {}) {
-    return new Ye(t, e).walk();
+async function Ms(t, e = {}) {
+    return new Es(t, e).walk();
 }
 
-function is(t, e = {}) {
-    return new Ye(t, e).iterateSync();
+function Ps(t, e = {}) {
+    return new Es(t, e).iterateSync();
 }
 
-function ns(t, e = {}) {
-    return new Ye(t, e).iterate();
+function Fs(t, e = {}) {
+    return new Es(t, e).iterate();
 }
 
-const rs = Qe;
+const Rs = Ts;
 
-const os = Object.assign(ts, {
-    sync: Qe
+const Os = Object.assign(Ls, {
+    sync: Ts
 });
 
-const hs = is;
+const zs = Ps;
 
-const as = Object.assign(ns, {
-    sync: is
+const Ds = Object.assign(Fs, {
+    sync: Ps
 });
 
-const ls = Object.assign(es, {
-    stream: Qe,
-    iterate: is
+const Ns = Object.assign(As, {
+    stream: Ts,
+    iterate: Ps
 });
 
-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 Bs = Object.assign(Ms, {
+    glob: Ms,
+    globSync: As,
+    sync: Ns,
+    globStream: Ls,
+    stream: Os,
+    globStreamSync: Ts,
+    streamSync: Rs,
+    globIterate: Fs,
+    iterate: Ds,
+    globIterateSync: Ps,
+    iterateSync: zs,
+    Glob: Es,
+    hasMagic: Cs,
+    escape: rt,
+    unescape: Z
 });
 
-cs.glob = cs;
+Bs.glob = Bs;
 
-async function fs(t, e) {
-    return e ? await cs(t, e) : await cs(t);
+async function Ws(t, e) {
+    return e ? await Bs(t, e) : await Bs(t);
 }
 
-exports.Glob = fs;
+exports.Glob = Ws;