lakutata 2.0.80 → 2.0.81

package/src/lib/helpers/Glob.mjs

@@ -1,35 +1,263 @@
-import { e as t } from "../../../vendor/Package.63.mjs";
+import { fileURLToPath as t } from "node:url";
 
-import { fileURLToPath as e } from "node:url";
+import { win32 as e, posix as s } from "node:path";
 
-import { win32 as s, posix as i } from "node:path";
+import { realpathSync as i, readlinkSync as n, readdirSync as r, readdir as o, lstatSync as h } from "fs";
 
-import { realpathSync as n, readlinkSync as r, readdirSync as o, readdir as h, lstatSync as a } from "fs";
+import * as a from "node:fs";
 
-import * as l from "node:fs";
+import { realpath as l, readlink as c, readdir as f, lstat as u } from "node:fs/promises";
 
-import { realpath as c, readlink as f, readdir as u, lstat as d } from "node:fs/promises";
+import { EventEmitter as d } from "node:events";
 
-import { EventEmitter as p } from "node:events";
+import p from "node:stream";
 
-import g from "node:stream";
+import { StringDecoder as g } from "node:string_decoder";
 
-import { StringDecoder as m } from "node:string_decoder";
+const m = (t, e, s) => {
+    const i = t instanceof RegExp ? w(t, s) : t;
+    const n = e instanceof RegExp ? w(e, s) : e;
+    const r = i !== null && n != null && y(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 w = (t, e) => {
+    const s = e.match(t);
+    return s ? s[0] : null;
+};
+
+const y = (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 b = "\0SLASH" + Math.random() + "\0";
+
+const S = "\0OPEN" + Math.random() + "\0";
+
+const k = "\0CLOSE" + Math.random() + "\0";
+
+const x = "\0COMMA" + Math.random() + "\0";
+
+const v = "\0PERIOD" + Math.random() + "\0";
+
+const E = new RegExp(b, "g");
+
+const C = new RegExp(S, "g");
+
+const T = new RegExp(k, "g");
+
+const A = new RegExp(x, "g");
+
+const L = new RegExp(v, "g");
+
+const M = /\\\\/g;
+
+const P = /\\{/g;
+
+const F = /\\}/g;
+
+const R = /\\,/g;
+
+const O = /\\./g;
+
+function z(t) {
+    return !isNaN(t) ? parseInt(t, 10) : t.charCodeAt(0);
+}
+
+function D(t) {
+    return t.replace(M, b).replace(P, S).replace(F, k).replace(R, x).replace(O, v);
+}
+
+function N(t) {
+    return t.replace(E, "\\").replace(C, "{").replace(T, "}").replace(A, ",").replace(L, ".");
+}
+
+function B(t) {
+    if (!t) {
+        return [ "" ];
+    }
+    const e = [];
+    const s = m("{", "}", 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 = B(r);
+    if (r.length) {
+        o[o.length - 1] += h.shift();
+        o.push.apply(o, h);
+    }
+    e.push.apply(e, o);
+    return e;
+}
+
+function W(t) {
+    if (!t) {
+        return [];
+    }
+    if (t.slice(0, 2) === "{}") {
+        t = "\\{\\}" + t.slice(2);
+    }
+    return U(D(t), true).map(N);
+}
+
+function I(t) {
+    return "{" + t + "}";
+}
+
+function _(t) {
+    return /^-?0\d/.test(t);
+}
 
-import "../../../vendor/Package.5.mjs";
+function j(t, e) {
+    return t <= e;
+}
 
-const w = 1024 * 64;
+function $(t, e) {
+    return t >= e;
+}
 
-const y = t => {
+function U(t, e) {
+    const s = [];
+    const i = m("{", "}", t);
+    if (!i) return [ t ];
+    const n = i.pre;
+    const r = i.post.length ? U(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 + k + i.post;
+                return U(t);
+            }
+            return [ t ];
+        }
+        let c;
+        if (a) {
+            c = i.body.split(/\.\./);
+        } else {
+            c = B(i.body);
+            if (c.length === 1 && c[0] !== undefined) {
+                c = U(c[0], false).map(I);
+                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 = z(c[0]);
+            const e = z(c[1]);
+            const s = Math.max(c[0].length, c[1].length);
+            let i = c.length === 3 && c[2] !== undefined ? Math.abs(z(c[2])) : 1;
+            let n = j;
+            const r = e < t;
+            if (r) {
+                i *= -1;
+                n = $;
+            }
+            const o = c.some(_);
+            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, U(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 G = 1024 * 64;
+
+const H = t => {
     if (typeof t !== "string") {
         throw new TypeError("invalid pattern");
     }
-    if (t.length > w) {
+    if (t.length > G) {
         throw new TypeError("pattern is too long");
     }
 };
 
-const b = {
+const Z = {
     "[:alnum:]": [ "\\p{L}\\p{Nl}\\p{Nd}", true ],
     "[:alpha:]": [ "\\p{L}\\p{Nl}", true ],
     "[:ascii:]": [ "\\x" + "00-\\x" + "7f", false ],
@@ -46,13 +274,13 @@ const b = {
     "[:xdigit:]": [ "A-Fa-f0-9", false ]
 };
 
-const S = t => t.replace(/[[\]\\-]/g, "\\$&");
+const q = t => t.replace(/[[\]\\-]/g, "\\$&");
 
-const k = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const V = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const v = t => t.join("");
+const J = t => t.join("");
 
-const x = (t, e) => {
+const K = (t, e) => {
     const s = e;
     if (t.charAt(s) !== "[") {
         throw new Error("not in a brace expression");
@@ -86,7 +314,7 @@ const x = (t, e) => {
             }
         }
         if (e === "[" && !a) {
-            for (const [e, [o, a, l]] of Object.entries(b)) {
+            for (const [e, [o, a, l]] of Object.entries(Z)) {
                 if (t.startsWith(e, r)) {
                     if (f) {
                         return [ "$.", false, t.length - s, true ];
@@ -101,16 +329,16 @@ const x = (t, e) => {
         a = false;
         if (f) {
             if (e > f) {
-                i.push(S(f) + "-" + S(e));
+                i.push(q(f) + "-" + q(e));
             } else if (e === f) {
-                i.push(S(e));
+                i.push(q(e));
             }
             f = "";
             r++;
             continue;
         }
         if (t.startsWith("-]", r + 1)) {
-            i.push(S(e + "-"));
+            i.push(q(e + "-"));
             r += 2;
             continue;
         }
@@ -119,7 +347,7 @@ const x = (t, e) => {
             r += 2;
             continue;
         }
-        i.push(S(e));
+        i.push(q(e));
         r++;
     }
     if (c < r) {
@@ -130,37 +358,42 @@ const x = (t, e) => {
     }
     if (n.length === 0 && i.length === 1 && /^\\?.$/.test(i[0]) && !l) {
         const t = i[0].length === 2 ? i[0].slice(-1) : i[0];
-        return [ k(t), false, c - s, false ];
+        return [ V(t), false, c - s, false ];
     }
-    const u = "[" + (l ? "^" : "") + v(i) + "]";
-    const d = "[" + (l ? "" : "^") + v(n) + "]";
+    const u = "[" + (l ? "^" : "") + J(i) + "]";
+    const d = "[" + (l ? "" : "^") + J(n) + "]";
     const p = i.length && n.length ? "(" + u + "|" + d + ")" : i.length ? u : d;
     return [ p, h, c - s, true ];
 };
 
-const E = (t, {windowsPathsNoEscape: e = false} = {}) => e ? t.replace(/\[([^\/\\])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+const Y = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = true} = {}) => {
+    if (s) {
+        return e ? t.replace(/\[([^\/\\])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+    }
+    return e ? t.replace(/\[([^\/\\{}])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+};
 
-const C = new Set([ "!", "?", "+", "*", "@" ]);
+const X = new Set([ "!", "?", "+", "*", "@" ]);
 
-const T = t => C.has(t);
+const Q = t => X.has(t);
 
-const L = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const tt = "(?!(?:^|/)\\.\\.?(?:$|/))";
 
-const A = "(?!\\.)";
+const et = "(?!\\.)";
 
-const M = new Set([ "[", "." ]);
+const st = new Set([ "[", "." ]);
 
-const P = new Set([ "..", "." ]);
+const it = new Set([ "..", "." ]);
 
-const F = new Set("().*{}+?[]^$\\!");
+const nt = new Set("().*{}+?[]^$\\!");
 
-const R = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const rt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const z = "[^/]";
+const ot = "[^/]";
 
-const O = z + "*?";
+const ht = ot + "*?";
 
-const D = z + "+?";
+const at = ot + "+?";
 
 class AST {
     type;
@@ -306,7 +539,7 @@ class AST {
                     l += s;
                     continue;
                 }
-                if (!i.noext && T(s) && t.charAt(a) === "(") {
+                if (!i.noext && Q(s) && t.charAt(a) === "(") {
                     e.push(l);
                     l = "";
                     const n = new AST(s, e);
@@ -347,7 +580,7 @@ class AST {
                 f += s;
                 continue;
             }
-            if (T(s) && t.charAt(a) === "(") {
+            if (Q(s) && t.charAt(a) === "(") {
                 l.push(f);
                 f = "";
                 const e = new AST(s, l);
@@ -404,7 +637,7 @@ class AST {
         const e = t ?? !!this.#a.dot;
         if (this.#t === this) this.#f();
         if (!this.type) {
-            const s = this.isStart() && this.isEnd();
+            const s = this.isStart() && this.isEnd() && !this.#i.some((t => typeof t !== "string"));
             const i = this.#i.map((e => {
                 const [i, n, r, o] = typeof e === "string" ? AST.#d(e, this.#e, s) : e.toRegExpSource(t);
                 this.#e = this.#e || r;
@@ -414,12 +647,12 @@ class AST {
             let n = "";
             if (this.isStart()) {
                 if (typeof this.#i[0] === "string") {
-                    const s = this.#i.length === 1 && P.has(this.#i[0]);
+                    const s = this.#i.length === 1 && it.has(this.#i[0]);
                     if (!s) {
-                        const s = M;
+                        const s = st;
                         const r = e && s.has(i.charAt(0)) || i.startsWith("\\.") && s.has(i.charAt(2)) || i.startsWith("\\.\\.") && s.has(i.charAt(4));
                         const o = !e && !t && s.has(i.charAt(0));
-                        n = r ? L : o ? A : "";
+                        n = r ? tt : o ? et : "";
                     }
                 }
             }
@@ -428,7 +661,7 @@ class AST {
                 r = "(?:$|\\/)";
             }
             const o = n + i + r;
-            return [ o, E(i), this.#e = !!this.#e, this.#s ];
+            return [ o, Y(i), this.#e = !!this.#e, this.#s ];
         }
         const s = this.type === "*" || this.type === "+";
         const i = this.type === "!" ? "(?:(?!(?:" : "(?:";
@@ -438,9 +671,9 @@ class AST {
             this.#i = [ t ];
             this.type = null;
             this.#e = undefined;
-            return [ t, E(this.toString()), false, false ];
+            return [ t, Y(this.toString()), false, false ];
         }
-        let r = !s || t || e || !A ? "" : this.#p(true);
+        let r = !s || t || e || !et ? "" : this.#p(true);
         if (r === n) {
             r = "";
         }
@@ -449,12 +682,12 @@ class AST {
         }
         let o = "";
         if (this.type === "!" && this.#c) {
-            o = (this.isStart() && !e ? A : "") + D;
+            o = (this.isStart() && !e ? et : "") + at;
         } else {
-            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? A : "") + O + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
+            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? et : "") + ht + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
             o = i + n + s;
         }
-        return [ o, E(n), this.#e = !!this.#e, this.#s ];
+        return [ o, Y(n), this.#e = !!this.#e, this.#s ];
     }
     #p(t) {
         return this.#i.map((e => {
@@ -474,7 +707,7 @@ class AST {
             const h = t.charAt(o);
             if (i) {
                 i = false;
-                n += (F.has(h) ? "\\" : "") + h;
+                n += (nt.has(h) ? "\\" : "") + h;
                 continue;
             }
             if (h === "\\") {
@@ -486,7 +719,7 @@ class AST {
                 continue;
             }
             if (h === "[") {
-                const [s, i, h, a] = x(t, o);
+                const [s, i, h, a] = K(t, o);
                 if (h) {
                     n += s;
                     r = r || i;
@@ -496,102 +729,107 @@ class AST {
                 }
             }
             if (h === "*") {
-                if (s && t === "*") n += D; else n += O;
+                n += s && t === "*" ? at : ht;
                 e = true;
                 continue;
             }
             if (h === "?") {
-                n += z;
+                n += ot;
                 e = true;
                 continue;
             }
-            n += R(h);
+            n += rt(h);
         }
-        return [ n, E(t), !!e, r ];
+        return [ n, Y(t), !!e, r ];
     }
 }
 
-const N = (t, {windowsPathsNoEscape: e = false} = {}) => e ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+const lt = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = false} = {}) => {
+    if (s) {
+        return e ? t.replace(/[?*()[\]{}]/g, "[$&]") : t.replace(/[?*()[\]\\{}]/g, "\\$&");
+    }
+    return e ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+};
 
-const B = (t, e, s = {}) => {
-    y(e);
+const ct = (t, e, s = {}) => {
+    H(e);
     if (!s.nocomment && e.charAt(0) === "#") {
         return false;
     }
     return new Minimatch(e, s).match(t);
 };
 
-const W = /^\*+([^+@!?\*\[\(]*)$/;
+const ft = /^\*+([^+@!?\*\[\(]*)$/;
 
-const I = t => e => !e.startsWith(".") && e.endsWith(t);
+const ut = t => e => !e.startsWith(".") && e.endsWith(t);
 
-const _ = t => e => e.endsWith(t);
+const dt = t => e => e.endsWith(t);
 
-const j = t => {
+const pt = t => {
     t = t.toLowerCase();
     return e => !e.startsWith(".") && e.toLowerCase().endsWith(t);
 };
 
-const U = t => {
+const gt = t => {
     t = t.toLowerCase();
     return e => e.toLowerCase().endsWith(t);
 };
 
-const G = /^\*+\.\*+$/;
+const mt = /^\*+\.\*+$/;
 
-const $ = t => !t.startsWith(".") && t.includes(".");
+const wt = t => !t.startsWith(".") && t.includes(".");
 
-const H = t => t !== "." && t !== ".." && t.includes(".");
+const yt = t => t !== "." && t !== ".." && t.includes(".");
 
-const q = /^\.\*+$/;
+const bt = /^\.\*+$/;
 
-const Z = t => t !== "." && t !== ".." && t.startsWith(".");
+const St = t => t !== "." && t !== ".." && t.startsWith(".");
 
-const V = /^\*+$/;
+const kt = /^\*+$/;
 
-const J = t => t.length !== 0 && !t.startsWith(".");
+const xt = t => t.length !== 0 && !t.startsWith(".");
 
-const K = t => t.length !== 0 && t !== "." && t !== "..";
+const vt = t => t.length !== 0 && t !== "." && t !== "..";
 
-const Y = /^\?+([^+@!?\*\[\(]*)?$/;
+const Et = /^\?+([^+@!?\*\[\(]*)?$/;
 
-const X = ([t, e = ""]) => {
-    const s = st([ t ]);
+const Ct = ([t, e = ""]) => {
+    const s = Mt([ t ]);
     if (!e) return s;
     e = e.toLowerCase();
     return t => s(t) && t.toLowerCase().endsWith(e);
 };
 
-const Q = ([t, e = ""]) => {
-    const s = it([ t ]);
+const Tt = ([t, e = ""]) => {
+    const s = Pt([ t ]);
     if (!e) return s;
     e = e.toLowerCase();
     return t => s(t) && t.toLowerCase().endsWith(e);
 };
 
-const tt = ([t, e = ""]) => {
-    const s = it([ t ]);
+const At = ([t, e = ""]) => {
+    const s = Pt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const et = ([t, e = ""]) => {
-    const s = st([ t ]);
+const Lt = ([t, e = ""]) => {
+    const s = Mt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const st = ([t]) => {
+const Mt = ([t]) => {
     const e = t.length;
     return t => t.length === e && !t.startsWith(".");
 };
 
-const it = ([t]) => {
+const Pt = ([t]) => {
     const e = t.length;
     return t => t.length === e && t !== "." && t !== "..";
 };
 
-const nt = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+const Ft = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
 
-const rt = {
+const Rt = {
     win32: {
         sep: "\\"
     },
@@ -600,80 +838,80 @@ const rt = {
     }
 };
 
-const ot = nt === "win32" ? rt.win32.sep : rt.posix.sep;
+const Ot = Ft === "win32" ? Rt.win32.sep : Rt.posix.sep;
 
-B.sep = ot;
+ct.sep = Ot;
 
-const ht = Symbol("globstar **");
+const zt = Symbol("globstar **");
 
-B.GLOBSTAR = ht;
+ct.GLOBSTAR = zt;
 
-const at = "[^/]";
+const Dt = "[^/]";
 
-const lt = at + "*?";
+const Nt = Dt + "*?";
 
-const ct = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const Bt = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 
-const ft = "(?:(?!(?:\\/|^)\\.).)*?";
+const Wt = "(?:(?!(?:\\/|^)\\.).)*?";
 
-const ut = (t, e = {}) => s => B(s, t, e);
+const It = (t, e = {}) => s => ct(s, t, e);
 
-B.filter = ut;
+ct.filter = It;
 
-const dt = (t, e = {}) => Object.assign({}, t, e);
+const _t = (t, e = {}) => Object.assign({}, t, e);
 
-const pt = t => {
+const jt = t => {
     if (!t || typeof t !== "object" || !Object.keys(t).length) {
-        return B;
+        return ct;
     }
-    const e = B;
-    const s = (s, i, n = {}) => e(s, i, dt(t, n));
+    const e = ct;
+    const s = (s, i, n = {}) => e(s, i, _t(t, n));
     return Object.assign(s, {
         Minimatch: class Minimatch extends e.Minimatch {
             constructor(e, s = {}) {
-                super(e, dt(t, s));
+                super(e, _t(t, s));
             }
             static defaults(s) {
-                return e.defaults(dt(t, s)).Minimatch;
+                return e.defaults(_t(t, s)).Minimatch;
             }
         },
         AST: class AST extends e.AST {
             constructor(e, s, i = {}) {
-                super(e, s, dt(t, i));
+                super(e, s, _t(t, i));
             }
             static fromGlob(s, i = {}) {
-                return e.AST.fromGlob(s, dt(t, i));
+                return e.AST.fromGlob(s, _t(t, i));
             }
         },
-        unescape: (s, i = {}) => e.unescape(s, dt(t, i)),
-        escape: (s, i = {}) => e.escape(s, dt(t, i)),
-        filter: (s, i = {}) => e.filter(s, dt(t, i)),
-        defaults: s => e.defaults(dt(t, s)),
-        makeRe: (s, i = {}) => e.makeRe(s, dt(t, i)),
-        braceExpand: (s, i = {}) => e.braceExpand(s, dt(t, i)),
-        match: (s, i, n = {}) => e.match(s, i, dt(t, n)),
+        unescape: (s, i = {}) => e.unescape(s, _t(t, i)),
+        escape: (s, i = {}) => e.escape(s, _t(t, i)),
+        filter: (s, i = {}) => e.filter(s, _t(t, i)),
+        defaults: s => e.defaults(_t(t, s)),
+        makeRe: (s, i = {}) => e.makeRe(s, _t(t, i)),
+        braceExpand: (s, i = {}) => e.braceExpand(s, _t(t, i)),
+        match: (s, i, n = {}) => e.match(s, i, _t(t, n)),
         sep: e.sep,
-        GLOBSTAR: ht
+        GLOBSTAR: zt
     });
 };
 
-B.defaults = pt;
+ct.defaults = jt;
 
-const gt = (e, s = {}) => {
-    y(e);
-    if (s.nobrace || !/\{(?:(?!\{).)*\}/.test(e)) {
-        return [ e ];
+const $t = (t, e = {}) => {
+    H(t);
+    if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(t)) {
+        return [ t ];
     }
-    return t(e);
+    return W(t);
 };
 
-B.braceExpand = gt;
+ct.braceExpand = $t;
 
-const mt = (t, e = {}) => new Minimatch(t, e).makeRe();
+const Ut = (t, e = {}) => new Minimatch(t, e).makeRe();
 
-B.makeRe = mt;
+ct.makeRe = Ut;
 
-const wt = (t, e, s = {}) => {
+const Gt = (t, e, s = {}) => {
     const i = new Minimatch(e, s);
     t = t.filter((t => i.match(t)));
     if (i.options.nonull && !t.length) {
@@ -682,11 +920,11 @@ const wt = (t, e, s = {}) => {
     return t;
 };
 
-B.match = wt;
+ct.match = Gt;
 
-const yt = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const Ht = /[?*]|[+@!]\(.*?\)|\[|\]/;
 
-const bt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const Zt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
 class Minimatch {
     options;
@@ -707,11 +945,11 @@ class Minimatch {
     windowsNoMagicRoot;
     regexp;
     constructor(t, e = {}) {
-        y(t);
+        H(t);
         e = e || {};
         this.options = e;
         this.pattern = t;
-        this.platform = e.platform || nt;
+        this.platform = e.platform || Ft;
         this.isWindows = this.platform === "win32";
         this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
@@ -765,7 +1003,7 @@ class Minimatch {
         this.debug(this.pattern, this.globParts);
         let i = this.globParts.map(((t, e, s) => {
             if (this.isWindows && this.windowsNoMagicRoot) {
-                const e = t[0] === "" && t[1] === "" && (t[2] === "?" || !yt.test(t[2])) && !yt.test(t[3]);
+                const e = t[0] === "" && t[1] === "" && (t[2] === "?" || !Ht.test(t[2])) && !Ht.test(t[3]);
                 const s = /^[a-z]:/i.test(t[0]);
                 if (e) {
                     return [ ...t.slice(0, 4), ...t.slice(4).map((t => this.parse(t))) ];
@@ -1032,7 +1270,7 @@ class Minimatch {
             if (l === false) {
                 return false;
             }
-            if (l === ht) {
+            if (l === zt) {
                 this.debug("GLOBSTAR", [ e, l, c ]);
                 var f = r;
                 var u = o + 1;
@@ -1087,25 +1325,25 @@ class Minimatch {
         }
     }
     braceExpand() {
-        return gt(this.pattern, this.options);
+        return $t(this.pattern, this.options);
     }
     parse(t) {
-        y(t);
+        H(t);
         const e = this.options;
-        if (t === "**") return ht;
+        if (t === "**") return zt;
         if (t === "") return "";
         let s;
         let i = null;
-        if (s = t.match(V)) {
-            i = e.dot ? K : J;
-        } else if (s = t.match(W)) {
-            i = (e.nocase ? e.dot ? U : j : e.dot ? _ : I)(s[1]);
-        } else if (s = t.match(Y)) {
-            i = (e.nocase ? e.dot ? Q : X : e.dot ? tt : et)(s);
-        } else if (s = t.match(G)) {
-            i = e.dot ? H : $;
-        } else if (s = t.match(q)) {
-            i = Z;
+        if (s = t.match(kt)) {
+            i = e.dot ? vt : xt;
+        } else if (s = t.match(ft)) {
+            i = (e.nocase ? e.dot ? gt : pt : e.dot ? dt : ut)(s[1]);
+        } else if (s = t.match(Et)) {
+            i = (e.nocase ? e.dot ? Tt : Ct : e.dot ? At : Lt)(s);
+        } else if (s = t.match(mt)) {
+            i = e.dot ? yt : wt;
+        } else if (s = t.match(bt)) {
+            i = St;
         }
         const n = AST.fromGlob(t, this.options).toMMPattern();
         if (i && typeof n === "object") {
@@ -1123,38 +1361,49 @@ class Minimatch {
             return this.regexp;
         }
         const e = this.options;
-        const s = e.noglobstar ? lt : e.dot ? ct : ft;
+        const s = e.noglobstar ? Nt : e.dot ? Bt : Wt;
         const i = new Set(e.nocase ? [ "i" ] : []);
         let n = t.map((t => {
             const e = t.map((t => {
                 if (t instanceof RegExp) {
                     for (const e of t.flags.split("")) i.add(e);
                 }
-                return typeof t === "string" ? bt(t) : t === ht ? ht : t._src;
+                return typeof t === "string" ? Zt(t) : t === zt ? zt : t._src;
             }));
             e.forEach(((t, i) => {
                 const n = e[i + 1];
                 const r = e[i - 1];
-                if (t !== ht || r === ht) {
+                if (t !== zt || r === zt) {
                     return;
                 }
                 if (r === undefined) {
-                    if (n !== undefined && n !== ht) {
+                    if (n !== undefined && n !== zt) {
                         e[i + 1] = "(?:\\/|" + s + "\\/)?" + n;
                     } else {
                         e[i] = s;
                     }
                 } else if (n === undefined) {
-                    e[i - 1] = r + "(?:\\/|" + s + ")?";
-                } else if (n !== ht) {
+                    e[i - 1] = r + "(?:\\/|\\/" + s + ")?";
+                } else if (n !== zt) {
                     e[i - 1] = r + "(?:\\/|\\/" + s + "\\/)" + n;
-                    e[i + 1] = ht;
+                    e[i + 1] = zt;
                 }
             }));
-            return e.filter((t => t !== ht)).join("/");
+            const n = e.filter((t => t !== zt));
+            if (this.partial && n.length >= 1) {
+                const t = [];
+                for (let e = 1; e <= n.length; e++) {
+                    t.push(n.slice(0, e).join("/"));
+                }
+                return "(?:" + t.join("|") + ")";
+            }
+            return n.join("/");
         })).join("|");
         const [r, o] = t.length > 1 ? [ "(?:", ")" ] : [ "", "" ];
         n = "^" + r + n + o + "$";
+        if (this.partial) {
+            n = "^(?:\\/|" + r + n.slice(1, -1) + o + ")$";
+        }
         if (this.negate) n = "^(?!" + n + ").+$";
         try {
             this.regexp = new RegExp(n, [ ...i ].join(""));
@@ -1217,34 +1466,34 @@ class Minimatch {
         return this.negate;
     }
     static defaults(t) {
-        return B.defaults(t).Minimatch;
+        return ct.defaults(t).Minimatch;
     }
 }
 
-B.AST = AST;
+ct.AST = AST;
 
-B.Minimatch = Minimatch;
+ct.Minimatch = Minimatch;
 
-B.escape = N;
+ct.escape = lt;
 
-B.unescape = E;
+ct.unescape = Y;
 
-const St = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const qt = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 
-const kt = new Set;
+const Vt = new Set;
 
-const vt = typeof process === "object" && !!process ? process : {};
+const Jt = typeof process === "object" && !!process ? process : {};
 
-const xt = (t, e, s, i) => {
-    typeof vt.emitWarning === "function" ? vt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
+const Kt = (t, e, s, i) => {
+    typeof Jt.emitWarning === "function" ? Jt.emitWarning(t, e, s, i) : console.error(`[${s}] ${e}: ${t}`);
 };
 
-let Et = globalThis.AbortController;
+let Yt = globalThis.AbortController;
 
-let Ct = globalThis.AbortSignal;
+let Xt = globalThis.AbortSignal;
 
-if (typeof Et === "undefined") {
-    Ct = class AbortSignal {
+if (typeof Yt === "undefined") {
+    Xt = class AbortSignal {
         onabort;
         _onabort=[];
         reason;
@@ -1253,11 +1502,11 @@ if (typeof Et === "undefined") {
             this._onabort.push(e);
         }
     };
-    Et = class AbortController {
+    Yt = class AbortController {
         constructor() {
             e();
         }
-        signal=new Ct;
+        signal=new Xt;
         abort(t) {
             if (this.signal.aborted) return;
             this.signal.reason = t;
@@ -1268,21 +1517,21 @@ if (typeof Et === "undefined") {
             this.signal.onabort?.(t);
         }
     };
-    let t = vt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    let t = Jt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
     const e = () => {
         if (!t) return;
         t = false;
-        xt("AbortController is not defined. If using lru-cache in " + "node 14, load an AbortController polyfill from the " + "`node-abort-controller` package. A minimal polyfill is " + "provided for use by LRUCache.fetch(), but it should not be " + "relied upon in other contexts (eg, passing it to other APIs that " + "use AbortController/AbortSignal might have undesirable effects). " + "You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", e);
+        Kt("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 Tt = t => !kt.has(t);
+const Qt = t => !Vt.has(t);
 
-const Lt = Symbol("type");
+const te = Symbol("type");
 
-const At = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+const ee = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
 
-const Mt = t => !At(t) ? null : t <= Math.pow(2, 8) ? Uint8Array : t <= Math.pow(2, 16) ? Uint16Array : t <= Math.pow(2, 32) ? Uint32Array : t <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+const se = t => !ee(t) ? null : t <= Math.pow(2, 8) ? Uint8Array : t <= Math.pow(2, 16) ? Uint16Array : t <= Math.pow(2, 32) ? Uint32Array : t <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
 
 class ZeroArray extends Array {
     constructor(t) {
@@ -1296,7 +1545,7 @@ class Stack {
     length;
     static #g=false;
     static create(t) {
-        const e = Mt(t);
+        const e = se(t);
         if (!e) return [];
         Stack.#g = true;
         const s = new Stack(t, e);
@@ -1325,7 +1574,7 @@ class LRUCache {
     #b;
     #S;
     #k;
-    #v;
+    #x;
     ttl;
     ttlResolution;
     ttlAutopurge;
@@ -1341,18 +1590,18 @@ class LRUCache {
     allowStaleOnFetchAbort;
     allowStaleOnFetchRejection;
     ignoreFetchAbort;
-    #x;
+    #v;
     #E;
     #C;
     #T;
-    #L;
     #A;
+    #L;
     #M;
     #P;
     #F;
     #R;
-    #z;
     #O;
+    #z;
     #D;
     #N;
     #B;
@@ -1363,11 +1612,11 @@ class LRUCache {
         return {
             starts: t.#D,
             ttls: t.#N,
-            sizes: t.#O,
+            sizes: t.#z,
             keyMap: t.#C,
             keyList: t.#T,
-            valList: t.#L,
-            next: t.#A,
+            valList: t.#A,
+            next: t.#L,
             prev: t.#M,
             get head() {
                 return t.#P;
@@ -1377,11 +1626,11 @@ 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.#H(e),
-            isStale: e => t.#q(e)
+            isStale: e => t.#Z(e)
         };
     }
     get max() {
@@ -1394,13 +1643,13 @@ class LRUCache {
         return this.#E;
     }
     get size() {
-        return this.#x;
+        return this.#v;
     }
     get fetchMethod() {
         return this.#k;
     }
     get memoMethod() {
-        return this.#v;
+        return this.#x;
     }
     get dispose() {
         return this.#y;
@@ -1412,12 +1661,12 @@ class LRUCache {
         return this.#S;
     }
     constructor(t) {
-        const {max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: o, allowStale: h, dispose: a, onInsert: l, disposeAfter: c, noDisposeOnSet: f, noUpdateTTL: u, maxSize: d = 0, maxEntrySize: p = 0, sizeCalculation: g, fetchMethod: m, memoMethod: w, noDeleteOnFetchRejection: y, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: S, allowStaleOnFetchAbort: k, ignoreFetchAbort: v} = t;
-        if (e !== 0 && !At(e)) {
+        const {max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: o, allowStale: h, dispose: a, onInsert: l, disposeAfter: c, noDisposeOnSet: f, noUpdateTTL: u, maxSize: d = 0, maxEntrySize: p = 0, sizeCalculation: g, fetchMethod: m, memoMethod: w, noDeleteOnFetchRejection: y, noDeleteOnStaleGet: b, allowStaleOnFetchRejection: S, allowStaleOnFetchAbort: k, ignoreFetchAbort: x} = t;
+        if (e !== 0 && !ee(e)) {
             throw new TypeError("max option must be a nonnegative integer");
         }
-        const x = e ? Mt(e) : Array;
-        if (!x) {
+        const v = e ? se(e) : Array;
+        if (!v) {
             throw new Error("invalid max value: " + e);
         }
         this.#m = e;
@@ -1435,7 +1684,7 @@ class LRUCache {
         if (w !== undefined && typeof w !== "function") {
             throw new TypeError("memoMethod must be a function if defined");
         }
-        this.#v = w;
+        this.#x = w;
         if (m !== undefined && typeof m !== "function") {
             throw new TypeError("fetchMethod must be a function if specified");
         }
@@ -1443,13 +1692,13 @@ class LRUCache {
         this.#W = !!m;
         this.#C = new Map;
         this.#T = new Array(e).fill(undefined);
-        this.#L = new Array(e).fill(undefined);
-        this.#A = new x(e);
-        this.#M = new x(e);
+        this.#A = new Array(e).fill(undefined);
+        this.#L = new v(e);
+        this.#M = new v(e);
         this.#P = 0;
         this.#F = 0;
         this.#R = Stack.create(e);
-        this.#x = 0;
+        this.#v = 0;
         this.#E = 0;
         if (typeof a === "function") {
             this.#y = a;
@@ -1459,10 +1708,10 @@ class LRUCache {
         }
         if (typeof c === "function") {
             this.#S = c;
-            this.#z = [];
+            this.#O = [];
         } else {
             this.#S = undefined;
-            this.#z = undefined;
+            this.#O = undefined;
         }
         this.#B = !!this.#y;
         this.#_ = !!this.#b;
@@ -1472,27 +1721,27 @@ class LRUCache {
         this.noDeleteOnFetchRejection = !!y;
         this.allowStaleOnFetchRejection = !!S;
         this.allowStaleOnFetchAbort = !!k;
-        this.ignoreFetchAbort = !!v;
+        this.ignoreFetchAbort = !!x;
         if (this.maxEntrySize !== 0) {
             if (this.#w !== 0) {
-                if (!At(this.#w)) {
+                if (!ee(this.#w)) {
                     throw new TypeError("maxSize must be a positive integer if specified");
                 }
             }
-            if (!At(this.maxEntrySize)) {
+            if (!ee(this.maxEntrySize)) {
                 throw new TypeError("maxEntrySize must be a positive integer if specified");
             }
-            this.#Z();
+            this.#q();
         }
         this.allowStale = !!h;
         this.noDeleteOnStaleGet = !!b;
         this.updateAgeOnGet = !!r;
         this.updateAgeOnHas = !!o;
-        this.ttlResolution = At(i) || i === 0 ? i : 1;
+        this.ttlResolution = ee(i) || i === 0 ? i : 1;
         this.ttlAutopurge = !!n;
         this.ttl = s || 0;
         if (this.ttl) {
-            if (!At(this.ttl)) {
+            if (!ee(this.ttl)) {
                 throw new TypeError("ttl must be a positive integer if specified");
             }
             this.#V();
@@ -1502,10 +1751,10 @@ class LRUCache {
         }
         if (!this.ttlAutopurge && !this.#m && !this.#w) {
             const t = "LRU_CACHE_UNBOUNDED";
-            if (Tt(t)) {
-                kt.add(t);
+            if (Qt(t)) {
+                Vt.add(t);
                 const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
-                xt(e, "UnboundedCacheWarning", t, LRUCache);
+                Kt(e, "UnboundedCacheWarning", t, LRUCache);
             }
         }
     }
@@ -1517,12 +1766,12 @@ class LRUCache {
         const e = new ZeroArray(this.#m);
         this.#N = t;
         this.#D = e;
-        this.#J = (s, i, n = St.now()) => {
+        this.#J = (s, i, n = qt.now()) => {
             e[s] = i !== 0 ? n : 0;
             t[s] = i;
             if (i !== 0 && this.ttlAutopurge) {
                 const t = setTimeout((() => {
-                    if (this.#q(s)) {
+                    if (this.#Z(s)) {
                         this.#K(this.#T[s], "expire");
                     }
                 }), i + 1);
@@ -1532,7 +1781,7 @@ class LRUCache {
             }
         };
         this.#Y = s => {
-            e[s] = t[s] !== 0 ? St.now() : 0;
+            e[s] = t[s] !== 0 ? qt.now() : 0;
         };
         this.#X = (n, r) => {
             if (t[r]) {
@@ -1548,7 +1797,7 @@ class LRUCache {
         };
         let s = 0;
         const i = () => {
-            const t = St.now();
+            const t = qt.now();
             if (this.ttlResolution > 0) {
                 s = t;
                 const e = setTimeout((() => s = 0), this.ttlResolution);
@@ -1571,7 +1820,7 @@ class LRUCache {
             const a = (s || i()) - h;
             return o - a;
         };
-        this.#q = n => {
+        this.#Z = n => {
             const r = e[n];
             const o = t[n];
             return !!o && !!r && (s || i()) - r > o;
@@ -1580,11 +1829,11 @@ class LRUCache {
     #Y=() => {};
     #X=() => {};
     #J=() => {};
-    #q=() => false;
-    #Z() {
+    #Z=() => false;
+    #q() {
         const t = new ZeroArray(this.#m);
         this.#E = 0;
-        this.#O = t;
+        this.#z = t;
         this.#Q = e => {
             this.#E -= t[e];
             t[e] = 0;
@@ -1593,13 +1842,13 @@ class LRUCache {
             if (this.#j(e)) {
                 return 0;
             }
-            if (!At(s)) {
+            if (!ee(s)) {
                 if (i) {
                     if (typeof i !== "function") {
                         throw new TypeError("sizeCalculation must be a function");
                     }
                     s = i(e, t);
-                    if (!At(s)) {
+                    if (!ee(s)) {
                         throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     }
                 } else {
@@ -1631,13 +1880,13 @@ class LRUCache {
         }
         return 0;
     };
-    * #$({allowStale: t = this.allowStale} = {}) {
-        if (this.#x) {
+    * #G({allowStale: t = this.allowStale} = {}) {
+        if (this.#v) {
             for (let e = this.#F; true; ) {
                 if (!this.#it(e)) {
                     break;
                 }
-                if (t || !this.#q(e)) {
+                if (t || !this.#Z(e)) {
                     yield e;
                 }
                 if (e === this.#P) {
@@ -1649,18 +1898,18 @@ class LRUCache {
         }
     }
     * #H({allowStale: t = this.allowStale} = {}) {
-        if (this.#x) {
+        if (this.#v) {
             for (let e = this.#P; true; ) {
                 if (!this.#it(e)) {
                     break;
                 }
-                if (t || !this.#q(e)) {
+                if (t || !this.#Z(e)) {
                     yield e;
                 }
                 if (e === this.#F) {
                     break;
                 } else {
-                    e = this.#A[e];
+                    e = this.#L[e];
                 }
             }
         }
@@ -1669,23 +1918,23 @@ class LRUCache {
         return t !== undefined && this.#C.get(this.#T[t]) === t;
     }
     * entries() {
-        for (const t of this.#$()) {
-            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#T[t], this.#L[t] ];
+        for (const t of this.#G()) {
+            if (this.#A[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#A[t])) {
+                yield [ this.#T[t], this.#A[t] ];
             }
         }
     }
     * rentries() {
         for (const t of this.#H()) {
-            if (this.#L[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#L[t])) {
-                yield [ this.#T[t], this.#L[t] ];
+            if (this.#A[t] !== undefined && this.#T[t] !== undefined && !this.#j(this.#A[t])) {
+                yield [ this.#T[t], this.#A[t] ];
             }
         }
     }
     * keys() {
-        for (const t of this.#$()) {
+        for (const t of this.#G()) {
             const e = this.#T[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
+            if (e !== undefined && !this.#j(this.#A[t])) {
                 yield e;
             }
         }
@@ -1693,24 +1942,24 @@ class LRUCache {
     * rkeys() {
         for (const t of this.#H()) {
             const e = this.#T[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
+            if (e !== undefined && !this.#j(this.#A[t])) {
                 yield e;
             }
         }
     }
     * values() {
-        for (const t of this.#$()) {
-            const e = this.#L[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
-                yield this.#L[t];
+        for (const t of this.#G()) {
+            const e = this.#A[t];
+            if (e !== undefined && !this.#j(this.#A[t])) {
+                yield this.#A[t];
             }
         }
     }
     * rvalues() {
         for (const t of this.#H()) {
-            const e = this.#L[t];
-            if (e !== undefined && !this.#j(this.#L[t])) {
-                yield this.#L[t];
+            const e = this.#A[t];
+            if (e !== undefined && !this.#j(this.#A[t])) {
+                yield this.#A[t];
             }
         }
     }
@@ -1719,8 +1968,8 @@ class LRUCache {
     }
     [Symbol.toStringTag]="LRUCache";
     find(t, e = {}) {
-        for (const s of this.#$()) {
-            const i = this.#L[s];
+        for (const s of this.#G()) {
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             if (t(n, this.#T[s], this)) {
@@ -1729,8 +1978,8 @@ class LRUCache {
         }
     }
     forEach(t, e = this) {
-        for (const s of this.#$()) {
-            const i = this.#L[s];
+        for (const s of this.#G()) {
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             t.call(e, n, this.#T[s], this);
@@ -1738,7 +1987,7 @@ class LRUCache {
     }
     rforEach(t, e = this) {
         for (const s of this.#H()) {
-            const i = this.#L[s];
+            const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
             t.call(e, n, this.#T[s], this);
@@ -1749,7 +1998,7 @@ class LRUCache {
         for (const e of this.#H({
             allowStale: true
         })) {
-            if (this.#q(e)) {
+            if (this.#Z(e)) {
                 this.#K(this.#T[e], "expire");
                 t = true;
             }
@@ -1759,7 +2008,7 @@ class LRUCache {
     info(t) {
         const e = this.#C.get(t);
         if (e === undefined) return undefined;
-        const s = this.#L[e];
+        const s = this.#A[e];
         const i = this.#j(s) ? s.__staleWhileFetching : s;
         if (i === undefined) return undefined;
         const n = {
@@ -1769,23 +2018,23 @@ class LRUCache {
             const t = this.#N[e];
             const s = this.#D[e];
             if (t && s) {
-                const e = t - (St.now() - s);
+                const e = t - (qt.now() - s);
                 n.ttl = e;
                 n.start = Date.now();
             }
         }
-        if (this.#O) {
-            n.size = this.#O[e];
+        if (this.#z) {
+            n.size = this.#z[e];
         }
         return n;
     }
     dump() {
         const t = [];
-        for (const e of this.#$({
+        for (const e of this.#G({
             allowStale: true
         })) {
             const s = this.#T[e];
-            const i = this.#L[e];
+            const i = this.#A[e];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined || s === undefined) continue;
             const r = {
@@ -1793,11 +2042,11 @@ class LRUCache {
             };
             if (this.#N && this.#D) {
                 r.ttl = this.#N[e];
-                const t = St.now() - this.#D[e];
+                const t = qt.now() - this.#D[e];
                 r.start = Math.floor(Date.now() - t);
             }
-            if (this.#O) {
-                r.size = this.#O[e];
+            if (this.#z) {
+                r.size = this.#z[e];
             }
             t.unshift([ s, r ]);
         }
@@ -1808,7 +2057,7 @@ class LRUCache {
         for (const [e, s] of t) {
             if (s.start) {
                 const t = Date.now() - s.start;
-                s.start = St.now() - t;
+                s.start = qt.now() - t;
             }
             this.set(e, s.value, s);
         }
@@ -1829,16 +2078,16 @@ class LRUCache {
             this.#K(t, "set");
             return this;
         }
-        let c = this.#x === 0 ? undefined : this.#C.get(t);
+        let c = this.#v === 0 ? undefined : this.#C.get(t);
         if (c === undefined) {
-            c = this.#x === 0 ? this.#F : this.#R.length !== 0 ? this.#R.pop() : this.#x === this.#m ? this.#st(false) : this.#x;
+            c = this.#v === 0 ? this.#F : this.#R.length !== 0 ? this.#R.pop() : this.#v === this.#m ? this.#st(false) : this.#v;
             this.#T[c] = t;
-            this.#L[c] = e;
+            this.#A[c] = e;
             this.#C.set(t, c);
-            this.#A[this.#F] = c;
+            this.#L[this.#F] = c;
             this.#M[c] = this.#F;
             this.#F = c;
-            this.#x++;
+            this.#v++;
             this.#et(c, l, h);
             if (h) h.set = "add";
             a = false;
@@ -1846,8 +2095,8 @@ class LRUCache {
                 this.#b?.(e, t, "add");
             }
         } else {
-            this.#G(c);
-            const s = this.#L[c];
+            this.#U(c);
+            const s = this.#A[c];
             if (e !== s) {
                 if (this.#W && this.#j(s)) {
                     s.__abortController.abort(new Error("replaced"));
@@ -1857,7 +2106,7 @@ class LRUCache {
                             this.#y?.(e, t, "set");
                         }
                         if (this.#I) {
-                            this.#z?.push([ e, t, "set" ]);
+                            this.#O?.push([ e, t, "set" ]);
                         }
                     }
                 } else if (!r) {
@@ -1865,12 +2114,12 @@ class LRUCache {
                         this.#y?.(s, t, "set");
                     }
                     if (this.#I) {
-                        this.#z?.push([ s, t, "set" ]);
+                        this.#O?.push([ s, t, "set" ]);
                     }
                 }
                 this.#Q(c);
                 this.#et(c, l, h);
-                this.#L[c] = e;
+                this.#A[c] = e;
                 if (h) {
                     h.set = "replace";
                     const t = s && this.#j(s) ? s.__staleWhileFetching : s;
@@ -1892,8 +2141,8 @@ class LRUCache {
             }
             if (h) this.#X(h, c);
         }
-        if (!r && this.#I && this.#z) {
-            const t = this.#z;
+        if (!r && this.#I && this.#O) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -1903,8 +2152,8 @@ class LRUCache {
     }
     pop() {
         try {
-            while (this.#x) {
-                const t = this.#L[this.#P];
+            while (this.#v) {
+                const t = this.#A[this.#P];
                 this.#st(true);
                 if (this.#j(t)) {
                     if (t.__staleWhileFetching) {
@@ -1915,8 +2164,8 @@ class LRUCache {
                 }
             }
         } finally {
-            if (this.#I && this.#z) {
-                const t = this.#z;
+            if (this.#I && this.#O) {
+                const t = this.#O;
                 let e;
                 while (e = t?.shift()) {
                     this.#S?.(...e);
@@ -1927,7 +2176,7 @@ class LRUCache {
     #st(t) {
         const e = this.#P;
         const s = this.#T[e];
-        const i = this.#L[e];
+        const i = this.#A[e];
         if (this.#W && this.#j(i)) {
             i.__abortController.abort(new Error("evicted"));
         } else if (this.#B || this.#I) {
@@ -1935,34 +2184,34 @@ class LRUCache {
                 this.#y?.(i, s, "evict");
             }
             if (this.#I) {
-                this.#z?.push([ i, s, "evict" ]);
+                this.#O?.push([ i, s, "evict" ]);
             }
         }
         this.#Q(e);
         if (t) {
             this.#T[e] = undefined;
-            this.#L[e] = undefined;
+            this.#A[e] = undefined;
             this.#R.push(e);
         }
-        if (this.#x === 1) {
+        if (this.#v === 1) {
             this.#P = this.#F = 0;
             this.#R.length = 0;
         } else {
-            this.#P = this.#A[e];
+            this.#P = this.#L[e];
         }
         this.#C.delete(s);
-        this.#x--;
+        this.#v--;
         return e;
     }
     has(t, e = {}) {
         const {updateAgeOnHas: s = this.updateAgeOnHas, status: i} = e;
         const n = this.#C.get(t);
         if (n !== undefined) {
-            const t = this.#L[n];
+            const t = this.#A[n];
             if (this.#j(t) && t.__staleWhileFetching === undefined) {
                 return false;
             }
-            if (!this.#q(n)) {
+            if (!this.#Z(n)) {
                 if (s) {
                     this.#Y(n);
                 }
@@ -1983,18 +2232,18 @@ class LRUCache {
     peek(t, e = {}) {
         const {allowStale: s = this.allowStale} = e;
         const i = this.#C.get(t);
-        if (i === undefined || !s && this.#q(i)) {
+        if (i === undefined || !s && this.#Z(i)) {
             return;
         }
-        const n = this.#L[i];
+        const n = this.#A[i];
         return this.#j(n) ? n.__staleWhileFetching : n;
     }
-    #U(t, e, s, i) {
-        const n = e === undefined ? undefined : this.#L[e];
+    #$(t, e, s, i) {
+        const n = e === undefined ? undefined : this.#A[e];
         if (this.#j(n)) {
             return n;
         }
-        const r = new Et;
+        const r = new Yt;
         const {signal: o} = s;
         o?.addEventListener("abort", (() => r.abort(o.reason)), {
             signal: r.signal
@@ -2020,10 +2269,10 @@ class LRUCache {
                 return c(r.signal.reason);
             }
             const l = u;
-            if (this.#L[e] === u) {
+            if (this.#A[e] === u) {
                 if (i === undefined) {
                     if (l.__staleWhileFetching) {
-                        this.#L[e] = l.__staleWhileFetching;
+                        this.#A[e] = l.__staleWhileFetching;
                     } else {
                         this.#K(t, "fetch");
                     }
@@ -2047,12 +2296,12 @@ class LRUCache {
             const h = o || s.allowStaleOnFetchRejection;
             const a = h || s.noDeleteOnFetchRejection;
             const l = u;
-            if (this.#L[e] === u) {
+            if (this.#A[e] === u) {
                 const s = !a || l.__staleWhileFetching === undefined;
                 if (s) {
                     this.#K(t, "fetch");
                 } else if (!o) {
-                    this.#L[e] = l.__staleWhileFetching;
+                    this.#A[e] = l.__staleWhileFetching;
                 }
             }
             if (h) {
@@ -2092,14 +2341,14 @@ class LRUCache {
             });
             e = this.#C.get(t);
         } else {
-            this.#L[e] = d;
+            this.#A[e] = d;
         }
         return d;
     }
     #j(t) {
         if (!this.#W) return false;
         const e = t;
-        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof Et;
+        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof Yt;
     }
     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;
@@ -2131,10 +2380,10 @@ class LRUCache {
         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];
+            const e = this.#A[b];
             if (this.#j(e)) {
                 const t = s && e.__staleWhileFetching !== undefined;
                 if (m) {
@@ -2143,17 +2392,17 @@ class LRUCache {
                 }
                 return t ? e.__staleWhileFetching : e.__returned = e;
             }
-            const n = this.#q(b);
+            const n = this.#Z(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) {
@@ -2169,7 +2418,7 @@ class LRUCache {
         return s;
     }
     memo(t, e = {}) {
-        const s = this.#v;
+        const s = this.#x;
         if (!s) {
             throw new Error("no memoMethod provided to constructor");
         }
@@ -2187,10 +2436,10 @@ class LRUCache {
         const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, status: r} = e;
         const o = this.#C.get(t);
         if (o !== undefined) {
-            const e = this.#L[o];
+            const e = this.#A[o];
             const h = this.#j(e);
             if (r) this.#X(r, o);
-            if (this.#q(o)) {
+            if (this.#Z(o)) {
                 if (r) r.get = "stale";
                 if (!h) {
                     if (!n) {
@@ -2209,7 +2458,7 @@ class LRUCache {
                 if (h) {
                     return e.__staleWhileFetching;
                 }
-                this.#G(o);
+                this.#U(o);
                 if (i) {
                     this.#Y(o);
                 }
@@ -2221,14 +2470,14 @@ class LRUCache {
     }
     #nt(t, e) {
         this.#M[e] = t;
-        this.#A[t] = e;
+        this.#L[t] = e;
     }
-    #G(t) {
+    #U(t) {
         if (t !== this.#F) {
             if (t === this.#P) {
-                this.#P = this.#A[t];
+                this.#P = this.#L[t];
             } else {
-                this.#nt(this.#M[t], this.#A[t]);
+                this.#nt(this.#M[t], this.#L[t]);
             }
             this.#nt(this.#F, t);
             this.#F = t;
@@ -2239,15 +2488,15 @@ class LRUCache {
     }
     #K(t, e) {
         let s = false;
-        if (this.#x !== 0) {
+        if (this.#v !== 0) {
             const i = this.#C.get(t);
             if (i !== undefined) {
                 s = true;
-                if (this.#x === 1) {
+                if (this.#v === 1) {
                     this.#rt(e);
                 } else {
                     this.#Q(i);
-                    const s = this.#L[i];
+                    const s = this.#A[i];
                     if (this.#j(s)) {
                         s.__abortController.abort(new Error("deleted"));
                     } else if (this.#B || this.#I) {
@@ -2255,29 +2504,29 @@ class LRUCache {
                             this.#y?.(s, t, e);
                         }
                         if (this.#I) {
-                            this.#z?.push([ s, t, e ]);
+                            this.#O?.push([ s, t, e ]);
                         }
                     }
                     this.#C.delete(t);
                     this.#T[i] = undefined;
-                    this.#L[i] = undefined;
+                    this.#A[i] = undefined;
                     if (i === this.#F) {
                         this.#F = this.#M[i];
                     } else if (i === this.#P) {
-                        this.#P = this.#A[i];
+                        this.#P = this.#L[i];
                     } else {
                         const t = this.#M[i];
-                        this.#A[t] = this.#A[i];
-                        const e = this.#A[i];
+                        this.#L[t] = this.#L[i];
+                        const e = this.#L[i];
                         this.#M[e] = this.#M[i];
                     }
-                    this.#x--;
+                    this.#v--;
                     this.#R.push(i);
                 }
             }
         }
-        if (this.#I && this.#z?.length) {
-            const t = this.#z;
+        if (this.#I && this.#O?.length) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -2292,7 +2541,7 @@ class LRUCache {
         for (const e of this.#H({
             allowStale: true
         })) {
-            const s = this.#L[e];
+            const s = this.#A[e];
             if (this.#j(s)) {
                 s.__abortController.abort(new Error("deleted"));
             } else {
@@ -2301,27 +2550,27 @@ class LRUCache {
                     this.#y?.(s, i, t);
                 }
                 if (this.#I) {
-                    this.#z?.push([ s, i, t ]);
+                    this.#O?.push([ s, i, t ]);
                 }
             }
         }
         this.#C.clear();
-        this.#L.fill(undefined);
+        this.#A.fill(undefined);
         this.#T.fill(undefined);
         if (this.#N && this.#D) {
             this.#N.fill(0);
             this.#D.fill(0);
         }
-        if (this.#O) {
-            this.#O.fill(0);
+        if (this.#z) {
+            this.#z.fill(0);
         }
         this.#P = 0;
         this.#F = 0;
         this.#R.length = 0;
         this.#E = 0;
-        this.#x = 0;
-        if (this.#I && this.#z) {
-            const t = this.#z;
+        this.#v = 0;
+        if (this.#I && this.#O) {
+            const t = this.#O;
             let e;
             while (e = t?.shift()) {
                 this.#S?.(...e);
@@ -2330,88 +2579,88 @@ class LRUCache {
     }
 }
 
-const Pt = typeof process === "object" && process ? process : {
+const ie = typeof process === "object" && process ? process : {
     stdout: null,
     stderr: null
 };
 
-const Ft = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof g || Rt(t) || zt(t));
+const ne = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof p || re(t) || oe(t));
 
-const Rt = t => !!t && typeof t === "object" && t instanceof p && typeof t.pipe === "function" && t.pipe !== g.Writable.prototype.pipe;
+const re = t => !!t && typeof t === "object" && t instanceof d && typeof t.pipe === "function" && t.pipe !== p.Writable.prototype.pipe;
 
-const zt = t => !!t && typeof t === "object" && t instanceof p && typeof t.write === "function" && typeof t.end === "function";
+const oe = t => !!t && typeof t === "object" && t instanceof d && typeof t.write === "function" && typeof t.end === "function";
 
-const Ot = Symbol("EOF");
+const he = Symbol("EOF");
 
-const Dt = Symbol("maybeEmitEnd");
+const ae = Symbol("maybeEmitEnd");
 
-const Nt = Symbol("emittedEnd");
+const le = Symbol("emittedEnd");
 
-const Bt = Symbol("emittingEnd");
+const ce = Symbol("emittingEnd");
 
-const Wt = Symbol("emittedError");
+const fe = Symbol("emittedError");
 
-const It = Symbol("closed");
+const ue = Symbol("closed");
 
-const _t = Symbol("read");
+const de = Symbol("read");
 
-const jt = Symbol("flush");
+const pe = Symbol("flush");
 
-const Ut = Symbol("flushChunk");
+const ge = Symbol("flushChunk");
 
-const Gt = Symbol("encoding");
+const me = Symbol("encoding");
 
-const $t = Symbol("decoder");
+const we = Symbol("decoder");
 
-const Ht = Symbol("flowing");
+const ye = Symbol("flowing");
 
-const qt = Symbol("paused");
+const be = Symbol("paused");
 
-const Zt = Symbol("resume");
+const Se = Symbol("resume");
 
-const Vt = Symbol("buffer");
+const ke = Symbol("buffer");
 
-const Jt = Symbol("pipes");
+const xe = Symbol("pipes");
 
-const Kt = Symbol("bufferLength");
+const ve = Symbol("bufferLength");
 
-const Yt = Symbol("bufferPush");
+const Ee = Symbol("bufferPush");
 
-const Xt = Symbol("bufferShift");
+const Ce = Symbol("bufferShift");
 
-const Qt = Symbol("objectMode");
+const Te = Symbol("objectMode");
 
-const te = Symbol("destroyed");
+const Ae = Symbol("destroyed");
 
-const ee = Symbol("error");
+const Le = Symbol("error");
 
-const se = Symbol("emitData");
+const Me = Symbol("emitData");
 
-const ie = Symbol("emitEnd");
+const Pe = Symbol("emitEnd");
 
-const ne = Symbol("emitEnd2");
+const Fe = Symbol("emitEnd2");
 
-const re = Symbol("async");
+const Re = Symbol("async");
 
-const oe = Symbol("abort");
+const Oe = Symbol("abort");
 
-const he = Symbol("aborted");
+const ze = Symbol("aborted");
 
-const ae = Symbol("signal");
+const De = Symbol("signal");
 
-const le = Symbol("dataListeners");
+const Ne = Symbol("dataListeners");
 
-const ce = Symbol("discarded");
+const Be = Symbol("discarded");
 
-const fe = t => Promise.resolve().then(t);
+const We = t => Promise.resolve().then(t);
 
-const ue = t => t();
+const Ie = t => t();
 
-const de = t => t === "end" || t === "finish" || t === "prefinish";
+const _e = t => t === "end" || t === "finish" || t === "prefinish";
 
-const pe = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
+const je = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
 
-const ge = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
+const $e = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
 
 class Pipe {
     src;
@@ -2422,7 +2671,7 @@ class Pipe {
         this.src = t;
         this.dest = e;
         this.opts = s;
-        this.ondrain = () => t[Zt]();
+        this.ondrain = () => t[Se]();
         this.dest.on("drain", this.ondrain);
     }
     unpipe() {
@@ -2447,30 +2696,30 @@ class PipeProxyErrors extends Pipe {
     }
 }
 
-const me = t => !!t.objectMode;
-
-const we = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
-
-class Minipass extends p {
-    [Ht]=false;
-    [qt]=false;
-    [Jt]=[];
-    [Vt]=[];
-    [Qt];
-    [Gt];
-    [re];
-    [$t];
-    [Ot]=false;
-    [Nt]=false;
-    [Bt]=false;
-    [It]=false;
-    [Wt]=null;
-    [Kt]=0;
-    [te]=false;
-    [ae];
+const Ue = t => !!t.objectMode;
+
+const Ge = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+
+class Minipass extends d {
+    [ye]=false;
+    [be]=false;
+    [xe]=[];
+    [ke]=[];
+    [Te];
+    [me];
+    [Re];
+    [we];
     [he]=false;
-    [le]=0;
+    [le]=false;
     [ce]=false;
+    [ue]=false;
+    [fe]=null;
+    [ve]=0;
+    [Ae]=false;
+    [De];
+    [ze]=false;
+    [Ne]=0;
+    [Be]=false;
     writable=true;
     readable=true;
     constructor(...t) {
@@ -2479,43 +2728,43 @@ class Minipass extends p {
         if (e.objectMode && typeof e.encoding === "string") {
             throw new TypeError("Encoding and objectMode may not be used together");
         }
-        if (me(e)) {
-            this[Qt] = true;
-            this[Gt] = null;
-        } else if (we(e)) {
-            this[Gt] = e.encoding;
-            this[Qt] = false;
+        if (Ue(e)) {
+            this[Te] = true;
+            this[me] = null;
+        } else if (Ge(e)) {
+            this[me] = e.encoding;
+            this[Te] = false;
         } else {
-            this[Qt] = false;
-            this[Gt] = null;
+            this[Te] = false;
+            this[me] = null;
         }
-        this[re] = !!e.async;
-        this[$t] = this[Gt] ? new m(this[Gt]) : null;
+        this[Re] = !!e.async;
+        this[we] = this[me] ? new g(this[me]) : null;
         if (e && e.debugExposeBuffer === true) {
             Object.defineProperty(this, "buffer", {
-                get: () => this[Vt]
+                get: () => this[ke]
             });
         }
         if (e && e.debugExposePipes === true) {
             Object.defineProperty(this, "pipes", {
-                get: () => this[Jt]
+                get: () => this[xe]
             });
         }
         const {signal: s} = e;
         if (s) {
-            this[ae] = s;
+            this[De] = s;
             if (s.aborted) {
-                this[oe]();
+                this[Oe]();
             } else {
-                s.addEventListener("abort", (() => this[oe]()));
+                s.addEventListener("abort", (() => this[Oe]()));
             }
         }
     }
     get bufferLength() {
-        return this[Kt];
+        return this[ve];
     }
     get encoding() {
-        return this[Gt];
+        return this[me];
     }
     set encoding(t) {
         throw new Error("Encoding must be set at instantiation time");
@@ -2524,30 +2773,30 @@ class Minipass extends p {
         throw new Error("Encoding must be set at instantiation time");
     }
     get objectMode() {
-        return this[Qt];
+        return this[Te];
     }
     set objectMode(t) {
         throw new Error("objectMode must be set at instantiation time");
     }
     get ["async"]() {
-        return this[re];
+        return this[Re];
     }
     set ["async"](t) {
-        this[re] = this[re] || !!t;
+        this[Re] = this[Re] || !!t;
     }
-    [oe]() {
-        this[he] = true;
-        this.emit("abort", this[ae]?.reason);
-        this.destroy(this[ae]?.reason);
+    [Oe]() {
+        this[ze] = true;
+        this.emit("abort", this[De]?.reason);
+        this.destroy(this[De]?.reason);
     }
     get aborted() {
-        return this[he];
+        return this[ze];
     }
     set aborted(t) {}
     write(t, e, s) {
-        if (this[he]) return false;
-        if (this[Ot]) throw new Error("write after end");
-        if (this[te]) {
+        if (this[ze]) return false;
+        if (this[he]) throw new Error("write after end");
+        if (this[Ae]) {
             this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
                 code: "ERR_STREAM_DESTROYED"
             }));
@@ -2558,70 +2807,70 @@ class Minipass extends p {
             e = "utf8";
         }
         if (!e) e = "utf8";
-        const i = this[re] ? fe : ue;
-        if (!this[Qt] && !Buffer.isBuffer(t)) {
-            if (ge(t)) {
+        const i = this[Re] ? We : Ie;
+        if (!this[Te] && !Buffer.isBuffer(t)) {
+            if ($e(t)) {
                 t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
-            } else if (pe(t)) {
+            } else if (je(t)) {
                 t = Buffer.from(t);
             } else if (typeof t !== "string") {
                 throw new Error("Non-contiguous data written to non-objectMode stream");
             }
         }
-        if (this[Qt]) {
-            if (this[Ht] && this[Kt] !== 0) this[jt](true);
-            if (this[Ht]) this.emit("data", t); else this[Yt](t);
-            if (this[Kt] !== 0) this.emit("readable");
+        if (this[Te]) {
+            if (this[ye] && this[ve] !== 0) this[pe](true);
+            if (this[ye]) this.emit("data", t); else this[Ee](t);
+            if (this[ve] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[Ht];
+            return this[ye];
         }
         if (!t.length) {
-            if (this[Kt] !== 0) this.emit("readable");
+            if (this[ve] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[Ht];
+            return this[ye];
         }
-        if (typeof t === "string" && !(e === this[Gt] && !this[$t]?.lastNeed)) {
+        if (typeof t === "string" && !(e === this[me] && !this[we]?.lastNeed)) {
             t = Buffer.from(t, e);
         }
-        if (Buffer.isBuffer(t) && this[Gt]) {
-            t = this[$t].write(t);
+        if (Buffer.isBuffer(t) && this[me]) {
+            t = this[we].write(t);
         }
-        if (this[Ht] && this[Kt] !== 0) this[jt](true);
-        if (this[Ht]) this.emit("data", t); else this[Yt](t);
-        if (this[Kt] !== 0) this.emit("readable");
+        if (this[ye] && this[ve] !== 0) this[pe](true);
+        if (this[ye]) this.emit("data", t); else this[Ee](t);
+        if (this[ve] !== 0) this.emit("readable");
         if (s) i(s);
-        return this[Ht];
+        return this[ye];
     }
     read(t) {
-        if (this[te]) return null;
-        this[ce] = false;
-        if (this[Kt] === 0 || t === 0 || t && t > this[Kt]) {
-            this[Dt]();
+        if (this[Ae]) return null;
+        this[Be] = false;
+        if (this[ve] === 0 || t === 0 || t && t > this[ve]) {
+            this[ae]();
             return null;
         }
-        if (this[Qt]) t = null;
-        if (this[Vt].length > 1 && !this[Qt]) {
-            this[Vt] = [ this[Gt] ? this[Vt].join("") : Buffer.concat(this[Vt], this[Kt]) ];
+        if (this[Te]) t = null;
+        if (this[ke].length > 1 && !this[Te]) {
+            this[ke] = [ this[me] ? this[ke].join("") : Buffer.concat(this[ke], this[ve]) ];
         }
-        const e = this[_t](t || null, this[Vt][0]);
-        this[Dt]();
+        const e = this[de](t || null, this[ke][0]);
+        this[ae]();
         return e;
     }
-    [_t](t, e) {
-        if (this[Qt]) this[Xt](); else {
+    [de](t, e) {
+        if (this[Te]) this[Ce](); else {
             const s = e;
-            if (t === s.length || t === null) this[Xt](); else if (typeof s === "string") {
-                this[Vt][0] = s.slice(t);
+            if (t === s.length || t === null) this[Ce](); else if (typeof s === "string") {
+                this[ke][0] = s.slice(t);
                 e = s.slice(0, t);
-                this[Kt] -= t;
+                this[ve] -= t;
             } else {
-                this[Vt][0] = s.subarray(t);
+                this[ke][0] = s.subarray(t);
                 e = s.subarray(0, t);
-                this[Kt] -= t;
+                this[ve] -= t;
             }
         }
         this.emit("data", e);
-        if (!this[Vt].length && !this[Ot]) this.emit("drain");
+        if (!this[ke].length && !this[he]) this.emit("drain");
         return e;
     }
     end(t, e, s) {
@@ -2635,78 +2884,78 @@ class Minipass extends p {
         }
         if (t !== undefined) this.write(t, e);
         if (s) this.once("end", s);
-        this[Ot] = true;
+        this[he] = true;
         this.writable = false;
-        if (this[Ht] || !this[qt]) this[Dt]();
+        if (this[ye] || !this[be]) this[ae]();
         return this;
     }
-    [Zt]() {
-        if (this[te]) return;
-        if (!this[le] && !this[Jt].length) {
-            this[ce] = true;
+    [Se]() {
+        if (this[Ae]) return;
+        if (!this[Ne] && !this[xe].length) {
+            this[Be] = true;
         }
-        this[qt] = false;
-        this[Ht] = true;
+        this[be] = false;
+        this[ye] = true;
         this.emit("resume");
-        if (this[Vt].length) this[jt](); else if (this[Ot]) this[Dt](); else this.emit("drain");
+        if (this[ke].length) this[pe](); else if (this[he]) this[ae](); else this.emit("drain");
     }
     resume() {
-        return this[Zt]();
+        return this[Se]();
     }
     pause() {
-        this[Ht] = false;
-        this[qt] = true;
-        this[ce] = false;
+        this[ye] = false;
+        this[be] = true;
+        this[Be] = false;
     }
     get destroyed() {
-        return this[te];
+        return this[Ae];
     }
     get flowing() {
-        return this[Ht];
+        return this[ye];
     }
     get paused() {
-        return this[qt];
+        return this[be];
     }
-    [Yt](t) {
-        if (this[Qt]) this[Kt] += 1; else this[Kt] += t.length;
-        this[Vt].push(t);
+    [Ee](t) {
+        if (this[Te]) this[ve] += 1; else this[ve] += t.length;
+        this[ke].push(t);
     }
-    [Xt]() {
-        if (this[Qt]) this[Kt] -= 1; else this[Kt] -= this[Vt][0].length;
-        return this[Vt].shift();
+    [Ce]() {
+        if (this[Te]) this[ve] -= 1; else this[ve] -= this[ke][0].length;
+        return this[ke].shift();
     }
-    [jt](t = false) {
-        do {} while (this[Ut](this[Xt]()) && this[Vt].length);
-        if (!t && !this[Vt].length && !this[Ot]) this.emit("drain");
+    [pe](t = false) {
+        do {} while (this[ge](this[Ce]()) && this[ke].length);
+        if (!t && !this[ke].length && !this[he]) this.emit("drain");
     }
-    [Ut](t) {
+    [ge](t) {
         this.emit("data", t);
-        return this[Ht];
+        return this[ye];
     }
     pipe(t, e) {
-        if (this[te]) return t;
-        this[ce] = false;
-        const s = this[Nt];
+        if (this[Ae]) return t;
+        this[Be] = false;
+        const s = this[le];
         e = e || {};
-        if (t === Pt.stdout || t === Pt.stderr) e.end = false; else e.end = e.end !== false;
+        if (t === ie.stdout || t === ie.stderr) e.end = false; else e.end = e.end !== false;
         e.proxyErrors = !!e.proxyErrors;
         if (s) {
             if (e.end) t.end();
         } else {
-            this[Jt].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
-            if (this[re]) fe((() => this[Zt]())); else this[Zt]();
+            this[xe].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+            if (this[Re]) We((() => this[Se]())); else this[Se]();
         }
         return t;
     }
     unpipe(t) {
-        const e = this[Jt].find((e => e.dest === t));
+        const e = this[xe].find((e => e.dest === t));
         if (e) {
-            if (this[Jt].length === 1) {
-                if (this[Ht] && this[le] === 0) {
-                    this[Ht] = false;
+            if (this[xe].length === 1) {
+                if (this[ye] && this[Ne] === 0) {
+                    this[ye] = false;
                 }
-                this[Jt] = [];
-            } else this[Jt].splice(this[Jt].indexOf(e), 1);
+                this[xe] = [];
+            } else this[xe].splice(this[xe].indexOf(e), 1);
             e.unpipe();
         }
     }
@@ -2716,19 +2965,19 @@ class Minipass extends p {
     on(t, e) {
         const s = super.on(t, e);
         if (t === "data") {
-            this[ce] = false;
-            this[le]++;
-            if (!this[Jt].length && !this[Ht]) {
-                this[Zt]();
+            this[Be] = false;
+            this[Ne]++;
+            if (!this[xe].length && !this[ye]) {
+                this[Se]();
             }
-        } else if (t === "readable" && this[Kt] !== 0) {
+        } else if (t === "readable" && this[ve] !== 0) {
             super.emit("readable");
-        } else if (de(t) && this[Nt]) {
+        } else if (_e(t) && this[le]) {
             super.emit(t);
             this.removeAllListeners(t);
-        } else if (t === "error" && this[Wt]) {
+        } else if (t === "error" && this[fe]) {
             const t = e;
-            if (this[re]) fe((() => t.call(this, this[Wt]))); else t.call(this, this[Wt]);
+            if (this[Re]) We((() => t.call(this, this[fe]))); else t.call(this, this[fe]);
         }
         return s;
     }
@@ -2738,9 +2987,9 @@ class Minipass extends p {
     off(t, e) {
         const s = super.off(t, e);
         if (t === "data") {
-            this[le] = this.listeners("data").length;
-            if (this[le] === 0 && !this[ce] && !this[Jt].length) {
-                this[Ht] = false;
+            this[Ne] = this.listeners("data").length;
+            if (this[Ne] === 0 && !this[Be] && !this[xe].length) {
+                this[ye] = false;
             }
         }
         return s;
@@ -2748,49 +2997,49 @@ class Minipass extends p {
     removeAllListeners(t) {
         const e = super.removeAllListeners(t);
         if (t === "data" || t === undefined) {
-            this[le] = 0;
-            if (!this[ce] && !this[Jt].length) {
-                this[Ht] = false;
+            this[Ne] = 0;
+            if (!this[Be] && !this[xe].length) {
+                this[ye] = false;
             }
         }
         return e;
     }
     get emittedEnd() {
-        return this[Nt];
+        return this[le];
     }
-    [Dt]() {
-        if (!this[Bt] && !this[Nt] && !this[te] && this[Vt].length === 0 && this[Ot]) {
-            this[Bt] = true;
+    [ae]() {
+        if (!this[ce] && !this[le] && !this[Ae] && this[ke].length === 0 && this[he]) {
+            this[ce] = true;
             this.emit("end");
             this.emit("prefinish");
             this.emit("finish");
-            if (this[It]) this.emit("close");
-            this[Bt] = false;
+            if (this[ue]) this.emit("close");
+            this[ce] = false;
         }
     }
     emit(t, ...e) {
         const s = e[0];
-        if (t !== "error" && t !== "close" && t !== te && this[te]) {
+        if (t !== "error" && t !== "close" && t !== Ae && this[Ae]) {
             return false;
         } else if (t === "data") {
-            return !this[Qt] && !s ? false : this[re] ? (fe((() => this[se](s))), true) : this[se](s);
+            return !this[Te] && !s ? false : this[Re] ? (We((() => this[Me](s))), true) : this[Me](s);
         } else if (t === "end") {
-            return this[ie]();
+            return this[Pe]();
         } else if (t === "close") {
-            this[It] = true;
-            if (!this[Nt] && !this[te]) return false;
+            this[ue] = true;
+            if (!this[le] && !this[Ae]) return false;
             const t = super.emit("close");
             this.removeAllListeners("close");
             return t;
         } else if (t === "error") {
-            this[Wt] = s;
-            super.emit(ee, s);
-            const t = !this[ae] || this.listeners("error").length ? super.emit("error", s) : false;
-            this[Dt]();
+            this[fe] = s;
+            super.emit(Le, s);
+            const t = !this[De] || this.listeners("error").length ? super.emit("error", s) : false;
+            this[ae]();
             return t;
         } else if (t === "resume") {
             const t = super.emit("resume");
-            this[Dt]();
+            this[ae]();
             return t;
         } else if (t === "finish" || t === "prefinish") {
             const e = super.emit(t);
@@ -2798,34 +3047,34 @@ class Minipass extends p {
             return e;
         }
         const i = super.emit(t, ...e);
-        this[Dt]();
+        this[ae]();
         return i;
     }
-    [se](t) {
-        for (const e of this[Jt]) {
+    [Me](t) {
+        for (const e of this[xe]) {
             if (e.dest.write(t) === false) this.pause();
         }
-        const e = this[ce] ? false : super.emit("data", t);
-        this[Dt]();
+        const e = this[Be] ? false : super.emit("data", t);
+        this[ae]();
         return e;
     }
-    [ie]() {
-        if (this[Nt]) return false;
-        this[Nt] = true;
+    [Pe]() {
+        if (this[le]) return false;
+        this[le] = true;
         this.readable = false;
-        return this[re] ? (fe((() => this[ne]())), true) : this[ne]();
+        return this[Re] ? (We((() => this[Fe]())), true) : this[Fe]();
     }
-    [ne]() {
-        if (this[$t]) {
-            const t = this[$t].end();
+    [Fe]() {
+        if (this[we]) {
+            const t = this[we].end();
             if (t) {
-                for (const e of this[Jt]) {
+                for (const e of this[xe]) {
                     e.dest.write(t);
                 }
-                if (!this[ce]) super.emit("data", t);
+                if (!this[Be]) super.emit("data", t);
             }
         }
-        for (const t of this[Jt]) {
+        for (const t of this[xe]) {
             t.end();
         }
         const t = super.emit("end");
@@ -2836,31 +3085,31 @@ class Minipass extends p {
         const t = Object.assign([], {
             dataLength: 0
         });
-        if (!this[Qt]) t.dataLength = 0;
+        if (!this[Te]) t.dataLength = 0;
         const e = this.promise();
         this.on("data", (e => {
             t.push(e);
-            if (!this[Qt]) t.dataLength += e.length;
+            if (!this[Te]) t.dataLength += e.length;
         }));
         await e;
         return t;
     }
     async concat() {
-        if (this[Qt]) {
+        if (this[Te]) {
             throw new Error("cannot concat in objectMode");
         }
         const t = await this.collect();
-        return this[Gt] ? t.join("") : Buffer.concat(t, t.dataLength);
+        return this[me] ? t.join("") : Buffer.concat(t, t.dataLength);
     }
     async promise() {
         return new Promise(((t, e) => {
-            this.on(te, (() => e(new Error("stream destroyed"))));
+            this.on(Ae, (() => e(new Error("stream destroyed"))));
             this.on("error", (t => e(t)));
             this.on("end", (() => t()));
         }));
     }
     [Symbol.asyncIterator]() {
-        this[ce] = false;
+        this[Be] = false;
         let t = false;
         const e = async () => {
             this.pause();
@@ -2877,30 +3126,30 @@ class Minipass extends p {
                 done: false,
                 value: s
             });
-            if (this[Ot]) return e();
+            if (this[he]) return e();
             let i;
             let n;
             const r = t => {
                 this.off("data", o);
                 this.off("end", h);
-                this.off(te, a);
+                this.off(Ae, a);
                 e();
                 n(t);
             };
             const o = t => {
                 this.off("error", r);
                 this.off("end", h);
-                this.off(te, a);
+                this.off(Ae, a);
                 this.pause();
                 i({
                     value: t,
-                    done: !!this[Ot]
+                    done: !!this[he]
                 });
             };
             const h = () => {
                 this.off("error", r);
                 this.off("data", o);
-                this.off(te, a);
+                this.off(Ae, a);
                 e();
                 i({
                     done: true,
@@ -2911,7 +3160,7 @@ class Minipass extends p {
             return new Promise(((t, e) => {
                 n = e;
                 i = t;
-                this.once(te, a);
+                this.once(Ae, a);
                 this.once("error", r);
                 this.once("end", h);
                 this.once("data", o);
@@ -2927,12 +3176,12 @@ class Minipass extends p {
         };
     }
     [Symbol.iterator]() {
-        this[ce] = false;
+        this[Be] = false;
         let t = false;
         const e = () => {
             this.pause();
-            this.off(ee, e);
-            this.off(te, e);
+            this.off(Le, e);
+            this.off(Ae, e);
             this.off("end", e);
             t = true;
             return {
@@ -2949,8 +3198,8 @@ class Minipass extends p {
             };
         };
         this.once("end", e);
-        this.once(ee, e);
-        this.once(te, e);
+        this.once(Le, e);
+        this.once(Ae, e);
         return {
             next: s,
             throw: e,
@@ -2961,110 +3210,110 @@ class Minipass extends p {
         };
     }
     destroy(t) {
-        if (this[te]) {
-            if (t) this.emit("error", t); else this.emit(te);
+        if (this[Ae]) {
+            if (t) this.emit("error", t); else this.emit(Ae);
             return this;
         }
-        this[te] = true;
-        this[ce] = true;
-        this[Vt].length = 0;
-        this[Kt] = 0;
+        this[Ae] = true;
+        this[Be] = true;
+        this[ke].length = 0;
+        this[ve] = 0;
         const e = this;
-        if (typeof e.close === "function" && !this[It]) e.close();
-        if (t) this.emit("error", t); else this.emit(te);
+        if (typeof e.close === "function" && !this[ue]) e.close();
+        if (t) this.emit("error", t); else this.emit(Ae);
         return this;
     }
     static get isStream() {
-        return Ft;
+        return ne;
     }
 }
 
-const ye = n.native;
+const He = i.native;
 
-const be = {
-    lstatSync: a,
-    readdir: h,
-    readdirSync: o,
-    readlinkSync: r,
-    realpathSync: ye,
+const Ze = {
+    lstatSync: h,
+    readdir: o,
+    readdirSync: r,
+    readlinkSync: n,
+    realpathSync: He,
     promises: {
-        lstat: d,
-        readdir: u,
-        readlink: f,
-        realpath: c
+        lstat: u,
+        readdir: f,
+        readlink: c,
+        realpath: l
     }
 };
 
-const Se = t => !t || t === be || t === l ? be : {
-    ...be,
+const qe = t => !t || t === Ze || t === a ? Ze : {
+    ...Ze,
     ...t,
     promises: {
-        ...be.promises,
+        ...Ze.promises,
         ...t.promises || {}
     }
 };
 
-const ke = /^\\\\\?\\([a-z]:)\\?$/i;
+const Ve = /^\\\\\?\\([a-z]:)\\?$/i;
 
-const ve = t => t.replace(/\//g, "\\").replace(ke, "$1\\");
+const Je = t => t.replace(/\//g, "\\").replace(Ve, "$1\\");
 
-const xe = /[\\\/]/;
+const Ke = /[\\\/]/;
 
-const Ee = 0;
+const Ye = 0;
 
-const Ce = 1;
+const Xe = 1;
 
-const Te = 2;
+const Qe = 2;
 
-const Le = 4;
+const ts = 4;
 
-const Ae = 6;
+const es = 6;
 
-const Me = 8;
+const ss = 8;
 
-const Pe = 10;
+const is = 10;
 
-const Fe = 12;
+const ns = 12;
 
-const Re = 15;
+const rs = 15;
 
-const ze = ~Re;
+const os = ~rs;
 
-const Oe = 16;
+const hs = 16;
 
-const De = 32;
+const as = 32;
 
-const Ne = 64;
+const ls = 64;
 
-const Be = 128;
+const cs = 128;
 
-const We = 256;
+const fs = 256;
 
-const Ie = 512;
+const us = 512;
 
-const _e = Ne | Be | Ie;
+const ds = ls | cs | us;
 
-const je = 1023;
+const ps = 1023;
 
-const Ue = t => t.isFile() ? Me : t.isDirectory() ? Le : t.isSymbolicLink() ? Pe : t.isCharacterDevice() ? Te : t.isBlockDevice() ? Ae : t.isSocket() ? Fe : t.isFIFO() ? Ce : Ee;
+const gs = t => t.isFile() ? ss : t.isDirectory() ? ts : t.isSymbolicLink() ? is : t.isCharacterDevice() ? Qe : t.isBlockDevice() ? es : t.isSocket() ? ns : t.isFIFO() ? Xe : Ye;
 
-const Ge = new Map;
+const ms = new Map;
 
-const $e = t => {
-    const e = Ge.get(t);
+const ws = t => {
+    const e = ms.get(t);
     if (e) return e;
     const s = t.normalize("NFKD");
-    Ge.set(t, s);
+    ms.set(t, s);
     return s;
 };
 
-const He = new Map;
+const ys = new Map;
 
-const qe = t => {
-    const e = He.get(t);
+const bs = t => {
+    const e = ys.get(t);
     if (e) return e;
-    const s = $e(t.toLowerCase());
-    He.set(t, s);
+    const s = ws(t.toLowerCase());
+    ys.set(t, s);
     return s;
 };
 
@@ -3085,7 +3334,7 @@ class ChildrenCache extends LRUCache {
     }
 }
 
-const Ze = Symbol("PathScurry setAsCwd");
+const Ss = Symbol("PathScurry setAsCwd");
 
 class PathBase {
     name;
@@ -3127,9 +3376,9 @@ class PathBase {
     get ino() {
         return this.#pt;
     }
-    #x;
+    #v;
     get size() {
-        return this.#x;
+        return this.#v;
     }
     #gt;
     get blocks() {
@@ -3159,46 +3408,46 @@ class PathBase {
     get mtime() {
         return this.#kt;
     }
-    #vt;
+    #xt;
     get ctime() {
-        return this.#vt;
+        return this.#xt;
     }
-    #xt;
+    #vt;
     get birthtime() {
-        return this.#xt;
+        return this.#vt;
     }
     #Et;
     #Ct;
     #Tt;
-    #Lt;
     #At;
+    #Lt;
     #Mt;
     #Pt;
     #Ft;
     #Rt;
-    #zt;
+    #Ot;
     get parentPath() {
         return (this.parent || this).fullpath();
     }
     get path() {
         return this.parentPath;
     }
-    constructor(t, e = Ee, s, i, n, r, o) {
+    constructor(t, e = Ye, s, i, n, r, o) {
         this.name = t;
-        this.#Et = n ? qe(t) : $e(t);
-        this.#Pt = e & je;
+        this.#Et = n ? bs(t) : ws(t);
+        this.#Pt = e & ps;
         this.nocase = n;
         this.roots = i;
         this.root = s || this;
         this.#Ft = r;
         this.#Tt = o.fullpath;
-        this.#At = o.relative;
+        this.#Lt = o.relative;
         this.#Mt = o.relativePosix;
         this.parent = o.parent;
         if (this.parent) {
             this.#ot = this.parent.#ot;
         } else {
-            this.#ot = Se(o.fs);
+            this.#ot = qe(o.fs);
         }
     }
     depth() {
@@ -3216,10 +3465,10 @@ class PathBase {
         const e = this.getRootString(t);
         const s = t.substring(e.length);
         const i = s.split(this.splitSep);
-        const n = e ? this.getRoot(e).#Ot(i) : this.#Ot(i);
+        const n = e ? this.getRoot(e).#zt(i) : this.#zt(i);
         return n;
     }
-    #Ot(t) {
+    #zt(t) {
         let e = this;
         for (const s of t) {
             e = e.child(s);
@@ -3235,7 +3484,7 @@ class PathBase {
             provisional: 0
         });
         this.#Ft.set(this, e);
-        this.#Pt &= ~Oe;
+        this.#Pt &= ~hs;
         return e;
     }
     child(t, e) {
@@ -3246,7 +3495,7 @@ class PathBase {
             return this.parent || this;
         }
         const s = this.children();
-        const i = this.nocase ? qe(t) : $e(t);
+        const i = this.nocase ? bs(t) : ws(t);
         for (const t of s) {
             if (t.#Et === i) {
                 return t;
@@ -3254,26 +3503,26 @@ class PathBase {
         }
         const n = this.parent ? this.sep : "";
         const r = this.#Tt ? this.#Tt + n + t : undefined;
-        const o = this.newChild(t, Ee, {
+        const o = this.newChild(t, Ye, {
             ...e,
             parent: this,
             fullpath: r
         });
         if (!this.canReaddir()) {
-            o.#Pt |= Be;
+            o.#Pt |= cs;
         }
         s.push(o);
         return o;
     }
     relative() {
         if (this.isCWD) return "";
-        if (this.#At !== undefined) {
-            return this.#At;
+        if (this.#Lt !== undefined) {
+            return this.#Lt;
         }
         const t = this.name;
         const e = this.parent;
         if (!e) {
-            return this.#At = this.name;
+            return this.#Lt = this.name;
         }
         const s = e.relative();
         return s + (!s || !e.parent ? "" : this.sep) + t;
@@ -3304,23 +3553,23 @@ class PathBase {
         return this.#Tt = i;
     }
     fullpathPosix() {
-        if (this.#Lt !== undefined) return this.#Lt;
-        if (this.sep === "/") return this.#Lt = this.fullpath();
+        if (this.#At !== undefined) return this.#At;
+        if (this.sep === "/") return this.#At = this.fullpath();
         if (!this.parent) {
             const t = this.fullpath().replace(/\\/g, "/");
             if (/^[a-z]:\//i.test(t)) {
-                return this.#Lt = `//?/${t}`;
+                return this.#At = `//?/${t}`;
             } else {
-                return this.#Lt = t;
+                return this.#At = t;
             }
         }
         const t = this.parent;
         const e = t.fullpathPosix();
         const s = e + (!e || !t.parent ? "" : "/") + this.name;
-        return this.#Lt = s;
+        return this.#At = s;
     }
     isUnknown() {
-        return (this.#Pt & Re) === Ee;
+        return (this.#Pt & rs) === Ye;
     }
     isType(t) {
         return this[`is${t}`]();
@@ -3329,34 +3578,34 @@ class PathBase {
         return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
     }
     isFile() {
-        return (this.#Pt & Re) === Me;
+        return (this.#Pt & rs) === ss;
     }
     isDirectory() {
-        return (this.#Pt & Re) === Le;
+        return (this.#Pt & rs) === ts;
     }
     isCharacterDevice() {
-        return (this.#Pt & Re) === Te;
+        return (this.#Pt & rs) === Qe;
     }
     isBlockDevice() {
-        return (this.#Pt & Re) === Ae;
+        return (this.#Pt & rs) === es;
     }
     isFIFO() {
-        return (this.#Pt & Re) === Ce;
+        return (this.#Pt & rs) === Xe;
     }
     isSocket() {
-        return (this.#Pt & Re) === Fe;
+        return (this.#Pt & rs) === ns;
     }
     isSymbolicLink() {
-        return (this.#Pt & Pe) === Pe;
+        return (this.#Pt & is) === is;
     }
     lstatCached() {
-        return this.#Pt & De ? this : undefined;
+        return this.#Pt & as ? this : undefined;
     }
     readlinkCached() {
         return this.#Rt;
     }
     realpathCached() {
-        return this.#zt;
+        return this.#Ot;
     }
     readdirCached() {
         const t = this.children();
@@ -3365,17 +3614,17 @@ class PathBase {
     canReadlink() {
         if (this.#Rt) return true;
         if (!this.parent) return false;
-        const t = this.#Pt & Re;
-        return !(t !== Ee && t !== Pe || this.#Pt & We || this.#Pt & Be);
+        const t = this.#Pt & rs;
+        return !(t !== Ye && t !== is || this.#Pt & fs || this.#Pt & cs);
     }
     calledReaddir() {
-        return !!(this.#Pt & Oe);
+        return !!(this.#Pt & hs);
     }
     isENOENT() {
-        return !!(this.#Pt & Be);
+        return !!(this.#Pt & cs);
     }
     isNamed(t) {
-        return !this.nocase ? this.#Et === $e(t) : this.#Et === qe(t);
+        return !this.nocase ? this.#Et === ws(t) : this.#Et === bs(t);
     }
     async readlink() {
         const t = this.#Rt;
@@ -3422,15 +3671,15 @@ class PathBase {
         }
     }
     #Nt(t) {
-        this.#Pt |= Oe;
+        this.#Pt |= hs;
         for (let e = t.provisional; e < t.length; e++) {
             const s = t[e];
             if (s) s.#Bt();
         }
     }
     #Bt() {
-        if (this.#Pt & Be) return;
-        this.#Pt = (this.#Pt | Be) & ze;
+        if (this.#Pt & cs) return;
+        this.#Pt = (this.#Pt | cs) & os;
         this.#Wt();
     }
     #Wt() {
@@ -3441,14 +3690,14 @@ class PathBase {
         }
     }
     #It() {
-        this.#Pt |= Ie;
+        this.#Pt |= us;
         this.#_t();
     }
     #_t() {
-        if (this.#Pt & Ne) return;
+        if (this.#Pt & ls) return;
         let t = this.#Pt;
-        if ((t & Re) === Le) t &= ze;
-        this.#Pt = t | Ne;
+        if ((t & rs) === ts) t &= os;
+        this.#Pt = t | ls;
         this.#Wt();
     }
     #jt(t = "") {
@@ -3460,7 +3709,7 @@ class PathBase {
             this.children().provisional = 0;
         }
     }
-    #Ut(t = "") {
+    #$t(t = "") {
         if (t === "ENOTDIR") {
             const t = this.parent;
             t.#_t();
@@ -3470,45 +3719,45 @@ class PathBase {
     }
     #Dt(t = "") {
         let e = this.#Pt;
-        e |= We;
-        if (t === "ENOENT") e |= Be;
+        e |= fs;
+        if (t === "ENOENT") e |= cs;
         if (t === "EINVAL" || t === "UNKNOWN") {
-            e &= ze;
+            e &= os;
         }
         this.#Pt = e;
         if (t === "ENOTDIR" && this.parent) {
             this.parent.#_t();
         }
     }
-    #Gt(t, e) {
-        return this.#$t(t, e) || this.#Ht(t, e);
+    #Ut(t, e) {
+        return this.#Gt(t, e) || this.#Ht(t, e);
     }
     #Ht(t, e) {
-        const s = Ue(t);
+        const s = gs(t);
         const i = this.newChild(t.name, s, {
             parent: this
         });
-        const n = i.#Pt & Re;
-        if (n !== Le && n !== Pe && n !== Ee) {
-            i.#Pt |= Ne;
+        const n = i.#Pt & rs;
+        if (n !== ts && n !== is && n !== Ye) {
+            i.#Pt |= ls;
         }
         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 ? qe(t.name) : $e(t.name);
+            const n = this.nocase ? bs(t.name) : ws(t.name);
             if (n !== i.#Et) {
                 continue;
             }
-            return this.#qt(t, i, s, e);
+            return this.#Zt(t, i, s, e);
         }
     }
-    #qt(t, e, s, i) {
+    #Zt(t, e, s, i) {
         const n = e.name;
-        e.#Pt = e.#Pt & ze | Ue(t);
+        e.#Pt = e.#Pt & os | gs(t);
         if (n !== t.name) e.name = t.name;
         if (s !== i.provisional) {
             if (s === i.length - 1) i.pop(); else i.splice(s, 1);
@@ -3518,34 +3767,34 @@ class PathBase {
         return e;
     }
     async lstat() {
-        if ((this.#Pt & Be) === 0) {
+        if ((this.#Pt & cs) === 0) {
             try {
-                this.#Zt(await this.#ot.promises.lstat(this.fullpath()));
+                this.#qt(await this.#ot.promises.lstat(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
     lstatSync() {
-        if ((this.#Pt & Be) === 0) {
+        if ((this.#Pt & cs) === 0) {
             try {
-                this.#Zt(this.#ot.lstatSync(this.fullpath()));
+                this.#qt(this.#ot.lstatSync(this.fullpath()));
                 return this;
             } catch (t) {
-                this.#Ut(t.code);
+                this.#$t(t.code);
             }
         }
     }
-    #Zt(t) {
+    #qt(t) {
         const {atime: e, atimeMs: s, birthtime: i, birthtimeMs: n, blksize: r, blocks: o, ctime: h, ctimeMs: a, dev: l, gid: c, ino: f, mode: u, mtime: d, mtimeMs: p, nlink: g, rdev: m, size: w, uid: y} = t;
         this.#St = e;
         this.#mt = s;
-        this.#xt = i;
+        this.#vt = i;
         this.#bt = n;
         this.#dt = r;
         this.#gt = o;
-        this.#vt = h;
+        this.#xt = h;
         this.#yt = a;
         this.#ht = l;
         this.#ft = c;
@@ -3555,12 +3804,12 @@ class PathBase {
         this.#wt = p;
         this.#lt = g;
         this.#ut = m;
-        this.#x = w;
+        this.#v = w;
         this.#ct = y;
-        const b = Ue(t);
-        this.#Pt = this.#Pt & ze | b | De;
-        if (b !== Ee && b !== Le && b !== Pe) {
-            this.#Pt |= Ne;
+        const b = gs(t);
+        this.#Pt = this.#Pt & os | b | as;
+        if (b !== Ye && b !== ts && b !== is) {
+            this.#Pt |= ls;
         }
     }
     #Vt=[];
@@ -3596,7 +3845,7 @@ class PathBase {
                 s.provisional = 0;
             } else {
                 for (const t of e) {
-                    this.#Gt(t, s);
+                    this.#Ut(t, s);
                 }
                 this.#Nt(s);
             }
@@ -3623,7 +3872,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) {
@@ -3648,7 +3897,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) {
@@ -3658,37 +3907,37 @@ class PathBase {
         return t.slice(0, t.provisional);
     }
     canReaddir() {
-        if (this.#Pt & _e) return false;
-        const t = Re & this.#Pt;
-        if (!(t === Ee || t === Le || t === Pe)) {
+        if (this.#Pt & ds) return false;
+        const t = rs & this.#Pt;
+        if (!(t === Ye || t === ts || t === is)) {
             return false;
         }
         return true;
     }
     shouldWalk(t, e) {
-        return (this.#Pt & Le) === Le && !(this.#Pt & _e) && !t.has(this) && (!e || e(this));
+        return (this.#Pt & ts) === ts && !(this.#Pt & ds) && !t.has(this) && (!e || e(this));
     }
     async realpath() {
-        if (this.#zt) return this.#zt;
-        if ((Ie | We | Be) & this.#Pt) return undefined;
+        if (this.#Ot) return this.#Ot;
+        if ((us | fs | cs) & this.#Pt) return undefined;
         try {
             const t = await this.#ot.promises.realpath(this.fullpath());
-            return this.#zt = this.resolve(t);
+            return this.#Ot = this.resolve(t);
         } catch (t) {
             this.#It();
         }
     }
     realpathSync() {
-        if (this.#zt) return this.#zt;
-        if ((Ie | We | Be) & this.#Pt) return undefined;
+        if (this.#Ot) return this.#Ot;
+        if ((us | fs | cs) & this.#Pt) return undefined;
         try {
             const t = this.#ot.realpathSync(this.fullpath());
-            return this.#zt = this.resolve(t);
+            return this.#Ot = this.resolve(t);
         } catch (t) {
             this.#It();
         }
     }
-    [Ze](t) {
+    [Ss](t) {
         if (t === this) return;
         t.isCWD = false;
         this.isCWD = true;
@@ -3697,14 +3946,14 @@ class PathBase {
         let i = this;
         while (i && i.parent) {
             e.add(i);
-            i.#At = s.join(this.sep);
+            i.#Lt = s.join(this.sep);
             i.#Mt = s.join("/");
             i = i.parent;
             s.push("..");
         }
         i = t;
         while (i && i.parent && !e.has(i)) {
-            i.#At = undefined;
+            i.#Lt = undefined;
             i.#Mt = undefined;
             i = i.parent;
         }
@@ -3713,18 +3962,18 @@ class PathBase {
 
 class PathWin32 extends PathBase {
     sep="\\";
-    splitSep=xe;
-    constructor(t, e = Ee, s, i, n, r, o) {
+    splitSep=Ke;
+    constructor(t, e = Ye, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
-    newChild(t, e = Ee, s = {}) {
+    newChild(t, e = Ye, s = {}) {
         return new PathWin32(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
     getRootString(t) {
-        return s.parse(t).root;
+        return e.parse(t).root;
     }
     getRoot(t) {
-        t = ve(t.toUpperCase());
+        t = Je(t.toUpperCase());
         if (t === this.root.name) {
             return this.root;
         }
@@ -3736,7 +3985,7 @@ class PathWin32 extends PathBase {
         return this.roots[t] = new PathScurryWin32(t, this).root;
     }
     sameRoot(t, e = this.root.name) {
-        t = t.toUpperCase().replace(/\//g, "\\").replace(ke, "$1\\");
+        t = t.toUpperCase().replace(/\//g, "\\").replace(Ve, "$1\\");
         return t === e;
     }
 }
@@ -3744,7 +3993,7 @@ class PathWin32 extends PathBase {
 class PathPosix extends PathBase {
     splitSep="/";
     sep="/";
-    constructor(t, e = Ee, s, i, n, r, o) {
+    constructor(t, e = Ye, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
     getRootString(t) {
@@ -3753,7 +4002,7 @@ class PathPosix extends PathBase {
     getRoot(t) {
         return this.root;
     }
-    newChild(t, e = Ee, s = {}) {
+    newChild(t, e = Ye, s = {}) {
         return new PathPosix(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
 }
@@ -3768,12 +4017,12 @@ class PathScurryBase {
     #Ft;
     nocase;
     #ot;
-    constructor(t = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = be} = {}) {
-        this.#ot = Se(o);
-        if (t instanceof URL || t.startsWith("file://")) {
-            t = e(t);
+    constructor(e = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = Ze} = {}) {
+        this.#ot = qe(o);
+        if (e instanceof URL || e.startsWith("file://")) {
+            e = t(e);
         }
-        const h = s.resolve(t);
+        const h = s.resolve(e);
         this.roots = Object.create(null);
         this.rootPath = this.parseRootPath(h);
         this.#Xt = new ResolveCache;
@@ -4218,16 +4467,16 @@ class PathScurryBase {
     chdir(t = this.cwd) {
         const e = this.cwd;
         this.cwd = typeof t === "string" ? this.cwd.resolve(t) : t;
-        this.cwd[Ze](e);
+        this.cwd[Ss](e);
     }
 }
 
 class PathScurryWin32 extends PathScurryBase {
     sep="\\";
-    constructor(t = process.cwd(), e = {}) {
-        const {nocase: i = true} = e;
-        super(t, s, "\\", {
-            ...e,
+    constructor(t = process.cwd(), s = {}) {
+        const {nocase: i = true} = s;
+        super(t, e, "\\", {
+            ...s,
             nocase: i
         });
         this.nocase = i;
@@ -4236,10 +4485,10 @@ class PathScurryWin32 extends PathScurryBase {
         }
     }
     parseRootPath(t) {
-        return s.parse(t).root.toUpperCase();
+        return e.parse(t).root.toUpperCase();
     }
     newRoot(t) {
-        return new PathWin32(this.rootPath, Le, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathWin32(this.rootPath, ts, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4251,18 +4500,18 @@ class PathScurryWin32 extends PathScurryBase {
 class PathScurryPosix extends PathScurryBase {
     sep="/";
     constructor(t = process.cwd(), e = {}) {
-        const {nocase: s = false} = e;
-        super(t, i, "/", {
+        const {nocase: i = false} = e;
+        super(t, s, "/", {
             ...e,
-            nocase: s
+            nocase: i
         });
-        this.nocase = s;
+        this.nocase = i;
     }
     parseRootPath(t) {
         return "/";
     }
     newRoot(t) {
-        return new PathPosix(this.rootPath, Le, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathPosix(this.rootPath, ts, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4281,13 +4530,13 @@ class PathScurryDarwin extends PathScurryPosix {
     }
 }
 
-const Ve = process.platform === "win32" ? PathWin32 : PathPosix;
+const ks = process.platform === "win32" ? PathWin32 : PathPosix;
 
-const Je = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+const xs = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-const Ke = t => t.length >= 1;
+const vs = t => t.length >= 1;
 
-const Ye = t => t.length >= 1;
+const Es = t => t.length >= 1;
 
 class Pattern {
     #te;
@@ -4302,10 +4551,10 @@ class Pattern {
     #ae;
     #le=true;
     constructor(t, e, s, i) {
-        if (!Ke(t)) {
+        if (!vs(t)) {
             throw new TypeError("empty pattern list");
         }
-        if (!Ye(e)) {
+        if (!Es(e)) {
             throw new TypeError("empty glob list");
         }
         if (e.length !== t.length) {
@@ -4354,7 +4603,7 @@ class Pattern {
         return typeof this.#te[this.#se] === "string";
     }
     isGlobstar() {
-        return this.#te[this.#se] === ht;
+        return this.#te[this.#se] === zt;
     }
     isRegExp() {
         return this.#te[this.#se] instanceof RegExp;
@@ -4400,7 +4649,7 @@ class Pattern {
     }
 }
 
-const Xe = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const Cs = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
 class Ignore {
     relative;
@@ -4409,7 +4658,7 @@ class Ignore {
     absoluteChildren;
     platform;
     mmopts;
-    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = Xe}) {
+    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = Cs}) {
         this.relative = [];
         this.absolute = [];
         this.relativeChildren = [];
@@ -4585,7 +4834,7 @@ class Processor {
                 const e = n === ".." || n === "" || n === ".";
                 this.matches.add(t.resolve(n), i, e);
                 continue;
-            } else if (n === ht) {
+            } else if (n === zt) {
                 if (!t.isSymbolicLink() || this.follow || e.checkFollowGlobstar()) {
                     this.subwalks.add(t, e);
                 }
@@ -4621,7 +4870,7 @@ class Processor {
                 const s = e.isAbsolute();
                 const n = e.pattern();
                 const r = e.rest();
-                if (n === ht) {
+                if (n === zt) {
                     i.testGlobstar(t, e, r, s);
                 } else if (n instanceof RegExp) {
                     i.testRegExp(t, n, r, s);
@@ -4679,7 +4928,7 @@ class Processor {
     }
 }
 
-const Qe = (t, e) => typeof t === "string" ? new Ignore([ t ], e) : Array.isArray(t) ? new Ignore(t, e) : t;
+const Ts = (t, e) => typeof t === "string" ? new Ignore([ t ], e) : Array.isArray(t) ? new Ignore(t, e) : t;
 
 class GlobUtil {
     path;
@@ -4701,7 +4950,7 @@ class GlobUtil {
         this.#ue = !s.posix && s.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = s.includeChildMatches !== false;
         if (s.ignore || !this.includeChildMatches) {
-            this.#fe = Qe(s.ignore ?? [], s);
+            this.#fe = Ts(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);
@@ -4976,9 +5225,9 @@ class GlobStream extends GlobUtil {
     }
 }
 
-const ts = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+const As = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 
-let es = class Glob {
+let Ls = class Glob {
     absolute;
     cwd;
     root;
@@ -5006,7 +5255,7 @@ let es = class Glob {
     includeChildMatches;
     opts;
     patterns;
-    constructor(t, s) {
+    constructor(e, s) {
         if (!s) throw new TypeError("glob options required");
         this.withFileTypes = !!s.withFileTypes;
         this.signal = s.signal;
@@ -5018,7 +5267,7 @@ let es = class Glob {
         if (!s.cwd) {
             this.cwd = "";
         } else if (s.cwd instanceof URL || s.cwd.startsWith("file://")) {
-            s.cwd = e(s.cwd);
+            s.cwd = t(s.cwd);
         }
         this.cwd = s.cwd || "";
         this.root = s.root;
@@ -5036,21 +5285,21 @@ let es = class Glob {
         if (this.withFileTypes && this.absolute !== undefined) {
             throw new Error("cannot set absolute and withFileTypes:true");
         }
-        if (typeof t === "string") {
-            t = [ t ];
+        if (typeof e === "string") {
+            e = [ e ];
         }
         this.windowsPathsNoEscape = !!s.windowsPathsNoEscape || s.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
-            t = t.map((t => t.replace(/\\/g, "/")));
+            e = e.map((t => t.replace(/\\/g, "/")));
         }
         if (this.matchBase) {
             if (s.noglobstar) {
                 throw new TypeError("base matching requires globstar");
             }
-            t = t.map((t => t.includes("/") ? t : `./**/${t}`));
+            e = e.map((t => t.includes("/") ? t : `./**/${t}`));
         }
-        this.pattern = t;
-        this.platform = s.platform || ts;
+        this.pattern = e;
+        this.platform = s.platform || As;
         this.opts = {
             ...s,
             platform: this.platform
@@ -5061,7 +5310,7 @@ let es = class Glob {
                 throw new Error("nocase option contradicts provided scurry option");
             }
         } else {
-            const t = s.platform === "win32" ? PathScurryWin32 : s.platform === "darwin" ? PathScurryDarwin : s.platform ? PathScurryPosix : Je;
+            const t = s.platform === "win32" ? PathScurryWin32 : s.platform === "darwin" ? PathScurryDarwin : s.platform ? PathScurryPosix : xs;
             this.scurry = new t(this.cwd, {
                 nocase: s.nocase,
                 fs: s.fs
@@ -5146,7 +5395,7 @@ let es = class Glob {
     }
 };
 
-const ss = (t, e = {}) => {
+const Ms = (t, e = {}) => {
     if (!Array.isArray(t)) {
         t = [ t ];
     }
@@ -5156,69 +5405,69 @@ const ss = (t, e = {}) => {
     return false;
 };
 
-function is(t, e = {}) {
-    return new es(t, e).streamSync();
+function Ps(t, e = {}) {
+    return new Ls(t, e).streamSync();
 }
 
-function ns(t, e = {}) {
-    return new es(t, e).stream();
+function Fs(t, e = {}) {
+    return new Ls(t, e).stream();
 }
 
-function rs(t, e = {}) {
-    return new es(t, e).walkSync();
+function Rs(t, e = {}) {
+    return new Ls(t, e).walkSync();
 }
 
-async function os(t, e = {}) {
-    return new es(t, e).walk();
+async function Os(t, e = {}) {
+    return new Ls(t, e).walk();
 }
 
-function hs(t, e = {}) {
-    return new es(t, e).iterateSync();
+function zs(t, e = {}) {
+    return new Ls(t, e).iterateSync();
 }
 
-function as(t, e = {}) {
-    return new es(t, e).iterate();
+function Ds(t, e = {}) {
+    return new Ls(t, e).iterate();
 }
 
-const ls = is;
+const Ns = Ps;
 
-const cs = Object.assign(ns, {
-    sync: is
+const Bs = Object.assign(Fs, {
+    sync: Ps
 });
 
-const fs = hs;
+const Ws = zs;
 
-const us = Object.assign(as, {
-    sync: hs
+const Is = Object.assign(Ds, {
+    sync: zs
 });
 
-const ds = Object.assign(rs, {
-    stream: is,
-    iterate: hs
+const _s = Object.assign(Rs, {
+    stream: Ps,
+    iterate: zs
 });
 
-const ps = Object.assign(os, {
-    glob: os,
-    globSync: rs,
-    sync: ds,
-    globStream: ns,
-    stream: cs,
-    globStreamSync: is,
-    streamSync: ls,
-    globIterate: as,
-    iterate: us,
-    globIterateSync: hs,
-    iterateSync: fs,
-    Glob: es,
-    hasMagic: ss,
-    escape: N,
-    unescape: E
+const js = Object.assign(Os, {
+    glob: Os,
+    globSync: Rs,
+    sync: _s,
+    globStream: Fs,
+    stream: Bs,
+    globStreamSync: Ps,
+    streamSync: Ns,
+    globIterate: Ds,
+    iterate: Is,
+    globIterateSync: zs,
+    iterateSync: Ws,
+    Glob: Ls,
+    hasMagic: Ms,
+    escape: lt,
+    unescape: Y
 });
 
-ps.glob = ps;
+js.glob = js;
 
-async function gs(t, e) {
-    return e ? await ps(t, e) : await ps(t);
+async function $s(t, e) {
+    return e ? await js(t, e) : await js(t);
 }
 
-export { gs as Glob };
+export { $s as Glob };