lakutata 2.0.82 → 2.0.83

package/src/lib/helpers/Glob.mjs

@@ -14,10 +14,10 @@ import p from "node:stream";
 
 import { StringDecoder as g } from "node:string_decoder";
 
-const balanced = (t, e, s) => {
-    const i = t instanceof RegExp ? maybeMatch(t, s) : t;
-    const n = e instanceof RegExp ? maybeMatch(e, s) : e;
-    const r = i !== null && n != null && range(i, n, s);
+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],
@@ -27,12 +27,12 @@ const balanced = (t, e, s) => {
     };
 };
 
-const maybeMatch = (t, e) => {
+const w = (t, e) => {
     const s = e.match(t);
     return s ? s[0] : null;
 };
 
-const range = (t, e, s) => {
+const y = (t, e, s) => {
     let i, n, r, o = undefined, h;
     let a = s.indexOf(t);
     let l = s.indexOf(e, a + 1);
@@ -67,19 +67,15 @@ const range = (t, e, s) => {
     return h;
 };
 
-const y = "\0SLASH" + Math.random() + "\0";
+const b = "\0SLASH" + Math.random() + "\0";
 
-const w = "\0OPEN" + Math.random() + "\0";
+const S = "\0OPEN" + Math.random() + "\0";
 
-const b = "\0CLOSE" + Math.random() + "\0";
+const k = "\0CLOSE" + Math.random() + "\0";
 
-const S = "\0COMMA" + Math.random() + "\0";
+const x = "\0COMMA" + Math.random() + "\0";
 
-const k = "\0PERIOD" + Math.random() + "\0";
-
-const x = new RegExp(y, "g");
-
-const v = new RegExp(w, "g");
+const v = "\0PERIOD" + Math.random() + "\0";
 
 const E = new RegExp(b, "g");
 
@@ -87,41 +83,45 @@ const C = new RegExp(S, "g");
 
 const T = new RegExp(k, "g");
 
-const A = /\\\\/g;
+const A = new RegExp(x, "g");
+
+const L = new RegExp(v, "g");
+
+const M = /\\\\/g;
 
-const L = /\\{/g;
+const P = /\\{/g;
 
-const M = /\\}/g;
+const F = /\\}/g;
 
-const P = /\\,/g;
+const R = /\\,/g;
 
-const F = /\\./g;
+const O = /\\./g;
 
-function numeric(t) {
+function z(t) {
     return !isNaN(t) ? parseInt(t, 10) : t.charCodeAt(0);
 }
 
-function escapeBraces(t) {
-    return t.replace(A, y).replace(L, w).replace(M, b).replace(P, S).replace(F, k);
+function D(t) {
+    return t.replace(M, b).replace(P, S).replace(F, k).replace(R, x).replace(O, v);
 }
 
-function unescapeBraces(t) {
-    return t.replace(x, "\\").replace(v, "{").replace(E, "}").replace(C, ",").replace(T, ".");
+function N(t) {
+    return t.replace(E, "\\").replace(C, "{").replace(T, "}").replace(A, ",").replace(L, ".");
 }
 
-function parseCommaParts(t) {
+function B(t) {
     if (!t) {
         return [ "" ];
     }
     const e = [];
-    const s = balanced("{", "}", t);
+    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 = parseCommaParts(r);
+    const h = B(r);
     if (r.length) {
         o[o.length - 1] += h.shift();
         o.push.apply(o, h);
@@ -130,38 +130,38 @@ function parseCommaParts(t) {
     return e;
 }
 
-function expand(t) {
+function W(t) {
     if (!t) {
         return [];
     }
     if (t.slice(0, 2) === "{}") {
         t = "\\{\\}" + t.slice(2);
     }
-    return expand_(escapeBraces(t), true).map(unescapeBraces);
+    return U(D(t), true).map(N);
 }
 
-function embrace(t) {
+function I(t) {
     return "{" + t + "}";
 }
 
-function isPadded(t) {
+function _(t) {
     return /^-?0\d/.test(t);
 }
 
-function lte(t, e) {
+function j(t, e) {
     return t <= e;
 }
 
-function gte(t, e) {
+function $(t, e) {
     return t >= e;
 }
 
-function expand_(t, e) {
+function U(t, e) {
     const s = [];
-    const i = balanced("{", "}", t);
+    const i = m("{", "}", t);
     if (!i) return [ t ];
     const n = i.pre;
-    const r = i.post.length ? expand_(i.post, false) : [ "" ];
+    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];
@@ -174,8 +174,8 @@ function expand_(t, e) {
         const l = i.body.indexOf(",") >= 0;
         if (!a && !l) {
             if (i.post.match(/,(?!,).*\}/)) {
-                t = i.pre + "{" + i.body + b + i.post;
-                return expand_(t);
+                t = i.pre + "{" + i.body + k + i.post;
+                return U(t);
             }
             return [ t ];
         }
@@ -183,9 +183,9 @@ function expand_(t, e) {
         if (a) {
             c = i.body.split(/\.\./);
         } else {
-            c = parseCommaParts(i.body);
+            c = B(i.body);
             if (c.length === 1 && c[0] !== undefined) {
-                c = expand_(c[0], false).map(embrace);
+                c = U(c[0], false).map(I);
                 if (c.length === 1) {
                     return r.map((t => i.pre + c[0] + t));
                 }
@@ -193,17 +193,17 @@ function expand_(t, e) {
         }
         let f;
         if (a && c[0] !== undefined && c[1] !== undefined) {
-            const t = numeric(c[0]);
-            const e = numeric(c[1]);
+            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(numeric(c[2])) : 1;
-            let n = lte;
+            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 = gte;
+                n = $;
             }
-            const o = c.some(isPadded);
+            const o = c.some(_);
             f = [];
             for (let r = t; n(r, e); r += i) {
                 let t;
@@ -231,7 +231,7 @@ function expand_(t, e) {
         } else {
             f = [];
             for (let t = 0; t < c.length; t++) {
-                f.push.apply(f, expand_(c[t], false));
+                f.push.apply(f, U(c[t], false));
             }
         }
         for (let t = 0; t < f.length; t++) {
@@ -246,18 +246,18 @@ function expand_(t, e) {
     return s;
 }
 
-const R = 1024 * 64;
+const G = 1024 * 64;
 
-const assertValidPattern = t => {
+const H = t => {
     if (typeof t !== "string") {
         throw new TypeError("invalid pattern");
     }
-    if (t.length > R) {
+    if (t.length > G) {
         throw new TypeError("pattern is too long");
     }
 };
 
-const O = {
+const Z = {
     "[:alnum:]": [ "\\p{L}\\p{Nl}\\p{Nd}", true ],
     "[:alpha:]": [ "\\p{L}\\p{Nl}", true ],
     "[:ascii:]": [ "\\x" + "00-\\x" + "7f", false ],
@@ -274,13 +274,13 @@ const O = {
     "[:xdigit:]": [ "A-Fa-f0-9", false ]
 };
 
-const braceEscape = t => t.replace(/[[\]\\-]/g, "\\$&");
+const q = t => t.replace(/[[\]\\-]/g, "\\$&");
 
-const regexpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const V = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const rangesToString = t => t.join("");
+const J = t => t.join("");
 
-const parseClass = (t, e) => {
+const K = (t, e) => {
     const s = e;
     if (t.charAt(s) !== "[") {
         throw new Error("not in a brace expression");
@@ -314,7 +314,7 @@ const parseClass = (t, e) => {
             }
         }
         if (e === "[" && !a) {
-            for (const [e, [o, a, l]] of Object.entries(O)) {
+            for (const [e, [o, a, l]] of Object.entries(Z)) {
                 if (t.startsWith(e, r)) {
                     if (f) {
                         return [ "$.", false, t.length - s, true ];
@@ -329,16 +329,16 @@ const parseClass = (t, e) => {
         a = false;
         if (f) {
             if (e > f) {
-                i.push(braceEscape(f) + "-" + braceEscape(e));
+                i.push(q(f) + "-" + q(e));
             } else if (e === f) {
-                i.push(braceEscape(e));
+                i.push(q(e));
             }
             f = "";
             r++;
             continue;
         }
         if (t.startsWith("-]", r + 1)) {
-            i.push(braceEscape(e + "-"));
+            i.push(q(e + "-"));
             r += 2;
             continue;
         }
@@ -347,7 +347,7 @@ const parseClass = (t, e) => {
             r += 2;
             continue;
         }
-        i.push(braceEscape(e));
+        i.push(q(e));
         r++;
     }
     if (c < r) {
@@ -358,42 +358,42 @@ const parseClass = (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 [ regexpEscape(t), false, c - s, false ];
+        return [ V(t), false, c - s, false ];
     }
-    const u = "[" + (l ? "^" : "") + rangesToString(i) + "]";
-    const d = "[" + (l ? "" : "^") + rangesToString(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 unescape = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = true} = {}) => {
+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 z = new Set([ "!", "?", "+", "*", "@" ]);
+const X = new Set([ "!", "?", "+", "*", "@" ]);
 
-const isExtglobType = t => z.has(t);
+const Q = t => X.has(t);
 
-const D = "(?!(?:^|/)\\.\\.?(?:$|/))";
+const tt = "(?!(?:^|/)\\.\\.?(?:$|/))";
 
-const B = "(?!\\.)";
+const et = "(?!\\.)";
 
-const N = new Set([ "[", "." ]);
+const st = new Set([ "[", "." ]);
 
-const I = new Set([ "..", "." ]);
+const it = new Set([ "..", "." ]);
 
-const W = new Set("().*{}+?[]^$\\!");
+const nt = new Set("().*{}+?[]^$\\!");
 
-const regExpEscape$1 = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const rt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
-const _ = "[^/]";
+const ot = "[^/]";
 
-const j = _ + "*?";
+const ht = ot + "*?";
 
-const $ = _ + "+?";
+const at = ot + "+?";
 
 class AST {
     type;
@@ -539,7 +539,7 @@ class AST {
                     l += s;
                     continue;
                 }
-                if (!i.noext && isExtglobType(s) && t.charAt(a) === "(") {
+                if (!i.noext && Q(s) && t.charAt(a) === "(") {
                     e.push(l);
                     l = "";
                     const n = new AST(s, e);
@@ -580,7 +580,7 @@ class AST {
                 f += s;
                 continue;
             }
-            if (isExtglobType(s) && t.charAt(a) === "(") {
+            if (Q(s) && t.charAt(a) === "(") {
                 l.push(f);
                 f = "";
                 const e = new AST(s, l);
@@ -647,12 +647,12 @@ class AST {
             let n = "";
             if (this.isStart()) {
                 if (typeof this.#i[0] === "string") {
-                    const s = this.#i.length === 1 && I.has(this.#i[0]);
+                    const s = this.#i.length === 1 && it.has(this.#i[0]);
                     if (!s) {
-                        const s = N;
+                        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 ? D : o ? B : "";
+                        n = r ? tt : o ? et : "";
                     }
                 }
             }
@@ -661,7 +661,7 @@ class AST {
                 r = "(?:$|\\/)";
             }
             const o = n + i + r;
-            return [ o, unescape(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 === "!" ? "(?:(?!(?:" : "(?:";
@@ -671,9 +671,9 @@ class AST {
             this.#i = [ t ];
             this.type = null;
             this.#e = undefined;
-            return [ t, unescape(this.toString()), false, false ];
+            return [ t, Y(this.toString()), false, false ];
         }
-        let r = !s || t || e || !B ? "" : this.#p(true);
+        let r = !s || t || e || !et ? "" : this.#p(true);
         if (r === n) {
             r = "";
         }
@@ -682,12 +682,12 @@ class AST {
         }
         let o = "";
         if (this.type === "!" && this.#c) {
-            o = (this.isStart() && !e ? B : "") + $;
+            o = (this.isStart() && !e ? et : "") + at;
         } else {
-            const s = this.type === "!" ? "))" + (this.isStart() && !e && !t ? B : "") + j + ")" : 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, unescape(n), this.#e = !!this.#e, this.#s ];
+        return [ o, Y(n), this.#e = !!this.#e, this.#s ];
     }
     #p(t) {
         return this.#i.map((e => {
@@ -707,7 +707,7 @@ class AST {
             const h = t.charAt(o);
             if (i) {
                 i = false;
-                n += (W.has(h) ? "\\" : "") + h;
+                n += (nt.has(h) ? "\\" : "") + h;
                 continue;
             }
             if (h === "\\") {
@@ -719,7 +719,7 @@ class AST {
                 continue;
             }
             if (h === "[") {
-                const [s, i, h, a] = parseClass(t, o);
+                const [s, i, h, a] = K(t, o);
                 if (h) {
                     n += s;
                     r = r || i;
@@ -729,107 +729,107 @@ class AST {
                 }
             }
             if (h === "*") {
-                n += s && t === "*" ? $ : j;
+                n += s && t === "*" ? at : ht;
                 e = true;
                 continue;
             }
             if (h === "?") {
-                n += _;
+                n += ot;
                 e = true;
                 continue;
             }
-            n += regExpEscape$1(h);
+            n += rt(h);
         }
-        return [ n, unescape(t), !!e, r ];
+        return [ n, Y(t), !!e, r ];
     }
 }
 
-const escape = (t, {windowsPathsNoEscape: e = false, magicalBraces: s = false} = {}) => {
+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 minimatch = (t, e, s = {}) => {
-    assertValidPattern(e);
+const ct = (t, e, s = {}) => {
+    H(e);
     if (!s.nocomment && e.charAt(0) === "#") {
         return false;
     }
     return new Minimatch(e, s).match(t);
 };
 
-const G = /^\*+([^+@!?\*\[\(]*)$/;
+const ft = /^\*+([^+@!?\*\[\(]*)$/;
 
-const starDotExtTest = t => e => !e.startsWith(".") && e.endsWith(t);
+const ut = t => e => !e.startsWith(".") && e.endsWith(t);
 
-const starDotExtTestDot = t => e => e.endsWith(t);
+const dt = t => e => e.endsWith(t);
 
-const starDotExtTestNocase = t => {
+const pt = t => {
     t = t.toLowerCase();
     return e => !e.startsWith(".") && e.toLowerCase().endsWith(t);
 };
 
-const starDotExtTestNocaseDot = t => {
+const gt = t => {
     t = t.toLowerCase();
     return e => e.toLowerCase().endsWith(t);
 };
 
-const U = /^\*+\.\*+$/;
+const mt = /^\*+\.\*+$/;
 
-const starDotStarTest = t => !t.startsWith(".") && t.includes(".");
+const wt = t => !t.startsWith(".") && t.includes(".");
 
-const starDotStarTestDot = t => t !== "." && t !== ".." && t.includes(".");
+const yt = t => t !== "." && t !== ".." && t.includes(".");
 
-const H = /^\.\*+$/;
+const bt = /^\.\*+$/;
 
-const dotStarTest = t => t !== "." && t !== ".." && t.startsWith(".");
+const St = t => t !== "." && t !== ".." && t.startsWith(".");
 
-const Z = /^\*+$/;
+const kt = /^\*+$/;
 
-const starTest = t => t.length !== 0 && !t.startsWith(".");
+const xt = t => t.length !== 0 && !t.startsWith(".");
 
-const starTestDot = t => t.length !== 0 && t !== "." && t !== "..";
+const vt = t => t.length !== 0 && t !== "." && t !== "..";
 
-const q = /^\?+([^+@!?\*\[\(]*)?$/;
+const Et = /^\?+([^+@!?\*\[\(]*)?$/;
 
-const qmarksTestNocase = ([t, e = ""]) => {
-    const s = qmarksTestNoExt([ 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 qmarksTestNocaseDot = ([t, e = ""]) => {
-    const s = qmarksTestNoExtDot([ 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 qmarksTestDot = ([t, e = ""]) => {
-    const s = qmarksTestNoExtDot([ t ]);
+const At = ([t, e = ""]) => {
+    const s = Pt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const qmarksTest = ([t, e = ""]) => {
-    const s = qmarksTestNoExt([ t ]);
+const Lt = ([t, e = ""]) => {
+    const s = Mt([ t ]);
     return !e ? s : t => s(t) && t.endsWith(e);
 };
 
-const qmarksTestNoExt = ([t]) => {
+const Mt = ([t]) => {
     const e = t.length;
     return t => t.length === e && !t.startsWith(".");
 };
 
-const qmarksTestNoExtDot = ([t]) => {
+const Pt = ([t]) => {
     const e = t.length;
     return t => t.length === e && t !== "." && t !== "..";
 };
 
-const V = 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 J = {
+const Rt = {
     win32: {
         sep: "\\"
     },
@@ -838,80 +838,80 @@ const J = {
     }
 };
 
-const K = V === "win32" ? J.win32.sep : J.posix.sep;
+const Ot = Ft === "win32" ? Rt.win32.sep : Rt.posix.sep;
 
-minimatch.sep = K;
+ct.sep = Ot;
 
-const Y = Symbol("globstar **");
+const zt = Symbol("globstar **");
 
-minimatch.GLOBSTAR = Y;
+ct.GLOBSTAR = zt;
 
-const X = "[^/]";
+const Dt = "[^/]";
 
-const Q = X + "*?";
+const Nt = Dt + "*?";
 
-const tt = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+const Bt = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
 
-const et = "(?:(?!(?:\\/|^)\\.).)*?";
+const Wt = "(?:(?!(?:\\/|^)\\.).)*?";
 
-const filter = (t, e = {}) => s => minimatch(s, t, e);
+const It = (t, e = {}) => s => ct(s, t, e);
 
-minimatch.filter = filter;
+ct.filter = It;
 
-const ext = (t, e = {}) => Object.assign({}, t, e);
+const _t = (t, e = {}) => Object.assign({}, t, e);
 
-const defaults = t => {
+const jt = t => {
     if (!t || typeof t !== "object" || !Object.keys(t).length) {
-        return minimatch;
+        return ct;
     }
-    const e = minimatch;
-    const m = (s, i, n = {}) => e(s, i, ext(t, n));
-    return Object.assign(m, {
+    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, ext(t, s));
+                super(e, _t(t, s));
             }
             static defaults(s) {
-                return e.defaults(ext(t, s)).Minimatch;
+                return e.defaults(_t(t, s)).Minimatch;
             }
         },
         AST: class AST extends e.AST {
             constructor(e, s, i = {}) {
-                super(e, s, ext(t, i));
+                super(e, s, _t(t, i));
             }
             static fromGlob(s, i = {}) {
-                return e.AST.fromGlob(s, ext(t, i));
+                return e.AST.fromGlob(s, _t(t, i));
             }
         },
-        unescape: (s, i = {}) => e.unescape(s, ext(t, i)),
-        escape: (s, i = {}) => e.escape(s, ext(t, i)),
-        filter: (s, i = {}) => e.filter(s, ext(t, i)),
-        defaults: s => e.defaults(ext(t, s)),
-        makeRe: (s, i = {}) => e.makeRe(s, ext(t, i)),
-        braceExpand: (s, i = {}) => e.braceExpand(s, ext(t, i)),
-        match: (s, i, n = {}) => e.match(s, i, ext(t, n)),
+        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: Y
+        GLOBSTAR: zt
     });
 };
 
-minimatch.defaults = defaults;
+ct.defaults = jt;
 
-const braceExpand = (t, e = {}) => {
-    assertValidPattern(t);
+const $t = (t, e = {}) => {
+    H(t);
     if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(t)) {
         return [ t ];
     }
-    return expand(t);
+    return W(t);
 };
 
-minimatch.braceExpand = braceExpand;
+ct.braceExpand = $t;
 
-const makeRe = (t, e = {}) => new Minimatch(t, e).makeRe();
+const Ut = (t, e = {}) => new Minimatch(t, e).makeRe();
 
-minimatch.makeRe = makeRe;
+ct.makeRe = Ut;
 
-const match = (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) {
@@ -920,11 +920,11 @@ const match = (t, e, s = {}) => {
     return t;
 };
 
-minimatch.match = match;
+ct.match = Gt;
 
-const st = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const Ht = /[?*]|[+@!]\(.*?\)|\[|\]/;
 
-const regExpEscape = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+const Zt = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 
 class Minimatch {
     options;
@@ -945,11 +945,11 @@ class Minimatch {
     windowsNoMagicRoot;
     regexp;
     constructor(t, e = {}) {
-        assertValidPattern(t);
+        H(t);
         e = e || {};
         this.options = e;
         this.pattern = t;
-        this.platform = e.platform || V;
+        this.platform = e.platform || Ft;
         this.isWindows = this.platform === "win32";
         this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === false;
         if (this.windowsPathsNoEscape) {
@@ -1003,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] === "?" || !st.test(t[2])) && !st.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))) ];
@@ -1270,7 +1270,7 @@ class Minimatch {
             if (l === false) {
                 return false;
             }
-            if (l === Y) {
+            if (l === zt) {
                 this.debug("GLOBSTAR", [ e, l, c ]);
                 var f = r;
                 var u = o + 1;
@@ -1325,25 +1325,25 @@ class Minimatch {
         }
     }
     braceExpand() {
-        return braceExpand(this.pattern, this.options);
+        return $t(this.pattern, this.options);
     }
     parse(t) {
-        assertValidPattern(t);
+        H(t);
         const e = this.options;
-        if (t === "**") return Y;
+        if (t === "**") return zt;
         if (t === "") return "";
         let s;
         let i = null;
-        if (s = t.match(Z)) {
-            i = e.dot ? starTestDot : starTest;
-        } else if (s = t.match(G)) {
-            i = (e.nocase ? e.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : e.dot ? starDotExtTestDot : starDotExtTest)(s[1]);
-        } else if (s = t.match(q)) {
-            i = (e.nocase ? e.dot ? qmarksTestNocaseDot : qmarksTestNocase : e.dot ? qmarksTestDot : qmarksTest)(s);
-        } else if (s = t.match(U)) {
-            i = e.dot ? starDotStarTestDot : starDotStarTest;
-        } else if (s = t.match(H)) {
-            i = dotStarTest;
+        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") {
@@ -1361,35 +1361,35 @@ class Minimatch {
             return this.regexp;
         }
         const e = this.options;
-        const s = e.noglobstar ? Q : e.dot ? tt : et;
+        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" ? regExpEscape(t) : t === Y ? Y : 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 !== Y || r === Y) {
+                if (t !== zt || r === zt) {
                     return;
                 }
                 if (r === undefined) {
-                    if (n !== undefined && n !== Y) {
+                    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 !== Y) {
+                } else if (n !== zt) {
                     e[i - 1] = r + "(?:\\/|\\/" + s + "\\/)" + n;
-                    e[i + 1] = Y;
+                    e[i + 1] = zt;
                 }
             }));
-            const n = e.filter((t => t !== Y));
+            const n = e.filter((t => t !== zt));
             if (this.partial && n.length >= 1) {
                 const t = [];
                 for (let e = 1; e <= n.length; e++) {
@@ -1466,34 +1466,34 @@ class Minimatch {
         return this.negate;
     }
     static defaults(t) {
-        return minimatch.defaults(t).Minimatch;
+        return ct.defaults(t).Minimatch;
     }
 }
 
-minimatch.AST = AST;
+ct.AST = AST;
 
-minimatch.Minimatch = Minimatch;
+ct.Minimatch = Minimatch;
 
-minimatch.escape = escape;
+ct.escape = lt;
 
-minimatch.unescape = unescape;
+ct.unescape = Y;
 
-const it = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const qt = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 
-const nt = new Set;
+const Vt = new Set;
 
-const rt = typeof process === "object" && !!process ? process : {};
+const Jt = typeof process === "object" && !!process ? process : {};
 
-const emitWarning = (t, e, s, i) => {
-    typeof rt.emitWarning === "function" ? rt.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 ot = globalThis.AbortController;
+let Yt = globalThis.AbortController;
 
-let ht = globalThis.AbortSignal;
+let Xt = globalThis.AbortSignal;
 
-if (typeof ot === "undefined") {
-    ht = class AbortSignal {
+if (typeof Yt === "undefined") {
+    Xt = class AbortSignal {
         onabort;
         _onabort=[];
         reason;
@@ -1502,11 +1502,11 @@ if (typeof ot === "undefined") {
             this._onabort.push(e);
         }
     };
-    ot = class AbortController {
+    Yt = class AbortController {
         constructor() {
-            warnACPolyfill();
+            e();
         }
-        signal=new ht;
+        signal=new Xt;
         abort(t) {
             if (this.signal.aborted) return;
             this.signal.reason = t;
@@ -1517,21 +1517,21 @@ if (typeof ot === "undefined") {
             this.signal.onabort?.(t);
         }
     };
-    let t = rt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
-    const warnACPolyfill = () => {
+    let t = Jt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+    const e = () => {
         if (!t) return;
         t = false;
-        emitWarning("AbortController is not defined. If using lru-cache in " + "node 14, load an AbortController polyfill from the " + "`node-abort-controller` package. A minimal polyfill is " + "provided for use by LRUCache.fetch(), but it should not be " + "relied upon in other contexts (eg, passing it to other APIs that " + "use AbortController/AbortSignal might have undesirable effects). " + "You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+        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 shouldWarn = t => !nt.has(t);
+const Qt = t => !Vt.has(t);
 
-const at = Symbol("type");
+const te = Symbol("type");
 
-const isPosInt = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
+const ee = t => t && t === Math.floor(t) && t > 0 && isFinite(t);
 
-const getUintArray = t => !isPosInt(t) ? null : t <= Math.pow(2, 8) ? Uint8Array : t <= Math.pow(2, 16) ? Uint16Array : t <= Math.pow(2, 32) ? Uint32Array : t <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+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) {
@@ -1545,7 +1545,7 @@ class Stack {
     length;
     static #g=false;
     static create(t) {
-        const e = getUintArray(t);
+        const e = se(t);
         if (!e) return [];
         Stack.#g = true;
         const s = new Stack(t, e);
@@ -1569,8 +1569,8 @@ class Stack {
 
 class LRUCache {
     #m;
-    #y;
     #w;
+    #y;
     #b;
     #S;
     #k;
@@ -1603,15 +1603,15 @@ class LRUCache {
     #O;
     #z;
     #D;
-    #B;
     #N;
-    #I;
+    #B;
     #W;
+    #I;
     #_;
     static unsafeExposeInternals(t) {
         return {
             starts: t.#D,
-            ttls: t.#B,
+            ttls: t.#N,
             sizes: t.#z,
             keyMap: t.#C,
             keyList: t.#T,
@@ -1627,8 +1627,8 @@ class LRUCache {
             free: t.#R,
             isBackgroundFetch: e => t.#j(e),
             backgroundFetch: (e, s, i, n) => t.#$(e, s, i, n),
-            moveToTail: e => t.#G(e),
-            indexes: e => t.#U(e),
+            moveToTail: e => t.#U(e),
+            indexes: e => t.#G(e),
             rindexes: e => t.#H(e),
             isStale: e => t.#Z(e)
         };
@@ -1637,7 +1637,7 @@ class LRUCache {
         return this.#m;
     }
     get maxSize() {
-        return this.#y;
+        return this.#w;
     }
     get calculatedSize() {
         return this.#E;
@@ -1652,7 +1652,7 @@ class LRUCache {
         return this.#x;
     }
     get dispose() {
-        return this.#w;
+        return this.#y;
     }
     get onInsert() {
         return this.#b;
@@ -1661,20 +1661,20 @@ class LRUCache {
         return this.#S;
     }
     constructor(t) {
-        const {max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: n, updateAgeOnGet: r, updateAgeOnHas: o, allowStale: h, dispose: a, onInsert: l, disposeAfter: c, noDisposeOnSet: f, noUpdateTTL: u, maxSize: d = 0, maxEntrySize: p = 0, sizeCalculation: g, fetchMethod: y, memoMethod: w, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: S, allowStaleOnFetchRejection: k, allowStaleOnFetchAbort: x, ignoreFetchAbort: v} = t;
-        if (e !== 0 && !isPosInt(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 E = e ? getUintArray(e) : Array;
-        if (!E) {
+        const v = e ? se(e) : Array;
+        if (!v) {
             throw new Error("invalid max value: " + e);
         }
         this.#m = e;
-        this.#y = d;
-        this.maxEntrySize = p || this.#y;
+        this.#w = d;
+        this.maxEntrySize = p || this.#w;
         this.sizeCalculation = g;
         if (this.sizeCalculation) {
-            if (!this.#y && !this.maxEntrySize) {
+            if (!this.#w && !this.maxEntrySize) {
                 throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
             }
             if (typeof this.sizeCalculation !== "function") {
@@ -1685,23 +1685,23 @@ class LRUCache {
             throw new TypeError("memoMethod must be a function if defined");
         }
         this.#x = w;
-        if (y !== undefined && typeof y !== "function") {
+        if (m !== undefined && typeof m !== "function") {
             throw new TypeError("fetchMethod must be a function if specified");
         }
-        this.#k = y;
-        this.#I = !!y;
+        this.#k = m;
+        this.#W = !!m;
         this.#C = new Map;
         this.#T = new Array(e).fill(undefined);
         this.#A = new Array(e).fill(undefined);
-        this.#L = new E(e);
-        this.#M = new E(e);
+        this.#L = new v(e);
+        this.#M = new v(e);
         this.#P = 0;
         this.#F = 0;
         this.#R = Stack.create(e);
         this.#v = 0;
         this.#E = 0;
         if (typeof a === "function") {
-            this.#w = a;
+            this.#y = a;
         }
         if (typeof l === "function") {
             this.#b = l;
@@ -1713,48 +1713,48 @@ class LRUCache {
             this.#S = undefined;
             this.#O = undefined;
         }
-        this.#N = !!this.#w;
+        this.#B = !!this.#y;
         this.#_ = !!this.#b;
-        this.#W = !!this.#S;
+        this.#I = !!this.#S;
         this.noDisposeOnSet = !!f;
         this.noUpdateTTL = !!u;
-        this.noDeleteOnFetchRejection = !!b;
-        this.allowStaleOnFetchRejection = !!k;
-        this.allowStaleOnFetchAbort = !!x;
-        this.ignoreFetchAbort = !!v;
+        this.noDeleteOnFetchRejection = !!y;
+        this.allowStaleOnFetchRejection = !!S;
+        this.allowStaleOnFetchAbort = !!k;
+        this.ignoreFetchAbort = !!x;
         if (this.maxEntrySize !== 0) {
-            if (this.#y !== 0) {
-                if (!isPosInt(this.#y)) {
+            if (this.#w !== 0) {
+                if (!ee(this.#w)) {
                     throw new TypeError("maxSize must be a positive integer if specified");
                 }
             }
-            if (!isPosInt(this.maxEntrySize)) {
+            if (!ee(this.maxEntrySize)) {
                 throw new TypeError("maxEntrySize must be a positive integer if specified");
             }
             this.#q();
         }
         this.allowStale = !!h;
-        this.noDeleteOnStaleGet = !!S;
+        this.noDeleteOnStaleGet = !!b;
         this.updateAgeOnGet = !!r;
         this.updateAgeOnHas = !!o;
-        this.ttlResolution = isPosInt(i) || i === 0 ? i : 1;
+        this.ttlResolution = ee(i) || i === 0 ? i : 1;
         this.ttlAutopurge = !!n;
         this.ttl = s || 0;
         if (this.ttl) {
-            if (!isPosInt(this.ttl)) {
+            if (!ee(this.ttl)) {
                 throw new TypeError("ttl must be a positive integer if specified");
             }
             this.#V();
         }
-        if (this.#m === 0 && this.ttl === 0 && this.#y === 0) {
+        if (this.#m === 0 && this.ttl === 0 && this.#w === 0) {
             throw new TypeError("At least one of max, maxSize, or ttl is required");
         }
-        if (!this.ttlAutopurge && !this.#m && !this.#y) {
+        if (!this.ttlAutopurge && !this.#m && !this.#w) {
             const t = "LRU_CACHE_UNBOUNDED";
-            if (shouldWarn(t)) {
-                nt.add(t);
+            if (Qt(t)) {
+                Vt.add(t);
                 const e = "TTL caching without ttlAutopurge, max, or maxSize can " + "result in unbounded memory consumption.";
-                emitWarning(e, "UnboundedCacheWarning", t, LRUCache);
+                Kt(e, "UnboundedCacheWarning", t, LRUCache);
             }
         }
     }
@@ -1764,9 +1764,9 @@ class LRUCache {
     #V() {
         const t = new ZeroArray(this.#m);
         const e = new ZeroArray(this.#m);
-        this.#B = t;
+        this.#N = t;
         this.#D = e;
-        this.#J = (s, i, n = it.now()) => {
+        this.#J = (s, i, n = qt.now()) => {
             e[s] = i !== 0 ? n : 0;
             t[s] = i;
             if (i !== 0 && this.ttlAutopurge) {
@@ -1781,23 +1781,23 @@ class LRUCache {
             }
         };
         this.#Y = s => {
-            e[s] = t[s] !== 0 ? it.now() : 0;
+            e[s] = t[s] !== 0 ? qt.now() : 0;
         };
-        this.#X = (i, n) => {
-            if (t[n]) {
-                const r = t[n];
-                const o = e[n];
-                if (!r || !o) return;
-                i.ttl = r;
-                i.start = o;
-                i.now = s || getNow();
-                const h = i.now - o;
-                i.remainingTTL = r - h;
+        this.#X = (n, r) => {
+            if (t[r]) {
+                const o = t[r];
+                const h = e[r];
+                if (!o || !h) return;
+                n.ttl = o;
+                n.start = h;
+                n.now = s || i();
+                const a = n.now - h;
+                n.remainingTTL = o - a;
             }
         };
         let s = 0;
-        const getNow = () => {
-            const t = it.now();
+        const i = () => {
+            const t = qt.now();
             if (this.ttlResolution > 0) {
                 s = t;
                 const e = setTimeout((() => s = 0), this.ttlResolution);
@@ -1807,23 +1807,23 @@ class LRUCache {
             }
             return t;
         };
-        this.getRemainingTTL = i => {
-            const n = this.#C.get(i);
-            if (n === undefined) {
+        this.getRemainingTTL = n => {
+            const r = this.#C.get(n);
+            if (r === undefined) {
                 return 0;
             }
-            const r = t[n];
-            const o = e[n];
-            if (!r || !o) {
+            const o = t[r];
+            const h = e[r];
+            if (!o || !h) {
                 return Infinity;
             }
-            const h = (s || getNow()) - o;
-            return r - h;
+            const a = (s || i()) - h;
+            return o - a;
         };
-        this.#Z = i => {
-            const n = e[i];
-            const r = t[i];
-            return !!r && !!n && (s || getNow()) - n > r;
+        this.#Z = n => {
+            const r = e[n];
+            const o = t[n];
+            return !!o && !!r && (s || i()) - r > o;
         };
     }
     #Y=() => {};
@@ -1842,13 +1842,13 @@ class LRUCache {
             if (this.#j(e)) {
                 return 0;
             }
-            if (!isPosInt(s)) {
+            if (!ee(s)) {
                 if (i) {
                     if (typeof i !== "function") {
                         throw new TypeError("sizeCalculation must be a function");
                     }
                     s = i(e, t);
-                    if (!isPosInt(s)) {
+                    if (!ee(s)) {
                         throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                     }
                 } else {
@@ -1859,8 +1859,8 @@ class LRUCache {
         };
         this.#et = (e, s, i) => {
             t[e] = s;
-            if (this.#y) {
-                const s = this.#y - t[e];
+            if (this.#w) {
+                const s = this.#w - t[e];
                 while (this.#E > s) {
                     this.#st(true);
                 }
@@ -1880,7 +1880,7 @@ class LRUCache {
         }
         return 0;
     };
-    * #U({allowStale: t = this.allowStale} = {}) {
+    * #G({allowStale: t = this.allowStale} = {}) {
         if (this.#v) {
             for (let e = this.#F; true; ) {
                 if (!this.#it(e)) {
@@ -1918,7 +1918,7 @@ class LRUCache {
         return t !== undefined && this.#C.get(this.#T[t]) === t;
     }
     * entries() {
-        for (const t of this.#U()) {
+        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] ];
             }
@@ -1932,7 +1932,7 @@ class LRUCache {
         }
     }
     * keys() {
-        for (const t of this.#U()) {
+        for (const t of this.#G()) {
             const e = this.#T[t];
             if (e !== undefined && !this.#j(this.#A[t])) {
                 yield e;
@@ -1948,7 +1948,7 @@ class LRUCache {
         }
     }
     * values() {
-        for (const t of this.#U()) {
+        for (const t of this.#G()) {
             const e = this.#A[t];
             if (e !== undefined && !this.#j(this.#A[t])) {
                 yield this.#A[t];
@@ -1968,7 +1968,7 @@ class LRUCache {
     }
     [Symbol.toStringTag]="LRUCache";
     find(t, e = {}) {
-        for (const s of this.#U()) {
+        for (const s of this.#G()) {
             const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
@@ -1978,7 +1978,7 @@ class LRUCache {
         }
     }
     forEach(t, e = this) {
-        for (const s of this.#U()) {
+        for (const s of this.#G()) {
             const i = this.#A[s];
             const n = this.#j(i) ? i.__staleWhileFetching : i;
             if (n === undefined) continue;
@@ -2014,11 +2014,11 @@ class LRUCache {
         const n = {
             value: i
         };
-        if (this.#B && this.#D) {
-            const t = this.#B[e];
+        if (this.#N && this.#D) {
+            const t = this.#N[e];
             const s = this.#D[e];
             if (t && s) {
-                const e = t - (it.now() - s);
+                const e = t - (qt.now() - s);
                 n.ttl = e;
                 n.start = Date.now();
             }
@@ -2030,7 +2030,7 @@ class LRUCache {
     }
     dump() {
         const t = [];
-        for (const e of this.#U({
+        for (const e of this.#G({
             allowStale: true
         })) {
             const s = this.#T[e];
@@ -2040,9 +2040,9 @@ class LRUCache {
             const r = {
                 value: n
             };
-            if (this.#B && this.#D) {
-                r.ttl = this.#B[e];
-                const t = it.now() - this.#D[e];
+            if (this.#N && this.#D) {
+                r.ttl = this.#N[e];
+                const t = qt.now() - this.#D[e];
                 r.start = Math.floor(Date.now() - t);
             }
             if (this.#z) {
@@ -2057,7 +2057,7 @@ class LRUCache {
         for (const [e, s] of t) {
             if (s.start) {
                 const t = Date.now() - s.start;
-                s.start = it.now() - t;
+                s.start = qt.now() - t;
             }
             this.set(e, s.value, s);
         }
@@ -2095,25 +2095,25 @@ class LRUCache {
                 this.#b?.(e, t, "add");
             }
         } else {
-            this.#G(c);
+            this.#U(c);
             const s = this.#A[c];
             if (e !== s) {
-                if (this.#I && this.#j(s)) {
+                if (this.#W && this.#j(s)) {
                     s.__abortController.abort(new Error("replaced"));
                     const {__staleWhileFetching: e} = s;
                     if (e !== undefined && !r) {
-                        if (this.#N) {
-                            this.#w?.(e, t, "set");
+                        if (this.#B) {
+                            this.#y?.(e, t, "set");
                         }
-                        if (this.#W) {
+                        if (this.#I) {
                             this.#O?.push([ e, t, "set" ]);
                         }
                     }
                 } else if (!r) {
-                    if (this.#N) {
-                        this.#w?.(s, t, "set");
+                    if (this.#B) {
+                        this.#y?.(s, t, "set");
                     }
-                    if (this.#W) {
+                    if (this.#I) {
                         this.#O?.push([ s, t, "set" ]);
                     }
                 }
@@ -2132,16 +2132,16 @@ class LRUCache {
                 this.onInsert?.(e, t, e === s ? "update" : "replace");
             }
         }
-        if (i !== 0 && !this.#B) {
+        if (i !== 0 && !this.#N) {
             this.#V();
         }
-        if (this.#B) {
+        if (this.#N) {
             if (!a) {
                 this.#J(c, i, n);
             }
             if (h) this.#X(h, c);
         }
-        if (!r && this.#W && this.#O) {
+        if (!r && this.#I && this.#O) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -2164,7 +2164,7 @@ class LRUCache {
                 }
             }
         } finally {
-            if (this.#W && this.#O) {
+            if (this.#I && this.#O) {
                 const t = this.#O;
                 let e;
                 while (e = t?.shift()) {
@@ -2177,13 +2177,13 @@ class LRUCache {
         const e = this.#P;
         const s = this.#T[e];
         const i = this.#A[e];
-        if (this.#I && this.#j(i)) {
+        if (this.#W && this.#j(i)) {
             i.__abortController.abort(new Error("evicted"));
-        } else if (this.#N || this.#W) {
-            if (this.#N) {
-                this.#w?.(i, s, "evict");
+        } else if (this.#B || this.#I) {
+            if (this.#B) {
+                this.#y?.(i, s, "evict");
             }
-            if (this.#W) {
+            if (this.#I) {
                 this.#O?.push([ i, s, "evict" ]);
             }
         }
@@ -2243,7 +2243,7 @@ class LRUCache {
         if (this.#j(n)) {
             return n;
         }
-        const r = new ot;
+        const r = new Yt;
         const {signal: o} = s;
         o?.addEventListener("abort", (() => r.abort(o.reason)), {
             signal: r.signal
@@ -2253,26 +2253,26 @@ class LRUCache {
             options: s,
             context: i
         };
-        const cb = (i, n = false) => {
+        const a = (i, n = false) => {
             const {aborted: o} = r.signal;
-            const l = s.ignoreFetchAbort && i !== undefined;
+            const a = s.ignoreFetchAbort && i !== undefined;
             if (s.status) {
                 if (o && !n) {
                     s.status.fetchAborted = true;
                     s.status.fetchError = r.signal.reason;
-                    if (l) s.status.fetchAbortIgnored = true;
+                    if (a) s.status.fetchAbortIgnored = true;
                 } else {
                     s.status.fetchResolved = true;
                 }
             }
-            if (o && !l && !n) {
-                return fetchFail(r.signal.reason);
+            if (o && !a && !n) {
+                return c(r.signal.reason);
             }
-            const c = a;
-            if (this.#A[e] === a) {
+            const l = u;
+            if (this.#A[e] === u) {
                 if (i === undefined) {
-                    if (c.__staleWhileFetching) {
-                        this.#A[e] = c.__staleWhileFetching;
+                    if (l.__staleWhileFetching) {
+                        this.#A[e] = l.__staleWhileFetching;
                     } else {
                         this.#K(t, "fetch");
                     }
@@ -2283,37 +2283,37 @@ class LRUCache {
             }
             return i;
         };
-        const eb = t => {
+        const l = t => {
             if (s.status) {
                 s.status.fetchRejected = true;
                 s.status.fetchError = t;
             }
-            return fetchFail(t);
+            return c(t);
         };
-        const fetchFail = i => {
+        const c = i => {
             const {aborted: n} = r.signal;
             const o = n && s.allowStaleOnFetchAbort;
             const h = o || s.allowStaleOnFetchRejection;
-            const l = h || s.noDeleteOnFetchRejection;
-            const c = a;
-            if (this.#A[e] === a) {
-                const s = !l || c.__staleWhileFetching === undefined;
+            const a = h || s.noDeleteOnFetchRejection;
+            const l = u;
+            if (this.#A[e] === u) {
+                const s = !a || l.__staleWhileFetching === undefined;
                 if (s) {
                     this.#K(t, "fetch");
                 } else if (!o) {
-                    this.#A[e] = c.__staleWhileFetching;
+                    this.#A[e] = l.__staleWhileFetching;
                 }
             }
             if (h) {
-                if (s.status && c.__staleWhileFetching !== undefined) {
+                if (s.status && l.__staleWhileFetching !== undefined) {
                     s.status.returnedStale = true;
                 }
-                return c.__staleWhileFetching;
-            } else if (c.__returned === c) {
+                return l.__staleWhileFetching;
+            } else if (l.__returned === l) {
                 throw i;
             }
         };
-        const pcall = (e, i) => {
+        const f = (e, i) => {
             const o = this.#k?.(t, n, h);
             if (o && o instanceof Promise) {
                 o.then((t => e(t === undefined ? undefined : t)), i);
@@ -2322,46 +2322,46 @@ class LRUCache {
                 if (!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) {
                     e(undefined);
                     if (s.allowStaleOnFetchAbort) {
-                        e = t => cb(t, true);
+                        e = t => a(t, true);
                     }
                 }
             }));
         };
         if (s.status) s.status.fetchDispatched = true;
-        const a = new Promise(pcall).then(cb, eb);
-        const l = Object.assign(a, {
+        const u = new Promise(f).then(a, l);
+        const d = Object.assign(u, {
             __abortController: r,
             __staleWhileFetching: n,
             __returned: undefined
         });
         if (e === undefined) {
-            this.set(t, l, {
+            this.set(t, d, {
                 ...h.options,
                 status: undefined
             });
             e = this.#C.get(t);
         } else {
-            this.#A[e] = l;
+            this.#A[e] = d;
         }
-        return l;
+        return d;
     }
     #j(t) {
-        if (!this.#I) return false;
+        if (!this.#W) return false;
         const e = t;
-        return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof ot;
+        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: y, signal: w} = e;
-        if (!this.#I) {
-            if (y) y.fetch = "get";
+        const {allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: n = this.noDeleteOnStaleGet, ttl: r = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: h = 0, sizeCalculation: a = this.sizeCalculation, noUpdateTTL: l = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: f = this.allowStaleOnFetchRejection, ignoreFetchAbort: u = this.ignoreFetchAbort, allowStaleOnFetchAbort: d = this.allowStaleOnFetchAbort, context: p, forceRefresh: g = false, status: m, signal: w} = e;
+        if (!this.#W) {
+            if (m) m.fetch = "get";
             return this.get(t, {
                 allowStale: s,
                 updateAgeOnGet: i,
                 noDeleteOnStaleGet: n,
-                status: y
+                status: m
             });
         }
-        const b = {
+        const y = {
             allowStale: s,
             updateAgeOnGet: i,
             noDeleteOnStaleGet: n,
@@ -2374,40 +2374,40 @@ class LRUCache {
             allowStaleOnFetchRejection: f,
             allowStaleOnFetchAbort: d,
             ignoreFetchAbort: u,
-            status: y,
+            status: m,
             signal: w
         };
-        let S = this.#C.get(t);
-        if (S === undefined) {
-            if (y) y.fetch = "miss";
-            const e = this.#$(t, S, b, p);
+        let b = this.#C.get(t);
+        if (b === undefined) {
+            if (m) m.fetch = "miss";
+            const e = this.#$(t, b, y, p);
             return e.__returned = e;
         } else {
-            const e = this.#A[S];
+            const e = this.#A[b];
             if (this.#j(e)) {
                 const t = s && e.__staleWhileFetching !== undefined;
-                if (y) {
-                    y.fetch = "inflight";
-                    if (t) y.returnedStale = true;
+                if (m) {
+                    m.fetch = "inflight";
+                    if (t) m.returnedStale = true;
                 }
                 return t ? e.__staleWhileFetching : e.__returned = e;
             }
-            const n = this.#Z(S);
+            const n = this.#Z(b);
             if (!g && !n) {
-                if (y) y.fetch = "hit";
-                this.#G(S);
+                if (m) m.fetch = "hit";
+                this.#U(b);
                 if (i) {
-                    this.#Y(S);
+                    this.#Y(b);
                 }
-                if (y) this.#X(y, S);
+                if (m) this.#X(m, b);
                 return e;
             }
-            const r = this.#$(t, S, b, p);
+            const r = this.#$(t, b, y, p);
             const o = r.__staleWhileFetching !== undefined;
             const h = o && s;
-            if (y) {
-                y.fetch = n ? "stale" : "refresh";
-                if (h && n) y.returnedStale = true;
+            if (m) {
+                m.fetch = n ? "stale" : "refresh";
+                if (h && n) m.returnedStale = true;
             }
             return h ? r.__staleWhileFetching : r.__returned = r;
         }
@@ -2458,7 +2458,7 @@ class LRUCache {
                 if (h) {
                     return e.__staleWhileFetching;
                 }
-                this.#G(o);
+                this.#U(o);
                 if (i) {
                     this.#Y(o);
                 }
@@ -2472,7 +2472,7 @@ class LRUCache {
         this.#M[e] = t;
         this.#L[t] = e;
     }
-    #G(t) {
+    #U(t) {
         if (t !== this.#F) {
             if (t === this.#P) {
                 this.#P = this.#L[t];
@@ -2499,11 +2499,11 @@ class LRUCache {
                     const s = this.#A[i];
                     if (this.#j(s)) {
                         s.__abortController.abort(new Error("deleted"));
-                    } else if (this.#N || this.#W) {
-                        if (this.#N) {
-                            this.#w?.(s, t, e);
+                    } else if (this.#B || this.#I) {
+                        if (this.#B) {
+                            this.#y?.(s, t, e);
                         }
-                        if (this.#W) {
+                        if (this.#I) {
                             this.#O?.push([ s, t, e ]);
                         }
                     }
@@ -2525,7 +2525,7 @@ class LRUCache {
                 }
             }
         }
-        if (this.#W && this.#O?.length) {
+        if (this.#I && this.#O?.length) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -2546,10 +2546,10 @@ class LRUCache {
                 s.__abortController.abort(new Error("deleted"));
             } else {
                 const i = this.#T[e];
-                if (this.#N) {
-                    this.#w?.(s, i, t);
+                if (this.#B) {
+                    this.#y?.(s, i, t);
                 }
-                if (this.#W) {
+                if (this.#I) {
                     this.#O?.push([ s, i, t ]);
                 }
             }
@@ -2557,8 +2557,8 @@ class LRUCache {
         this.#C.clear();
         this.#A.fill(undefined);
         this.#T.fill(undefined);
-        if (this.#B && this.#D) {
-            this.#B.fill(0);
+        if (this.#N && this.#D) {
+            this.#N.fill(0);
             this.#D.fill(0);
         }
         if (this.#z) {
@@ -2569,7 +2569,7 @@ class LRUCache {
         this.#R.length = 0;
         this.#E = 0;
         this.#v = 0;
-        if (this.#W && this.#O) {
+        if (this.#I && this.#O) {
             const t = this.#O;
             let e;
             while (e = t?.shift()) {
@@ -2579,88 +2579,88 @@ class LRUCache {
     }
 }
 
-const lt = typeof process === "object" && process ? process : {
+const ie = typeof process === "object" && process ? process : {
     stdout: null,
     stderr: null
 };
 
-const isStream = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof p || isReadable(t) || isWritable(t));
+const ne = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof p || re(t) || oe(t));
 
-const isReadable = t => !!t && typeof t === "object" && t instanceof d && typeof t.pipe === "function" && t.pipe !== p.Writable.prototype.pipe;
+const re = t => !!t && typeof t === "object" && t instanceof d && typeof t.pipe === "function" && t.pipe !== p.Writable.prototype.pipe;
 
-const isWritable = t => !!t && typeof t === "object" && t instanceof d && 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 ct = Symbol("EOF");
+const he = Symbol("EOF");
 
-const ft = Symbol("maybeEmitEnd");
+const ae = Symbol("maybeEmitEnd");
 
-const ut = Symbol("emittedEnd");
+const le = Symbol("emittedEnd");
 
-const dt = Symbol("emittingEnd");
+const ce = Symbol("emittingEnd");
 
-const pt = Symbol("emittedError");
+const fe = Symbol("emittedError");
 
-const gt = Symbol("closed");
+const ue = Symbol("closed");
 
-const mt = Symbol("read");
+const de = Symbol("read");
 
-const yt = Symbol("flush");
+const pe = Symbol("flush");
 
-const wt = Symbol("flushChunk");
+const ge = Symbol("flushChunk");
 
-const bt = Symbol("encoding");
+const me = Symbol("encoding");
 
-const St = Symbol("decoder");
+const we = Symbol("decoder");
 
-const kt = Symbol("flowing");
+const ye = Symbol("flowing");
 
-const xt = Symbol("paused");
+const be = Symbol("paused");
 
-const vt = Symbol("resume");
+const Se = Symbol("resume");
 
-const Et = Symbol("buffer");
+const ke = Symbol("buffer");
 
-const Ct = Symbol("pipes");
+const xe = Symbol("pipes");
 
-const Tt = Symbol("bufferLength");
+const ve = Symbol("bufferLength");
 
-const At = Symbol("bufferPush");
+const Ee = Symbol("bufferPush");
 
-const Lt = Symbol("bufferShift");
+const Ce = Symbol("bufferShift");
 
-const Mt = Symbol("objectMode");
+const Te = Symbol("objectMode");
 
-const Pt = Symbol("destroyed");
+const Ae = Symbol("destroyed");
 
-const Ft = Symbol("error");
+const Le = Symbol("error");
 
-const Rt = Symbol("emitData");
+const Me = Symbol("emitData");
 
-const Ot = Symbol("emitEnd");
+const Pe = Symbol("emitEnd");
 
-const zt = Symbol("emitEnd2");
+const Fe = Symbol("emitEnd2");
 
-const Dt = Symbol("async");
+const Re = Symbol("async");
 
-const Bt = Symbol("abort");
+const Oe = Symbol("abort");
 
-const Nt = Symbol("aborted");
+const ze = Symbol("aborted");
 
-const It = Symbol("signal");
+const De = Symbol("signal");
 
-const Wt = Symbol("dataListeners");
+const Ne = Symbol("dataListeners");
 
-const _t = Symbol("discarded");
+const Be = Symbol("discarded");
 
-const defer = t => Promise.resolve().then(t);
+const We = t => Promise.resolve().then(t);
 
-const nodefer = t => t();
+const Ie = t => t();
 
-const isEndish = t => t === "end" || t === "finish" || t === "prefinish";
+const _e = t => t === "end" || t === "finish" || t === "prefinish";
 
-const isArrayBufferLike = 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 isArrayBufferView = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
+const $e = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
 
 class Pipe {
     src;
@@ -2671,7 +2671,7 @@ class Pipe {
         this.src = t;
         this.dest = e;
         this.opts = s;
-        this.ondrain = () => t[vt]();
+        this.ondrain = () => t[Se]();
         this.dest.on("drain", this.ondrain);
     }
     unpipe() {
@@ -2696,30 +2696,30 @@ class PipeProxyErrors extends Pipe {
     }
 }
 
-const isObjectModeOptions = t => !!t.objectMode;
+const Ue = t => !!t.objectMode;
 
-const isEncodingOptions = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+const Ge = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
 
 class Minipass extends d {
-    [kt]=false;
-    [xt]=false;
-    [Ct]=[];
-    [Et]=[];
-    [Mt];
-    [bt];
-    [Dt];
-    [St];
-    [ct]=false;
-    [ut]=false;
-    [dt]=false;
-    [gt]=false;
-    [pt]=null;
-    [Tt]=0;
-    [Pt]=false;
-    [It];
-    [Nt]=false;
-    [Wt]=0;
-    [_t]=false;
+    [ye]=false;
+    [be]=false;
+    [xe]=[];
+    [ke]=[];
+    [Te];
+    [me];
+    [Re];
+    [we];
+    [he]=false;
+    [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) {
@@ -2728,43 +2728,43 @@ class Minipass extends d {
         if (e.objectMode && typeof e.encoding === "string") {
             throw new TypeError("Encoding and objectMode may not be used together");
         }
-        if (isObjectModeOptions(e)) {
-            this[Mt] = true;
-            this[bt] = null;
-        } else if (isEncodingOptions(e)) {
-            this[bt] = e.encoding;
-            this[Mt] = false;
+        if (Ue(e)) {
+            this[Te] = true;
+            this[me] = null;
+        } else if (Ge(e)) {
+            this[me] = e.encoding;
+            this[Te] = false;
         } else {
-            this[Mt] = false;
-            this[bt] = null;
+            this[Te] = false;
+            this[me] = null;
         }
-        this[Dt] = !!e.async;
-        this[St] = this[bt] ? new g(this[bt]) : 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[Et]
+                get: () => this[ke]
             });
         }
         if (e && e.debugExposePipes === true) {
             Object.defineProperty(this, "pipes", {
-                get: () => this[Ct]
+                get: () => this[xe]
             });
         }
         const {signal: s} = e;
         if (s) {
-            this[It] = s;
+            this[De] = s;
             if (s.aborted) {
-                this[Bt]();
+                this[Oe]();
             } else {
-                s.addEventListener("abort", (() => this[Bt]()));
+                s.addEventListener("abort", (() => this[Oe]()));
             }
         }
     }
     get bufferLength() {
-        return this[Tt];
+        return this[ve];
     }
     get encoding() {
-        return this[bt];
+        return this[me];
     }
     set encoding(t) {
         throw new Error("Encoding must be set at instantiation time");
@@ -2773,30 +2773,30 @@ class Minipass extends d {
         throw new Error("Encoding must be set at instantiation time");
     }
     get objectMode() {
-        return this[Mt];
+        return this[Te];
     }
     set objectMode(t) {
         throw new Error("objectMode must be set at instantiation time");
     }
     get ["async"]() {
-        return this[Dt];
+        return this[Re];
     }
     set ["async"](t) {
-        this[Dt] = this[Dt] || !!t;
+        this[Re] = this[Re] || !!t;
     }
-    [Bt]() {
-        this[Nt] = true;
-        this.emit("abort", this[It]?.reason);
-        this.destroy(this[It]?.reason);
+    [Oe]() {
+        this[ze] = true;
+        this.emit("abort", this[De]?.reason);
+        this.destroy(this[De]?.reason);
     }
     get aborted() {
-        return this[Nt];
+        return this[ze];
     }
     set aborted(t) {}
     write(t, e, s) {
-        if (this[Nt]) return false;
-        if (this[ct]) throw new Error("write after end");
-        if (this[Pt]) {
+        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"
             }));
@@ -2807,70 +2807,70 @@ class Minipass extends d {
             e = "utf8";
         }
         if (!e) e = "utf8";
-        const i = this[Dt] ? defer : nodefer;
-        if (!this[Mt] && !Buffer.isBuffer(t)) {
-            if (isArrayBufferView(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 (isArrayBufferLike(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[Mt]) {
-            if (this[kt] && this[Tt] !== 0) this[yt](true);
-            if (this[kt]) this.emit("data", t); else this[At](t);
-            if (this[Tt] !== 0) this.emit("readable");
+        if (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[kt];
+            return this[ye];
         }
         if (!t.length) {
-            if (this[Tt] !== 0) this.emit("readable");
+            if (this[ve] !== 0) this.emit("readable");
             if (s) i(s);
-            return this[kt];
+            return this[ye];
         }
-        if (typeof t === "string" && !(e === this[bt] && !this[St]?.lastNeed)) {
+        if (typeof t === "string" && !(e === this[me] && !this[we]?.lastNeed)) {
             t = Buffer.from(t, e);
         }
-        if (Buffer.isBuffer(t) && this[bt]) {
-            t = this[St].write(t);
+        if (Buffer.isBuffer(t) && this[me]) {
+            t = this[we].write(t);
         }
-        if (this[kt] && this[Tt] !== 0) this[yt](true);
-        if (this[kt]) this.emit("data", t); else this[At](t);
-        if (this[Tt] !== 0) this.emit("readable");
+        if (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[kt];
+        return this[ye];
     }
     read(t) {
-        if (this[Pt]) return null;
-        this[_t] = false;
-        if (this[Tt] === 0 || t === 0 || t && t > this[Tt]) {
-            this[ft]();
+        if (this[Ae]) return null;
+        this[Be] = false;
+        if (this[ve] === 0 || t === 0 || t && t > this[ve]) {
+            this[ae]();
             return null;
         }
-        if (this[Mt]) t = null;
-        if (this[Et].length > 1 && !this[Mt]) {
-            this[Et] = [ this[bt] ? this[Et].join("") : Buffer.concat(this[Et], this[Tt]) ];
+        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[mt](t || null, this[Et][0]);
-        this[ft]();
+        const e = this[de](t || null, this[ke][0]);
+        this[ae]();
         return e;
     }
-    [mt](t, e) {
-        if (this[Mt]) this[Lt](); else {
+    [de](t, e) {
+        if (this[Te]) this[Ce](); else {
             const s = e;
-            if (t === s.length || t === null) this[Lt](); else if (typeof s === "string") {
-                this[Et][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[Tt] -= t;
+                this[ve] -= t;
             } else {
-                this[Et][0] = s.subarray(t);
+                this[ke][0] = s.subarray(t);
                 e = s.subarray(0, t);
-                this[Tt] -= t;
+                this[ve] -= t;
             }
         }
         this.emit("data", e);
-        if (!this[Et].length && !this[ct]) this.emit("drain");
+        if (!this[ke].length && !this[he]) this.emit("drain");
         return e;
     }
     end(t, e, s) {
@@ -2884,78 +2884,78 @@ class Minipass extends d {
         }
         if (t !== undefined) this.write(t, e);
         if (s) this.once("end", s);
-        this[ct] = true;
+        this[he] = true;
         this.writable = false;
-        if (this[kt] || !this[xt]) this[ft]();
+        if (this[ye] || !this[be]) this[ae]();
         return this;
     }
-    [vt]() {
-        if (this[Pt]) return;
-        if (!this[Wt] && !this[Ct].length) {
-            this[_t] = true;
+    [Se]() {
+        if (this[Ae]) return;
+        if (!this[Ne] && !this[xe].length) {
+            this[Be] = true;
         }
-        this[xt] = false;
-        this[kt] = true;
+        this[be] = false;
+        this[ye] = true;
         this.emit("resume");
-        if (this[Et].length) this[yt](); else if (this[ct]) this[ft](); else this.emit("drain");
+        if (this[ke].length) this[pe](); else if (this[he]) this[ae](); else this.emit("drain");
     }
     resume() {
-        return this[vt]();
+        return this[Se]();
     }
     pause() {
-        this[kt] = false;
-        this[xt] = true;
-        this[_t] = false;
+        this[ye] = false;
+        this[be] = true;
+        this[Be] = false;
     }
     get destroyed() {
-        return this[Pt];
+        return this[Ae];
     }
     get flowing() {
-        return this[kt];
+        return this[ye];
     }
     get paused() {
-        return this[xt];
+        return this[be];
     }
-    [At](t) {
-        if (this[Mt]) this[Tt] += 1; else this[Tt] += t.length;
-        this[Et].push(t);
+    [Ee](t) {
+        if (this[Te]) this[ve] += 1; else this[ve] += t.length;
+        this[ke].push(t);
     }
-    [Lt]() {
-        if (this[Mt]) this[Tt] -= 1; else this[Tt] -= this[Et][0].length;
-        return this[Et].shift();
+    [Ce]() {
+        if (this[Te]) this[ve] -= 1; else this[ve] -= this[ke][0].length;
+        return this[ke].shift();
     }
-    [yt](t = false) {
-        do {} while (this[wt](this[Lt]()) && this[Et].length);
-        if (!t && !this[Et].length && !this[ct]) 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");
     }
-    [wt](t) {
+    [ge](t) {
         this.emit("data", t);
-        return this[kt];
+        return this[ye];
     }
     pipe(t, e) {
-        if (this[Pt]) return t;
-        this[_t] = false;
-        const s = this[ut];
+        if (this[Ae]) return t;
+        this[Be] = false;
+        const s = this[le];
         e = e || {};
-        if (t === lt.stdout || t === lt.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[Ct].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
-            if (this[Dt]) defer((() => this[vt]())); else this[vt]();
+            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[Ct].find((e => e.dest === t));
+        const e = this[xe].find((e => e.dest === t));
         if (e) {
-            if (this[Ct].length === 1) {
-                if (this[kt] && this[Wt] === 0) {
-                    this[kt] = false;
+            if (this[xe].length === 1) {
+                if (this[ye] && this[Ne] === 0) {
+                    this[ye] = false;
                 }
-                this[Ct] = [];
-            } else this[Ct].splice(this[Ct].indexOf(e), 1);
+                this[xe] = [];
+            } else this[xe].splice(this[xe].indexOf(e), 1);
             e.unpipe();
         }
     }
@@ -2965,19 +2965,19 @@ class Minipass extends d {
     on(t, e) {
         const s = super.on(t, e);
         if (t === "data") {
-            this[_t] = false;
-            this[Wt]++;
-            if (!this[Ct].length && !this[kt]) {
-                this[vt]();
+            this[Be] = false;
+            this[Ne]++;
+            if (!this[xe].length && !this[ye]) {
+                this[Se]();
             }
-        } else if (t === "readable" && this[Tt] !== 0) {
+        } else if (t === "readable" && this[ve] !== 0) {
             super.emit("readable");
-        } else if (isEndish(t) && this[ut]) {
+        } else if (_e(t) && this[le]) {
             super.emit(t);
             this.removeAllListeners(t);
-        } else if (t === "error" && this[pt]) {
+        } else if (t === "error" && this[fe]) {
             const t = e;
-            if (this[Dt]) defer((() => t.call(this, this[pt]))); else t.call(this, this[pt]);
+            if (this[Re]) We((() => t.call(this, this[fe]))); else t.call(this, this[fe]);
         }
         return s;
     }
@@ -2987,9 +2987,9 @@ class Minipass extends d {
     off(t, e) {
         const s = super.off(t, e);
         if (t === "data") {
-            this[Wt] = this.listeners("data").length;
-            if (this[Wt] === 0 && !this[_t] && !this[Ct].length) {
-                this[kt] = false;
+            this[Ne] = this.listeners("data").length;
+            if (this[Ne] === 0 && !this[Be] && !this[xe].length) {
+                this[ye] = false;
             }
         }
         return s;
@@ -2997,49 +2997,49 @@ class Minipass extends d {
     removeAllListeners(t) {
         const e = super.removeAllListeners(t);
         if (t === "data" || t === undefined) {
-            this[Wt] = 0;
-            if (!this[_t] && !this[Ct].length) {
-                this[kt] = false;
+            this[Ne] = 0;
+            if (!this[Be] && !this[xe].length) {
+                this[ye] = false;
             }
         }
         return e;
     }
     get emittedEnd() {
-        return this[ut];
+        return this[le];
     }
-    [ft]() {
-        if (!this[dt] && !this[ut] && !this[Pt] && this[Et].length === 0 && this[ct]) {
-            this[dt] = 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[gt]) this.emit("close");
-            this[dt] = false;
+            if (this[ue]) this.emit("close");
+            this[ce] = false;
         }
     }
     emit(t, ...e) {
         const s = e[0];
-        if (t !== "error" && t !== "close" && t !== Pt && this[Pt]) {
+        if (t !== "error" && t !== "close" && t !== Ae && this[Ae]) {
             return false;
         } else if (t === "data") {
-            return !this[Mt] && !s ? false : this[Dt] ? (defer((() => this[Rt](s))), true) : this[Rt](s);
+            return !this[Te] && !s ? false : this[Re] ? (We((() => this[Me](s))), true) : this[Me](s);
         } else if (t === "end") {
-            return this[Ot]();
+            return this[Pe]();
         } else if (t === "close") {
-            this[gt] = true;
-            if (!this[ut] && !this[Pt]) 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[pt] = s;
-            super.emit(Ft, s);
-            const t = !this[It] || this.listeners("error").length ? super.emit("error", s) : false;
-            this[ft]();
+            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[ft]();
+            this[ae]();
             return t;
         } else if (t === "finish" || t === "prefinish") {
             const e = super.emit(t);
@@ -3047,34 +3047,34 @@ class Minipass extends d {
             return e;
         }
         const i = super.emit(t, ...e);
-        this[ft]();
+        this[ae]();
         return i;
     }
-    [Rt](t) {
-        for (const e of this[Ct]) {
+    [Me](t) {
+        for (const e of this[xe]) {
             if (e.dest.write(t) === false) this.pause();
         }
-        const e = this[_t] ? false : super.emit("data", t);
-        this[ft]();
+        const e = this[Be] ? false : super.emit("data", t);
+        this[ae]();
         return e;
     }
-    [Ot]() {
-        if (this[ut]) return false;
-        this[ut] = true;
+    [Pe]() {
+        if (this[le]) return false;
+        this[le] = true;
         this.readable = false;
-        return this[Dt] ? (defer((() => this[zt]())), true) : this[zt]();
+        return this[Re] ? (We((() => this[Fe]())), true) : this[Fe]();
     }
-    [zt]() {
-        if (this[St]) {
-            const t = this[St].end();
+    [Fe]() {
+        if (this[we]) {
+            const t = this[we].end();
             if (t) {
-                for (const e of this[Ct]) {
+                for (const e of this[xe]) {
                     e.dest.write(t);
                 }
-                if (!this[_t]) super.emit("data", t);
+                if (!this[Be]) super.emit("data", t);
             }
         }
-        for (const t of this[Ct]) {
+        for (const t of this[xe]) {
             t.end();
         }
         const t = super.emit("end");
@@ -3085,33 +3085,33 @@ class Minipass extends d {
         const t = Object.assign([], {
             dataLength: 0
         });
-        if (!this[Mt]) t.dataLength = 0;
+        if (!this[Te]) t.dataLength = 0;
         const e = this.promise();
         this.on("data", (e => {
             t.push(e);
-            if (!this[Mt]) t.dataLength += e.length;
+            if (!this[Te]) t.dataLength += e.length;
         }));
         await e;
         return t;
     }
     async concat() {
-        if (this[Mt]) {
+        if (this[Te]) {
             throw new Error("cannot concat in objectMode");
         }
         const t = await this.collect();
-        return this[bt] ? 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(Pt, (() => 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[_t] = false;
+        this[Be] = false;
         let t = false;
-        const stop = async () => {
+        const e = async () => {
             this.pause();
             t = true;
             return {
@@ -3119,123 +3119,123 @@ class Minipass extends d {
                 done: true
             };
         };
-        const next = () => {
-            if (t) return stop();
-            const e = this.read();
-            if (e !== null) return Promise.resolve({
+        const s = () => {
+            if (t) return e();
+            const s = this.read();
+            if (s !== null) return Promise.resolve({
                 done: false,
-                value: e
+                value: s
             });
-            if (this[ct]) return stop();
-            let s;
+            if (this[he]) return e();
             let i;
-            const onerr = t => {
-                this.off("data", ondata);
-                this.off("end", onend);
-                this.off(Pt, ondestroy);
-                stop();
-                i(t);
+            let n;
+            const r = t => {
+                this.off("data", o);
+                this.off("end", h);
+                this.off(Ae, a);
+                e();
+                n(t);
             };
-            const ondata = t => {
-                this.off("error", onerr);
-                this.off("end", onend);
-                this.off(Pt, ondestroy);
+            const o = t => {
+                this.off("error", r);
+                this.off("end", h);
+                this.off(Ae, a);
                 this.pause();
-                s({
+                i({
                     value: t,
-                    done: !!this[ct]
+                    done: !!this[he]
                 });
             };
-            const onend = () => {
-                this.off("error", onerr);
-                this.off("data", ondata);
-                this.off(Pt, ondestroy);
-                stop();
-                s({
+            const h = () => {
+                this.off("error", r);
+                this.off("data", o);
+                this.off(Ae, a);
+                e();
+                i({
                     done: true,
                     value: undefined
                 });
             };
-            const ondestroy = () => onerr(new Error("stream destroyed"));
+            const a = () => r(new Error("stream destroyed"));
             return new Promise(((t, e) => {
-                i = e;
-                s = t;
-                this.once(Pt, ondestroy);
-                this.once("error", onerr);
-                this.once("end", onend);
-                this.once("data", ondata);
+                n = e;
+                i = t;
+                this.once(Ae, a);
+                this.once("error", r);
+                this.once("end", h);
+                this.once("data", o);
             }));
         };
         return {
-            next,
-            throw: stop,
-            return: stop,
+            next: s,
+            throw: e,
+            return: e,
             [Symbol.asyncIterator]() {
                 return this;
             }
         };
     }
     [Symbol.iterator]() {
-        this[_t] = false;
+        this[Be] = false;
         let t = false;
-        const stop = () => {
+        const e = () => {
             this.pause();
-            this.off(Ft, stop);
-            this.off(Pt, stop);
-            this.off("end", stop);
+            this.off(Le, e);
+            this.off(Ae, e);
+            this.off("end", e);
             t = true;
             return {
                 done: true,
                 value: undefined
             };
         };
-        const next = () => {
-            if (t) return stop();
-            const e = this.read();
-            return e === null ? stop() : {
+        const s = () => {
+            if (t) return e();
+            const s = this.read();
+            return s === null ? e() : {
                 done: false,
-                value: e
+                value: s
             };
         };
-        this.once("end", stop);
-        this.once(Ft, stop);
-        this.once(Pt, stop);
+        this.once("end", e);
+        this.once(Le, e);
+        this.once(Ae, e);
         return {
-            next,
-            throw: stop,
-            return: stop,
+            next: s,
+            throw: e,
+            return: e,
             [Symbol.iterator]() {
                 return this;
             }
         };
     }
     destroy(t) {
-        if (this[Pt]) {
-            if (t) this.emit("error", t); else this.emit(Pt);
+        if (this[Ae]) {
+            if (t) this.emit("error", t); else this.emit(Ae);
             return this;
         }
-        this[Pt] = true;
-        this[_t] = true;
-        this[Et].length = 0;
-        this[Tt] = 0;
+        this[Ae] = true;
+        this[Be] = true;
+        this[ke].length = 0;
+        this[ve] = 0;
         const e = this;
-        if (typeof e.close === "function" && !this[gt]) e.close();
-        if (t) this.emit("error", t); else this.emit(Pt);
+        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 isStream;
+        return ne;
     }
 }
 
-const jt = i.native;
+const He = i.native;
 
-const $t = {
+const Ze = {
     lstatSync: h,
     readdir: o,
     readdirSync: r,
     readlinkSync: n,
-    realpathSync: jt,
+    realpathSync: He,
     promises: {
         lstat: u,
         readdir: f,
@@ -3244,76 +3244,76 @@ const $t = {
     }
 };
 
-const fsFromOption = t => !t || t === $t || t === a ? $t : {
-    ...$t,
+const qe = t => !t || t === Ze || t === a ? Ze : {
+    ...Ze,
     ...t,
     promises: {
-        ...$t.promises,
+        ...Ze.promises,
         ...t.promises || {}
     }
 };
 
-const Gt = /^\\\\\?\\([a-z]:)\\?$/i;
+const Ve = /^\\\\\?\\([a-z]:)\\?$/i;
 
-const uncToDrive = t => t.replace(/\//g, "\\").replace(Gt, "$1\\");
+const Je = t => t.replace(/\//g, "\\").replace(Ve, "$1\\");
 
-const Ut = /[\\\/]/;
+const Ke = /[\\\/]/;
 
-const Ht = 0;
+const Ye = 0;
 
-const Zt = 1;
+const Xe = 1;
 
-const qt = 2;
+const Qe = 2;
 
-const Vt = 4;
+const ts = 4;
 
-const Jt = 6;
+const es = 6;
 
-const Kt = 8;
+const ss = 8;
 
-const Yt = 10;
+const is = 10;
 
-const Xt = 12;
+const ns = 12;
 
-const Qt = 15;
+const rs = 15;
 
-const te = ~Qt;
+const os = ~rs;
 
-const ee = 16;
+const hs = 16;
 
-const se = 32;
+const as = 32;
 
-const ie = 64;
+const ls = 64;
 
-const ne = 128;
+const cs = 128;
 
-const re = 256;
+const fs = 256;
 
-const oe = 512;
+const us = 512;
 
-const he = ie | ne | oe;
+const ds = ls | cs | us;
 
-const ae = 1023;
+const ps = 1023;
 
-const entToType = t => t.isFile() ? Kt : t.isDirectory() ? Vt : t.isSymbolicLink() ? Yt : t.isCharacterDevice() ? qt : t.isBlockDevice() ? Jt : t.isSocket() ? Xt : t.isFIFO() ? Zt : Ht;
+const 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 le = new Map;
+const ms = new Map;
 
-const normalize = t => {
-    const e = le.get(t);
+const ws = t => {
+    const e = ms.get(t);
     if (e) return e;
     const s = t.normalize("NFKD");
-    le.set(t, s);
+    ms.set(t, s);
     return s;
 };
 
-const ce = new Map;
+const ys = new Map;
 
-const normalizeNocase = t => {
-    const e = ce.get(t);
+const bs = t => {
+    const e = ys.get(t);
     if (e) return e;
-    const s = normalize(t.toLowerCase());
-    ce.set(t, s);
+    const s = ws(t.toLowerCase());
+    ys.set(t, s);
     return s;
 };
 
@@ -3334,7 +3334,7 @@ class ChildrenCache extends LRUCache {
     }
 }
 
-const fe = Symbol("PathScurry setAsCwd");
+const Ss = Symbol("PathScurry setAsCwd");
 
 class PathBase {
     name;
@@ -3388,13 +3388,13 @@ class PathBase {
     get atimeMs() {
         return this.#mt;
     }
-    #yt;
+    #wt;
     get mtimeMs() {
-        return this.#yt;
+        return this.#wt;
     }
-    #wt;
+    #yt;
     get ctimeMs() {
-        return this.#wt;
+        return this.#yt;
     }
     #bt;
     get birthtimeMs() {
@@ -3432,10 +3432,10 @@ class PathBase {
     get path() {
         return this.parentPath;
     }
-    constructor(t, e = Ht, s, i, n, r, o) {
+    constructor(t, e = Ye, s, i, n, r, o) {
         this.name = t;
-        this.#Et = n ? normalizeNocase(t) : normalize(t);
-        this.#Pt = e & ae;
+        this.#Et = n ? bs(t) : ws(t);
+        this.#Pt = e & ps;
         this.nocase = n;
         this.roots = i;
         this.root = s || this;
@@ -3447,7 +3447,7 @@ class PathBase {
         if (this.parent) {
             this.#ot = this.parent.#ot;
         } else {
-            this.#ot = fsFromOption(o.fs);
+            this.#ot = qe(o.fs);
         }
     }
     depth() {
@@ -3484,7 +3484,7 @@ class PathBase {
             provisional: 0
         });
         this.#Ft.set(this, e);
-        this.#Pt &= ~ee;
+        this.#Pt &= ~hs;
         return e;
     }
     child(t, e) {
@@ -3495,7 +3495,7 @@ class PathBase {
             return this.parent || this;
         }
         const s = this.children();
-        const i = this.nocase ? normalizeNocase(t) : normalize(t);
+        const i = this.nocase ? bs(t) : ws(t);
         for (const t of s) {
             if (t.#Et === i) {
                 return t;
@@ -3503,13 +3503,13 @@ class PathBase {
         }
         const n = this.parent ? this.sep : "";
         const r = this.#Tt ? this.#Tt + n + t : undefined;
-        const o = this.newChild(t, Ht, {
+        const o = this.newChild(t, Ye, {
             ...e,
             parent: this,
             fullpath: r
         });
         if (!this.canReaddir()) {
-            o.#Pt |= ne;
+            o.#Pt |= cs;
         }
         s.push(o);
         return o;
@@ -3569,7 +3569,7 @@ class PathBase {
         return this.#At = s;
     }
     isUnknown() {
-        return (this.#Pt & Qt) === Ht;
+        return (this.#Pt & rs) === Ye;
     }
     isType(t) {
         return this[`is${t}`]();
@@ -3578,28 +3578,28 @@ class PathBase {
         return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
     }
     isFile() {
-        return (this.#Pt & Qt) === Kt;
+        return (this.#Pt & rs) === ss;
     }
     isDirectory() {
-        return (this.#Pt & Qt) === Vt;
+        return (this.#Pt & rs) === ts;
     }
     isCharacterDevice() {
-        return (this.#Pt & Qt) === qt;
+        return (this.#Pt & rs) === Qe;
     }
     isBlockDevice() {
-        return (this.#Pt & Qt) === Jt;
+        return (this.#Pt & rs) === es;
     }
     isFIFO() {
-        return (this.#Pt & Qt) === Zt;
+        return (this.#Pt & rs) === Xe;
     }
     isSocket() {
-        return (this.#Pt & Qt) === Xt;
+        return (this.#Pt & rs) === ns;
     }
     isSymbolicLink() {
-        return (this.#Pt & Yt) === Yt;
+        return (this.#Pt & is) === is;
     }
     lstatCached() {
-        return this.#Pt & se ? this : undefined;
+        return this.#Pt & as ? this : undefined;
     }
     readlinkCached() {
         return this.#Rt;
@@ -3614,17 +3614,17 @@ class PathBase {
     canReadlink() {
         if (this.#Rt) return true;
         if (!this.parent) return false;
-        const t = this.#Pt & Qt;
-        return !(t !== Ht && t !== Yt || this.#Pt & re || this.#Pt & ne);
+        const t = this.#Pt & rs;
+        return !(t !== Ye && t !== is || this.#Pt & fs || this.#Pt & cs);
     }
     calledReaddir() {
-        return !!(this.#Pt & ee);
+        return !!(this.#Pt & hs);
     }
     isENOENT() {
-        return !!(this.#Pt & ne);
+        return !!(this.#Pt & cs);
     }
     isNamed(t) {
-        return !this.nocase ? this.#Et === normalize(t) : this.#Et === normalizeNocase(t);
+        return !this.nocase ? this.#Et === ws(t) : this.#Et === bs(t);
     }
     async readlink() {
         const t = this.#Rt;
@@ -3670,41 +3670,41 @@ class PathBase {
             return undefined;
         }
     }
-    #Bt(t) {
-        this.#Pt |= ee;
+    #Nt(t) {
+        this.#Pt |= hs;
         for (let e = t.provisional; e < t.length; e++) {
             const s = t[e];
-            if (s) s.#Nt();
+            if (s) s.#Bt();
         }
     }
-    #Nt() {
-        if (this.#Pt & ne) return;
-        this.#Pt = (this.#Pt | ne) & te;
-        this.#It();
+    #Bt() {
+        if (this.#Pt & cs) return;
+        this.#Pt = (this.#Pt | cs) & os;
+        this.#Wt();
     }
-    #It() {
+    #Wt() {
         const t = this.children();
         t.provisional = 0;
         for (const e of t) {
-            e.#Nt();
+            e.#Bt();
         }
     }
-    #Wt() {
-        this.#Pt |= oe;
+    #It() {
+        this.#Pt |= us;
         this.#_t();
     }
     #_t() {
-        if (this.#Pt & ie) return;
+        if (this.#Pt & ls) return;
         let t = this.#Pt;
-        if ((t & Qt) === Vt) t &= te;
-        this.#Pt = t | ie;
-        this.#It();
+        if ((t & rs) === ts) t &= os;
+        this.#Pt = t | ls;
+        this.#Wt();
     }
     #jt(t = "") {
         if (t === "ENOTDIR" || t === "EPERM") {
             this.#_t();
         } else if (t === "ENOENT") {
-            this.#Nt();
+            this.#Bt();
         } else {
             this.children().provisional = 0;
         }
@@ -3714,41 +3714,41 @@ class PathBase {
             const t = this.parent;
             t.#_t();
         } else if (t === "ENOENT") {
-            this.#Nt();
+            this.#Bt();
         }
     }
     #Dt(t = "") {
         let e = this.#Pt;
-        e |= re;
-        if (t === "ENOENT") e |= ne;
+        e |= fs;
+        if (t === "ENOENT") e |= cs;
         if (t === "EINVAL" || t === "UNKNOWN") {
-            e &= te;
+            e &= os;
         }
         this.#Pt = e;
         if (t === "ENOTDIR" && this.parent) {
             this.parent.#_t();
         }
     }
-    #Gt(t, e) {
-        return this.#Ut(t, e) || this.#Ht(t, e);
+    #Ut(t, e) {
+        return this.#Gt(t, e) || this.#Ht(t, e);
     }
     #Ht(t, e) {
-        const s = entToType(t);
+        const s = gs(t);
         const i = this.newChild(t.name, s, {
             parent: this
         });
-        const n = i.#Pt & Qt;
-        if (n !== Vt && n !== Yt && n !== Ht) {
-            i.#Pt |= ie;
+        const n = i.#Pt & rs;
+        if (n !== ts && n !== is && n !== Ye) {
+            i.#Pt |= ls;
         }
         e.unshift(i);
         e.provisional++;
         return i;
     }
-    #Ut(t, e) {
+    #Gt(t, e) {
         for (let s = e.provisional; s < e.length; s++) {
             const i = e[s];
-            const n = this.nocase ? normalizeNocase(t.name) : normalize(t.name);
+            const n = this.nocase ? bs(t.name) : ws(t.name);
             if (n !== i.#Et) {
                 continue;
             }
@@ -3757,7 +3757,7 @@ class PathBase {
     }
     #Zt(t, e, s, i) {
         const n = e.name;
-        e.#Pt = e.#Pt & te | entToType(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);
@@ -3767,7 +3767,7 @@ class PathBase {
         return e;
     }
     async lstat() {
-        if ((this.#Pt & ne) === 0) {
+        if ((this.#Pt & cs) === 0) {
             try {
                 this.#qt(await this.#ot.promises.lstat(this.fullpath()));
                 return this;
@@ -3777,7 +3777,7 @@ class PathBase {
         }
     }
     lstatSync() {
-        if ((this.#Pt & ne) === 0) {
+        if ((this.#Pt & cs) === 0) {
             try {
                 this.#qt(this.#ot.lstatSync(this.fullpath()));
                 return this;
@@ -3787,7 +3787,7 @@ class PathBase {
         }
     }
     #qt(t) {
-        const {atime: e, atimeMs: s, birthtime: i, birthtimeMs: n, blksize: r, blocks: o, ctime: h, ctimeMs: a, dev: l, gid: c, ino: f, mode: u, mtime: d, mtimeMs: p, nlink: g, rdev: y, size: w, uid: b} = t;
+        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.#vt = i;
@@ -3795,21 +3795,21 @@ class PathBase {
         this.#dt = r;
         this.#gt = o;
         this.#xt = h;
-        this.#wt = a;
+        this.#yt = a;
         this.#ht = l;
         this.#ft = c;
         this.#pt = f;
         this.#at = u;
         this.#kt = d;
-        this.#yt = p;
+        this.#wt = p;
         this.#lt = g;
-        this.#ut = y;
+        this.#ut = m;
         this.#v = w;
-        this.#ct = b;
-        const S = entToType(t);
-        this.#Pt = this.#Pt & te | S | se;
-        if (S !== Ht && S !== Vt && S !== Yt) {
-            this.#Pt |= ie;
+        this.#ct = y;
+        const b = gs(t);
+        this.#Pt = this.#Pt & os | b | as;
+        if (b !== Ye && b !== ts && b !== is) {
+            this.#Pt |= ls;
         }
     }
     #Vt=[];
@@ -3845,9 +3845,9 @@ class PathBase {
                 s.provisional = 0;
             } else {
                 for (const t of e) {
-                    this.#Gt(t, s);
+                    this.#Ut(t, s);
                 }
-                this.#Bt(s);
+                this.#Nt(s);
             }
             this.#Kt(s.slice(0, s.provisional));
             return;
@@ -3866,21 +3866,21 @@ class PathBase {
         if (this.#Yt) {
             await this.#Yt;
         } else {
-            let resolve = () => {};
-            this.#Yt = new Promise((t => resolve = t));
+            let s = () => {};
+            this.#Yt = new Promise((t => s = t));
             try {
                 for (const s of await this.#ot.promises.readdir(e, {
                     withFileTypes: true
                 })) {
-                    this.#Gt(s, t);
+                    this.#Ut(s, t);
                 }
-                this.#Bt(t);
+                this.#Nt(t);
             } catch (e) {
                 this.#jt(e.code);
                 t.provisional = 0;
             }
             this.#Yt = undefined;
-            resolve();
+            s();
         }
         return t.slice(0, t.provisional);
     }
@@ -3897,9 +3897,9 @@ class PathBase {
             for (const s of this.#ot.readdirSync(e, {
                 withFileTypes: true
             })) {
-                this.#Gt(s, t);
+                this.#Ut(s, t);
             }
-            this.#Bt(t);
+            this.#Nt(t);
         } catch (e) {
             this.#jt(e.code);
             t.provisional = 0;
@@ -3907,37 +3907,37 @@ class PathBase {
         return t.slice(0, t.provisional);
     }
     canReaddir() {
-        if (this.#Pt & he) return false;
-        const t = Qt & this.#Pt;
-        if (!(t === Ht || t === Vt || t === Yt)) {
+        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 & Vt) === Vt && !(this.#Pt & he) && !t.has(this) && (!e || e(this));
+        return (this.#Pt & ts) === ts && !(this.#Pt & ds) && !t.has(this) && (!e || e(this));
     }
     async realpath() {
         if (this.#Ot) return this.#Ot;
-        if ((oe | re | ne) & this.#Pt) return undefined;
+        if ((us | fs | cs) & this.#Pt) return undefined;
         try {
             const t = await this.#ot.promises.realpath(this.fullpath());
             return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#Wt();
+            this.#It();
         }
     }
     realpathSync() {
         if (this.#Ot) return this.#Ot;
-        if ((oe | re | ne) & this.#Pt) return undefined;
+        if ((us | fs | cs) & this.#Pt) return undefined;
         try {
             const t = this.#ot.realpathSync(this.fullpath());
             return this.#Ot = this.resolve(t);
         } catch (t) {
-            this.#Wt();
+            this.#It();
         }
     }
-    [fe](t) {
+    [Ss](t) {
         if (t === this) return;
         t.isCWD = false;
         this.isCWD = true;
@@ -3962,18 +3962,18 @@ class PathBase {
 
 class PathWin32 extends PathBase {
     sep="\\";
-    splitSep=Ut;
-    constructor(t, e = Ht, 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 = Ht, s = {}) {
+    newChild(t, e = Ye, s = {}) {
         return new PathWin32(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
     getRootString(t) {
         return e.parse(t).root;
     }
     getRoot(t) {
-        t = uncToDrive(t.toUpperCase());
+        t = Je(t.toUpperCase());
         if (t === this.root.name) {
             return this.root;
         }
@@ -3985,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(Gt, "$1\\");
+        t = t.toUpperCase().replace(/\//g, "\\").replace(Ve, "$1\\");
         return t === e;
     }
 }
@@ -3993,7 +3993,7 @@ class PathWin32 extends PathBase {
 class PathPosix extends PathBase {
     splitSep="/";
     sep="/";
-    constructor(t, e = Ht, s, i, n, r, o) {
+    constructor(t, e = Ye, s, i, n, r, o) {
         super(t, e, s, i, n, r, o);
     }
     getRootString(t) {
@@ -4002,7 +4002,7 @@ class PathPosix extends PathBase {
     getRoot(t) {
         return this.root;
     }
-    newChild(t, e = Ht, s = {}) {
+    newChild(t, e = Ye, s = {}) {
         return new PathPosix(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
     }
 }
@@ -4017,8 +4017,8 @@ class PathScurryBase {
     #Ft;
     nocase;
     #ot;
-    constructor(e = process.cwd(), s, i, {nocase: n, childrenCacheSize: r = 16 * 1024, fs: o = $t} = {}) {
-        this.#ot = fsFromOption(o);
+    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);
         }
@@ -4231,38 +4231,38 @@ class PathScurryBase {
             o.push(s ? t : t.fullpath());
         }
         const h = new Set;
-        const walk = (t, e) => {
+        const a = (t, e) => {
             h.add(t);
-            t.readdirCB(((t, a) => {
+            t.readdirCB(((t, l) => {
                 if (t) {
                     return e(t);
                 }
-                let l = a.length;
-                if (!l) return e();
-                const next = () => {
-                    if (--l === 0) {
+                let c = l.length;
+                if (!c) return e();
+                const f = () => {
+                    if (--c === 0) {
                         e();
                     }
                 };
-                for (const t of a) {
+                for (const t of l) {
                     if (!n || n(t)) {
                         o.push(s ? t : t.fullpath());
                     }
                     if (i && t.isSymbolicLink()) {
-                        t.realpath().then((t => t?.isUnknown() ? t.lstat() : t)).then((t => t?.shouldWalk(h, r) ? walk(t, next) : next()));
+                        t.realpath().then((t => t?.isUnknown() ? t.lstat() : t)).then((t => t?.shouldWalk(h, r) ? a(t, f) : f()));
                     } else {
                         if (t.shouldWalk(h, r)) {
-                            walk(t, next);
+                            a(t, f);
                         } else {
-                            next();
+                            f();
                         }
                     }
                 }
             }), true);
         };
-        const a = t;
+        const l = t;
         return new Promise(((t, e) => {
-            walk(a, (s => {
+            a(l, (s => {
                 if (s) return e(s);
                 t(o);
             }));
@@ -4360,7 +4360,7 @@ class PathScurryBase {
         const h = new Set;
         const a = [ t ];
         let l = 0;
-        const process = () => {
+        const c = () => {
             let t = false;
             while (!t) {
                 const e = a.shift();
@@ -4370,21 +4370,21 @@ class PathScurryBase {
                 }
                 l++;
                 h.add(e);
-                const onReaddir = (e, f, u = false) => {
+                const f = (e, d, p = false) => {
                     if (e) return o.emit("error", e);
-                    if (i && !u) {
+                    if (i && !p) {
                         const t = [];
-                        for (const e of f) {
+                        for (const e of d) {
                             if (e.isSymbolicLink()) {
                                 t.push(e.realpath().then((t => t?.isUnknown() ? t.lstat() : t)));
                             }
                         }
                         if (t.length) {
-                            Promise.all(t).then((() => onReaddir(null, f, true)));
+                            Promise.all(t).then((() => f(null, d, true)));
                             return;
                         }
                     }
-                    for (const e of f) {
+                    for (const e of d) {
                         if (e && (!n || n(e))) {
                             if (!o.write(s ? e : e.fullpath())) {
                                 t = true;
@@ -4392,24 +4392,24 @@ class PathScurryBase {
                         }
                     }
                     l--;
-                    for (const t of f) {
+                    for (const t of d) {
                         const e = t.realpathCached() || t;
                         if (e.shouldWalk(h, r)) {
                             a.push(e);
                         }
                     }
                     if (t && !o.flowing) {
-                        o.once("drain", process);
-                    } else if (!c) {
-                        process();
+                        o.once("drain", c);
+                    } else if (!u) {
+                        c();
                     }
                 };
-                let c = true;
-                e.readdirCB(onReaddir, true);
-                c = false;
+                let u = true;
+                e.readdirCB(f, true);
+                u = false;
             }
         };
-        process();
+        c();
         return o;
     }
     streamSync(t = this.cwd, e = {}) {
@@ -4429,7 +4429,7 @@ class PathScurryBase {
         }
         const a = [ t ];
         let l = 0;
-        const process = () => {
+        const c = () => {
             let t = false;
             while (!t) {
                 const e = a.shift();
@@ -4459,15 +4459,15 @@ class PathScurryBase {
                     }
                 }
             }
-            if (t && !o.flowing) o.once("drain", process);
+            if (t && !o.flowing) o.once("drain", c);
         };
-        process();
+        c();
         return o;
     }
     chdir(t = this.cwd) {
         const e = this.cwd;
         this.cwd = typeof t === "string" ? this.cwd.resolve(t) : t;
-        this.cwd[fe](e);
+        this.cwd[Ss](e);
     }
 }
 
@@ -4488,7 +4488,7 @@ class PathScurryWin32 extends PathScurryBase {
         return e.parse(t).root.toUpperCase();
     }
     newRoot(t) {
-        return new PathWin32(this.rootPath, Vt, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathWin32(this.rootPath, ts, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4511,7 +4511,7 @@ class PathScurryPosix extends PathScurryBase {
         return "/";
     }
     newRoot(t) {
-        return new PathPosix(this.rootPath, Vt, undefined, this.roots, this.nocase, this.childrenCache(), {
+        return new PathPosix(this.rootPath, ts, undefined, this.roots, this.nocase, this.childrenCache(), {
             fs: t
         });
     }
@@ -4530,13 +4530,13 @@ class PathScurryDarwin extends PathScurryPosix {
     }
 }
 
-const ue = process.platform === "win32" ? PathWin32 : PathPosix;
+const ks = process.platform === "win32" ? PathWin32 : PathPosix;
 
-const de = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
+const xs = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-const isPatternList = t => t.length >= 1;
+const vs = t => t.length >= 1;
 
-const isGlobList = t => t.length >= 1;
+const Es = t => t.length >= 1;
 
 class Pattern {
     #te;
@@ -4551,10 +4551,10 @@ class Pattern {
     #ae;
     #le=true;
     constructor(t, e, s, i) {
-        if (!isPatternList(t)) {
+        if (!vs(t)) {
             throw new TypeError("empty pattern list");
         }
-        if (!isGlobList(e)) {
+        if (!Es(e)) {
             throw new TypeError("empty glob list");
         }
         if (e.length !== t.length) {
@@ -4603,7 +4603,7 @@ class Pattern {
         return typeof this.#te[this.#se] === "string";
     }
     isGlobstar() {
-        return this.#te[this.#se] === Y;
+        return this.#te[this.#se] === zt;
     }
     isRegExp() {
         return this.#te[this.#se] instanceof RegExp;
@@ -4649,7 +4649,7 @@ class Pattern {
     }
 }
 
-const pe = 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;
@@ -4658,7 +4658,7 @@ class Ignore {
     absoluteChildren;
     platform;
     mmopts;
-    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = pe}) {
+    constructor(t, {nobrace: e, nocase: s, noext: i, noglobstar: n, platform: r = Cs}) {
         this.relative = [];
         this.absolute = [];
         this.relativeChildren = [];
@@ -4834,7 +4834,7 @@ class Processor {
                 const e = n === ".." || n === "" || n === ".";
                 this.matches.add(t.resolve(n), i, e);
                 continue;
-            } else if (n === Y) {
+            } else if (n === zt) {
                 if (!t.isSymbolicLink() || this.follow || e.checkFollowGlobstar()) {
                     this.subwalks.add(t, e);
                 }
@@ -4870,7 +4870,7 @@ class Processor {
                 const s = e.isAbsolute();
                 const n = e.pattern();
                 const r = e.rest();
-                if (n === Y) {
+                if (n === zt) {
                     i.testGlobstar(t, e, r, s);
                 } else if (n instanceof RegExp) {
                     i.testRegExp(t, n, r, s);
@@ -4928,7 +4928,7 @@ class Processor {
     }
 }
 
-const makeIgnore = (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;
@@ -4950,7 +4950,7 @@ class GlobUtil {
         this.#ue = !s.posix && s.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = s.includeChildMatches !== false;
         if (s.ignore || !this.includeChildMatches) {
-            this.#fe = makeIgnore(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);
@@ -5069,13 +5069,13 @@ class GlobUtil {
         }
         s.processPatterns(t, e);
         let n = 1;
-        const next = () => {
+        const r = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
             if (this.#de(t)) continue;
             n++;
-            this.match(t, e, i).then((() => next()));
+            this.match(t, e, i).then((() => r()));
         }
         for (const t of s.subwalkTargets()) {
             if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
@@ -5083,28 +5083,28 @@ class GlobUtil {
             }
             n++;
             const e = t.readdirCached();
-            if (t.calledReaddir()) this.walkCB3(t, e, s, next); else {
-                t.readdirCB(((e, i) => this.walkCB3(t, i, s, next)), true);
+            if (t.calledReaddir()) this.walkCB3(t, e, s, r); else {
+                t.readdirCB(((e, i) => this.walkCB3(t, i, s, r)), true);
             }
         }
-        next();
+        r();
     }
     walkCB3(t, e, s, i) {
         s = s.filterEntries(t, e);
         let n = 1;
-        const next = () => {
+        const r = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
             if (this.#de(t)) continue;
             n++;
-            this.match(t, e, i).then((() => next()));
+            this.match(t, e, i).then((() => r()));
         }
         for (const [t, e] of s.subwalks.entries()) {
             n++;
-            this.walkCB2(t, e, s.child(), next);
+            this.walkCB2(t, e, s.child(), r);
         }
-        next();
+        r();
     }
     walkCBSync(t, e, s) {
         if (this.signal?.aborted) s();
@@ -5119,7 +5119,7 @@ class GlobUtil {
         }
         s.processPatterns(t, e);
         let n = 1;
-        const next = () => {
+        const r = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
@@ -5132,14 +5132,14 @@ class GlobUtil {
             }
             n++;
             const e = t.readdirSync();
-            this.walkCB3Sync(t, e, s, next);
+            this.walkCB3Sync(t, e, s, r);
         }
-        next();
+        r();
     }
     walkCB3Sync(t, e, s, i) {
         s = s.filterEntries(t, e);
         let n = 1;
-        const next = () => {
+        const r = () => {
             if (--n === 0) i();
         };
         for (const [t, e, i] of s.matches.entries()) {
@@ -5148,9 +5148,9 @@ class GlobUtil {
         }
         for (const [t, e] of s.subwalks.entries()) {
             n++;
-            this.walkCB2Sync(t, e, s.child(), next);
+            this.walkCB2Sync(t, e, s.child(), r);
         }
-        next();
+        r();
     }
 }
 
@@ -5225,9 +5225,9 @@ class GlobStream extends GlobUtil {
     }
 }
 
-const ge = 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 me = class Glob {
+let Ls = class Glob {
     absolute;
     cwd;
     root;
@@ -5299,7 +5299,7 @@ let me = class Glob {
             e = e.map((t => t.includes("/") ? t : `./**/${t}`));
         }
         this.pattern = e;
-        this.platform = s.platform || ge;
+        this.platform = s.platform || As;
         this.opts = {
             ...s,
             platform: this.platform
@@ -5310,7 +5310,7 @@ let me = 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 : de;
+            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
@@ -5395,7 +5395,7 @@ let me = class Glob {
     }
 };
 
-const hasMagic = (t, e = {}) => {
+const Ms = (t, e = {}) => {
     if (!Array.isArray(t)) {
         t = [ t ];
     }
@@ -5405,69 +5405,69 @@ const hasMagic = (t, e = {}) => {
     return false;
 };
 
-function globStreamSync(t, e = {}) {
-    return new me(t, e).streamSync();
+function Ps(t, e = {}) {
+    return new Ls(t, e).streamSync();
 }
 
-function globStream(t, e = {}) {
-    return new me(t, e).stream();
+function Fs(t, e = {}) {
+    return new Ls(t, e).stream();
 }
 
-function globSync(t, e = {}) {
-    return new me(t, e).walkSync();
+function Rs(t, e = {}) {
+    return new Ls(t, e).walkSync();
 }
 
-async function glob_(t, e = {}) {
-    return new me(t, e).walk();
+async function Os(t, e = {}) {
+    return new Ls(t, e).walk();
 }
 
-function globIterateSync(t, e = {}) {
-    return new me(t, e).iterateSync();
+function zs(t, e = {}) {
+    return new Ls(t, e).iterateSync();
 }
 
-function globIterate(t, e = {}) {
-    return new me(t, e).iterate();
+function Ds(t, e = {}) {
+    return new Ls(t, e).iterate();
 }
 
-const ye = globStreamSync;
+const Ns = Ps;
 
-const we = Object.assign(globStream, {
-    sync: globStreamSync
+const Bs = Object.assign(Fs, {
+    sync: Ps
 });
 
-const be = globIterateSync;
+const Ws = zs;
 
-const Se = Object.assign(globIterate, {
-    sync: globIterateSync
+const Is = Object.assign(Ds, {
+    sync: zs
 });
 
-const ke = Object.assign(globSync, {
-    stream: globStreamSync,
-    iterate: globIterateSync
+const _s = Object.assign(Rs, {
+    stream: Ps,
+    iterate: zs
 });
 
-const xe = Object.assign(glob_, {
-    glob: glob_,
-    globSync,
-    sync: ke,
-    globStream,
-    stream: we,
-    globStreamSync,
-    streamSync: ye,
-    globIterate,
-    iterate: Se,
-    globIterateSync,
-    iterateSync: be,
-    Glob: me,
-    hasMagic,
-    escape,
-    unescape
+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
 });
 
-xe.glob = xe;
+js.glob = js;
 
-async function Glob(t, e) {
-    return e ? await xe(t, e) : await xe(t);
+async function $s(t, e) {
+    return e ? await js(t, e) : await js(t);
 }
 
-export { Glob };
+export { $s as Glob };