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

package/dist/compiled/globby/index.js

@@ -229,10 +229,10 @@
                 let x = E;
                 let C = 0;
                 const S = t.length;
-                let v = 0;
                 let $ = 0;
+                let v = 0;
                 let T;
-                const advance = ()=>t[v++];
+                const advance = ()=>t[$++];
                 const push = (t)=>{
                     if ("text" === t.type && "dot" === x.type) x.type = "text";
                     if (x && "text" === x.type && "text" === t.type) {
@@ -248,7 +248,7 @@
                 push({
                     type: "bos"
                 });
-                while(v < S){
+                while($ < S){
                     w = b[b.length - 1];
                     T = advance();
                     if (T === R || T === A) continue;
@@ -269,7 +269,7 @@
                     if (T === h) {
                         C++;
                         let t;
-                        while(v < S && (t = advance())){
+                        while($ < S && (t = advance())){
                             T += t;
                             if (t === h) {
                                 C++;
@@ -323,7 +323,7 @@
                         const t = T;
                         let n;
                         if (true !== e.keepQuotes) T = "";
-                        while(v < S && (n = advance())){
+                        while($ < S && (n = advance())){
                             if (n === i) {
                                 T += n + advance();
                                 continue;
@@ -342,14 +342,14 @@
                     }
                     if (T === p) {
                         s.assertDepth(b.length);
-                        $++;
+                        v++;
                         const t = x.value && "$" === x.value.slice(-1) || true === w.dollar;
                         const e = {
                             type: "brace",
                             open: true,
                             close: false,
                             dollar: t,
-                            depth: $,
+                            depth: v,
                             commas: 0,
                             ranges: 0,
                             nodes: []
@@ -377,11 +377,11 @@
                             type: t,
                             value: T
                         });
-                        $--;
+                        v--;
                         w = b[b.length - 1];
                         continue;
                     }
-                    if (T === a && $ > 0) {
+                    if (T === a && v > 0) {
                         if (w.ranges > 0) {
                             w.ranges = 0;
                             const t = w.nodes.shift();
@@ -400,9 +400,9 @@
                         w.commas++;
                         continue;
                     }
-                    if (T === c && $ > 0 && 0 === w.commas) {
+                    if (T === c && v > 0 && 0 === w.commas) {
                         const t = w.nodes;
-                        if (0 === $ || 0 === t.length) {
+                        if (0 === v || 0 === t.length) {
                             push({
                                 type: "text",
                                 value: T
@@ -731,7 +731,7 @@
             };
             t.exports = fill;
         },
-        869: (t)=>{
+        425: (t)=>{
             function makeArray(t) {
                 return Array.isArray(t) ? t : [
                     t
@@ -741,45 +741,153 @@
             const n = "";
             const r = " ";
             const s = "\\";
-            const o = /^\s+$/;
-            const i = /(?:[^\\]|^)\\$/;
-            const u = /^\\!/;
-            const a = /^\\#/;
-            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 u = /(?:[^\\]|^)\\$/;
+            const a = /^\\!/;
+            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 y = 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 y = [
-                [
-                    /^\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 _ = {
+                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 A = "\\]^-[";
+            const escapeMember = (t)=>A.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 u = n;
+                const a = t[i];
+                if ("!" === a || "^" === a) {
+                    u = "^";
+                    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 = _[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(u, c)
+                    };
+                }
+            };
+            const m = "[]";
+            const E = "\0";
+            const b = new RegExp(`${E}(\\d+)${E}`, "g");
+            const w = "";
+            const x = "";
+            const extractBrackets = (t)=>{
+                const i = [];
+                const hold = (t)=>`${E}${i.push(t) - 1}${E}`;
+                const { length: u } = t;
+                let a = n;
+                let c = 0;
+                while(c < u){
+                    const n = t[c];
+                    if (n === s) {
+                        const n = t[c + 1];
+                        if (n === e || n === h && c + 2 === u) a += hold(m);
+                        else if ("*" === n || "[" === n || n === r || n === s) a += t.slice(c, c + 2);
+                        else a += hold(o.test(n) ? s + n : n);
+                        c += 2;
+                    } else if (n === E) {
+                        a += hold(`[${E}]`);
+                        c++;
+                    } else if ("[" === n) {
+                        const e = scanBracket(t, c);
+                        if (null === e) {
+                            a += hold(m);
+                            c = u;
+                        } else {
+                            a += hold(e.source);
+                            c = e.end + 1;
+                        }
+                    } else {
+                        a += n;
+                        c++;
+                    }
+                }
+                return {
+                    source: a,
+                    sources: i
+                };
+            };
+            const C = null;
+            const S = /\/(?!$)/;
+            const $ = [
+                [
+                    /(\\+)( ?)/g,
+                    (t, e, n)=>n ? e.slice(0, e.length - e.length % 2) + r : e,
+                    s + r
                 ],
                 [
                     /[\\$.|*+(){^]/g,
@@ -787,72 +895,204 @@
                 ],
                 [
                     /(?!\\)\?/g,
-                    ()=>"[^/]"
+                    ()=>"[^/]",
+                    "?"
                 ],
                 [
                     /^\//,
-                    ()=>"^"
+                    ()=>"^",
+                    h
                 ],
                 [
                     /\//g,
-                    ()=>"\\/"
+                    ()=>"\\/",
+                    h
                 ],
                 [
-                    /^\^*\\\*\\\*\\\//,
-                    ()=>"^(?:.*\\/)?"
+                    /^\^*(?:\\\*\\\*\\\/)+/,
+                    ()=>"^(?:.*\\/)?",
+                    "*"
                 ],
                 [
-                    /^(?=[^^])/,
-                    function() {
-                        return /\/(?!$)/.test(this) ? "^" : "(?:^|\\/)";
+                    C,
+                    (t, e)=>{
+                        if (!t || "^" === t[0]) return t;
+                        const n = S.test(e) ? "^" : "(?:^|\\/)";
+                        return n + t;
                     }
                 ],
                 [
                     /\\\/\\\*\\\*(?=\\\/|$)/g,
-                    (t, e, n)=>e + 6 < n.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+                    (t, e, n)=>e + 6 < n.length ? "\\/" === n.slice(e + 6) ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${x}`,
+                    "*"
                 ],
                 [
                     /(^|[^\\]+)(\\\*)+(?=.+)/g,
                     (t, e, n)=>{
                         const r = n.replace(/\\\*/g, "[^\\/]*");
                         return e + r;
-                    }
+                    },
+                    "*"
+                ],
+                [
+                    /(^|[^\\])((?:\\\\)*)\\\*$/,
+                    (t, e, n)=>n.length / 2 % 2 === 0 ? e + n + w : 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}(?=$|\\/$)`
+                    C,
+                    (t)=>{
+                        const e = t[t.length - 1];
+                        if (!e || e === w || e === x) return t;
+                        return e === h ? `${t}$` : `${t}(?=$|\\/$)`;
+                    }
                 ]
             ];
-            const _ = /(^|\\\/)?\\\*$/;
-            const A = "regex";
-            const R = "checkRegex";
-            const m = "_";
-            const E = {
-                [A] (t, e) {
-                    const n = e ? `${e}[^/]+` : "[^/]*";
-                    return `${n}(?=$|\\/$)`;
-                },
-                [R] (t, e) {
-                    const n = e ? `${e}[^/]*` : "[^/]*";
-                    return `${n}(?=$|\\/$)`;
+            const v = /(^|\\\/)?\uE000$/;
+            const T = "regex";
+            const H = "checkRegex";
+            const O = "_";
+            const replaceTrailingWildcard = (t, e)=>{
+                const n = e ? `${e}[^/]+` : "[^/]*";
+                return `${n}(?=$|\\/$)`;
+            };
+            const L = /\uE001$/;
+            const replaceTrailingDoublestar = ()=>".+(?=$|\\/$)";
+            const P = "[^\\/]*";
+            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(P) < 0) return t;
+                const e = [];
+                const { length: r } = t;
+                let o = 0;
+                while(o < r){
+                    const n = t[o];
+                    if (t.startsWith(P, o)) {
+                        e.push({
+                            wildcard: true
+                        });
+                        o += P.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 u = [];
+                const flush = ()=>{
+                    let t;
+                    u.forEach((e, n)=>{
+                        if (e.wildcard) t = n;
+                    });
+                    u.forEach((e, n)=>{
+                        if (!e.wildcard) {
+                            i += e.single;
+                            return;
+                        }
+                        i += n === t ? P : `(?:(?!${separatorAfter(u, n)})[^\\/])*`;
+                    });
+                    u = [];
+                };
+                e.forEach((t)=>{
+                    if (void 0 === t.boundary) return void u.push(t);
+                    flush();
+                    i += t.boundary;
+                });
+                flush();
+                return i;
+            };
+            const makeRegexPrefix = (t)=>{
+                const { source: n, sources: r } = extractBrackets(t);
+                const s = $.reduce((n, [r, s, o])=>{
+                    if (r === C) 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(b, (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 === w ? `${n}$` : r === x ? `${n}.*$` : m;
+            };
+            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)=>y.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) && !u.test(t);
+            const splitPattern = (t)=>t.split(l).filter(Boolean);
             class IgnoreRule {
                 constructor(t, e, n, r, s, o){
                     this.pattern = t;
@@ -862,77 +1102,125 @@
                     define(this, "ignoreCase", r);
                     define(this, "regexPrefix", o);
                 }
+                get _basenameOnly() {
+                    return define(this, "_basenameOnly", matchesBasename(this.body));
+                }
                 get regex() {
-                    const t = m + A;
+                    const t = O + T;
                     if (this[t]) return this[t];
-                    return this._make(A, t);
+                    return this._make(T, t);
                 }
                 get checkRegex() {
-                    const t = m + R;
+                    const t = O + H;
                     if (this[t]) return this[t];
-                    return this._make(R, t);
+                    return this._make(H, t);
                 }
                 _make(t, e) {
-                    const n = this.regexPrefix.replace(_, E[t]);
+                    const n = pinWildcards(t === T ? this.regexPrefix.replace(v, replaceTrailingWildcard).replace(L, 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(u, "!").replace(a, "#");
-                const o = makeRegexPrefix(s);
-                return new IgnoreRule(t, e, s, n, r, o);
+                const u = s[s.length - 1];
+                if (u === r || "\r" === u || "\n" === u) s = trimEnd(s);
+                if (!s) return;
+                s = s.replace(a, "!").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[y]) {
                         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 u = n[i];
+                        if (u.checkRegex.test(t)) {
+                            r = !u.negative;
+                            s = u.negative;
+                            o = u.negative ? e : u;
+                            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((u)=>{
-                        const { negative: a } = u;
-                        if (o === a && s !== o || a && !s && !o && !n) return;
-                        const c = u[r].test(t);
-                        if (!c) return;
-                        s = !a;
-                        o = a;
-                        i = a ? e : u;
-                    });
-                    const u = {
+                    const u = this._rules;
+                    const { length: a } = u;
+                    const c = 2 * this._basenameCount >= a;
+                    const l = c ? basenameOf(t) : t;
+                    for(let f = 0; f < a; f++){
+                        const a = u[f];
+                        const { negative: p } = a;
+                        const d = o === p && s !== o || p && !s && !o && !n;
+                        if (!d && a[r].test(c && a._basenameOnly ? l : t)) {
+                            s = !p;
+                            o = p;
+                            i = p ? e : a;
+                        }
+                    }
+                    const f = {
                         ignored: s,
                         unignored: o
                     };
-                    if (i) u.rule = i;
-                    return u;
+                    if (i) f.rule = i;
+                    return f;
                 }
             }
             const throwError = (t, e)=>{
@@ -947,12 +1235,21 @@
                 }
                 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, y, true);
                     this._rules = new RuleManager(e);
                     this._strictPathCheck = !n;
                     this._initCache();
@@ -968,28 +1265,23 @@
                 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, R);
+                    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, A);
-                    const s = this._t(r.join(p) + p, e, n, r);
-                    return e[t] = s.ignored ? s : this._rules.test(t, n, A);
+                _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, T);
                 }
                 ignores(t) {
                     return this._test(t, this._ignoreCache, false).ignored;
@@ -1563,11 +1855,11 @@
                 const g = s.isWindows(e);
                 const y = r.globChars(g);
                 const _ = r.extglobChars(y);
-                const { DOT_LITERAL: A, PLUS_LITERAL: R, SLASH_LITERAL: m, ONE_CHAR: E, DOTS_SLASH: b, NO_DOT: w, NO_DOT_SLASH: x, NO_DOTS_SLASH: C, QMARK: S, QMARK_NO_DOT: v, STAR: $, START_ANCHOR: T } = y;
+                const { DOT_LITERAL: A, PLUS_LITERAL: R, SLASH_LITERAL: m, ONE_CHAR: E, DOTS_SLASH: b, NO_DOT: w, NO_DOT_SLASH: x, NO_DOTS_SLASH: C, QMARK: S, QMARK_NO_DOT: $, STAR: v, START_ANCHOR: T } = y;
                 const globstar = (t)=>`(${h}(?:(?!${T}${t.dot ? b : A}).)*?)`;
                 const H = n.dot ? "" : w;
-                const O = n.dot ? S : v;
-                let L = true === n.bash ? globstar(n) : $;
+                const O = n.dot ? S : $;
+                let L = true === n.bash ? globstar(n) : v;
                 if (n.capture) L = `(${L})`;
                 if ("boolean" == typeof n.noext) n.noextglob = n.noext;
                 const P = {
@@ -2037,7 +2329,7 @@
                             push({
                                 type: "qmark",
                                 value: B,
-                                output: v
+                                output: $
                             });
                             continue;
                         }
@@ -2497,8 +2789,8 @@
                 let x = t;
                 let C = -1;
                 let S = 0;
-                let v = 0;
-                let $ = false;
+                let $ = 0;
+                let v = false;
                 let T = false;
                 let H = false;
                 let O = false;
@@ -2544,14 +2836,14 @@
                                 continue;
                             }
                             if (true !== P && F === a && (F = advance()) === a) {
-                                $ = G.isBrace = true;
+                                v = G.isBrace = true;
                                 H = G.isGlob = true;
                                 M = true;
                                 if (true === m) continue;
                                 break;
                             }
                             if (true !== P && F === u) {
-                                $ = G.isBrace = true;
+                                v = G.isBrace = true;
                                 H = G.isGlob = true;
                                 M = true;
                                 if (true === m) continue;
@@ -2561,7 +2853,7 @@
                                 B--;
                                 if (0 === B) {
                                     P = false;
-                                    $ = G.isBrace = true;
+                                    v = G.isBrace = true;
                                     M = true;
                                     break;
                                 }
@@ -2583,7 +2875,7 @@
                             S += 2;
                             continue;
                         }
-                        v = C + 1;
+                        $ = C + 1;
                         continue;
                     }
                     if (true !== n.noext) {
@@ -2680,11 +2972,11 @@
                 if (S > 0) {
                     W = x.slice(0, S);
                     x = x.slice(S);
-                    v -= S;
+                    $ -= S;
                 }
-                if (U && true === H && v > 0) {
-                    U = x.slice(0, v);
-                    j = x.slice(v);
+                if (U && true === H && $ > 0) {
+                    U = x.slice(0, $);
+                    j = x.slice($);
                 } else if (true === H) {
                     U = "";
                     j = x;
@@ -2702,7 +2994,7 @@
                     start: S,
                     base: U,
                     glob: j,
-                    isBrace: $,
+                    isBrace: v,
                     isBracket: T,
                     isGlob: H,
                     isExtglob: O,
@@ -3042,9 +3334,9 @@
             convertPathToPattern: ()=>P,
             generateGlobTasks: ()=>O,
             generateGlobTasksSync: ()=>L,
-            globby: ()=>v,
+            globby: ()=>$,
             globbyStream: ()=>T,
-            globbySync: ()=>$,
+            globbySync: ()=>v,
             isDynamicPattern: ()=>H,
             isGitIgnored: ()=>isGitIgnored,
             isGitIgnoredSync: ()=>isGitIgnoredSync,
@@ -3242,7 +3534,7 @@
         }
         const g = require("node:fs/promises");
         const y = require("node:os");
-        var _ = __nccwpck_require__(869);
+        var _ = __nccwpck_require__(425);
         function isPathInside(t, e) {
             const n = r.relative(e, t);
             return Boolean(n && ".." !== n && !n.startsWith(`..${r.sep}`) && n !== r.resolve(t));
@@ -4545,14 +4837,14 @@
             });
             return appendPruneIgnorePatterns(a, n);
         };
-        const v = normalizeArguments(async (t, e)=>{
+        const $ = normalizeArguments(async (t, e)=>{
             assertGlobalGitignoreAsyncSupport(e);
             const { options: n, pruneIgnorePatterns: r, filter: s } = await applyIgnoreFilesAndGetFilter(e);
             const o = await generateTasks(t, n, r);
             const i = await Promise.all(o.map((t)=>c(t.patterns, t.options)));
             return unionFastGlobResultsAsync(i, s);
         });
-        const $ = normalizeArgumentsSync((t, e)=>{
+        const v = normalizeArgumentsSync((t, e)=>{
             assertGlobalGitignoreSyncSupport(e);
             const { options: n, pruneIgnorePatterns: r, filter: s } = applyIgnoreFilesAndGetFilterSync(e);
             const o = generateTasksSync(t, n, r);