@bleedingdev/modern-js-utils 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

package/dist/compiled/globby/index.mjs

@@ -208,7 +208,7 @@ var e = {
     358: (t, e, n)=>{
         const r = n(816);
         const s = n(372);
-        const { MAX_LENGTH: o, CHAR_BACKSLASH: i, CHAR_BACKTICK: a, CHAR_COMMA: u, CHAR_DOT: c, CHAR_LEFT_PARENTHESES: l, CHAR_RIGHT_PARENTHESES: f, CHAR_LEFT_CURLY_BRACE: p, CHAR_RIGHT_CURLY_BRACE: d, CHAR_LEFT_SQUARE_BRACKET: h, CHAR_RIGHT_SQUARE_BRACKET: g, CHAR_DOUBLE_QUOTE: _, CHAR_SINGLE_QUOTE: A, CHAR_NO_BREAK_SPACE: R, CHAR_ZERO_WIDTH_NOBREAK_SPACE: m } = n(872);
+        const { MAX_LENGTH: o, CHAR_BACKSLASH: i, CHAR_BACKTICK: a, CHAR_COMMA: u, CHAR_DOT: c, CHAR_LEFT_PARENTHESES: l, CHAR_RIGHT_PARENTHESES: f, CHAR_LEFT_CURLY_BRACE: p, CHAR_RIGHT_CURLY_BRACE: d, CHAR_LEFT_SQUARE_BRACKET: h, CHAR_RIGHT_SQUARE_BRACKET: g, CHAR_DOUBLE_QUOTE: _, CHAR_SINGLE_QUOTE: A, CHAR_NO_BREAK_SPACE: m, CHAR_ZERO_WIDTH_NOBREAK_SPACE: R } = n(872);
         const parse = (t, e = {})=>{
             if ("string" != typeof t) throw new TypeError("Expected a string");
             const n = e || {};
@@ -248,7 +248,7 @@ var e = {
             while(H < $){
                 C = w[w.length - 1];
                 O = advance();
-                if (O === m || O === R) continue;
+                if (O === R || O === m) continue;
                 if (O === i) {
                     push({
                         type: "text",
@@ -725,7 +725,7 @@ var e = {
         };
         t.exports = fill;
     },
-    869: (t)=>{
+    425: (t)=>{
         function makeArray(t) {
             return Array.isArray(t) ? t : [
                 t
@@ -735,45 +735,153 @@ var e = {
         const n = "";
         const r = " ";
         const s = "\\";
-        const o = /^\s+$/;
-        const i = /(?:[^\\]|^)\\$/;
-        const a = /^\\!/;
-        const u = /^\\#/;
-        const c = /\r?\n/g;
-        const l = /^\.{0,2}\/|^\.{1,2}$/;
-        const f = /\/$/;
-        const p = "/";
-        let d = "node-ignore";
-        if ("u" > typeof Symbol) d = Symbol.for("node-ignore");
-        const h = d;
+        const o = /[.*+?()[\]{}^$|\\/]/;
+        const i = "\ufeff";
+        const a = /(?:[^\\]|^)\\$/;
+        const u = /^\\!/;
+        const c = /^\\#/;
+        const l = /\r?\n/g;
+        const f = "//";
+        const p = 47;
+        const d = 46;
+        const h = "/";
+        let g = "node-ignore";
+        if ("u" > typeof Symbol) g = Symbol.for("node-ignore");
+        const _ = g;
         const define = (t, e, n)=>{
             Object.defineProperty(t, e, {
                 value: n
             });
             return n;
         };
-        const g = /([0-z])-([0-z])/g;
         const RETURN_FALSE = ()=>false;
-        const sanitizeRange = (t)=>t.replace(g, (t, e, r)=>e.charCodeAt(0) <= r.charCodeAt(0) ? t : n);
         const cleanRangeBackSlash = (t)=>{
             const { length: e } = t;
             return t.slice(0, e - e % 2);
         };
-        const _ = [
-            [
-                /^\uFEFF/,
-                ()=>n
-            ],
-            [
-                /((?:\\\\)*?)(\\?\s+)$/,
-                (t, e, s)=>e + (0 === s.indexOf("\\") ? r : n)
-            ],
-            [
-                /(\\+?)\s/g,
-                (t, e)=>{
-                    const { length: n } = e;
-                    return e.slice(0, n - n % 2) + r;
+        const A = {
+            alnum: "0-9A-Za-z",
+            alpha: "A-Za-z",
+            blank: " \\t",
+            cntrl: "\\x00-\\x1f\\x7f",
+            digit: "0-9",
+            graph: "!-.0-~",
+            lower: "a-z",
+            print: " -.0-~",
+            punct: "!-.:-@\\[-`{-~",
+            space: " \\t\\n\\r",
+            upper: "A-Z",
+            xdigit: "0-9A-Fa-f"
+        };
+        const m = "\\]^-[";
+        const escapeMember = (t)=>m.indexOf(t) < 0 ? t : s + t;
+        const R = "(?!\\/)";
+        const classSource = (t, e)=>{
+            if (t) return `[^\\/${e}]`;
+            const n = `[${e}]`;
+            return new RegExp(n).test("/") ? R + n : n;
+        };
+        const scanBracket = (t, r)=>{
+            const { length: o } = t;
+            let i = r + 1;
+            let a = n;
+            const u = t[i];
+            if ("!" === u || "^" === u) {
+                a = "^";
+                i++;
+            }
+            let c = n;
+            let l = n;
+            for(;;){
+                const r = t[i];
+                if (r === e) return null;
+                if (r === s) {
+                    const n = t[i + 1];
+                    if (n === e) return null;
+                    c += escapeMember(n);
+                    l = n;
+                    i++;
+                } else if ("-" === r && l && i + 1 < o && "]" !== t[i + 1]) {
+                    i++;
+                    let e = t[i];
+                    if (e === s) e = t[i += 1];
+                    if (l <= e) c += `-${escapeMember(e)}`;
+                    l = n;
+                } else if ("[" === r && ":" === t[i + 1]) {
+                    const r = i + 2;
+                    let s = r;
+                    while(s < o && "]" !== t[s])s++;
+                    if (s === o) return null;
+                    if (s > r && ":" === t[s - 1]) {
+                        const o = A[t.slice(r, s - 1)];
+                        if (o === e) return null;
+                        c += o;
+                        l = n;
+                        i = s;
+                    } else {
+                        c += escapeMember("[");
+                        l = "[";
+                        i = r - 2;
+                    }
+                } else {
+                    c += escapeMember(r);
+                    l = r;
                 }
+                i++;
+                if ("]" === t[i]) return {
+                    end: i,
+                    source: classSource(a, c)
+                };
+            }
+        };
+        const E = "[]";
+        const b = "\0";
+        const w = new RegExp(`${b}(\\d+)${b}`, "g");
+        const C = "";
+        const v = "";
+        const extractBrackets = (t)=>{
+            const i = [];
+            const hold = (t)=>`${b}${i.push(t) - 1}${b}`;
+            const { length: a } = t;
+            let u = n;
+            let c = 0;
+            while(c < a){
+                const n = t[c];
+                if (n === s) {
+                    const n = t[c + 1];
+                    if (n === e || n === h && c + 2 === a) u += hold(E);
+                    else if ("*" === n || "[" === n || n === r || n === s) u += t.slice(c, c + 2);
+                    else u += hold(o.test(n) ? s + n : n);
+                    c += 2;
+                } else if (n === b) {
+                    u += hold(`[${b}]`);
+                    c++;
+                } else if ("[" === n) {
+                    const e = scanBracket(t, c);
+                    if (null === e) {
+                        u += hold(E);
+                        c = a;
+                    } else {
+                        u += hold(e.source);
+                        c = e.end + 1;
+                    }
+                } else {
+                    u += n;
+                    c++;
+                }
+            }
+            return {
+                source: u,
+                sources: i
+            };
+        };
+        const S = null;
+        const $ = /\/(?!$)/;
+        const H = [
+            [
+                /(\\+)( ?)/g,
+                (t, e, n)=>n ? e.slice(0, e.length - e.length % 2) + r : e,
+                s + r
             ],
             [
                 /[\\$.|*+(){^]/g,
@@ -781,72 +889,204 @@ var e = {
             ],
             [
                 /(?!\\)\?/g,
-                ()=>"[^/]"
+                ()=>"[^/]",
+                "?"
             ],
             [
                 /^\//,
-                ()=>"^"
+                ()=>"^",
+                h
             ],
             [
                 /\//g,
-                ()=>"\\/"
+                ()=>"\\/",
+                h
             ],
             [
-                /^\^*\\\*\\\*\\\//,
-                ()=>"^(?:.*\\/)?"
+                /^\^*(?:\\\*\\\*\\\/)+/,
+                ()=>"^(?:.*\\/)?",
+                "*"
             ],
             [
-                /^(?=[^^])/,
-                function() {
-                    return /\/(?!$)/.test(this) ? "^" : "(?:^|\\/)";
+                S,
+                (t, e)=>{
+                    if (!t || "^" === t[0]) return t;
+                    const n = $.test(e) ? "^" : "(?:^|\\/)";
+                    return n + t;
                 }
             ],
             [
                 /\\\/\\\*\\\*(?=\\\/|$)/g,
-                (t, e, n)=>e + 6 < n.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+                (t, e, n)=>e + 6 < n.length ? "\\/" === n.slice(e + 6) ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${v}`,
+                "*"
             ],
             [
                 /(^|[^\\]+)(\\\*)+(?=.+)/g,
                 (t, e, n)=>{
                     const r = n.replace(/\\\*/g, "[^\\/]*");
                     return e + r;
-                }
+                },
+                "*"
+            ],
+            [
+                /(^|[^\\])((?:\\\\)*)\\\*$/,
+                (t, e, n)=>n.length / 2 % 2 === 0 ? e + n + C : t,
+                "*"
             ],
             [
                 /\\\\\\(?=[$.|*+(){^])/g,
-                ()=>s
+                ()=>s,
+                s + s
             ],
             [
                 /\\\\/g,
-                ()=>s
+                ()=>s,
+                s + s
             ],
             [
-                /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-                (t, e, n, r, o)=>e === s ? `\\[${n}${cleanRangeBackSlash(r)}${o}` : "]" === o ? r.length % 2 === 0 ? `[${sanitizeRange(n)}${r}]` : "[]" : "[]"
+                /\\\[([^\]/]*?)(\\*)($|\])/g,
+                (t, e, n, r)=>`\\[${e}${cleanRangeBackSlash(n)}${r}`,
+                "["
             ],
             [
-                /(?:[^*])$/,
-                (t)=>/\/$/.test(t) ? `${t}$` : `${t}(?=$|\\/$)`
+                S,
+                (t)=>{
+                    const e = t[t.length - 1];
+                    if (!e || e === C || e === v) return t;
+                    return e === h ? `${t}$` : `${t}(?=$|\\/$)`;
+                }
             ]
         ];
-        const A = /(^|\\\/)?\\\*$/;
-        const R = "regex";
-        const m = "checkRegex";
-        const E = "_";
-        const b = {
-            [R] (t, e) {
-                const n = e ? `${e}[^/]+` : "[^/]*";
-                return `${n}(?=$|\\/$)`;
-            },
-            [m] (t, e) {
-                const n = e ? `${e}[^/]*` : "[^/]*";
-                return `${n}(?=$|\\/$)`;
+        const T = /(^|\\\/)?\uE000$/;
+        const O = "regex";
+        const L = "checkRegex";
+        const k = "_";
+        const replaceTrailingWildcard = (t, e)=>{
+            const n = e ? `${e}[^/]+` : "[^/]*";
+            return `${n}(?=$|\\/$)`;
+        };
+        const P = /\uE001$/;
+        const replaceTrailingDoublestar = ()=>".+(?=$|\\/$)";
+        const I = "[^\\/]*";
+        const separatorAfter = (t, e)=>{
+            let r = n;
+            for(let n = e + 1; n < t.length && !t[n].wildcard; n++)r += t[n].single;
+            return r;
+        };
+        const pinWildcards = (t)=>{
+            if (t.indexOf(I) < 0) return t;
+            const e = [];
+            const { length: r } = t;
+            let o = 0;
+            while(o < r){
+                const n = t[o];
+                if (t.startsWith(I, o)) {
+                    e.push({
+                        wildcard: true
+                    });
+                    o += I.length;
+                } else if ("[" === n) {
+                    let n = o + 1;
+                    if ("^" === t[n]) n++;
+                    if ("]" === t[n]) n++;
+                    while(n < r && "]" !== t[n])n += t[n] === s ? 2 : 1;
+                    n++;
+                    e.push({
+                        single: t.slice(o, n)
+                    });
+                    o = n;
+                } else if (n === s) {
+                    e.push({
+                        single: t.slice(o, o + 2)
+                    });
+                    o += 2;
+                } else if ("(" === n) {
+                    let n = 0;
+                    let i = o;
+                    do {
+                        if (t[i] === s) i++;
+                        else if ("(" === t[i]) n++;
+                        else if (")" === t[i]) n--;
+                        i++;
+                    }while (i < r && n > 0);
+                    if ("*+?".indexOf(t[i]) >= 0) i++;
+                    e.push({
+                        boundary: t.slice(o, i)
+                    });
+                    o = i;
+                } else if ("^" === n || "$" === n) {
+                    e.push({
+                        boundary: n
+                    });
+                    o++;
+                } else {
+                    e.push({
+                        single: n
+                    });
+                    o++;
+                }
             }
+            let i = n;
+            let a = [];
+            const flush = ()=>{
+                let t;
+                a.forEach((e, n)=>{
+                    if (e.wildcard) t = n;
+                });
+                a.forEach((e, n)=>{
+                    if (!e.wildcard) {
+                        i += e.single;
+                        return;
+                    }
+                    i += n === t ? I : `(?:(?!${separatorAfter(a, n)})[^\\/])*`;
+                });
+                a = [];
+            };
+            e.forEach((t)=>{
+                if (void 0 === t.boundary) return void a.push(t);
+                flush();
+                i += t.boundary;
+            });
+            flush();
+            return i;
+        };
+        const makeRegexPrefix = (t)=>{
+            const { source: n, sources: r } = extractBrackets(t);
+            const s = H.reduce((n, [r, s, o])=>{
+                if (r === S) return s(n, t);
+                if (o !== e && n.indexOf(o) < 0) return n;
+                return r.test(n) ? n.replace(r, s.bind(t)) : n;
+            }, n);
+            return r.length ? s.replace(w, (t, e)=>r[e]) : s;
+        };
+        const checkSourceOf = (t, e)=>{
+            if (t[t.length - 1] === h) e = makeRegexPrefix(t.slice(0, -1));
+            const n = e.slice(0, -1);
+            const r = e[e.length - 1];
+            return r === C ? `${n}$` : r === v ? `${n}.*$` : E;
+        };
+        const matchesBasename = (t)=>{
+            const e = t.indexOf(h);
+            return e < 0 || e === t.length - 1;
+        };
+        const basenameOf = (t)=>{
+            const e = t.length - 1;
+            const n = t.lastIndexOf(h, t[e] === h ? e - 1 : e);
+            return n < 0 ? t : t.slice(n + 1);
+        };
+        const parentOf = (t)=>{
+            if (t.charCodeAt(0) === p || t.indexOf(f) >= 0) {
+                const e = t.split(h).filter(Boolean);
+                e.pop();
+                return e.length ? e.join(h) + h : n;
+            }
+            const e = t.length - 1;
+            const r = t.lastIndexOf(h, t.charCodeAt(e) === p ? e - 1 : e);
+            return r < 0 ? n : t.slice(0, r + 1);
         };
-        const makeRegexPrefix = (t)=>_.reduce((e, [n, r])=>e.replace(n, r.bind(t)), t);
         const isString = (t)=>"string" == typeof t;
-        const checkPattern = (t)=>t && isString(t) && !o.test(t) && !i.test(t) && 0 !== t.indexOf("#");
-        const splitPattern = (t)=>t.split(c).filter(Boolean);
+        const checkPattern = (t)=>t && isString(t) && !a.test(t);
+        const splitPattern = (t)=>t.split(l).filter(Boolean);
         class IgnoreRule {
             constructor(t, e, n, r, s, o){
                 this.pattern = t;
@@ -856,77 +1096,125 @@ var e = {
                 define(this, "ignoreCase", r);
                 define(this, "regexPrefix", o);
             }
+            get _basenameOnly() {
+                return define(this, "_basenameOnly", matchesBasename(this.body));
+            }
             get regex() {
-                const t = E + R;
+                const t = k + O;
                 if (this[t]) return this[t];
-                return this._make(R, t);
+                return this._make(O, t);
             }
             get checkRegex() {
-                const t = E + m;
+                const t = k + L;
                 if (this[t]) return this[t];
-                return this._make(m, t);
+                return this._make(L, t);
             }
             _make(t, e) {
-                const n = this.regexPrefix.replace(A, b[t]);
+                const n = pinWildcards(t === O ? this.regexPrefix.replace(T, replaceTrailingWildcard).replace(P, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix));
                 const r = this.ignoreCase ? new RegExp(n, "i") : new RegExp(n);
                 return define(this, e, r);
             }
         }
+        const isLineEnd = (t)=>"\r" === t || "\n" === t;
+        const trimEnd = (t)=>{
+            let e = t.length;
+            while(e && isLineEnd(t[e - 1]))e--;
+            const n = e;
+            while(e && t[e - 1] === r)e--;
+            if (e === n) return t.slice(0, e);
+            let o = 0;
+            while(o < e && t[e - o - 1] === s)o++;
+            return o % 2 ? t.slice(0, e - 1) + r : t.slice(0, e);
+        };
         const createRule = ({ pattern: t, mark: e }, n)=>{
-            let r = false;
-            let s = t;
-            if (0 === s.indexOf("!")) {
-                r = true;
-                s = s.substr(1);
+            let s = t[0] === i ? t.slice(1) : t;
+            if ("#" === s[0]) return;
+            let o = false;
+            if ("!" === s[0]) {
+                o = true;
+                s = s.slice(1);
             }
-            s = s.replace(a, "!").replace(u, "#");
-            const o = makeRegexPrefix(s);
-            return new IgnoreRule(t, e, s, n, r, o);
+            const a = s[s.length - 1];
+            if (a === r || "\r" === a || "\n" === a) s = trimEnd(s);
+            if (!s) return;
+            s = s.replace(u, "!").replace(c, "#");
+            const l = makeRegexPrefix(s);
+            return new IgnoreRule(t, e, s, n, o, l);
         };
         class RuleManager {
             constructor(t){
                 this._ignoreCase = t;
                 this._rules = [];
+                this._basenameCount = 0;
             }
             _add(t) {
-                if (t && t[h]) {
+                if (t && t[_]) {
                     this._rules = this._rules.concat(t._rules._rules);
+                    this._basenameCount += t._rules._basenameCount;
                     this._added = true;
                     return;
                 }
                 if (isString(t)) t = {
                     pattern: t
                 };
-                if (checkPattern(t.pattern)) {
-                    const e = createRule(t, this._ignoreCase);
+                const e = checkPattern(t.pattern) && createRule(t, this._ignoreCase);
+                if (e) {
                     this._added = true;
                     this._rules.push(e);
+                    if (matchesBasename(e.body)) this._basenameCount++;
                 }
             }
             add(t) {
                 this._added = false;
                 makeArray(isString(t) ? splitPattern(t) : t).forEach(this._add, this);
+                if (this._added) this._literalRules = e;
                 return this._added;
             }
+            testLiteral(t) {
+                const n = this._literalRules || (this._literalRules = this._rules.filter(({ body: t })=>"*" === t[t.length - (t[t.length - 1] === h ? 2 : 1)]));
+                let r = false;
+                let s = false;
+                let o;
+                for(let i = n.length - 1; i >= 0; i--){
+                    const a = n[i];
+                    if (a.checkRegex.test(t)) {
+                        r = !a.negative;
+                        s = a.negative;
+                        o = a.negative ? e : a;
+                        break;
+                    }
+                }
+                const i = {
+                    ignored: r,
+                    unignored: s
+                };
+                if (o) i.rule = o;
+                return i;
+            }
             test(t, n, r) {
                 let s = false;
                 let o = false;
                 let i;
-                this._rules.forEach((a)=>{
-                    const { negative: u } = a;
-                    if (o === u && s !== o || u && !s && !o && !n) return;
-                    const c = a[r].test(t);
-                    if (!c) return;
-                    s = !u;
-                    o = u;
-                    i = u ? e : a;
-                });
-                const a = {
+                const a = this._rules;
+                const { length: u } = a;
+                const c = 2 * this._basenameCount >= u;
+                const l = c ? basenameOf(t) : t;
+                for(let f = 0; f < u; f++){
+                    const u = a[f];
+                    const { negative: p } = u;
+                    const d = o === p && s !== o || p && !s && !o && !n;
+                    if (!d && u[r].test(c && u._basenameOnly ? l : t)) {
+                        s = !p;
+                        o = p;
+                        i = p ? e : u;
+                    }
+                }
+                const f = {
                     ignored: s,
                     unignored: o
                 };
-                if (i) a.rule = i;
-                return a;
+                if (i) f.rule = i;
+                return f;
             }
         }
         const throwError = (t, e)=>{
@@ -941,12 +1229,21 @@ var e = {
             }
             return true;
         };
-        const isNotRelative = (t)=>l.test(t);
+        const isNotRelative = (t)=>{
+            const e = t.charCodeAt(0);
+            if (e === p) return true;
+            if (e !== d) return false;
+            if (1 === t.length) return true;
+            const n = t.charCodeAt(1);
+            if (n === p) return true;
+            if (n !== d) return false;
+            return 2 === t.length || t.charCodeAt(2) === p;
+        };
         checkPath.isNotRelative = isNotRelative;
         checkPath.convert = (t)=>t;
         class Ignore {
             constructor({ ignorecase: t = true, ignoreCase: e = t, allowRelativePaths: n = false } = {}){
-                define(this, h, true);
+                define(this, _, true);
                 this._rules = new RuleManager(e);
                 this._strictPathCheck = !n;
                 this._initCache();
@@ -962,28 +1259,23 @@ var e = {
             addPattern(t) {
                 return this.add(t);
             }
-            _test(t, e, n, r) {
-                const s = t && checkPath.convert(t);
-                checkPath(s, t, this._strictPathCheck ? throwError : RETURN_FALSE);
-                return this._t(s, e, n, r);
+            _test(t, e, n) {
+                const r = t && checkPath.convert(t);
+                checkPath(r, t, this._strictPathCheck ? throwError : RETURN_FALSE);
+                return this._t(r, e, n);
             }
             checkIgnore(t) {
-                if (!f.test(t)) return this.test(t);
-                const e = t.split(p).filter(Boolean);
-                e.pop();
-                if (e.length) {
-                    const t = this._t(e.join(p) + p, this._testCache, true, e);
-                    if (t.ignored) return t;
-                }
-                return this._rules.test(t, false, m);
+                if (t.charCodeAt(t.length - 1) !== p) return this.test(t);
+                const e = this._t(t, this._testCache, true);
+                if (e.ignored) return e;
+                const n = this._rules.testLiteral(t);
+                return n.ignored || n.unignored ? n : e;
             }
-            _t(t, e, n, r) {
-                if (t in e) return e[t];
-                if (!r) r = t.split(p).filter(Boolean);
-                r.pop();
-                if (!r.length) return e[t] = this._rules.test(t, n, R);
-                const s = this._t(r.join(p) + p, e, n, r);
-                return e[t] = s.ignored ? s : this._rules.test(t, n, R);
+            _t(t, n, r) {
+                if (t in n) return n[t];
+                const s = parentOf(t);
+                const o = s ? this._t(s, n, r) : e;
+                return n[t] = o && o.ignored ? o : this._rules.test(t, r, O);
             }
             ignores(t) {
                 return this._test(t, this._ignoreCache, false).ignored;
@@ -1186,8 +1478,8 @@ var e = {
         const g = `${a}{1,2}${d}`;
         const _ = `(?!${a})`;
         const A = `(?!${h}${g})`;
-        const R = `(?!${a}{0,1}${d})`;
-        const m = `(?!${g})`;
+        const m = `(?!${a}{0,1}${d})`;
+        const R = `(?!${g})`;
         const E = `[^.${l}]`;
         const b = `${p}*?`;
         const w = {
@@ -1201,8 +1493,8 @@ var e = {
             DOTS_SLASH: g,
             NO_DOT: _,
             NO_DOTS: A,
-            NO_DOT_SLASH: R,
-            NO_DOTS_SLASH: m,
+            NO_DOT_SLASH: m,
+            NO_DOTS_SLASH: R,
             QMARK_NO_DOT: E,
             STAR: b,
             START_ANCHOR: h
@@ -1552,12 +1844,12 @@ var e = {
             const g = s.isWindows(e);
             const _ = r.globChars(g);
             const A = r.extglobChars(_);
-            const { DOT_LITERAL: R, PLUS_LITERAL: m, SLASH_LITERAL: E, ONE_CHAR: b, DOTS_SLASH: w, NO_DOT: C, NO_DOT_SLASH: v, NO_DOTS_SLASH: S, QMARK: $, QMARK_NO_DOT: H, STAR: T, START_ANCHOR: O } = _;
-            const globstar = (t)=>`(${h}(?:(?!${O}${t.dot ? w : R}).)*?)`;
+            const { DOT_LITERAL: m, PLUS_LITERAL: R, SLASH_LITERAL: E, ONE_CHAR: b, DOTS_SLASH: w, NO_DOT: C, NO_DOT_SLASH: v, NO_DOTS_SLASH: S, QMARK: $, QMARK_NO_DOT: H, STAR: T, START_ANCHOR: O } = _;
+            const globstar = (t)=>`(${h}(?:(?!${O}${t.dot ? w : m}).)*?)`;
             const L = n.dot ? "" : C;
-            const P = n.dot ? $ : H;
-            let k = true === n.bash ? globstar(n) : T;
-            if (n.capture) k = `(${k})`;
+            const k = n.dot ? $ : H;
+            let P = true === n.bash ? globstar(n) : T;
+            if (n.capture) P = `(${P})`;
             if ("boolean" == typeof n.noext) n.noextglob = n.noext;
             const I = {
                 input: t,
@@ -1582,9 +1874,9 @@ var e = {
             const M = [];
             const B = [];
             let D = p;
-            let F;
+            let G;
             const eos = ()=>I.index === f - 1;
-            const G = I.peek = (e = 1)=>t[I.index + e];
+            const F = I.peek = (e = 1)=>t[I.index + e];
             const U = I.advance = ()=>t[++I.index] || "";
             const remaining = ()=>t.slice(I.index + 1);
             const consume = (t = "", e = 0)=>{
@@ -1597,7 +1889,7 @@ var e = {
             };
             const negate = ()=>{
                 let t = 1;
-                while("!" === G() && ("(" !== G(2) || "?" === G(3))){
+                while("!" === F() && ("(" !== F(2) || "?" === F(3))){
                     U();
                     I.start++;
                     t++;
@@ -1623,7 +1915,7 @@ var e = {
                         I.output = I.output.slice(0, -D.output.length);
                         D.type = "star";
                         D.value = "*";
-                        D.output = k;
+                        D.output = P;
                         I.output += D.output;
                     }
                 }
@@ -1684,7 +1976,7 @@ var e = {
                     push({
                         type: "paren",
                         extglob: true,
-                        value: F,
+                        value: G,
                         output: ""
                     });
                     decrement("parens");
@@ -1693,9 +1985,9 @@ var e = {
                 let u = r.close + (n.capture ? ")" : "");
                 let c;
                 if ("negate" === r.type) {
-                    let t = k;
+                    let t = P;
                     if (r.inner && r.inner.length > 1 && r.inner.includes("/")) t = globstar(n);
-                    if (t !== k || eos() || /^\)+$/.test(remaining())) u = r.close = `)$))${t}`;
+                    if (t !== P || eos() || /^\)+$/.test(remaining())) u = r.close = `)$))${t}`;
                     if (r.inner.includes("*") && (c = remaining()) && /^\.[^\\/.]+$/.test(c)) {
                         const n = parse(c, {
                             ...e,
@@ -1708,7 +2000,7 @@ var e = {
                 push({
                     type: "paren",
                     extglob: true,
-                    value: F,
+                    value: G,
                     output: u
                 });
                 decrement("parens");
@@ -1722,13 +2014,13 @@ var e = {
                     }
                     if ("?" === s) {
                         if (e) return e + s + (o ? $.repeat(o.length) : "");
-                        if (0 === i) return P + (o ? $.repeat(o.length) : "");
+                        if (0 === i) return k + (o ? $.repeat(o.length) : "");
                         return $.repeat(n.length);
                     }
-                    if ("." === s) return R.repeat(n.length);
+                    if ("." === s) return m.repeat(n.length);
                     if ("*" === s) {
-                        if (e) return e + s + (o ? k : "");
-                        return k;
+                        if (e) return e + s + (o ? P : "");
+                        return P;
                     }
                     return e ? t : `\\${t}`;
                 });
@@ -1741,17 +2033,17 @@ var e = {
                 return I;
             }
             while(!eos()){
-                F = U();
-                if ("\0" === F) continue;
-                if ("\\" === F) {
-                    const t = G();
+                G = U();
+                if ("\0" === G) continue;
+                if ("\\" === G) {
+                    const t = F();
                     if ("/" === t && true !== n.bash) continue;
                     if ("." === t || ";" === t) continue;
                     if (!t) {
-                        F += "\\";
+                        G += "\\";
                         push({
                             type: "text",
-                            value: F
+                            value: G
                         });
                         continue;
                     }
@@ -1760,20 +2052,20 @@ var e = {
                     if (e && e[0].length > 2) {
                         r = e[0].length;
                         I.index += r;
-                        if (r % 2 !== 0) F += "\\";
+                        if (r % 2 !== 0) G += "\\";
                     }
-                    if (true === n.unescape) F = U();
-                    else F += U();
+                    if (true === n.unescape) G = U();
+                    else G += U();
                     if (0 === I.brackets) {
                         push({
                             type: "text",
-                            value: F
+                            value: G
                         });
                         continue;
                     }
                 }
-                if (I.brackets > 0 && ("]" !== F || "[" === D.value || "[^" === D.value)) {
-                    if (false !== n.posix && ":" === F) {
+                if (I.brackets > 0 && ("]" !== G || "[" === D.value || "[^" === D.value)) {
+                    if (false !== n.posix && ":" === G) {
                         const t = D.value.slice(1);
                         if (t.includes("[")) {
                             D.posix = true;
@@ -1792,40 +2084,40 @@ var e = {
                             }
                         }
                     }
-                    if ("[" === F && ":" !== G() || "-" === F && "]" === G()) F = `\\${F}`;
-                    if ("]" === F && ("[" === D.value || "[^" === D.value)) F = `\\${F}`;
-                    if (true === n.posix && "!" === F && "[" === D.value) F = "^";
-                    D.value += F;
+                    if ("[" === G && ":" !== F() || "-" === G && "]" === F()) G = `\\${G}`;
+                    if ("]" === G && ("[" === D.value || "[^" === D.value)) G = `\\${G}`;
+                    if (true === n.posix && "!" === G && "[" === D.value) G = "^";
+                    D.value += G;
                     append({
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if (1 === I.quotes && '"' !== F) {
-                    F = s.escapeRegex(F);
-                    D.value += F;
+                if (1 === I.quotes && '"' !== G) {
+                    G = s.escapeRegex(G);
+                    D.value += G;
                     append({
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if ('"' === F) {
+                if ('"' === G) {
                     I.quotes = 1 === I.quotes ? 0 : 1;
                     if (true === n.keepQuotes) push({
                         type: "text",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if ("(" === F) {
+                if ("(" === G) {
                     increment("parens");
                     push({
                         type: "paren",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if (")" === F) {
+                if (")" === G) {
                     if (0 === I.parens && true === n.strictBrackets) throw new SyntaxError(syntaxError("opening", "("));
                     const t = N[N.length - 1];
                     if (t && I.parens === t.parens + 1) {
@@ -1834,30 +2126,30 @@ var e = {
                     }
                     push({
                         type: "paren",
-                        value: F,
+                        value: G,
                         output: I.parens ? ")" : "\\)"
                     });
                     decrement("parens");
                     continue;
                 }
-                if ("[" === F) {
+                if ("[" === G) {
                     if (true !== n.nobracket && remaining().includes("]")) increment("brackets");
                     else {
                         if (true !== n.nobracket && true === n.strictBrackets) throw new SyntaxError(syntaxError("closing", "]"));
-                        F = `\\${F}`;
+                        G = `\\${G}`;
                     }
                     push({
                         type: "bracket",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if ("]" === F) {
+                if ("]" === G) {
                     if (true === n.nobracket || D && "bracket" === D.type && 1 === D.value.length) {
                         push({
                             type: "text",
-                            value: F,
-                            output: `\\${F}`
+                            value: G,
+                            output: `\\${G}`
                         });
                         continue;
                     }
@@ -1865,17 +2157,17 @@ var e = {
                         if (true === n.strictBrackets) throw new SyntaxError(syntaxError("opening", "["));
                         push({
                             type: "text",
-                            value: F,
-                            output: `\\${F}`
+                            value: G,
+                            output: `\\${G}`
                         });
                         continue;
                     }
                     decrement("brackets");
                     const t = D.value.slice(1);
-                    if (true !== D.posix && "^" === t[0] && !t.includes("/")) F = `/${F}`;
-                    D.value += F;
+                    if (true !== D.posix && "^" === t[0] && !t.includes("/")) G = `/${G}`;
+                    D.value += G;
                     append({
-                        value: F
+                        value: G
                     });
                     if (false === n.literalBrackets || s.hasRegexChars(t)) continue;
                     const e = s.escapeRegex(D.value);
@@ -1889,11 +2181,11 @@ var e = {
                     I.output += D.value;
                     continue;
                 }
-                if ("{" === F && true !== n.nobrace) {
+                if ("{" === G && true !== n.nobrace) {
                     increment("braces");
                     const t = {
                         type: "brace",
-                        value: F,
+                        value: G,
                         output: "(",
                         outputIndex: I.output.length,
                         tokensIndex: I.tokens.length
@@ -1902,13 +2194,13 @@ var e = {
                     push(t);
                     continue;
                 }
-                if ("}" === F) {
+                if ("}" === G) {
                     const t = M[M.length - 1];
                     if (true === n.nobrace || !t) {
                         push({
                             type: "text",
-                            value: F,
-                            output: F
+                            value: G,
+                            output: G
                         });
                         continue;
                     }
@@ -1928,29 +2220,29 @@ var e = {
                         const n = I.output.slice(0, t.outputIndex);
                         const r = I.tokens.slice(t.tokensIndex);
                         t.value = t.output = "\\{";
-                        F = e = "\\}";
+                        G = e = "\\}";
                         I.output = n;
                         for (const t of r)I.output += t.output || t.value;
                     }
                     push({
                         type: "brace",
-                        value: F,
+                        value: G,
                         output: e
                     });
                     decrement("braces");
                     M.pop();
                     continue;
                 }
-                if ("|" === F) {
+                if ("|" === G) {
                     if (N.length > 0) N[N.length - 1].conditions++;
                     push({
                         type: "text",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if ("," === F) {
-                    let t = F;
+                if ("," === G) {
+                    let t = G;
                     const e = M[M.length - 1];
                     if (e && "braces" === B[B.length - 1]) {
                         e.comma = true;
@@ -1958,12 +2250,12 @@ var e = {
                     }
                     push({
                         type: "comma",
-                        value: F,
+                        value: G,
                         output: t
                     });
                     continue;
                 }
-                if ("/" === F) {
+                if ("/" === G) {
                     if ("dot" === D.type && I.index === I.start + 1) {
                         I.start = I.index + 1;
                         I.consumed = "";
@@ -1974,50 +2266,50 @@ var e = {
                     }
                     push({
                         type: "slash",
-                        value: F,
+                        value: G,
                         output: E
                     });
                     continue;
                 }
-                if ("." === F) {
+                if ("." === G) {
                     if (I.braces > 0 && "dot" === D.type) {
-                        if ("." === D.value) D.output = R;
+                        if ("." === D.value) D.output = m;
                         const t = M[M.length - 1];
                         D.type = "dots";
-                        D.output += F;
-                        D.value += F;
+                        D.output += G;
+                        D.value += G;
                         t.dots = true;
                         continue;
                     }
                     if (I.braces + I.parens === 0 && "bos" !== D.type && "slash" !== D.type) {
                         push({
                             type: "text",
-                            value: F,
-                            output: R
+                            value: G,
+                            output: m
                         });
                         continue;
                     }
                     push({
                         type: "dot",
-                        value: F,
-                        output: R
+                        value: G,
+                        output: m
                     });
                     continue;
                 }
-                if ("?" === F) {
+                if ("?" === G) {
                     const t = D && "(" === D.value;
-                    if (!t && true !== n.noextglob && "(" === G() && "?" !== G(2)) {
-                        extglobOpen("qmark", F);
+                    if (!t && true !== n.noextglob && "(" === F() && "?" !== F(2)) {
+                        extglobOpen("qmark", G);
                         continue;
                     }
                     if (D && "paren" === D.type) {
-                        const t = G();
-                        let e = F;
+                        const t = F();
+                        let e = G;
                         if ("<" === t && !s.supportsLookbehinds()) throw new Error("Node.js v10 or higher is required for regex lookbehinds");
-                        if ("(" === D.value && !/[!=<:]/.test(t) || "<" === t && !/<([!=]|\w+>)/.test(remaining())) e = `\\${F}`;
+                        if ("(" === D.value && !/[!=<:]/.test(t) || "<" === t && !/<([!=]|\w+>)/.test(remaining())) e = `\\${G}`;
                         push({
                             type: "text",
-                            value: F,
+                            value: G,
                             output: e
                         });
                         continue;
@@ -2025,22 +2317,22 @@ var e = {
                     if (true !== n.dot && ("slash" === D.type || "bos" === D.type)) {
                         push({
                             type: "qmark",
-                            value: F,
+                            value: G,
                             output: H
                         });
                         continue;
                     }
                     push({
                         type: "qmark",
-                        value: F,
+                        value: G,
                         output: $
                     });
                     continue;
                 }
-                if ("!" === F) {
-                    if (true !== n.noextglob && "(" === G()) {
-                        if ("?" !== G(2) || !/[!=<:]/.test(G(3))) {
-                            extglobOpen("negate", F);
+                if ("!" === G) {
+                    if (true !== n.noextglob && "(" === F()) {
+                        if ("?" !== F(2) || !/[!=<:]/.test(F(3))) {
+                            extglobOpen("negate", G);
                             continue;
                         }
                     }
@@ -2049,79 +2341,79 @@ var e = {
                         continue;
                     }
                 }
-                if ("+" === F) {
-                    if (true !== n.noextglob && "(" === G() && "?" !== G(2)) {
-                        extglobOpen("plus", F);
+                if ("+" === G) {
+                    if (true !== n.noextglob && "(" === F() && "?" !== F(2)) {
+                        extglobOpen("plus", G);
                         continue;
                     }
                     if (D && "(" === D.value || false === n.regex) {
                         push({
                             type: "plus",
-                            value: F,
-                            output: m
+                            value: G,
+                            output: R
                         });
                         continue;
                     }
                     if (D && ("bracket" === D.type || "paren" === D.type || "brace" === D.type) || I.parens > 0) {
                         push({
                             type: "plus",
-                            value: F
+                            value: G
                         });
                         continue;
                     }
                     push({
                         type: "plus",
-                        value: m
+                        value: R
                     });
                     continue;
                 }
-                if ("@" === F) {
-                    if (true !== n.noextglob && "(" === G() && "?" !== G(2)) {
+                if ("@" === G) {
+                    if (true !== n.noextglob && "(" === F() && "?" !== F(2)) {
                         push({
                             type: "at",
                             extglob: true,
-                            value: F,
+                            value: G,
                             output: ""
                         });
                         continue;
                     }
                     push({
                         type: "text",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
-                if ("*" !== F) {
-                    if ("$" === F || "^" === F) F = `\\${F}`;
+                if ("*" !== G) {
+                    if ("$" === G || "^" === G) G = `\\${G}`;
                     const t = a.exec(remaining());
                     if (t) {
-                        F += t[0];
+                        G += t[0];
                         I.index += t[0].length;
                     }
                     push({
                         type: "text",
-                        value: F
+                        value: G
                     });
                     continue;
                 }
                 if (D && ("globstar" === D.type || true === D.star)) {
                     D.type = "star";
                     D.star = true;
-                    D.value += F;
-                    D.output = k;
+                    D.value += G;
+                    D.output = P;
                     I.backtrack = true;
                     I.globstar = true;
-                    consume(F);
+                    consume(G);
                     continue;
                 }
                 let e = remaining();
                 if (true !== n.noextglob && /^\([^?]/.test(e)) {
-                    extglobOpen("star", F);
+                    extglobOpen("star", G);
                     continue;
                 }
                 if ("star" === D.type) {
                     if (true === n.noglobstar) {
-                        consume(F);
+                        consume(G);
                         continue;
                     }
                     const r = D.prev;
@@ -2131,7 +2423,7 @@ var e = {
                     if (true === n.bash && (!o || e[0] && "/" !== e[0])) {
                         push({
                             type: "star",
-                            value: F,
+                            value: G,
                             output: ""
                         });
                         continue;
@@ -2141,7 +2433,7 @@ var e = {
                     if (!o && "paren" !== r.type && !a && !u) {
                         push({
                             type: "star",
-                            value: F,
+                            value: G,
                             output: ""
                         });
                         continue;
@@ -2154,11 +2446,11 @@ var e = {
                     }
                     if ("bos" === r.type && eos()) {
                         D.type = "globstar";
-                        D.value += F;
+                        D.value += G;
                         D.output = globstar(n);
                         I.output = D.output;
                         I.globstar = true;
-                        consume(F);
+                        consume(G);
                         continue;
                     }
                     if ("slash" === r.type && "bos" !== r.prev.type && !i && eos()) {
@@ -2166,10 +2458,10 @@ var e = {
                         r.output = `(?:${r.output}`;
                         D.type = "globstar";
                         D.output = globstar(n) + (n.strictSlashes ? ")" : "|$)");
-                        D.value += F;
+                        D.value += G;
                         I.globstar = true;
                         I.output += r.output + D.output;
-                        consume(F);
+                        consume(G);
                         continue;
                     }
                     if ("slash" === r.type && "bos" !== r.prev.type && "/" === e[0]) {
@@ -2178,10 +2470,10 @@ var e = {
                         r.output = `(?:${r.output}`;
                         D.type = "globstar";
                         D.output = `${globstar(n)}${E}|${E}${t})`;
-                        D.value += F;
+                        D.value += G;
                         I.output += r.output + D.output;
                         I.globstar = true;
-                        consume(F + U());
+                        consume(G + U());
                         push({
                             type: "slash",
                             value: "/",
@@ -2191,11 +2483,11 @@ var e = {
                     }
                     if ("bos" === r.type && "/" === e[0]) {
                         D.type = "globstar";
-                        D.value += F;
+                        D.value += G;
                         D.output = `(?:^|${E}|${globstar(n)}${E})`;
                         I.output = D.output;
                         I.globstar = true;
-                        consume(F + U());
+                        consume(G + U());
                         push({
                             type: "slash",
                             value: "/",
@@ -2206,16 +2498,16 @@ var e = {
                     I.output = I.output.slice(0, -D.output.length);
                     D.type = "globstar";
                     D.output = globstar(n);
-                    D.value += F;
+                    D.value += G;
                     I.output += D.output;
                     I.globstar = true;
-                    consume(F);
+                    consume(G);
                     continue;
                 }
                 const r = {
                     type: "star",
-                    value: F,
-                    output: k
+                    value: G,
+                    output: P
                 };
                 if (true === n.bash) {
                     r.output = ".*?";
@@ -2224,7 +2516,7 @@ var e = {
                     continue;
                 }
                 if (D && ("bracket" === D.type || "paren" === D.type) && true === n.regex) {
-                    r.output = F;
+                    r.output = G;
                     push(r);
                     continue;
                 }
@@ -2239,7 +2531,7 @@ var e = {
                         I.output += L;
                         D.output += L;
                     }
-                    if ("*" !== G()) {
+                    if ("*" !== F()) {
                         I.output += b;
                         D.output += b;
                     }
@@ -2284,8 +2576,8 @@ var e = {
             if (a > i) throw new SyntaxError(`Input length: ${a}, exceeds maximum allowed length: ${i}`);
             t = c[t] || t;
             const u = s.isWindows(e);
-            const { DOT_LITERAL: l, SLASH_LITERAL: f, ONE_CHAR: p, DOTS_SLASH: d, NO_DOT: h, NO_DOTS: g, NO_DOTS_SLASH: _, STAR: A, START_ANCHOR: R } = r.globChars(u);
-            const m = n.dot ? g : h;
+            const { DOT_LITERAL: l, SLASH_LITERAL: f, ONE_CHAR: p, DOTS_SLASH: d, NO_DOT: h, NO_DOTS: g, NO_DOTS_SLASH: _, STAR: A, START_ANCHOR: m } = r.globChars(u);
+            const R = n.dot ? g : h;
             const E = n.dot ? _ : h;
             const b = n.capture ? "" : "?:";
             const w = {
@@ -2296,26 +2588,26 @@ var e = {
             if (n.capture) C = `(${C})`;
             const globstar = (t)=>{
                 if (true === t.noglobstar) return C;
-                return `(${b}(?:(?!${R}${t.dot ? d : l}).)*?)`;
+                return `(${b}(?:(?!${m}${t.dot ? d : l}).)*?)`;
             };
             const create = (t)=>{
                 switch(t){
                     case "*":
-                        return `${m}${p}${C}`;
+                        return `${R}${p}${C}`;
                     case ".*":
                         return `${l}${p}${C}`;
                     case "*.*":
-                        return `${m}${C}${l}${p}${C}`;
+                        return `${R}${C}${l}${p}${C}`;
                     case "*/*":
-                        return `${m}${C}${f}${p}${E}${C}`;
+                        return `${R}${C}${f}${p}${E}${C}`;
                     case "**":
-                        return m + globstar(n);
+                        return R + globstar(n);
                     case "**/*":
-                        return `(?:${m}${globstar(n)}${f})?${E}${p}${C}`;
+                        return `(?:${R}${globstar(n)}${f})?${E}${p}${C}`;
                     case "**/*.*":
-                        return `(?:${m}${globstar(n)}${f})?${E}${C}${l}${p}${C}`;
+                        return `(?:${R}${globstar(n)}${f})?${E}${C}${l}${p}${C}`;
                     case "**/.*":
-                        return `(?:${m}${globstar(n)}${f})?${l}${p}${C}`;
+                        return `(?:${R}${globstar(n)}${f})?${l}${p}${C}`;
                     default:
                         {
                             const e = /^(.*?)\.(\w+)$/.exec(t);
@@ -2469,14 +2761,14 @@ var e = {
     },
     779: (t, e, n)=>{
         const r = n(445);
-        const { CHAR_ASTERISK: s, CHAR_AT: o, CHAR_BACKWARD_SLASH: i, CHAR_COMMA: a, CHAR_DOT: u, CHAR_EXCLAMATION_MARK: c, CHAR_FORWARD_SLASH: l, CHAR_LEFT_CURLY_BRACE: f, CHAR_LEFT_PARENTHESES: p, CHAR_LEFT_SQUARE_BRACKET: d, CHAR_PLUS: h, CHAR_QUESTION_MARK: g, CHAR_RIGHT_CURLY_BRACE: _, CHAR_RIGHT_PARENTHESES: A, CHAR_RIGHT_SQUARE_BRACKET: R } = n(193);
+        const { CHAR_ASTERISK: s, CHAR_AT: o, CHAR_BACKWARD_SLASH: i, CHAR_COMMA: a, CHAR_DOT: u, CHAR_EXCLAMATION_MARK: c, CHAR_FORWARD_SLASH: l, CHAR_LEFT_CURLY_BRACE: f, CHAR_LEFT_PARENTHESES: p, CHAR_LEFT_SQUARE_BRACKET: d, CHAR_PLUS: h, CHAR_QUESTION_MARK: g, CHAR_RIGHT_CURLY_BRACE: _, CHAR_RIGHT_PARENTHESES: A, CHAR_RIGHT_SQUARE_BRACKET: m } = n(193);
         const isPathSeparator = (t)=>t === l || t === i;
         const depth = (t)=>{
             if (true !== t.isPrefix) t.depth = t.isGlobstar ? 1 / 0 : 1;
         };
         const scan = (t, e)=>{
             const n = e || {};
-            const m = t.length - 1;
+            const R = t.length - 1;
             const E = true === n.parts || true === n.scanToEnd;
             const b = [];
             const w = [];
@@ -2488,28 +2780,28 @@ var e = {
             let T = false;
             let O = false;
             let L = false;
-            let P = false;
             let k = false;
+            let P = false;
             let I = false;
             let N = false;
             let M = false;
             let B = false;
             let D = false;
-            let F = 0;
-            let G;
+            let G = 0;
+            let F;
             let U;
             let W = {
                 value: "",
                 depth: 0,
                 isGlob: false
             };
-            const eos = ()=>S >= m;
+            const eos = ()=>S >= R;
             const peek = ()=>v.charCodeAt(S + 1);
             const advance = ()=>{
-                G = U;
+                F = U;
                 return v.charCodeAt(++S);
             };
-            while(S < m){
+            while(S < R){
                 U = advance();
                 let t;
                 if (U === i) {
@@ -2519,7 +2811,7 @@ var e = {
                     continue;
                 }
                 if (true === I || U === f) {
-                    F++;
+                    G++;
                     while(true !== eos() && (U = advance())){
                         if (U === i) {
                             N = W.backslashes = true;
@@ -2527,7 +2819,7 @@ var e = {
                             continue;
                         }
                         if (U === f) {
-                            F++;
+                            G++;
                             continue;
                         }
                         if (true !== I && U === u && (U = advance()) === u) {
@@ -2545,8 +2837,8 @@ var e = {
                             break;
                         }
                         if (U === _) {
-                            F--;
-                            if (0 === F) {
+                            G--;
+                            if (0 === G) {
                                 I = false;
                                 T = W.isBrace = true;
                                 D = true;
@@ -2566,7 +2858,7 @@ var e = {
                         isGlob: false
                     };
                     if (true === D) continue;
-                    if (G === u && S === $ + 1) {
+                    if (F === u && S === $ + 1) {
                         $ += 2;
                         continue;
                     }
@@ -2577,7 +2869,7 @@ var e = {
                     const t = U === h || U === o || U === s || U === g || U === c;
                     if (true === t && peek() === p) {
                         L = W.isGlob = true;
-                        P = W.isExtglob = true;
+                        k = W.isExtglob = true;
                         D = true;
                         if (U === c && S === $) B = true;
                         if (true === E) {
@@ -2599,7 +2891,7 @@ var e = {
                     }
                 }
                 if (U === s) {
-                    if (G === s) k = W.isGlobstar = true;
+                    if (F === s) P = W.isGlobstar = true;
                     L = W.isGlob = true;
                     D = true;
                     if (true === E) continue;
@@ -2618,7 +2910,7 @@ var e = {
                             advance();
                             continue;
                         }
-                        if (t === R) {
+                        if (t === m) {
                             O = W.isBracket = true;
                             L = W.isGlob = true;
                             D = true;
@@ -2658,7 +2950,7 @@ var e = {
                 }
             }
             if (true === n.noext) {
-                P = false;
+                k = false;
                 L = false;
             }
             let K = v;
@@ -2692,8 +2984,8 @@ var e = {
                 isBrace: T,
                 isBracket: O,
                 isGlob: L,
-                isExtglob: P,
-                isGlobstar: k,
+                isExtglob: k,
+                isGlobstar: P,
                 negated: M,
                 negatedExtglob: B
             };
@@ -3013,8 +3305,8 @@ __nccwpck_require__.d(r, {
     Kd: ()=>N,
     li: ()=>M,
     IK: ()=>L,
-    AG: ()=>k,
-    Hz: ()=>P,
+    AG: ()=>P,
+    Hz: ()=>k,
     ey: ()=>I,
     Zh: ()=>isGitIgnored,
     kD: ()=>isGitIgnoredSync,
@@ -3217,9 +3509,9 @@ const g = require("node:url");
 function toPath(t) {
     return t instanceof URL ? (0, g.fileURLToPath)(t) : t;
 }
-const R = require("node:fs/promises");
-const m = require("node:os");
-var E = __nccwpck_require__(869);
+const m = require("node:fs/promises");
+const R = require("node:os");
+var E = __nccwpck_require__(425);
 function isPathInside(t, e) {
     const n = i.relative(e, t);
     return Boolean(n && ".." !== n && !n.startsWith(`..${i.sep}`) && n !== i.resolve(t));
@@ -3507,7 +3799,7 @@ const S = {
 };
 const $ = "**/.gitignore";
 const H = 10;
-const getReadFileMethod = (t)=>bindFsMethod(t?.promises, "readFile") ?? bindFsMethod(R, "readFile") ?? promisifyFsMethod(t, "readFile");
+const getReadFileMethod = (t)=>bindFsMethod(t?.promises, "readFile") ?? bindFsMethod(m, "readFile") ?? promisifyFsMethod(t, "readFile");
 const getReadFileSyncMethod = (t)=>bindFsMethod(t, "readFileSync") ?? bindFsMethod(o, "readFileSync");
 const shouldSkipIgnoreFileError = (t, e)=>{
     if (!t) return Boolean(e);
@@ -3684,7 +3976,7 @@ const parseGitConfigValue = (t)=>{
 };
 const resolveConfigPath = (t, e)=>{
     if (e.startsWith("~/")) {
-        const t = m.homedir();
+        const t = R.homedir();
         const n = i.join(t, e.slice(2));
         if (!isPathInside(n, t)) return i.join(t, ".globby-invalid-path-traversal");
         return n;
@@ -3731,7 +4023,7 @@ const parseIncludeIfCondition = (t)=>{
     return e ? e[1] : void 0;
 };
 const normalizeGitConfigConditionPattern = (t, e)=>{
-    if (t.startsWith("~/")) t = i.join(m.homedir(), t.slice(2));
+    if (t.startsWith("~/")) t = i.join(R.homedir(), t.slice(2));
     else if (t.startsWith("./")) t = i.resolve(i.dirname(e), t.slice(2));
     else if (!i.isAbsolute(t)) t = `**/${t}`;
     if (t.endsWith("/")) t += "**";
@@ -3903,7 +4195,7 @@ const getGitDirectoryAsync = async (t, e)=>{
         return n;
     }
 };
-const getXdgConfigHome = ()=>s.env.XDG_CONFIG_HOME || i.join(m.homedir(), ".config");
+const getXdgConfigHome = ()=>s.env.XDG_CONFIG_HOME || i.join(R.homedir(), ".config");
 const getGitConfigPaths = ()=>{
     if ("GIT_CONFIG_GLOBAL" in s.env) {
         const t = s.env.GIT_CONFIG_GLOBAL;
@@ -3913,7 +4205,7 @@ const getGitConfigPaths = ()=>{
     }
     return [
         i.join(getXdgConfigHome(), "git", "config"),
-        i.join(m.homedir(), ".gitconfig")
+        i.join(R.homedir(), ".gitconfig")
     ];
 };
 const getDefaultGlobalGitignorePath = ()=>i.join(getXdgConfigHome(), "git", "ignore");
@@ -4529,14 +4821,14 @@ const L = normalizeArguments(async (t, e)=>{
     const i = await Promise.all(o.map((t)=>(0, p["default"])(t.patterns, t.options)));
     return unionFastGlobResultsAsync(i, s);
 });
-const P = normalizeArgumentsSync((t, e)=>{
+const k = normalizeArgumentsSync((t, e)=>{
     assertGlobalGitignoreSyncSupport(e);
     const { options: n, pruneIgnorePatterns: r, filter: s } = applyIgnoreFilesAndGetFilterSync(e);
     const o = generateTasksSync(t, n, r);
     const i = o.map((t)=>p["default"].sync(t.patterns, t.options));
     return unionFastGlobResults(i, s);
 });
-const k = normalizeArgumentsSync((t, e)=>{
+const P = normalizeArgumentsSync((t, e)=>{
     assertGlobalGitignoreAsyncSupport(e);
     const n = new Set;
     const r = a.Readable.from(async function*() {
@@ -4559,8 +4851,8 @@ const N = normalizeArguments(generateTasks);
 const M = normalizeArgumentsSync(generateTasksSync);
 const { convertPathToPattern: B } = p["default"];
 var D = r.a;
-var F = r.Kd;
-var G = r.li;
+var G = r.Kd;
+var F = r.li;
 var U = r.IK;
 var W = r.AG;
 var K = r.Hz;
@@ -4569,4 +4861,4 @@ var q = r.Zh;
 var z = r.kD;
 var Q = r.dK;
 var X = r.Sb;
-export { D as convertPathToPattern, F as generateGlobTasks, G as generateGlobTasksSync, U as globby, W as globbyStream, K as globbySync, j as isDynamicPattern, q as isGitIgnored, z as isGitIgnoredSync, Q as isIgnoredByIgnoreFiles, X as isIgnoredByIgnoreFilesSync };
+export { D as convertPathToPattern, G as generateGlobTasks, F as generateGlobTasksSync, U as globby, W as globbyStream, K as globbySync, j as isDynamicPattern, q as isGitIgnored, z as isGitIgnoredSync, Q as isIgnoredByIgnoreFiles, X as isIgnoredByIgnoreFilesSync };