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

package/dist/compiled/globby/index.mjs

@@ -0,0 +1,4572 @@
+/*! LICENSE: index.mjs.LICENSE.txt */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import * as t from "fast-glob";
+var e = {
+    793: (t, e, n)=>{
+        const r = n(816);
+        const s = n(248);
+        const o = n(369);
+        const i = n(358);
+        const braces = (t, e = {})=>{
+            let n = [];
+            if (Array.isArray(t)) for (const r of t){
+                const t = braces.create(r, e);
+                if (Array.isArray(t)) n.push(...t);
+                else n.push(t);
+            }
+            else n = [].concat(braces.create(t, e));
+            if (e && true === e.expand && true === e.nodupes) n = [
+                ...new Set(n)
+            ];
+            return n;
+        };
+        braces.parse = (t, e = {})=>i(t, e);
+        braces.stringify = (t, e = {})=>{
+            if ("string" == typeof t) return r(braces.parse(t, e), e);
+            return r(t, e);
+        };
+        braces.compile = (t, e = {})=>{
+            if ("string" == typeof t) t = braces.parse(t, e);
+            return s(t, e);
+        };
+        braces.expand = (t, e = {})=>{
+            if ("string" == typeof t) t = braces.parse(t, e);
+            let n = o(t, e);
+            if (true === e.noempty) n = n.filter(Boolean);
+            if (true === e.nodupes) n = [
+                ...new Set(n)
+            ];
+            return n;
+        };
+        braces.create = (t, e = {})=>{
+            if ("" === t || t.length < 3) return [
+                t
+            ];
+            return true !== e.expand ? braces.compile(t, e) : braces.expand(t, e);
+        };
+        t.exports = braces;
+    },
+    248: (t, e, n)=>{
+        const r = n(790);
+        const s = n(372);
+        const compile = (t, e = {})=>{
+            const walk = (t, n = {}, o = 0)=>{
+                s.assertDepth(o);
+                const i = s.isInvalidBrace(n);
+                const a = true === t.invalid && true === e.escapeInvalid;
+                const u = true === i || true === a;
+                const c = true === e.escapeInvalid ? "\\" : "";
+                let l = "";
+                if (true === t.isOpen) return c + t.value;
+                if (true === t.isClose) {
+                    console.log("node.isClose", c, t.value);
+                    return c + t.value;
+                }
+                if ("open" === t.type) return u ? c + t.value : "(";
+                if ("close" === t.type) return u ? c + t.value : ")";
+                if ("comma" === t.type) return "comma" === t.prev.type ? "" : u ? t.value : "|";
+                if (t.value) return t.value;
+                if (t.nodes && t.ranges > 0) {
+                    const n = s.reduce(t.nodes);
+                    const o = r(...n, {
+                        ...e,
+                        wrap: false,
+                        toRegex: true,
+                        strictZeros: true
+                    });
+                    if (0 !== o.length) return n.length > 1 && o.length > 1 ? `(${o})` : o;
+                }
+                if (t.nodes) for (const e of t.nodes)l += walk(e, t, o + 1);
+                return l;
+            };
+            return walk(t);
+        };
+        t.exports = compile;
+    },
+    872: (t)=>{
+        t.exports = {
+            MAX_LENGTH: 1e4,
+            MAX_AST_DEPTH: 100,
+            CHAR_0: "0",
+            CHAR_9: "9",
+            CHAR_UPPERCASE_A: "A",
+            CHAR_LOWERCASE_A: "a",
+            CHAR_UPPERCASE_Z: "Z",
+            CHAR_LOWERCASE_Z: "z",
+            CHAR_LEFT_PARENTHESES: "(",
+            CHAR_RIGHT_PARENTHESES: ")",
+            CHAR_ASTERISK: "*",
+            CHAR_AMPERSAND: "&",
+            CHAR_AT: "@",
+            CHAR_BACKSLASH: "\\",
+            CHAR_BACKTICK: "`",
+            CHAR_CARRIAGE_RETURN: "\r",
+            CHAR_CIRCUMFLEX_ACCENT: "^",
+            CHAR_COLON: ":",
+            CHAR_COMMA: ",",
+            CHAR_DOLLAR: "$",
+            CHAR_DOT: ".",
+            CHAR_DOUBLE_QUOTE: '"',
+            CHAR_EQUAL: "=",
+            CHAR_EXCLAMATION_MARK: "!",
+            CHAR_FORM_FEED: "\f",
+            CHAR_FORWARD_SLASH: "/",
+            CHAR_HASH: "#",
+            CHAR_HYPHEN_MINUS: "-",
+            CHAR_LEFT_ANGLE_BRACKET: "<",
+            CHAR_LEFT_CURLY_BRACE: "{",
+            CHAR_LEFT_SQUARE_BRACKET: "[",
+            CHAR_LINE_FEED: "\n",
+            CHAR_NO_BREAK_SPACE: " ",
+            CHAR_PERCENT: "%",
+            CHAR_PLUS: "+",
+            CHAR_QUESTION_MARK: "?",
+            CHAR_RIGHT_ANGLE_BRACKET: ">",
+            CHAR_RIGHT_CURLY_BRACE: "}",
+            CHAR_RIGHT_SQUARE_BRACKET: "]",
+            CHAR_SEMICOLON: ";",
+            CHAR_SINGLE_QUOTE: "'",
+            CHAR_SPACE: " ",
+            CHAR_TAB: "\t",
+            CHAR_UNDERSCORE: "_",
+            CHAR_VERTICAL_LINE: "|",
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\ufeff"
+        };
+    },
+    369: (t, e, n)=>{
+        const r = n(790);
+        const s = n(816);
+        const o = n(372);
+        const append = (t = "", e = "", n = false)=>{
+            const r = [];
+            t = [].concat(t);
+            e = [].concat(e);
+            if (!e.length) return t;
+            if (!t.length) return n ? o.flatten(e).map((t)=>`{${t}}`) : e;
+            for (const s of t)if (Array.isArray(s)) for (const t of s)r.push(append(t, e, n));
+            else for (let t of e){
+                if (true === n && "string" == typeof t) t = `{${t}}`;
+                r.push(Array.isArray(t) ? append(s, t, n) : s + t);
+            }
+            return o.flatten(r);
+        };
+        const expand = (t, e = {})=>{
+            const n = void 0 === e.rangeLimit ? 1e3 : e.rangeLimit;
+            const walk = (t, i = {}, a = 0)=>{
+                o.assertDepth(a);
+                t.queue = [];
+                let u = i;
+                let c = i.queue;
+                while("brace" !== u.type && "root" !== u.type && u.parent){
+                    u = u.parent;
+                    c = u.queue;
+                }
+                if (t.invalid || t.dollar) return void c.push(append(c.pop(), s(t, e)));
+                if ("brace" === t.type && true !== t.invalid && 2 === t.nodes.length) return void c.push(append(c.pop(), [
+                    "{}"
+                ]));
+                if (t.nodes && t.ranges > 0) {
+                    const i = o.reduce(t.nodes);
+                    if (o.exceedsLimit(...i, e.step, n)) throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
+                    let a = r(...i, e);
+                    if (0 === a.length) a = s(t, e);
+                    c.push(append(c.pop(), a));
+                    t.nodes = [];
+                    return;
+                }
+                const l = o.encloseBrace(t);
+                let f = t.queue;
+                let p = t;
+                while("brace" !== p.type && "root" !== p.type && p.parent){
+                    p = p.parent;
+                    f = p.queue;
+                }
+                for(let e = 0; e < t.nodes.length; e++){
+                    const n = t.nodes[e];
+                    if ("comma" === n.type && "brace" === t.type) {
+                        if (1 === e) f.push("");
+                        f.push("");
+                        continue;
+                    }
+                    if ("close" === n.type) {
+                        c.push(append(c.pop(), f, l));
+                        continue;
+                    }
+                    if (n.value && "open" !== n.type) {
+                        f.push(append(f.pop(), n.value));
+                        continue;
+                    }
+                    if (n.nodes) walk(n, t, a + 1);
+                }
+                return f;
+            };
+            return o.flatten(walk(t));
+        };
+        t.exports = expand;
+    },
+    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 parse = (t, e = {})=>{
+            if ("string" != typeof t) throw new TypeError("Expected a string");
+            const n = e || {};
+            const E = "number" == typeof n.maxLength ? Math.min(o, n.maxLength) : o;
+            if (t.length > E) throw new SyntaxError(`Input length (${t.length}), exceeds max characters (${E})`);
+            const b = {
+                type: "root",
+                input: t,
+                nodes: []
+            };
+            const w = [
+                b
+            ];
+            let C = b;
+            let v = b;
+            let S = 0;
+            const $ = t.length;
+            let H = 0;
+            let T = 0;
+            let O;
+            const advance = ()=>t[H++];
+            const push = (t)=>{
+                if ("text" === t.type && "dot" === v.type) v.type = "text";
+                if (v && "text" === v.type && "text" === t.type) {
+                    v.value += t.value;
+                    return;
+                }
+                C.nodes.push(t);
+                t.parent = C;
+                t.prev = v;
+                v = t;
+                return t;
+            };
+            push({
+                type: "bos"
+            });
+            while(H < $){
+                C = w[w.length - 1];
+                O = advance();
+                if (O === m || O === R) continue;
+                if (O === i) {
+                    push({
+                        type: "text",
+                        value: (e.keepEscaping ? O : "") + advance()
+                    });
+                    continue;
+                }
+                if (O === g) {
+                    push({
+                        type: "text",
+                        value: "\\" + O
+                    });
+                    continue;
+                }
+                if (O === h) {
+                    S++;
+                    let t;
+                    while(H < $ && (t = advance())){
+                        O += t;
+                        if (t === h) {
+                            S++;
+                            continue;
+                        }
+                        if (t === i) {
+                            O += advance();
+                            continue;
+                        }
+                        if (t === g) {
+                            S--;
+                            if (0 === S) break;
+                        }
+                    }
+                    push({
+                        type: "text",
+                        value: O
+                    });
+                    continue;
+                }
+                if (O === l) {
+                    s.assertDepth(w.length);
+                    C = push({
+                        type: "paren",
+                        nodes: []
+                    });
+                    w.push(C);
+                    push({
+                        type: "text",
+                        value: O
+                    });
+                    continue;
+                }
+                if (O === f) {
+                    if ("paren" !== C.type) {
+                        push({
+                            type: "text",
+                            value: O
+                        });
+                        continue;
+                    }
+                    C = w.pop();
+                    push({
+                        type: "text",
+                        value: O
+                    });
+                    C = w[w.length - 1];
+                    continue;
+                }
+                if (O === _ || O === A || O === a) {
+                    const t = O;
+                    let n;
+                    if (true !== e.keepQuotes) O = "";
+                    while(H < $ && (n = advance())){
+                        if (n === i) {
+                            O += n + advance();
+                            continue;
+                        }
+                        if (n === t) {
+                            if (true === e.keepQuotes) O += n;
+                            break;
+                        }
+                        O += n;
+                    }
+                    push({
+                        type: "text",
+                        value: O
+                    });
+                    continue;
+                }
+                if (O === p) {
+                    s.assertDepth(w.length);
+                    T++;
+                    const t = v.value && "$" === v.value.slice(-1) || true === C.dollar;
+                    const e = {
+                        type: "brace",
+                        open: true,
+                        close: false,
+                        dollar: t,
+                        depth: T,
+                        commas: 0,
+                        ranges: 0,
+                        nodes: []
+                    };
+                    C = push(e);
+                    w.push(C);
+                    push({
+                        type: "open",
+                        value: O
+                    });
+                    continue;
+                }
+                if (O === d) {
+                    if ("brace" !== C.type) {
+                        push({
+                            type: "text",
+                            value: O
+                        });
+                        continue;
+                    }
+                    const t = "close";
+                    C = w.pop();
+                    C.close = true;
+                    push({
+                        type: t,
+                        value: O
+                    });
+                    T--;
+                    C = w[w.length - 1];
+                    continue;
+                }
+                if (O === u && T > 0) {
+                    if (C.ranges > 0) {
+                        C.ranges = 0;
+                        const t = C.nodes.shift();
+                        C.nodes = [
+                            t,
+                            {
+                                type: "text",
+                                value: r(C)
+                            }
+                        ];
+                    }
+                    push({
+                        type: "comma",
+                        value: O
+                    });
+                    C.commas++;
+                    continue;
+                }
+                if (O === c && T > 0 && 0 === C.commas) {
+                    const t = C.nodes;
+                    if (0 === T || 0 === t.length) {
+                        push({
+                            type: "text",
+                            value: O
+                        });
+                        continue;
+                    }
+                    if ("dot" === v.type) {
+                        C.range = [];
+                        v.value += O;
+                        v.type = "range";
+                        if (3 !== C.nodes.length && 5 !== C.nodes.length) {
+                            C.invalid = true;
+                            C.ranges = 0;
+                            v.type = "text";
+                            continue;
+                        }
+                        C.ranges++;
+                        C.args = [];
+                        continue;
+                    }
+                    if ("range" === v.type) {
+                        t.pop();
+                        const e = t[t.length - 1];
+                        e.value += v.value + O;
+                        v = e;
+                        C.ranges--;
+                        continue;
+                    }
+                    push({
+                        type: "dot",
+                        value: O
+                    });
+                    continue;
+                }
+                push({
+                    type: "text",
+                    value: O
+                });
+            }
+            do {
+                C = w.pop();
+                if ("root" !== C.type) {
+                    C.nodes.forEach((t)=>{
+                        if (!t.nodes) {
+                            if ("open" === t.type) t.isOpen = true;
+                            if ("close" === t.type) t.isClose = true;
+                            if (!t.nodes) t.type = "text";
+                            t.invalid = true;
+                        }
+                    });
+                    const t = w[w.length - 1];
+                    const e = t.nodes.indexOf(C);
+                    t.nodes.splice(e, 1, ...C.nodes);
+                }
+            }while (w.length > 0);
+            push({
+                type: "eos"
+            });
+            return b;
+        };
+        t.exports = parse;
+    },
+    816: (t, e, n)=>{
+        const r = n(372);
+        t.exports = (t, e = {})=>{
+            const stringify = (t, n = {}, s = 0)=>{
+                r.assertDepth(s);
+                const o = e.escapeInvalid && r.isInvalidBrace(n);
+                const i = true === t.invalid && true === e.escapeInvalid;
+                let a = "";
+                if (t.value) {
+                    if ((o || i) && r.isOpenOrClose(t)) return "\\" + t.value;
+                    return t.value;
+                }
+                if (t.value) return t.value;
+                if (t.nodes) for (const e of t.nodes)a += stringify(e, {}, s + 1);
+                return a;
+            };
+            return stringify(t);
+        };
+    },
+    372: (t, e, n)=>{
+        const { MAX_AST_DEPTH: r } = n(872);
+        e.assertDepth = (t)=>{
+            if (t > r) throw new SyntaxError("AST nesting depth exceeds the maximum of " + r);
+        };
+        e.isInteger = (t)=>{
+            if ("number" == typeof t) return Number.isInteger(t);
+            if ("string" == typeof t && "" !== t.trim()) return Number.isInteger(Number(t));
+            return false;
+        };
+        e.find = (t, e)=>t.nodes.find((t)=>t.type === e);
+        e.exceedsLimit = (t, n, r = 1, s)=>{
+            if (false === s) return false;
+            if (!e.isInteger(t) || !e.isInteger(n)) return false;
+            return (Number(n) - Number(t)) / Number(r) >= s;
+        };
+        e.escapeNode = (t, e = 0, n)=>{
+            const r = t.nodes[e];
+            if (!r) return;
+            if (n && r.type === n || "open" === r.type || "close" === r.type) {
+                if (true !== r.escaped) {
+                    r.value = "\\" + r.value;
+                    r.escaped = true;
+                }
+            }
+        };
+        e.encloseBrace = (t)=>{
+            if ("brace" !== t.type) return false;
+            if (t.commas >> 0 + t.ranges === 0) {
+                t.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        e.isInvalidBrace = (t)=>{
+            if ("brace" !== t.type) return false;
+            if (true === t.invalid || t.dollar) return true;
+            if (t.commas >> 0 + t.ranges === 0) {
+                t.invalid = true;
+                return true;
+            }
+            if (true !== t.open || true !== t.close) {
+                t.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        e.isOpenOrClose = (t)=>{
+            if ("open" === t.type || "close" === t.type) return true;
+            return true === t.open || true === t.close;
+        };
+        e.reduce = (t)=>t.reduce((t, e)=>{
+                if ("text" === e.type) t.push(e.value);
+                if ("range" === e.type) e.type = "text";
+                return t;
+            }, []);
+        e.flatten = (...t)=>{
+            const e = [];
+            const flat = (t)=>{
+                for(let n = 0; n < t.length; n++){
+                    const r = t[n];
+                    if (Array.isArray(r)) {
+                        flat(r);
+                        continue;
+                    }
+                    if (void 0 !== r) e.push(r);
+                }
+                return e;
+            };
+            flat(t);
+            return e;
+        };
+    },
+    790: (t, e, n)=>{
+        /*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ const r = n(23);
+        const s = n(491);
+        const isObject = (t)=>null !== t && "object" == typeof t && !Array.isArray(t);
+        const transform = (t)=>(e)=>true === t ? Number(e) : String(e);
+        const isValidValue = (t)=>"number" == typeof t || "string" == typeof t && "" !== t;
+        const isNumber = (t)=>Number.isInteger(+t);
+        const zeros = (t)=>{
+            let e = `${t}`;
+            let n = -1;
+            if ("-" === e[0]) e = e.slice(1);
+            if ("0" === e) return false;
+            while("0" === e[++n]);
+            return n > 0;
+        };
+        const stringify = (t, e, n)=>{
+            if ("string" == typeof t || "string" == typeof e) return true;
+            return true === n.stringify;
+        };
+        const pad = (t, e, n)=>{
+            if (e > 0) {
+                let n = "-" === t[0] ? "-" : "";
+                if (n) t = t.slice(1);
+                t = n + t.padStart(n ? e - 1 : e, "0");
+            }
+            if (false === n) return String(t);
+            return t;
+        };
+        const toMaxLen = (t, e)=>{
+            let n = "-" === t[0] ? "-" : "";
+            if (n) {
+                t = t.slice(1);
+                e--;
+            }
+            while(t.length < e)t = "0" + t;
+            return n ? "-" + t : t;
+        };
+        const toSequence = (t, e, n)=>{
+            t.negatives.sort((t, e)=>t < e ? -1 : t > e ? 1 : 0);
+            t.positives.sort((t, e)=>t < e ? -1 : t > e ? 1 : 0);
+            let r = e.capture ? "" : "?:";
+            let s = "";
+            let o = "";
+            let i;
+            if (t.positives.length) s = t.positives.map((t)=>toMaxLen(String(t), n)).join("|");
+            if (t.negatives.length) o = `-(${r}${t.negatives.map((t)=>toMaxLen(String(t), n)).join("|")})`;
+            i = s && o ? `${s}|${o}` : s || o;
+            if (e.wrap) return `(${r}${i})`;
+            return i;
+        };
+        const toRange = (t, e, n, r)=>{
+            if (n) return s(t, e, {
+                wrap: false,
+                ...r
+            });
+            let o = String.fromCharCode(t);
+            if (t === e) return o;
+            let i = String.fromCharCode(e);
+            return `[${o}-${i}]`;
+        };
+        const toRegex = (t, e, n)=>{
+            if (Array.isArray(t)) {
+                let e = true === n.wrap;
+                let r = n.capture ? "" : "?:";
+                return e ? `(${r}${t.join("|")})` : t.join("|");
+            }
+            return s(t, e, n);
+        };
+        const rangeError = (...t)=>new RangeError("Invalid range arguments: " + r.inspect(...t));
+        const invalidRange = (t, e, n)=>{
+            if (true === n.strictRanges) throw rangeError([
+                t,
+                e
+            ]);
+            return [];
+        };
+        const invalidStep = (t, e)=>{
+            if (true === e.strictRanges) throw new TypeError(`Expected step "${t}" to be a number`);
+            return [];
+        };
+        const fillNumbers = (t, e, n = 1, r = {})=>{
+            let s = Number(t);
+            let o = Number(e);
+            if (!Number.isInteger(s) || !Number.isInteger(o)) {
+                if (true === r.strictRanges) throw rangeError([
+                    t,
+                    e
+                ]);
+                return [];
+            }
+            if (0 === s) s = 0;
+            if (0 === o) o = 0;
+            let i = s > o;
+            let a = String(t);
+            let u = String(e);
+            let c = String(n);
+            n = Math.max(Math.abs(n), 1);
+            let l = zeros(a) || zeros(u) || zeros(c);
+            let f = l ? Math.max(a.length, u.length, c.length) : 0;
+            let p = false === l && false === stringify(t, e, r);
+            let d = r.transform || transform(p);
+            if (r.toRegex && 1 === n) return toRange(toMaxLen(t, f), toMaxLen(e, f), true, r);
+            let h = {
+                negatives: [],
+                positives: []
+            };
+            let push = (t)=>h[t < 0 ? "negatives" : "positives"].push(Math.abs(t));
+            let g = [];
+            let _ = 0;
+            while(i ? s >= o : s <= o){
+                if (true === r.toRegex && n > 1) push(s);
+                else g.push(pad(d(s, _), f, p));
+                s = i ? s - n : s + n;
+                _++;
+            }
+            if (true === r.toRegex) return n > 1 ? toSequence(h, r, f) : toRegex(g, null, {
+                wrap: false,
+                ...r
+            });
+            return g;
+        };
+        const fillLetters = (t, e, n = 1, r = {})=>{
+            if (!isNumber(t) && t.length > 1 || !isNumber(e) && e.length > 1) return invalidRange(t, e, r);
+            let s = r.transform || ((t)=>String.fromCharCode(t));
+            let o = `${t}`.charCodeAt(0);
+            let i = `${e}`.charCodeAt(0);
+            let a = o > i;
+            let u = Math.min(o, i);
+            let c = Math.max(o, i);
+            if (r.toRegex && 1 === n) return toRange(u, c, false, r);
+            let l = [];
+            let f = 0;
+            while(a ? o >= i : o <= i){
+                l.push(s(o, f));
+                o = a ? o - n : o + n;
+                f++;
+            }
+            if (true === r.toRegex) return toRegex(l, null, {
+                wrap: false,
+                options: r
+            });
+            return l;
+        };
+        const fill = (t, e, n, r = {})=>{
+            if (null == e && isValidValue(t)) return [
+                t
+            ];
+            if (!isValidValue(t) || !isValidValue(e)) return invalidRange(t, e, r);
+            if ("function" == typeof n) return fill(t, e, 1, {
+                transform: n
+            });
+            if (isObject(n)) return fill(t, e, 0, n);
+            let s = {
+                ...r
+            };
+            if (true === s.capture) s.wrap = true;
+            n = n || s.step || 1;
+            if (!isNumber(n)) {
+                if (null != n && !isObject(n)) return invalidStep(n, s);
+                return fill(t, e, 1, n);
+            }
+            if (isNumber(t) && isNumber(e)) return fillNumbers(t, e, n, s);
+            return fillLetters(t, e, Math.max(Math.abs(n), 1), s);
+        };
+        t.exports = fill;
+    },
+    869: (t)=>{
+        function makeArray(t) {
+            return Array.isArray(t) ? t : [
+                t
+            ];
+        }
+        const e = void 0;
+        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 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;
+                }
+            ],
+            [
+                /[\\$.|*+(){^]/g,
+                (t)=>`\\${t}`
+            ],
+            [
+                /(?!\\)\?/g,
+                ()=>"[^/]"
+            ],
+            [
+                /^\//,
+                ()=>"^"
+            ],
+            [
+                /\//g,
+                ()=>"\\/"
+            ],
+            [
+                /^\^*\\\*\\\*\\\//,
+                ()=>"^(?:.*\\/)?"
+            ],
+            [
+                /^(?=[^^])/,
+                function() {
+                    return /\/(?!$)/.test(this) ? "^" : "(?:^|\\/)";
+                }
+            ],
+            [
+                /\\\/\\\*\\\*(?=\\\/|$)/g,
+                (t, e, n)=>e + 6 < n.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+            ],
+            [
+                /(^|[^\\]+)(\\\*)+(?=.+)/g,
+                (t, e, n)=>{
+                    const r = n.replace(/\\\*/g, "[^\\/]*");
+                    return e + r;
+                }
+            ],
+            [
+                /\\\\\\(?=[$.|*+(){^])/g,
+                ()=>s
+            ],
+            [
+                /\\\\/g,
+                ()=>s
+            ],
+            [
+                /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+                (t, e, n, r, o)=>e === s ? `\\[${n}${cleanRangeBackSlash(r)}${o}` : "]" === o ? r.length % 2 === 0 ? `[${sanitizeRange(n)}${r}]` : "[]" : "[]"
+            ],
+            [
+                /(?:[^*])$/,
+                (t)=>/\/$/.test(t) ? `${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 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);
+        class IgnoreRule {
+            constructor(t, e, n, r, s, o){
+                this.pattern = t;
+                this.mark = e;
+                this.negative = s;
+                define(this, "body", n);
+                define(this, "ignoreCase", r);
+                define(this, "regexPrefix", o);
+            }
+            get regex() {
+                const t = E + R;
+                if (this[t]) return this[t];
+                return this._make(R, t);
+            }
+            get checkRegex() {
+                const t = E + m;
+                if (this[t]) return this[t];
+                return this._make(m, t);
+            }
+            _make(t, e) {
+                const n = this.regexPrefix.replace(A, b[t]);
+                const r = this.ignoreCase ? new RegExp(n, "i") : new RegExp(n);
+                return define(this, e, r);
+            }
+        }
+        const createRule = ({ pattern: t, mark: e }, n)=>{
+            let r = false;
+            let s = t;
+            if (0 === s.indexOf("!")) {
+                r = true;
+                s = s.substr(1);
+            }
+            s = s.replace(a, "!").replace(u, "#");
+            const o = makeRegexPrefix(s);
+            return new IgnoreRule(t, e, s, n, r, o);
+        };
+        class RuleManager {
+            constructor(t){
+                this._ignoreCase = t;
+                this._rules = [];
+            }
+            _add(t) {
+                if (t && t[h]) {
+                    this._rules = this._rules.concat(t._rules._rules);
+                    this._added = true;
+                    return;
+                }
+                if (isString(t)) t = {
+                    pattern: t
+                };
+                if (checkPattern(t.pattern)) {
+                    const e = createRule(t, this._ignoreCase);
+                    this._added = true;
+                    this._rules.push(e);
+                }
+            }
+            add(t) {
+                this._added = false;
+                makeArray(isString(t) ? splitPattern(t) : t).forEach(this._add, this);
+                return this._added;
+            }
+            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 = {
+                    ignored: s,
+                    unignored: o
+                };
+                if (i) a.rule = i;
+                return a;
+            }
+        }
+        const throwError = (t, e)=>{
+            throw new e(t);
+        };
+        const checkPath = (t, e, n)=>{
+            if (!isString(t)) return n(`path must be a string, but got \`${e}\``, TypeError);
+            if (!t) return n("path must not be empty", TypeError);
+            if (checkPath.isNotRelative(t)) {
+                const t = "`path.relative()`d";
+                return n(`path should be a ${t} string, but got "${e}"`, RangeError);
+            }
+            return true;
+        };
+        const isNotRelative = (t)=>l.test(t);
+        checkPath.isNotRelative = isNotRelative;
+        checkPath.convert = (t)=>t;
+        class Ignore {
+            constructor({ ignorecase: t = true, ignoreCase: e = t, allowRelativePaths: n = false } = {}){
+                define(this, h, true);
+                this._rules = new RuleManager(e);
+                this._strictPathCheck = !n;
+                this._initCache();
+            }
+            _initCache() {
+                this._ignoreCache = Object.create(null);
+                this._testCache = Object.create(null);
+            }
+            add(t) {
+                if (this._rules.add(t)) this._initCache();
+                return this;
+            }
+            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);
+            }
+            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);
+            }
+            _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);
+            }
+            ignores(t) {
+                return this._test(t, this._ignoreCache, false).ignored;
+            }
+            createFilter() {
+                return (t)=>!this.ignores(t);
+            }
+            filter(t) {
+                return makeArray(t).filter(this.createFilter());
+            }
+            test(t) {
+                return this._test(t, this._testCache, true);
+            }
+        }
+        const factory = (t)=>new Ignore(t);
+        const isPathValid = (t)=>checkPath(t && checkPath.convert(t), t, RETURN_FALSE);
+        const setupWindows = ()=>{
+            const makePosix = (t)=>/^\\\\\?\\/.test(t) || /["<>|\u0000-\u001F]+/u.test(t) ? t : t.replace(/\\/g, "/");
+            checkPath.convert = makePosix;
+            const t = /^[a-z]:\//i;
+            checkPath.isNotRelative = (e)=>t.test(e) || isNotRelative(e);
+        };
+        if ("u" > typeof process && "win32" === process.platform) setupWindows();
+        t.exports = factory;
+        factory.default = factory;
+        t.exports.isPathValid = isPathValid;
+        define(t.exports, Symbol.for("setupWindows"), setupWindows);
+    },
+    460: (t)=>{
+        /*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ t.exports = function(t) {
+            if ("number" == typeof t) return t - t === 0;
+            if ("string" == typeof t && "" !== t.trim()) return Number.isFinite ? Number.isFinite(+t) : isFinite(+t);
+            return false;
+        };
+    },
+    639: (t, e, n)=>{
+        const r = n(23);
+        const s = n(793);
+        const o = n(176);
+        const i = n(445);
+        const isEmptyString = (t)=>"" === t || "./" === t;
+        const hasBraces = (t)=>{
+            const e = t.indexOf("{");
+            return e > -1 && t.indexOf("}", e) > -1;
+        };
+        const micromatch = (t, e, n)=>{
+            e = [].concat(e);
+            t = [].concat(t);
+            let r = new Set;
+            let s = new Set;
+            let i = new Set;
+            let a = 0;
+            let onResult = (t)=>{
+                i.add(t.output);
+                if (n && n.onResult) n.onResult(t);
+            };
+            for(let i = 0; i < e.length; i++){
+                let u = o(String(e[i]), {
+                    ...n,
+                    onResult: onResult
+                }, true);
+                let c = u.state.negated || u.state.negatedExtglob;
+                if (c) a++;
+                for (let e of t){
+                    let t = u(e, true);
+                    let n = c ? !t.isMatch : t.isMatch;
+                    if (n) if (c) r.add(t.output);
+                    else {
+                        r.delete(t.output);
+                        s.add(t.output);
+                    }
+                }
+            }
+            let u = a === e.length ? [
+                ...i
+            ] : [
+                ...s
+            ];
+            let c = u.filter((t)=>!r.has(t));
+            if (n && 0 === c.length) {
+                if (true === n.failglob) throw new Error(`No matches found for "${e.join(", ")}"`);
+                if (true === n.nonull || true === n.nullglob) return n.unescape ? e.map((t)=>t.replace(/\\/g, "")) : e;
+            }
+            return c;
+        };
+        micromatch.match = micromatch;
+        micromatch.matcher = (t, e)=>o(t, e);
+        micromatch.isMatch = (t, e, n)=>o(e, n)(t);
+        micromatch.any = micromatch.isMatch;
+        micromatch.not = (t, e, n = {})=>{
+            e = [].concat(e).map(String);
+            let r = new Set;
+            let s = [];
+            let onResult = (t)=>{
+                if (n.onResult) n.onResult(t);
+                s.push(t.output);
+            };
+            let o = new Set(micromatch(t, e, {
+                ...n,
+                onResult: onResult
+            }));
+            for (let t of s)if (!o.has(t)) r.add(t);
+            return [
+                ...r
+            ];
+        };
+        micromatch.contains = (t, e, n)=>{
+            if ("string" != typeof t) throw new TypeError(`Expected a string: "${r.inspect(t)}"`);
+            if (Array.isArray(e)) return e.some((e)=>micromatch.contains(t, e, n));
+            if ("string" == typeof e) {
+                if (isEmptyString(t) || isEmptyString(e)) return false;
+                if (t.includes(e) || t.startsWith("./") && t.slice(2).includes(e)) return true;
+            }
+            return micromatch.isMatch(t, e, {
+                ...n,
+                contains: true
+            });
+        };
+        micromatch.matchKeys = (t, e, n)=>{
+            if (!i.isObject(t)) throw new TypeError("Expected the first argument to be an object");
+            let r = micromatch(Object.keys(t), e, n);
+            let s = {};
+            for (let e of r)s[e] = t[e];
+            return s;
+        };
+        micromatch.some = (t, e, n)=>{
+            let r = [].concat(t);
+            for (let t of [].concat(e)){
+                let e = o(String(t), n);
+                if (r.some((t)=>e(t))) return true;
+            }
+            return false;
+        };
+        micromatch.every = (t, e, n)=>{
+            let r = [].concat(t);
+            for (let t of [].concat(e)){
+                let e = o(String(t), n);
+                if (!r.every((t)=>e(t))) return false;
+            }
+            return true;
+        };
+        micromatch.all = (t, e, n)=>{
+            if ("string" != typeof t) throw new TypeError(`Expected a string: "${r.inspect(t)}"`);
+            return [].concat(e).every((e)=>o(e, n)(t));
+        };
+        micromatch.capture = (t, e, n)=>{
+            let r = i.isWindows(n);
+            let s = o.makeRe(String(t), {
+                ...n,
+                capture: true
+            });
+            let a = s.exec(r ? i.toPosixSlashes(e) : e);
+            if (a) return a.slice(1).map((t)=>void 0 === t ? "" : t);
+        };
+        micromatch.makeRe = (...t)=>o.makeRe(...t);
+        micromatch.scan = (...t)=>o.scan(...t);
+        micromatch.parse = (t, e)=>{
+            let n = [];
+            for (let r of [].concat(t || []))for (let t of s(String(r), e))n.push(o.parse(t, e));
+            return n;
+        };
+        micromatch.braces = (t, e)=>{
+            if ("string" != typeof t) throw new TypeError("Expected a string");
+            if (e && true === e.nobrace || !hasBraces(t)) return [
+                t
+            ];
+            return s(t, e);
+        };
+        micromatch.braceExpand = (t, e)=>{
+            if ("string" != typeof t) throw new TypeError("Expected a string");
+            return micromatch.braces(t, {
+                ...e,
+                expand: true
+            });
+        };
+        micromatch.hasBraces = hasBraces;
+        t.exports = micromatch;
+    },
+    176: (t, e, n)=>{
+        t.exports = n(810);
+    },
+    193: (t, e, n)=>{
+        const r = n(928);
+        const s = "\\\\/";
+        const o = `[^${s}]`;
+        const i = 0;
+        const a = "\\.";
+        const u = "\\+";
+        const c = "\\?";
+        const l = "\\/";
+        const f = "(?=.)";
+        const p = "[^/]";
+        const d = `(?:${l}|$)`;
+        const h = `(?:^|${l})`;
+        const g = `${a}{1,2}${d}`;
+        const _ = `(?!${a})`;
+        const A = `(?!${h}${g})`;
+        const R = `(?!${a}{0,1}${d})`;
+        const m = `(?!${g})`;
+        const E = `[^.${l}]`;
+        const b = `${p}*?`;
+        const w = {
+            DOT_LITERAL: a,
+            PLUS_LITERAL: u,
+            QMARK_LITERAL: c,
+            SLASH_LITERAL: l,
+            ONE_CHAR: f,
+            QMARK: p,
+            END_ANCHOR: d,
+            DOTS_SLASH: g,
+            NO_DOT: _,
+            NO_DOTS: A,
+            NO_DOT_SLASH: R,
+            NO_DOTS_SLASH: m,
+            QMARK_NO_DOT: E,
+            STAR: b,
+            START_ANCHOR: h
+        };
+        const C = {
+            ...w,
+            SLASH_LITERAL: `[${s}]`,
+            QMARK: o,
+            STAR: `${o}*?`,
+            DOTS_SLASH: `${a}{1,2}(?:[${s}]|$)`,
+            NO_DOT: `(?!${a})`,
+            NO_DOTS: `(?!(?:^|[${s}])${a}{1,2}(?:[${s}]|$))`,
+            NO_DOT_SLASH: `(?!${a}{0,1}(?:[${s}]|$))`,
+            NO_DOTS_SLASH: `(?!${a}{1,2}(?:[${s}]|$))`,
+            QMARK_NO_DOT: `[^.${s}]`,
+            START_ANCHOR: `(?:^|[${s}])`,
+            END_ANCHOR: `(?:[${s}]|$)`
+        };
+        const v = {
+            __proto__: null,
+            alnum: "a-zA-Z0-9",
+            alpha: "a-zA-Z",
+            ascii: "\\x00-\\x7F",
+            blank: " \\t",
+            cntrl: "\\x00-\\x1F\\x7F",
+            digit: "0-9",
+            graph: "\\x21-\\x7E",
+            lower: "a-z",
+            print: "\\x20-\\x7E ",
+            punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+            space: " \\t\\r\\n\\v\\f",
+            upper: "A-Z",
+            word: "A-Za-z0-9_",
+            xdigit: "A-Fa-f0-9"
+        };
+        t.exports = {
+            DEFAULT_MAX_EXTGLOB_RECURSION: i,
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE: v,
+            REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+            REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+            REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+            REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+            REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+            REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+            REPLACEMENTS: {
+                __proto__: null,
+                "***": "*",
+                "**/**": "**",
+                "**/**/**": "**"
+            },
+            CHAR_0: 48,
+            CHAR_9: 57,
+            CHAR_UPPERCASE_A: 65,
+            CHAR_LOWERCASE_A: 97,
+            CHAR_UPPERCASE_Z: 90,
+            CHAR_LOWERCASE_Z: 122,
+            CHAR_LEFT_PARENTHESES: 40,
+            CHAR_RIGHT_PARENTHESES: 41,
+            CHAR_ASTERISK: 42,
+            CHAR_AMPERSAND: 38,
+            CHAR_AT: 64,
+            CHAR_BACKWARD_SLASH: 92,
+            CHAR_CARRIAGE_RETURN: 13,
+            CHAR_CIRCUMFLEX_ACCENT: 94,
+            CHAR_COLON: 58,
+            CHAR_COMMA: 44,
+            CHAR_DOT: 46,
+            CHAR_DOUBLE_QUOTE: 34,
+            CHAR_EQUAL: 61,
+            CHAR_EXCLAMATION_MARK: 33,
+            CHAR_FORM_FEED: 12,
+            CHAR_FORWARD_SLASH: 47,
+            CHAR_GRAVE_ACCENT: 96,
+            CHAR_HASH: 35,
+            CHAR_HYPHEN_MINUS: 45,
+            CHAR_LEFT_ANGLE_BRACKET: 60,
+            CHAR_LEFT_CURLY_BRACE: 123,
+            CHAR_LEFT_SQUARE_BRACKET: 91,
+            CHAR_LINE_FEED: 10,
+            CHAR_NO_BREAK_SPACE: 160,
+            CHAR_PERCENT: 37,
+            CHAR_PLUS: 43,
+            CHAR_QUESTION_MARK: 63,
+            CHAR_RIGHT_ANGLE_BRACKET: 62,
+            CHAR_RIGHT_CURLY_BRACE: 125,
+            CHAR_RIGHT_SQUARE_BRACKET: 93,
+            CHAR_SEMICOLON: 59,
+            CHAR_SINGLE_QUOTE: 39,
+            CHAR_SPACE: 32,
+            CHAR_TAB: 9,
+            CHAR_UNDERSCORE: 95,
+            CHAR_VERTICAL_LINE: 124,
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            SEP: r.sep,
+            extglobChars (t) {
+                return {
+                    "!": {
+                        type: "negate",
+                        open: "(?:(?!(?:",
+                        close: `))${t.STAR})`
+                    },
+                    "?": {
+                        type: "qmark",
+                        open: "(?:",
+                        close: ")?"
+                    },
+                    "+": {
+                        type: "plus",
+                        open: "(?:",
+                        close: ")+"
+                    },
+                    "*": {
+                        type: "star",
+                        open: "(?:",
+                        close: ")*"
+                    },
+                    "@": {
+                        type: "at",
+                        open: "(?:",
+                        close: ")"
+                    }
+                };
+            },
+            globChars (t) {
+                return true === t ? C : w;
+            }
+        };
+    },
+    143: (t, e, n)=>{
+        const r = n(193);
+        const s = n(445);
+        const { MAX_LENGTH: o, POSIX_REGEX_SOURCE: i, REGEX_NON_SPECIAL_CHARS: a, REGEX_SPECIAL_CHARS_BACKREF: u, REPLACEMENTS: c } = r;
+        const expandRange = (t, e)=>{
+            if ("function" == typeof e.expandRange) return e.expandRange(...t, e);
+            t.sort();
+            const n = `[${t.join("-")}]`;
+            try {
+                new RegExp(n);
+            } catch (e) {
+                return t.map((t)=>s.escapeRegex(t)).join("..");
+            }
+            return n;
+        };
+        const syntaxError = (t, e)=>`Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`;
+        const splitTopLevel = (t)=>{
+            const e = [];
+            let n = 0;
+            let r = 0;
+            let s = 0;
+            let o = "";
+            let i = false;
+            for (const a of t){
+                if (true === i) {
+                    o += a;
+                    i = false;
+                    continue;
+                }
+                if ("\\" === a) {
+                    o += a;
+                    i = true;
+                    continue;
+                }
+                if ('"' === a) {
+                    s = 1 === s ? 0 : 1;
+                    o += a;
+                    continue;
+                }
+                if (0 === s) {
+                    if ("[" === a) n++;
+                    else if ("]" === a && n > 0) n--;
+                    else if (0 === n) {
+                        if ("(" === a) r++;
+                        else if (")" === a && r > 0) r--;
+                        else if ("|" === a && 0 === r) {
+                            e.push(o);
+                            o = "";
+                            continue;
+                        }
+                    }
+                }
+                o += a;
+            }
+            e.push(o);
+            return e;
+        };
+        const isPlainBranch = (t)=>{
+            let e = false;
+            for (const n of t){
+                if (true === e) {
+                    e = false;
+                    continue;
+                }
+                if ("\\" === n) {
+                    e = true;
+                    continue;
+                }
+                if (/[?*+@!()[\]{}]/.test(n)) return false;
+            }
+            return true;
+        };
+        const normalizeSimpleBranch = (t)=>{
+            let e = t.trim();
+            let n = true;
+            while(true === n){
+                n = false;
+                if (/^@\([^\\()[\]{}|]+\)$/.test(e)) {
+                    e = e.slice(2, -1);
+                    n = true;
+                }
+            }
+            if (!isPlainBranch(e)) return;
+            return e.replace(/\\(.)/g, "$1");
+        };
+        const hasRepeatedCharPrefixOverlap = (t)=>{
+            const e = t.map(normalizeSimpleBranch).filter(Boolean);
+            for(let t = 0; t < e.length; t++)for(let n = t + 1; n < e.length; n++){
+                const r = e[t];
+                const s = e[n];
+                const o = r[0];
+                if (o && r === o.repeat(r.length) && s === o.repeat(s.length)) {
+                    if (r === s || r.startsWith(s) || s.startsWith(r)) return true;
+                }
+            }
+            return false;
+        };
+        const parseRepeatedExtglob = (t, e = true)=>{
+            if ("+" !== t[0] && "*" !== t[0] || "(" !== t[1]) return;
+            let n = 0;
+            let r = 0;
+            let s = 0;
+            let o = false;
+            for(let i = 1; i < t.length; i++){
+                const a = t[i];
+                if (true === o) {
+                    o = false;
+                    continue;
+                }
+                if ("\\" === a) {
+                    o = true;
+                    continue;
+                }
+                if ('"' === a) {
+                    s = 1 === s ? 0 : 1;
+                    continue;
+                }
+                if (1 !== s) {
+                    if ("[" === a) {
+                        n++;
+                        continue;
+                    }
+                    if ("]" === a && n > 0) {
+                        n--;
+                        continue;
+                    }
+                    if (!(n > 0)) {
+                        if ("(" === a) {
+                            r++;
+                            continue;
+                        }
+                        if (")" === a) {
+                            r--;
+                            if (0 === r) {
+                                if (true === e && i !== t.length - 1) return;
+                                return {
+                                    type: t[0],
+                                    body: t.slice(2, i),
+                                    end: i
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const getStarExtglobSequenceOutput = (t)=>{
+            let e = 0;
+            const n = [];
+            while(e < t.length){
+                const r = parseRepeatedExtglob(t.slice(e), false);
+                if (!r || "*" !== r.type) return;
+                const s = splitTopLevel(r.body).map((t)=>t.trim());
+                if (1 !== s.length) return;
+                const o = normalizeSimpleBranch(s[0]);
+                if (!o || 1 !== o.length) return;
+                n.push(o);
+                e += r.end + 1;
+            }
+            if (n.length < 1) return;
+            const r = 1 === n.length ? s.escapeRegex(n[0]) : `[${n.map((t)=>s.escapeRegex(t)).join("")}]`;
+            return `${r}*`;
+        };
+        const repeatedExtglobRecursion = (t)=>{
+            let e = 0;
+            let n = t.trim();
+            let r = parseRepeatedExtglob(n);
+            while(r){
+                e++;
+                n = r.body.trim();
+                r = parseRepeatedExtglob(n);
+            }
+            return e;
+        };
+        const analyzeRepeatedExtglob = (t, e)=>{
+            if (false === e.maxExtglobRecursion) return {
+                risky: false
+            };
+            const n = "number" == typeof e.maxExtglobRecursion ? e.maxExtglobRecursion : r.DEFAULT_MAX_EXTGLOB_RECURSION;
+            const s = splitTopLevel(t).map((t)=>t.trim());
+            if (s.length > 1) {
+                if (s.some((t)=>"" === t) || s.some((t)=>/^[*?]+$/.test(t)) || hasRepeatedCharPrefixOverlap(s)) return {
+                    risky: true
+                };
+            }
+            for (const t of s){
+                const e = getStarExtglobSequenceOutput(t);
+                if (e) return {
+                    risky: true,
+                    safeOutput: e
+                };
+                if (repeatedExtglobRecursion(t) > n) return {
+                    risky: true
+                };
+            }
+            return {
+                risky: false
+            };
+        };
+        const parse = (t, e)=>{
+            if ("string" != typeof t) throw new TypeError("Expected a string");
+            t = c[t] || t;
+            const n = {
+                ...e
+            };
+            const l = "number" == typeof n.maxLength ? Math.min(o, n.maxLength) : o;
+            let f = t.length;
+            if (f > l) throw new SyntaxError(`Input length: ${f}, exceeds maximum allowed length: ${l}`);
+            const p = {
+                type: "bos",
+                value: "",
+                output: n.prepend || ""
+            };
+            const d = [
+                p
+            ];
+            const h = n.capture ? "" : "?:";
+            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 L = n.dot ? "" : C;
+            const P = n.dot ? $ : H;
+            let k = true === n.bash ? globstar(n) : T;
+            if (n.capture) k = `(${k})`;
+            if ("boolean" == typeof n.noext) n.noextglob = n.noext;
+            const I = {
+                input: t,
+                index: -1,
+                start: 0,
+                dot: true === n.dot,
+                consumed: "",
+                output: "",
+                prefix: "",
+                backtrack: false,
+                negated: false,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: false,
+                tokens: d
+            };
+            t = s.removePrefix(t, I);
+            f = t.length;
+            const N = [];
+            const M = [];
+            const B = [];
+            let D = p;
+            let F;
+            const eos = ()=>I.index === f - 1;
+            const G = 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)=>{
+                I.consumed += t;
+                I.index += e;
+            };
+            const append = (t)=>{
+                I.output += null != t.output ? t.output : t.value;
+                consume(t.value);
+            };
+            const negate = ()=>{
+                let t = 1;
+                while("!" === G() && ("(" !== G(2) || "?" === G(3))){
+                    U();
+                    I.start++;
+                    t++;
+                }
+                if (t % 2 === 0) return false;
+                I.negated = true;
+                I.start++;
+                return true;
+            };
+            const increment = (t)=>{
+                I[t]++;
+                B.push(t);
+            };
+            const decrement = (t)=>{
+                I[t]--;
+                B.pop();
+            };
+            const push = (t)=>{
+                if ("globstar" === D.type) {
+                    const e = I.braces > 0 && ("comma" === t.type || "brace" === t.type);
+                    const n = true === t.extglob || N.length && ("pipe" === t.type || "paren" === t.type);
+                    if ("slash" !== t.type && "paren" !== t.type && !e && !n) {
+                        I.output = I.output.slice(0, -D.output.length);
+                        D.type = "star";
+                        D.value = "*";
+                        D.output = k;
+                        I.output += D.output;
+                    }
+                }
+                if (N.length && "paren" !== t.type) N[N.length - 1].inner += t.value;
+                if (t.value || t.output) append(t);
+                if (D && "text" === D.type && "text" === t.type) {
+                    D.value += t.value;
+                    D.output = (D.output || "") + t.value;
+                    return;
+                }
+                t.prev = D;
+                d.push(t);
+                D = t;
+            };
+            const extglobOpen = (t, e)=>{
+                const r = {
+                    ...A[e],
+                    conditions: 1,
+                    inner: ""
+                };
+                r.prev = D;
+                r.parens = I.parens;
+                r.output = I.output;
+                r.startIndex = I.index;
+                r.tokensIndex = d.length;
+                const s = (n.capture ? "(" : "") + r.open;
+                increment("parens");
+                push({
+                    type: t,
+                    value: e,
+                    output: I.output ? "" : b
+                });
+                push({
+                    type: "paren",
+                    extglob: true,
+                    value: U(),
+                    output: s
+                });
+                N.push(r);
+            };
+            const extglobClose = (r)=>{
+                const o = t.slice(r.startIndex, I.index + 1);
+                const i = t.slice(r.startIndex + 2, I.index);
+                const a = analyzeRepeatedExtglob(i, n);
+                if (("plus" === r.type || "star" === r.type) && a.risky) {
+                    const t = a.safeOutput ? (r.output ? "" : b) + (n.capture ? `(${a.safeOutput})` : a.safeOutput) : void 0;
+                    const e = d[r.tokensIndex];
+                    e.type = "text";
+                    e.value = o;
+                    e.output = t || s.escapeRegex(o);
+                    for(let t = r.tokensIndex + 1; t < d.length; t++){
+                        d[t].value = "";
+                        d[t].output = "";
+                        delete d[t].suffix;
+                    }
+                    I.output = r.output + e.output;
+                    I.backtrack = true;
+                    push({
+                        type: "paren",
+                        extglob: true,
+                        value: F,
+                        output: ""
+                    });
+                    decrement("parens");
+                    return;
+                }
+                let u = r.close + (n.capture ? ")" : "");
+                let c;
+                if ("negate" === r.type) {
+                    let t = k;
+                    if (r.inner && r.inner.length > 1 && r.inner.includes("/")) t = globstar(n);
+                    if (t !== k || eos() || /^\)+$/.test(remaining())) u = r.close = `)$))${t}`;
+                    if (r.inner.includes("*") && (c = remaining()) && /^\.[^\\/.]+$/.test(c)) {
+                        const n = parse(c, {
+                            ...e,
+                            fastpaths: false
+                        }).output;
+                        u = r.close = `)${n})${t})`;
+                    }
+                    if ("bos" === r.prev.type) I.negatedExtglob = true;
+                }
+                push({
+                    type: "paren",
+                    extglob: true,
+                    value: F,
+                    output: u
+                });
+                decrement("parens");
+            };
+            if (false !== n.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+                let r = false;
+                let o = t.replace(u, (t, e, n, s, o, i)=>{
+                    if ("\\" === s) {
+                        r = true;
+                        return t;
+                    }
+                    if ("?" === s) {
+                        if (e) return e + s + (o ? $.repeat(o.length) : "");
+                        if (0 === i) return P + (o ? $.repeat(o.length) : "");
+                        return $.repeat(n.length);
+                    }
+                    if ("." === s) return R.repeat(n.length);
+                    if ("*" === s) {
+                        if (e) return e + s + (o ? k : "");
+                        return k;
+                    }
+                    return e ? t : `\\${t}`;
+                });
+                if (true === r) o = true === n.unescape ? o.replace(/\\/g, "") : o.replace(/\\+/g, (t)=>t.length % 2 === 0 ? "\\\\" : t ? "\\" : "");
+                if (o === t && true === n.contains) {
+                    I.output = t;
+                    return I;
+                }
+                I.output = s.wrapOutput(o, I, e);
+                return I;
+            }
+            while(!eos()){
+                F = U();
+                if ("\0" === F) continue;
+                if ("\\" === F) {
+                    const t = G();
+                    if ("/" === t && true !== n.bash) continue;
+                    if ("." === t || ";" === t) continue;
+                    if (!t) {
+                        F += "\\";
+                        push({
+                            type: "text",
+                            value: F
+                        });
+                        continue;
+                    }
+                    const e = /^\\+/.exec(remaining());
+                    let r = 0;
+                    if (e && e[0].length > 2) {
+                        r = e[0].length;
+                        I.index += r;
+                        if (r % 2 !== 0) F += "\\";
+                    }
+                    if (true === n.unescape) F = U();
+                    else F += U();
+                    if (0 === I.brackets) {
+                        push({
+                            type: "text",
+                            value: F
+                        });
+                        continue;
+                    }
+                }
+                if (I.brackets > 0 && ("]" !== F || "[" === D.value || "[^" === D.value)) {
+                    if (false !== n.posix && ":" === F) {
+                        const t = D.value.slice(1);
+                        if (t.includes("[")) {
+                            D.posix = true;
+                            if (t.includes(":")) {
+                                const t = D.value.lastIndexOf("[");
+                                const e = D.value.slice(0, t);
+                                const n = D.value.slice(t + 2);
+                                const r = i[n];
+                                if (r) {
+                                    D.value = e + r;
+                                    I.backtrack = true;
+                                    U();
+                                    if (!p.output && 1 === d.indexOf(D)) p.output = b;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    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;
+                    append({
+                        value: F
+                    });
+                    continue;
+                }
+                if (1 === I.quotes && '"' !== F) {
+                    F = s.escapeRegex(F);
+                    D.value += F;
+                    append({
+                        value: F
+                    });
+                    continue;
+                }
+                if ('"' === F) {
+                    I.quotes = 1 === I.quotes ? 0 : 1;
+                    if (true === n.keepQuotes) push({
+                        type: "text",
+                        value: F
+                    });
+                    continue;
+                }
+                if ("(" === F) {
+                    increment("parens");
+                    push({
+                        type: "paren",
+                        value: F
+                    });
+                    continue;
+                }
+                if (")" === F) {
+                    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) {
+                        extglobClose(N.pop());
+                        continue;
+                    }
+                    push({
+                        type: "paren",
+                        value: F,
+                        output: I.parens ? ")" : "\\)"
+                    });
+                    decrement("parens");
+                    continue;
+                }
+                if ("[" === F) {
+                    if (true !== n.nobracket && remaining().includes("]")) increment("brackets");
+                    else {
+                        if (true !== n.nobracket && true === n.strictBrackets) throw new SyntaxError(syntaxError("closing", "]"));
+                        F = `\\${F}`;
+                    }
+                    push({
+                        type: "bracket",
+                        value: F
+                    });
+                    continue;
+                }
+                if ("]" === F) {
+                    if (true === n.nobracket || D && "bracket" === D.type && 1 === D.value.length) {
+                        push({
+                            type: "text",
+                            value: F,
+                            output: `\\${F}`
+                        });
+                        continue;
+                    }
+                    if (0 === I.brackets) {
+                        if (true === n.strictBrackets) throw new SyntaxError(syntaxError("opening", "["));
+                        push({
+                            type: "text",
+                            value: F,
+                            output: `\\${F}`
+                        });
+                        continue;
+                    }
+                    decrement("brackets");
+                    const t = D.value.slice(1);
+                    if (true !== D.posix && "^" === t[0] && !t.includes("/")) F = `/${F}`;
+                    D.value += F;
+                    append({
+                        value: F
+                    });
+                    if (false === n.literalBrackets || s.hasRegexChars(t)) continue;
+                    const e = s.escapeRegex(D.value);
+                    I.output = I.output.slice(0, -D.value.length);
+                    if (true === n.literalBrackets) {
+                        I.output += e;
+                        D.value = e;
+                        continue;
+                    }
+                    D.value = `(${h}${e}|${D.value})`;
+                    I.output += D.value;
+                    continue;
+                }
+                if ("{" === F && true !== n.nobrace) {
+                    increment("braces");
+                    const t = {
+                        type: "brace",
+                        value: F,
+                        output: "(",
+                        outputIndex: I.output.length,
+                        tokensIndex: I.tokens.length
+                    };
+                    M.push(t);
+                    push(t);
+                    continue;
+                }
+                if ("}" === F) {
+                    const t = M[M.length - 1];
+                    if (true === n.nobrace || !t) {
+                        push({
+                            type: "text",
+                            value: F,
+                            output: F
+                        });
+                        continue;
+                    }
+                    let e = ")";
+                    if (true === t.dots) {
+                        const t = d.slice();
+                        const r = [];
+                        for(let e = t.length - 1; e >= 0; e--){
+                            d.pop();
+                            if ("brace" === t[e].type) break;
+                            if ("dots" !== t[e].type) r.unshift(t[e].value);
+                        }
+                        e = expandRange(r, n);
+                        I.backtrack = true;
+                    }
+                    if (true !== t.comma && true !== t.dots) {
+                        const n = I.output.slice(0, t.outputIndex);
+                        const r = I.tokens.slice(t.tokensIndex);
+                        t.value = t.output = "\\{";
+                        F = e = "\\}";
+                        I.output = n;
+                        for (const t of r)I.output += t.output || t.value;
+                    }
+                    push({
+                        type: "brace",
+                        value: F,
+                        output: e
+                    });
+                    decrement("braces");
+                    M.pop();
+                    continue;
+                }
+                if ("|" === F) {
+                    if (N.length > 0) N[N.length - 1].conditions++;
+                    push({
+                        type: "text",
+                        value: F
+                    });
+                    continue;
+                }
+                if ("," === F) {
+                    let t = F;
+                    const e = M[M.length - 1];
+                    if (e && "braces" === B[B.length - 1]) {
+                        e.comma = true;
+                        t = "|";
+                    }
+                    push({
+                        type: "comma",
+                        value: F,
+                        output: t
+                    });
+                    continue;
+                }
+                if ("/" === F) {
+                    if ("dot" === D.type && I.index === I.start + 1) {
+                        I.start = I.index + 1;
+                        I.consumed = "";
+                        I.output = "";
+                        d.pop();
+                        D = p;
+                        continue;
+                    }
+                    push({
+                        type: "slash",
+                        value: F,
+                        output: E
+                    });
+                    continue;
+                }
+                if ("." === F) {
+                    if (I.braces > 0 && "dot" === D.type) {
+                        if ("." === D.value) D.output = R;
+                        const t = M[M.length - 1];
+                        D.type = "dots";
+                        D.output += F;
+                        D.value += F;
+                        t.dots = true;
+                        continue;
+                    }
+                    if (I.braces + I.parens === 0 && "bos" !== D.type && "slash" !== D.type) {
+                        push({
+                            type: "text",
+                            value: F,
+                            output: R
+                        });
+                        continue;
+                    }
+                    push({
+                        type: "dot",
+                        value: F,
+                        output: R
+                    });
+                    continue;
+                }
+                if ("?" === F) {
+                    const t = D && "(" === D.value;
+                    if (!t && true !== n.noextglob && "(" === G() && "?" !== G(2)) {
+                        extglobOpen("qmark", F);
+                        continue;
+                    }
+                    if (D && "paren" === D.type) {
+                        const t = G();
+                        let e = F;
+                        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}`;
+                        push({
+                            type: "text",
+                            value: F,
+                            output: e
+                        });
+                        continue;
+                    }
+                    if (true !== n.dot && ("slash" === D.type || "bos" === D.type)) {
+                        push({
+                            type: "qmark",
+                            value: F,
+                            output: H
+                        });
+                        continue;
+                    }
+                    push({
+                        type: "qmark",
+                        value: F,
+                        output: $
+                    });
+                    continue;
+                }
+                if ("!" === F) {
+                    if (true !== n.noextglob && "(" === G()) {
+                        if ("?" !== G(2) || !/[!=<:]/.test(G(3))) {
+                            extglobOpen("negate", F);
+                            continue;
+                        }
+                    }
+                    if (true !== n.nonegate && 0 === I.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ("+" === F) {
+                    if (true !== n.noextglob && "(" === G() && "?" !== G(2)) {
+                        extglobOpen("plus", F);
+                        continue;
+                    }
+                    if (D && "(" === D.value || false === n.regex) {
+                        push({
+                            type: "plus",
+                            value: F,
+                            output: m
+                        });
+                        continue;
+                    }
+                    if (D && ("bracket" === D.type || "paren" === D.type || "brace" === D.type) || I.parens > 0) {
+                        push({
+                            type: "plus",
+                            value: F
+                        });
+                        continue;
+                    }
+                    push({
+                        type: "plus",
+                        value: m
+                    });
+                    continue;
+                }
+                if ("@" === F) {
+                    if (true !== n.noextglob && "(" === G() && "?" !== G(2)) {
+                        push({
+                            type: "at",
+                            extglob: true,
+                            value: F,
+                            output: ""
+                        });
+                        continue;
+                    }
+                    push({
+                        type: "text",
+                        value: F
+                    });
+                    continue;
+                }
+                if ("*" !== F) {
+                    if ("$" === F || "^" === F) F = `\\${F}`;
+                    const t = a.exec(remaining());
+                    if (t) {
+                        F += t[0];
+                        I.index += t[0].length;
+                    }
+                    push({
+                        type: "text",
+                        value: F
+                    });
+                    continue;
+                }
+                if (D && ("globstar" === D.type || true === D.star)) {
+                    D.type = "star";
+                    D.star = true;
+                    D.value += F;
+                    D.output = k;
+                    I.backtrack = true;
+                    I.globstar = true;
+                    consume(F);
+                    continue;
+                }
+                let e = remaining();
+                if (true !== n.noextglob && /^\([^?]/.test(e)) {
+                    extglobOpen("star", F);
+                    continue;
+                }
+                if ("star" === D.type) {
+                    if (true === n.noglobstar) {
+                        consume(F);
+                        continue;
+                    }
+                    const r = D.prev;
+                    const s = r.prev;
+                    const o = "slash" === r.type || "bos" === r.type;
+                    const i = s && ("star" === s.type || "globstar" === s.type);
+                    if (true === n.bash && (!o || e[0] && "/" !== e[0])) {
+                        push({
+                            type: "star",
+                            value: F,
+                            output: ""
+                        });
+                        continue;
+                    }
+                    const a = I.braces > 0 && ("comma" === r.type || "brace" === r.type);
+                    const u = N.length && ("pipe" === r.type || "paren" === r.type);
+                    if (!o && "paren" !== r.type && !a && !u) {
+                        push({
+                            type: "star",
+                            value: F,
+                            output: ""
+                        });
+                        continue;
+                    }
+                    while("/**" === e.slice(0, 3)){
+                        const n = t[I.index + 4];
+                        if (n && "/" !== n) break;
+                        e = e.slice(3);
+                        consume("/**", 3);
+                    }
+                    if ("bos" === r.type && eos()) {
+                        D.type = "globstar";
+                        D.value += F;
+                        D.output = globstar(n);
+                        I.output = D.output;
+                        I.globstar = true;
+                        consume(F);
+                        continue;
+                    }
+                    if ("slash" === r.type && "bos" !== r.prev.type && !i && eos()) {
+                        I.output = I.output.slice(0, -(r.output + D.output).length);
+                        r.output = `(?:${r.output}`;
+                        D.type = "globstar";
+                        D.output = globstar(n) + (n.strictSlashes ? ")" : "|$)");
+                        D.value += F;
+                        I.globstar = true;
+                        I.output += r.output + D.output;
+                        consume(F);
+                        continue;
+                    }
+                    if ("slash" === r.type && "bos" !== r.prev.type && "/" === e[0]) {
+                        const t = void 0 !== e[1] ? "|$" : "";
+                        I.output = I.output.slice(0, -(r.output + D.output).length);
+                        r.output = `(?:${r.output}`;
+                        D.type = "globstar";
+                        D.output = `${globstar(n)}${E}|${E}${t})`;
+                        D.value += F;
+                        I.output += r.output + D.output;
+                        I.globstar = true;
+                        consume(F + U());
+                        push({
+                            type: "slash",
+                            value: "/",
+                            output: ""
+                        });
+                        continue;
+                    }
+                    if ("bos" === r.type && "/" === e[0]) {
+                        D.type = "globstar";
+                        D.value += F;
+                        D.output = `(?:^|${E}|${globstar(n)}${E})`;
+                        I.output = D.output;
+                        I.globstar = true;
+                        consume(F + U());
+                        push({
+                            type: "slash",
+                            value: "/",
+                            output: ""
+                        });
+                        continue;
+                    }
+                    I.output = I.output.slice(0, -D.output.length);
+                    D.type = "globstar";
+                    D.output = globstar(n);
+                    D.value += F;
+                    I.output += D.output;
+                    I.globstar = true;
+                    consume(F);
+                    continue;
+                }
+                const r = {
+                    type: "star",
+                    value: F,
+                    output: k
+                };
+                if (true === n.bash) {
+                    r.output = ".*?";
+                    if ("bos" === D.type || "slash" === D.type) r.output = L + r.output;
+                    push(r);
+                    continue;
+                }
+                if (D && ("bracket" === D.type || "paren" === D.type) && true === n.regex) {
+                    r.output = F;
+                    push(r);
+                    continue;
+                }
+                if (I.index === I.start || "slash" === D.type || "dot" === D.type) {
+                    if ("dot" === D.type) {
+                        I.output += v;
+                        D.output += v;
+                    } else if (true === n.dot) {
+                        I.output += S;
+                        D.output += S;
+                    } else {
+                        I.output += L;
+                        D.output += L;
+                    }
+                    if ("*" !== G()) {
+                        I.output += b;
+                        D.output += b;
+                    }
+                }
+                push(r);
+            }
+            while(I.brackets > 0){
+                if (true === n.strictBrackets) throw new SyntaxError(syntaxError("closing", "]"));
+                I.output = s.escapeLast(I.output, "[");
+                decrement("brackets");
+            }
+            while(I.parens > 0){
+                if (true === n.strictBrackets) throw new SyntaxError(syntaxError("closing", ")"));
+                I.output = s.escapeLast(I.output, "(");
+                decrement("parens");
+            }
+            while(I.braces > 0){
+                if (true === n.strictBrackets) throw new SyntaxError(syntaxError("closing", "}"));
+                I.output = s.escapeLast(I.output, "{");
+                decrement("braces");
+            }
+            if (true !== n.strictSlashes && ("star" === D.type || "bracket" === D.type)) push({
+                type: "maybe_slash",
+                value: "",
+                output: `${E}?`
+            });
+            if (true === I.backtrack) {
+                I.output = "";
+                for (const t of I.tokens){
+                    I.output += null != t.output ? t.output : t.value;
+                    if (t.suffix) I.output += t.suffix;
+                }
+            }
+            return I;
+        };
+        parse.fastpaths = (t, e)=>{
+            const n = {
+                ...e
+            };
+            const i = "number" == typeof n.maxLength ? Math.min(o, n.maxLength) : o;
+            const a = t.length;
+            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 E = n.dot ? _ : h;
+            const b = n.capture ? "" : "?:";
+            const w = {
+                negated: false,
+                prefix: ""
+            };
+            let C = true === n.bash ? ".*?" : A;
+            if (n.capture) C = `(${C})`;
+            const globstar = (t)=>{
+                if (true === t.noglobstar) return C;
+                return `(${b}(?:(?!${R}${t.dot ? d : l}).)*?)`;
+            };
+            const create = (t)=>{
+                switch(t){
+                    case "*":
+                        return `${m}${p}${C}`;
+                    case ".*":
+                        return `${l}${p}${C}`;
+                    case "*.*":
+                        return `${m}${C}${l}${p}${C}`;
+                    case "*/*":
+                        return `${m}${C}${f}${p}${E}${C}`;
+                    case "**":
+                        return m + globstar(n);
+                    case "**/*":
+                        return `(?:${m}${globstar(n)}${f})?${E}${p}${C}`;
+                    case "**/*.*":
+                        return `(?:${m}${globstar(n)}${f})?${E}${C}${l}${p}${C}`;
+                    case "**/.*":
+                        return `(?:${m}${globstar(n)}${f})?${l}${p}${C}`;
+                    default:
+                        {
+                            const e = /^(.*?)\.(\w+)$/.exec(t);
+                            if (!e) return;
+                            const n = create(e[1]);
+                            if (!n) return;
+                            return n + l + e[2];
+                        }
+                }
+            };
+            const v = s.removePrefix(t, w);
+            let S = create(v);
+            if (S && true !== n.strictSlashes) S += `${f}?`;
+            return S;
+        };
+        t.exports = parse;
+    },
+    810: (t, e, n)=>{
+        const r = n(928);
+        const s = n(779);
+        const o = n(143);
+        const i = n(445);
+        const a = n(193);
+        const isObject = (t)=>t && "object" == typeof t && !Array.isArray(t);
+        const picomatch = (t, e, n = false)=>{
+            if (Array.isArray(t)) {
+                const r = t.map((t)=>picomatch(t, e, n));
+                const arrayMatcher = (t)=>{
+                    for (const e of r){
+                        const n = e(t);
+                        if (n) return n;
+                    }
+                    return false;
+                };
+                return arrayMatcher;
+            }
+            const r = isObject(t) && t.tokens && t.input;
+            if ("" === t || "string" != typeof t && !r) throw new TypeError("Expected pattern to be a non-empty string");
+            const s = e || {};
+            const o = i.isWindows(e);
+            const a = r ? picomatch.compileRe(t, e) : picomatch.makeRe(t, e, false, true);
+            const u = a.state;
+            delete a.state;
+            let isIgnored = ()=>false;
+            if (s.ignore) {
+                const t = {
+                    ...e,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(s.ignore, t, n);
+            }
+            const matcher = (n, r = false)=>{
+                const { isMatch: i, match: c, output: l } = picomatch.test(n, a, e, {
+                    glob: t,
+                    posix: o
+                });
+                const f = {
+                    glob: t,
+                    state: u,
+                    regex: a,
+                    posix: o,
+                    input: n,
+                    output: l,
+                    match: c,
+                    isMatch: i
+                };
+                if ("function" == typeof s.onResult) s.onResult(f);
+                if (false === i) {
+                    f.isMatch = false;
+                    return r ? f : false;
+                }
+                if (isIgnored(n)) {
+                    if ("function" == typeof s.onIgnore) s.onIgnore(f);
+                    f.isMatch = false;
+                    return r ? f : false;
+                }
+                if ("function" == typeof s.onMatch) s.onMatch(f);
+                return r ? f : true;
+            };
+            if (n) matcher.state = u;
+            return matcher;
+        };
+        picomatch.test = (t, e, n, { glob: r, posix: s } = {})=>{
+            if ("string" != typeof t) throw new TypeError("Expected input to be a string");
+            if ("" === t) return {
+                isMatch: false,
+                output: ""
+            };
+            const o = n || {};
+            const a = o.format || (s ? i.toPosixSlashes : null);
+            let u = t === r;
+            let c = u && a ? a(t) : t;
+            if (false === u) {
+                c = a ? a(t) : t;
+                u = c === r;
+            }
+            if (false === u || true === o.capture) u = true === o.matchBase || true === o.basename ? picomatch.matchBase(t, e, n, s) : e.exec(c);
+            return {
+                isMatch: Boolean(u),
+                match: u,
+                output: c
+            };
+        };
+        picomatch.matchBase = (t, e, n, s = i.isWindows(n))=>{
+            const o = e instanceof RegExp ? e : picomatch.makeRe(e, n);
+            return o.test(r.basename(t));
+        };
+        picomatch.isMatch = (t, e, n)=>picomatch(e, n)(t);
+        picomatch.parse = (t, e)=>{
+            if (Array.isArray(t)) return t.map((t)=>picomatch.parse(t, e));
+            return o(t, {
+                ...e,
+                fastpaths: false
+            });
+        };
+        picomatch.scan = (t, e)=>s(t, e);
+        picomatch.compileRe = (t, e, n = false, r = false)=>{
+            if (true === n) return t.output;
+            const s = e || {};
+            const o = s.contains ? "" : "^";
+            const i = s.contains ? "" : "$";
+            let a = `${o}(?:${t.output})${i}`;
+            if (t && true === t.negated) a = `^(?!${a}).*$`;
+            const u = picomatch.toRegex(a, e);
+            if (true === r) u.state = t;
+            return u;
+        };
+        picomatch.makeRe = (t, e = {}, n = false, r = false)=>{
+            if (!t || "string" != typeof t) throw new TypeError("Expected a non-empty string");
+            let s = {
+                negated: false,
+                fastpaths: true
+            };
+            if (false !== e.fastpaths && ("." === t[0] || "*" === t[0])) s.output = o.fastpaths(t, e);
+            if (!s.output) s = o(t, e);
+            return picomatch.compileRe(s, e, n, r);
+        };
+        picomatch.toRegex = (t, e)=>{
+            try {
+                const n = e || {};
+                return new RegExp(t, n.flags || (n.nocase ? "i" : ""));
+            } catch (t) {
+                if (e && true === e.debug) throw t;
+                return /$^/;
+            }
+        };
+        picomatch.constants = a;
+        t.exports = picomatch;
+    },
+    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 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 E = true === n.parts || true === n.scanToEnd;
+            const b = [];
+            const w = [];
+            const C = [];
+            let v = t;
+            let S = -1;
+            let $ = 0;
+            let H = 0;
+            let T = false;
+            let O = false;
+            let L = false;
+            let P = false;
+            let k = false;
+            let I = false;
+            let N = false;
+            let M = false;
+            let B = false;
+            let D = false;
+            let F = 0;
+            let G;
+            let U;
+            let W = {
+                value: "",
+                depth: 0,
+                isGlob: false
+            };
+            const eos = ()=>S >= m;
+            const peek = ()=>v.charCodeAt(S + 1);
+            const advance = ()=>{
+                G = U;
+                return v.charCodeAt(++S);
+            };
+            while(S < m){
+                U = advance();
+                let t;
+                if (U === i) {
+                    N = W.backslashes = true;
+                    U = advance();
+                    if (U === f) I = true;
+                    continue;
+                }
+                if (true === I || U === f) {
+                    F++;
+                    while(true !== eos() && (U = advance())){
+                        if (U === i) {
+                            N = W.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (U === f) {
+                            F++;
+                            continue;
+                        }
+                        if (true !== I && U === u && (U = advance()) === u) {
+                            T = W.isBrace = true;
+                            L = W.isGlob = true;
+                            D = true;
+                            if (true === E) continue;
+                            break;
+                        }
+                        if (true !== I && U === a) {
+                            T = W.isBrace = true;
+                            L = W.isGlob = true;
+                            D = true;
+                            if (true === E) continue;
+                            break;
+                        }
+                        if (U === _) {
+                            F--;
+                            if (0 === F) {
+                                I = false;
+                                T = W.isBrace = true;
+                                D = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (true === E) continue;
+                    break;
+                }
+                if (U === l) {
+                    b.push(S);
+                    w.push(W);
+                    W = {
+                        value: "",
+                        depth: 0,
+                        isGlob: false
+                    };
+                    if (true === D) continue;
+                    if (G === u && S === $ + 1) {
+                        $ += 2;
+                        continue;
+                    }
+                    H = S + 1;
+                    continue;
+                }
+                if (true !== n.noext) {
+                    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;
+                        D = true;
+                        if (U === c && S === $) B = true;
+                        if (true === E) {
+                            while(true !== eos() && (U = advance())){
+                                if (U === i) {
+                                    N = W.backslashes = true;
+                                    U = advance();
+                                    continue;
+                                }
+                                if (U === A) {
+                                    L = W.isGlob = true;
+                                    D = true;
+                                    break;
+                                }
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if (U === s) {
+                    if (G === s) k = W.isGlobstar = true;
+                    L = W.isGlob = true;
+                    D = true;
+                    if (true === E) continue;
+                    break;
+                }
+                if (U === g) {
+                    L = W.isGlob = true;
+                    D = true;
+                    if (true === E) continue;
+                    break;
+                }
+                if (U === d) {
+                    while(true !== eos() && (t = advance())){
+                        if (t === i) {
+                            N = W.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (t === R) {
+                            O = W.isBracket = true;
+                            L = W.isGlob = true;
+                            D = true;
+                            break;
+                        }
+                    }
+                    if (true === E) continue;
+                    break;
+                }
+                if (true !== n.nonegate && U === c && S === $) {
+                    M = W.negated = true;
+                    $++;
+                    continue;
+                }
+                if (true !== n.noparen && U === p) {
+                    L = W.isGlob = true;
+                    if (true === E) {
+                        while(true !== eos() && (U = advance())){
+                            if (U === p) {
+                                N = W.backslashes = true;
+                                U = advance();
+                                continue;
+                            }
+                            if (U === A) {
+                                D = true;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (true === L) {
+                    D = true;
+                    if (true === E) continue;
+                    break;
+                }
+            }
+            if (true === n.noext) {
+                P = false;
+                L = false;
+            }
+            let K = v;
+            let j = "";
+            let q = "";
+            if ($ > 0) {
+                j = v.slice(0, $);
+                v = v.slice($);
+                H -= $;
+            }
+            if (K && true === L && H > 0) {
+                K = v.slice(0, H);
+                q = v.slice(H);
+            } else if (true === L) {
+                K = "";
+                q = v;
+            } else K = v;
+            if (K && "" !== K && "/" !== K && K !== v) {
+                if (isPathSeparator(K.charCodeAt(K.length - 1))) K = K.slice(0, -1);
+            }
+            if (true === n.unescape) {
+                if (q) q = r.removeBackslashes(q);
+                if (K && true === N) K = r.removeBackslashes(K);
+            }
+            const z = {
+                prefix: j,
+                input: t,
+                start: $,
+                base: K,
+                glob: q,
+                isBrace: T,
+                isBracket: O,
+                isGlob: L,
+                isExtglob: P,
+                isGlobstar: k,
+                negated: M,
+                negatedExtglob: B
+            };
+            if (true === n.tokens) {
+                z.maxDepth = 0;
+                if (!isPathSeparator(U)) w.push(W);
+                z.tokens = w;
+            }
+            if (true === n.parts || true === n.tokens) {
+                let e;
+                for(let r = 0; r < b.length; r++){
+                    const s = e ? e + 1 : $;
+                    const o = b[r];
+                    const i = t.slice(s, o);
+                    if (n.tokens) {
+                        if (0 === r && 0 !== $) {
+                            w[r].isPrefix = true;
+                            w[r].value = j;
+                        } else w[r].value = i;
+                        depth(w[r]);
+                        z.maxDepth += w[r].depth;
+                    }
+                    if (0 !== r || "" !== i) C.push(i);
+                    e = o;
+                }
+                if (e && e + 1 < t.length) {
+                    const r = t.slice(e + 1);
+                    C.push(r);
+                    if (n.tokens) {
+                        w[w.length - 1].value = r;
+                        depth(w[w.length - 1]);
+                        z.maxDepth += w[w.length - 1].depth;
+                    }
+                }
+                z.slashes = b;
+                z.parts = C;
+            }
+            return z;
+        };
+        t.exports = scan;
+    },
+    445: (t, e, n)=>{
+        const r = n(928);
+        const s = "win32" === process.platform;
+        const { REGEX_BACKSLASH: o, REGEX_REMOVE_BACKSLASH: i, REGEX_SPECIAL_CHARS: a, REGEX_SPECIAL_CHARS_GLOBAL: u } = n(193);
+        e.isObject = (t)=>null !== t && "object" == typeof t && !Array.isArray(t);
+        e.hasRegexChars = (t)=>a.test(t);
+        e.isRegexChar = (t)=>1 === t.length && e.hasRegexChars(t);
+        e.escapeRegex = (t)=>t.replace(u, "\\$1");
+        e.toPosixSlashes = (t)=>t.replace(o, "/");
+        e.removeBackslashes = (t)=>t.replace(i, (t)=>"\\" === t ? "" : t);
+        e.supportsLookbehinds = ()=>{
+            const t = process.version.slice(1).split(".").map(Number);
+            if (3 === t.length && t[0] >= 9 || 8 === t[0] && t[1] >= 10) return true;
+            return false;
+        };
+        e.isWindows = (t)=>{
+            if (t && "boolean" == typeof t.windows) return t.windows;
+            return true === s || "\\" === r.sep;
+        };
+        e.escapeLast = (t, n, r)=>{
+            const s = t.lastIndexOf(n, r);
+            if (-1 === s) return t;
+            if ("\\" === t[s - 1]) return e.escapeLast(t, n, s - 1);
+            return `${t.slice(0, s)}\\${t.slice(s)}`;
+        };
+        e.removePrefix = (t, e = {})=>{
+            let n = t;
+            if (n.startsWith("./")) {
+                n = n.slice(2);
+                e.prefix = "./";
+            }
+            return n;
+        };
+        e.wrapOutput = (t, e = {}, n = {})=>{
+            const r = n.contains ? "" : "^";
+            const s = n.contains ? "" : "$";
+            let o = `${r}(?:${t})${s}`;
+            if (true === e.negated) o = `(?:^(?!${o}).*$)`;
+            return o;
+        };
+    },
+    491: (t, e, n)=>{
+        /*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ const r = n(460);
+        const toRegexRange = (t, e, n)=>{
+            if (false === r(t)) throw new TypeError("toRegexRange: expected the first argument to be a number");
+            if (void 0 === e || t === e) return String(t);
+            if (false === r(e)) throw new TypeError("toRegexRange: expected the second argument to be a number.");
+            let s = {
+                relaxZeros: true,
+                ...n
+            };
+            if ("boolean" == typeof s.strictZeros) s.relaxZeros = false === s.strictZeros;
+            let o = String(s.relaxZeros);
+            let i = String(s.shorthand);
+            let a = String(s.capture);
+            let u = String(s.wrap);
+            let c = t + ":" + e + "=" + o + i + a + u;
+            if (toRegexRange.cache.hasOwnProperty(c)) return toRegexRange.cache[c].result;
+            let l = Math.min(t, e);
+            let f = Math.max(t, e);
+            if (1 === Math.abs(l - f)) {
+                let n = t + "|" + e;
+                if (s.capture) return `(${n})`;
+                if (false === s.wrap) return n;
+                return `(?:${n})`;
+            }
+            let p = hasPadding(t) || hasPadding(e);
+            let d = {
+                min: t,
+                max: e,
+                a: l,
+                b: f
+            };
+            let h = [];
+            let g = [];
+            if (p) {
+                d.isPadded = p;
+                d.maxLen = String(d.max).length;
+            }
+            if (l < 0) {
+                let t = f < 0 ? Math.abs(f) : 1;
+                g = splitToPatterns(t, Math.abs(l), d, s);
+                l = d.a = 0;
+            }
+            if (f >= 0) h = splitToPatterns(l, f, d, s);
+            d.negatives = g;
+            d.positives = h;
+            d.result = collatePatterns(g, h, s);
+            if (true === s.capture) d.result = `(${d.result})`;
+            else if (false !== s.wrap && h.length + g.length > 1) d.result = `(?:${d.result})`;
+            toRegexRange.cache[c] = d;
+            return d.result;
+        };
+        function collatePatterns(t, e, n) {
+            let r = filterPatterns(t, e, "-", false, n) || [];
+            let s = filterPatterns(e, t, "", false, n) || [];
+            let o = filterPatterns(t, e, "-?", true, n) || [];
+            let i = r.concat(o).concat(s);
+            return i.join("|");
+        }
+        function splitToRanges(t, e) {
+            let n = 1;
+            let r = 1;
+            let s = countNines(t, n);
+            let o = new Set([
+                e
+            ]);
+            while(t <= s && s <= e){
+                o.add(s);
+                n += 1;
+                s = countNines(t, n);
+            }
+            s = countZeros(e + 1, r) - 1;
+            while(t < s && s <= e){
+                o.add(s);
+                r += 1;
+                s = countZeros(e + 1, r) - 1;
+            }
+            o = [
+                ...o
+            ];
+            o.sort(compare);
+            return o;
+        }
+        function rangeToPattern(t, e, n) {
+            if (t === e) return {
+                pattern: t,
+                count: [],
+                digits: 0
+            };
+            let r = zip(t, e);
+            let s = r.length;
+            let o = "";
+            let i = 0;
+            for(let t = 0; t < s; t++){
+                let [e, s] = r[t];
+                if (e === s) o += e;
+                else if ("0" !== e || "9" !== s) o += toCharacterClass(e, s, n);
+                else i++;
+            }
+            if (i) o += true === n.shorthand ? "\\d" : "[0-9]";
+            return {
+                pattern: o,
+                count: [
+                    i
+                ],
+                digits: s
+            };
+        }
+        function splitToPatterns(t, e, n, r) {
+            let s = splitToRanges(t, e);
+            let o = [];
+            let i = t;
+            let a;
+            for(let t = 0; t < s.length; t++){
+                let e = s[t];
+                let u = rangeToPattern(String(i), String(e), r);
+                let c = "";
+                if (!n.isPadded && a && a.pattern === u.pattern) {
+                    if (a.count.length > 1) a.count.pop();
+                    a.count.push(u.count[0]);
+                    a.string = a.pattern + toQuantifier(a.count);
+                    i = e + 1;
+                    continue;
+                }
+                if (n.isPadded) c = padZeros(e, n, r);
+                u.string = c + u.pattern + toQuantifier(u.count);
+                o.push(u);
+                i = e + 1;
+                a = u;
+            }
+            return o;
+        }
+        function filterPatterns(t, e, n, r, s) {
+            let o = [];
+            for (let s of t){
+                let { string: t } = s;
+                if (!r && !contains(e, "string", t)) o.push(n + t);
+                if (r && contains(e, "string", t)) o.push(n + t);
+            }
+            return o;
+        }
+        function zip(t, e) {
+            let n = [];
+            for(let r = 0; r < t.length; r++)n.push([
+                t[r],
+                e[r]
+            ]);
+            return n;
+        }
+        function compare(t, e) {
+            return t > e ? 1 : e > t ? -1 : 0;
+        }
+        function contains(t, e, n) {
+            return t.some((t)=>t[e] === n);
+        }
+        function countNines(t, e) {
+            return Number(String(t).slice(0, -e) + "9".repeat(e));
+        }
+        function countZeros(t, e) {
+            return t - t % Math.pow(10, e);
+        }
+        function toQuantifier(t) {
+            let [e = 0, n = ""] = t;
+            if (n || e > 1) return `{${e + (n ? "," + n : "")}}`;
+            return "";
+        }
+        function toCharacterClass(t, e, n) {
+            return `[${t}${e - t === 1 ? "" : "-"}${e}]`;
+        }
+        function hasPadding(t) {
+            return /^-?(0+)\d/.test(t);
+        }
+        function padZeros(t, e, n) {
+            if (!e.isPadded) return t;
+            let r = Math.abs(e.maxLen - String(t).length);
+            let s = false !== n.relaxZeros;
+            switch(r){
+                case 0:
+                    return "";
+                case 1:
+                    return s ? "0?" : "0";
+                case 2:
+                    return s ? "0{0,2}" : "00";
+                default:
+                    return s ? `0{0,${r}}` : `0{${r}}`;
+            }
+        }
+        toRegexRange.cache = {};
+        toRegexRange.clearCache = ()=>toRegexRange.cache = {};
+        t.exports = toRegexRange;
+    },
+    928: (t)=>{
+        t.exports = require("path");
+    },
+    23: (t)=>{
+        t.exports = require("util");
+    }
+};
+var n = {};
+function __nccwpck_require__(t) {
+    var r = n[t];
+    if (void 0 !== r) return r.exports;
+    var s = n[t] = {
+        exports: {}
+    };
+    var o = true;
+    try {
+        e[t](s, s.exports, __nccwpck_require__);
+        o = false;
+    } finally{
+        if (o) delete n[t];
+    }
+    return s.exports;
+}
+if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = decodeURIComponent(new URL(".", import.meta.url).pathname).slice(import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/";
+(()=>{
+    __nccwpck_require__.d = (t, e)=>{
+        for(var n in e)if (__nccwpck_require__.o(e, n) && !__nccwpck_require__.o(t, n)) Object.defineProperty(t, n, {
+            enumerable: true,
+            get: e[n]
+        });
+    };
+})();
+(()=>{
+    __nccwpck_require__.o = (t, e)=>Object.prototype.hasOwnProperty.call(t, e);
+})();
+var r = {};
+__nccwpck_require__.d(r, {
+    a: ()=>B,
+    Kd: ()=>N,
+    li: ()=>M,
+    IK: ()=>L,
+    AG: ()=>k,
+    Hz: ()=>P,
+    ey: ()=>I,
+    Zh: ()=>isGitIgnored,
+    kD: ()=>isGitIgnoredSync,
+    dK: ()=>isIgnoredByIgnoreFiles,
+    Sb: ()=>isIgnoredByIgnoreFilesSync
+});
+const s = require("node:process");
+const o = require("node:fs");
+const i = require("node:path");
+const a = require("node:stream");
+const u = require("node:events");
+const c = require("node:stream/promises");
+function mergeStreams(t) {
+    if (!Array.isArray(t)) throw new TypeError(`Expected an array, got \`${typeof t}\`.`);
+    for (const e of t)validateStream(e);
+    const e = t.some(({ readableObjectMode: t })=>t);
+    const n = getHighWaterMark(t, e);
+    const r = new MergedStream({
+        objectMode: e,
+        writableHighWaterMark: n,
+        readableHighWaterMark: n
+    });
+    for (const e of t)r.add(e);
+    return r;
+}
+const getHighWaterMark = (t, e)=>{
+    if (0 === t.length) return (0, a.getDefaultHighWaterMark)(e);
+    const n = t.filter(({ readableObjectMode: t })=>t === e).map(({ readableHighWaterMark: t })=>t);
+    return Math.max(...n);
+};
+class MergedStream extends a.PassThrough {
+    #t = new Set([]);
+    #e = new Set([]);
+    #n = new Set([]);
+    #r;
+    #s = Symbol("unpipe");
+    #o = new WeakMap;
+    add(t) {
+        validateStream(t);
+        if (this.#t.has(t)) return;
+        this.#t.add(t);
+        this.#r ??= onMergedStreamFinished(this, this.#t, this.#s);
+        const e = endWhenStreamsDone({
+            passThroughStream: this,
+            stream: t,
+            streams: this.#t,
+            ended: this.#e,
+            aborted: this.#n,
+            onFinished: this.#r,
+            unpipeEvent: this.#s
+        });
+        this.#o.set(t, e);
+        t.pipe(this, {
+            end: false
+        });
+    }
+    async remove(t) {
+        validateStream(t);
+        if (!this.#t.has(t)) return false;
+        const e = this.#o.get(t);
+        if (void 0 === e) return false;
+        this.#o.delete(t);
+        t.unpipe(this);
+        await e;
+        return true;
+    }
+}
+const onMergedStreamFinished = async (t, e, n)=>{
+    updateMaxListeners(t, l);
+    const r = new AbortController;
+    try {
+        await Promise.race([
+            onMergedStreamEnd(t, r),
+            onInputStreamsUnpipe(t, e, n, r)
+        ]);
+    } finally{
+        r.abort();
+        updateMaxListeners(t, -l);
+    }
+};
+const onMergedStreamEnd = async (t, { signal: e })=>{
+    try {
+        await (0, c.finished)(t, {
+            signal: e,
+            cleanup: true
+        });
+    } catch (e) {
+        errorOrAbortStream(t, e);
+        throw e;
+    }
+};
+const onInputStreamsUnpipe = async (t, e, n, { signal: r })=>{
+    for await (const [s] of (0, u.on)(t, "unpipe", {
+        signal: r
+    }))if (e.has(s)) s.emit(n);
+};
+const validateStream = (t)=>{
+    if ("function" != typeof t?.pipe) throw new TypeError(`Expected a readable stream, got: \`${typeof t}\`.`);
+};
+const endWhenStreamsDone = async ({ passThroughStream: t, stream: e, streams: n, ended: r, aborted: s, onFinished: o, unpipeEvent: i })=>{
+    updateMaxListeners(t, f);
+    const a = new AbortController;
+    try {
+        await Promise.race([
+            afterMergedStreamFinished(o, e, a),
+            onInputStreamEnd({
+                passThroughStream: t,
+                stream: e,
+                streams: n,
+                ended: r,
+                aborted: s,
+                controller: a
+            }),
+            onInputStreamUnpipe({
+                stream: e,
+                streams: n,
+                ended: r,
+                aborted: s,
+                unpipeEvent: i,
+                controller: a
+            })
+        ]);
+    } finally{
+        a.abort();
+        updateMaxListeners(t, -f);
+    }
+    if (n.size > 0 && n.size === r.size + s.size) if (0 === r.size && s.size > 0) abortStream(t);
+    else endStream(t);
+};
+const afterMergedStreamFinished = async (t, e, { signal: n })=>{
+    try {
+        await t;
+        if (!n.aborted) abortStream(e);
+    } catch (t) {
+        if (!n.aborted) errorOrAbortStream(e, t);
+    }
+};
+const onInputStreamEnd = async ({ passThroughStream: t, stream: e, streams: n, ended: r, aborted: s, controller: { signal: o } })=>{
+    try {
+        await (0, c.finished)(e, {
+            signal: o,
+            cleanup: true,
+            readable: true,
+            writable: false
+        });
+        if (n.has(e)) r.add(e);
+    } catch (r) {
+        if (o.aborted || !n.has(e)) return;
+        if (isAbortError(r)) s.add(e);
+        else errorStream(t, r);
+    }
+};
+const onInputStreamUnpipe = async ({ stream: t, streams: e, ended: n, aborted: r, unpipeEvent: s, controller: { signal: o } })=>{
+    await (0, u.once)(t, s, {
+        signal: o
+    });
+    if (!t.readable) return (0, u.once)(o, "abort", {
+        signal: o
+    });
+    e.delete(t);
+    n.delete(t);
+    r.delete(t);
+};
+const endStream = (t)=>{
+    if (t.writable) t.end();
+};
+const errorOrAbortStream = (t, e)=>{
+    if (isAbortError(e)) abortStream(t);
+    else errorStream(t, e);
+};
+const isAbortError = (t)=>t?.code === "ERR_STREAM_PREMATURE_CLOSE";
+const abortStream = (t)=>{
+    if (t.readable || t.writable) t.destroy();
+};
+const errorStream = (t, e)=>{
+    if (!t.destroyed) {
+        t.once("error", noop);
+        t.destroy(e);
+    }
+};
+const noop = ()=>{};
+const updateMaxListeners = (t, e)=>{
+    const n = t.getMaxListeners();
+    if (0 !== n && 1 / 0 !== n) t.setMaxListeners(n + e);
+};
+const l = 2;
+const f = 1;
+var x = (t)=>{
+    var e = {};
+    __nccwpck_require__.d(e, t);
+    return e;
+};
+const p = x({
+    ["default"]: ()=>t["default"]
+});
+const d = require("node:util");
+const h = require("node:child_process");
+const g = require("node:url");
+(0, d.promisify)(h.execFile);
+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);
+function isPathInside(t, e) {
+    const n = i.relative(e, t);
+    return Boolean(n && ".." !== n && !n.startsWith(`..${i.sep}`) && n !== i.resolve(t));
+}
+function slash(t) {
+    const e = t.startsWith("\\\\?\\");
+    if (e) return t;
+    return t.replace(/\\/g, "/");
+}
+var b = __nccwpck_require__(639);
+const isNegativePattern = (t)=>"!" === t[0];
+const normalizeAbsolutePatternToRelative = (t)=>{
+    if (!t.startsWith("/")) return t;
+    const e = t.slice(1);
+    const n = e.indexOf("/");
+    const r = n > 0 ? e.slice(0, n) : e;
+    if (n > 0 && !p["default"].isDynamicPattern(r)) return t;
+    return e;
+};
+const absolutePrefixesMatch = (t, e)=>e === t;
+const getStaticAbsolutePathPrefix = (t)=>{
+    if (!i.isAbsolute(t)) return;
+    const e = [];
+    for (const n of t.split("/"))if (n) {
+        if (p["default"].isDynamicPattern(n)) break;
+        e.push(n);
+    }
+    return 0 === e.length ? void 0 : `/${e.join("/")}`;
+};
+const normalizeNegativePattern = (t, e = [], n = false)=>{
+    if (!t.startsWith("/")) return t;
+    const r = normalizeAbsolutePatternToRelative(t);
+    if (r !== t) return r;
+    if (n) return t.slice(1);
+    const s = getStaticAbsolutePathPrefix(t);
+    const o = void 0 !== s && e.some((t)=>absolutePrefixesMatch(t, s));
+    return o ? t : t.slice(1);
+};
+const bindFsMethod = (t, e)=>{
+    const n = t?.[e];
+    return "function" == typeof n ? n.bind(t) : void 0;
+};
+const promisifyFsMethod = (t, e)=>{
+    const n = t?.[e];
+    if ("function" != typeof n) return;
+    return (0, d.promisify)(n.bind(t));
+};
+const normalizeDirectoryPatternForFastGlob = (t)=>{
+    if (!t.endsWith("/")) return t;
+    const e = t.replace(/\/+$/u, "");
+    if (!e) return "/**";
+    if ("**" === e) return "**/**";
+    const n = e.startsWith("/");
+    const r = n ? e.slice(1) : e;
+    const s = r.includes("/");
+    const o = !n && !s && !e.startsWith("**/");
+    const i = o ? "**/" : "";
+    return `${i}${e}/**`;
+};
+const getParentDirectoryPrefix = (t)=>{
+    const e = isNegativePattern(t) ? t.slice(1) : t;
+    const n = e.match(/^(\.\.\/)+/);
+    return n ? n[0] : "";
+};
+const adjustIgnorePatternsForParentDirectories = (t, e)=>{
+    if (0 === t.length || 0 === e.length) return e;
+    const n = t.map((t)=>getParentDirectoryPrefix(t));
+    const r = n[0];
+    if (!r) return e;
+    const s = n.every((t)=>t === r);
+    if (!s) return e;
+    return e.map((t)=>{
+        if (t.startsWith("**/") && !t.startsWith("../")) return r + t;
+        return t;
+    });
+};
+const getAsyncStatMethod = (t)=>bindFsMethod(t?.promises, "stat") ?? bindFsMethod(o.promises, "stat");
+const getStatSyncMethod = (t)=>{
+    if (t) return bindFsMethod(t, "statSync");
+    return bindFsMethod(o, "statSync");
+};
+const pathHasGitDirectory = (t)=>Boolean(t?.isDirectory?.() || t?.isFile?.());
+const buildPathChain = (t, e)=>{
+    const n = [];
+    let r = t;
+    n.push(r);
+    while(r !== e){
+        const t = i.dirname(r);
+        if (t === r) break;
+        r = t;
+        n.push(r);
+    }
+    return n;
+};
+const findGitRootInChain = async (t, e)=>{
+    for (const n of t){
+        const t = i.join(n, ".git");
+        try {
+            const r = await e(t);
+            if (pathHasGitDirectory(r)) return n;
+        } catch  {}
+    }
+};
+const findGitRootSyncUncached = (t, e)=>{
+    const n = getStatSyncMethod(e);
+    if (!n) return;
+    const r = i.resolve(t);
+    const { root: s } = i.parse(r);
+    const o = buildPathChain(r, s);
+    for (const t of o){
+        const e = i.join(t, ".git");
+        try {
+            const r = n(e);
+            if (pathHasGitDirectory(r)) return t;
+        } catch  {}
+    }
+};
+const findGitRootSync = (t, e)=>{
+    if ("string" != typeof t) throw new TypeError("cwd must be a string");
+    return findGitRootSyncUncached(t, e);
+};
+const findGitRootAsyncUncached = async (t, e)=>{
+    const n = getAsyncStatMethod(e);
+    if (!n) return findGitRootSync(t, e);
+    const r = i.resolve(t);
+    const { root: s } = i.parse(r);
+    const o = buildPathChain(r, s);
+    return findGitRootInChain(o, n);
+};
+const findGitRoot = async (t, e)=>{
+    if ("string" != typeof t) throw new TypeError("cwd must be a string");
+    return findGitRootAsyncUncached(t, e);
+};
+const isWithinGitRoot = (t, e)=>{
+    const n = i.resolve(t);
+    const r = i.resolve(e);
+    return r === n || isPathInside(r, n);
+};
+const getParentGitignorePaths = (t, e)=>{
+    if (t && "string" != typeof t) throw new TypeError("gitRoot must be a string or undefined");
+    if ("string" != typeof e) throw new TypeError("cwd must be a string");
+    if (!t) return [];
+    if (!isWithinGitRoot(t, e)) return [];
+    const n = buildPathChain(i.resolve(e), i.resolve(t));
+    return [
+        ...n
+    ].reverse().map((t)=>i.join(t, ".gitignore"));
+};
+const w = /(?<!\\)[*?[]/u;
+const hasGitignoreWildcards = (t)=>w.test(t);
+const C = /[(){}|\\]/u;
+const unescapeGitignorePattern = (t)=>t.replaceAll(/\\(.)/gu, "$1");
+const normalizeGitignorePatternForIgnore = (t)=>t.replaceAll(/\\(.)/gu, (t, e)=>"*[]\\".includes(e) ? t : e);
+const toLiteralPattern = (t)=>p["default"].escapePath(unescapeGitignorePattern(t));
+const finalSegment = (t)=>t.replace(/\/+$/u, "").split("/").pop();
+const toStandaloneRule = (t)=>t.replace(/^([#!])/u, String.raw`\$1`);
+const isInsideCwd = (t)=>"" !== t && !t.startsWith("..") && !i.isAbsolute(t);
+const anchorToCwd = (t, e, n)=>{
+    const r = slash(i.relative(n, i.join(t, e)));
+    return isInsideCwd(r) ? r : void 0;
+};
+const createNameComparer = ()=>{
+    const t = new Map;
+    const matchesName = (e, n)=>{
+        const r = unescapeGitignorePattern(n);
+        if (!(0, E.isPathValid)(r)) return true;
+        const s = normalizeGitignorePatternForIgnore(e);
+        let o = t.get(s);
+        if (!o) {
+            o = E().add([
+                toStandaloneRule(s)
+            ]);
+            t.set(s, o);
+        }
+        return o.ignores(r);
+    };
+    return (t, e)=>{
+        if (hasGitignoreWildcards(t) && hasGitignoreWildcards(e)) return true;
+        return hasGitignoreWildcards(e) ? matchesName(e, t) : matchesName(t, e);
+    };
+};
+const getNegationFinalSegments = (t)=>t.filter((t)=>isNegativePattern(t.pattern)).map((t)=>finalSegment(t.pattern.slice(1))).filter(Boolean);
+const negationsCouldRescue = (t, e)=>{
+    if (0 === e.length) return false;
+    const n = createNameComparer();
+    return getNegationFinalSegments(t).some((t)=>e.some((e)=>n(e, t)));
+};
+const expandBraceGroups = (t)=>{
+    if (!t.includes("{")) return [
+        t
+    ];
+    const e = p["default"].generateTasks(t).flatMap((t)=>t.patterns);
+    return e.length > 0 ? e : [
+        t
+    ];
+};
+const convertIgnorePatternsForIgnoreFileSearch = (t, e)=>{
+    if (0 === t.length) return t;
+    const n = createNameComparer();
+    const r = e.flatMap((t)=>expandBraceGroups(t));
+    if (r.some((t)=>C.test(t.slice(0, t.lastIndexOf("/") + 1)))) return [];
+    const s = r.map((t)=>finalSegment(t)).filter(Boolean);
+    const couldNameAnIgnoreFile = (t)=>{
+        const e = finalSegment(t.replace(/\/\*\*$/u, ""));
+        if (!e || C.test(e)) return true;
+        return s.some((t)=>C.test(t) ? hasGitignoreWildcards(e) || b.isMatch(unescapeGitignorePattern(e), t, {
+                dot: true,
+                nocase: true
+            }) : n(e, t));
+    };
+    return t.filter((t)=>!expandBraceGroups(t).some((t)=>couldNameAnIgnoreFile(t)));
+};
+const getRulePrune = ({ pattern: t, directory: e }, { cwd: n, matcher: r, hasNegations: s, canSkipAtAnyDepth: o, canMatchIgnoreFile: a, gitignoreOnlySearch: u })=>{
+    if (isNegativePattern(t)) return;
+    const c = t.endsWith("/");
+    const l = t.replace(/\/+$/u, "");
+    if (!l) return;
+    const f = l.startsWith("**/") && !l.slice(3).includes("/") ? l.slice(3) : l;
+    if (a(finalSegment(f))) return;
+    const d = hasGitignoreWildcards(f);
+    if (d && C.test(f)) return;
+    const toFastGlob = (t)=>normalizeDirectoryPatternForFastGlob(`/${t}${c ? "/" : ""}`).replace(/^\//u, "");
+    if (!f.includes("/") && o(f)) {
+        const t = slash(i.relative(n, e));
+        const r = isInsideCwd(t) ? `${p["default"].escapePath(t)}/` : "";
+        return {
+            pattern: toFastGlob(`${r}**/${d ? f : toLiteralPattern(f)}`),
+            guardName: f
+        };
+    }
+    const h = f.replace(/^\//u, "");
+    const g = anchorToCwd(e, d ? h : unescapeGitignorePattern(h), n);
+    if (void 0 === g) return;
+    const _ = finalSegment(h);
+    if (d) return s ? void 0 : {
+        pattern: toFastGlob(g),
+        guardName: _
+    };
+    if (!r(i.resolve(n, g) + i.sep).ignored) return;
+    const A = !u || g.includes("/");
+    return {
+        pattern: toFastGlob(p["default"].escapePath(g)),
+        guardName: A ? _ : void 0
+    };
+};
+const buildPrunePatternsAndGuards = (t, e, n, { gitignoreOnlySearch: r = false, searchesForGitignoreFiles: s = false } = {})=>{
+    if (!e || !n || !t || 0 === t.length) return {
+        patterns: [],
+        guardNames: []
+    };
+    const o = getNegationFinalSegments(t);
+    const i = createNameComparer();
+    const a = {
+        cwd: n,
+        matcher: e,
+        hasNegations: o.length > 0,
+        canSkipAtAnyDepth: (t)=>!o.some((e)=>i(t, e)),
+        canMatchIgnoreFile: (t)=>s && i(t, ".gitignore"),
+        gitignoreOnlySearch: r
+    };
+    const u = [];
+    const c = [];
+    for (const e of t){
+        const t = getRulePrune(e, a);
+        if (t) {
+            u.push(t.pattern);
+            if (void 0 !== t.guardName) c.push(t.guardName);
+        }
+    }
+    return {
+        patterns: u,
+        guardNames: c
+    };
+};
+const convertPatternsForFastGlob = (t, e, n)=>buildPrunePatternsAndGuards(t, e, n).patterns;
+const v = [
+    "**/node_modules",
+    "**/flow-typed",
+    "**/coverage",
+    "**/.git"
+];
+const S = {
+    absolute: true,
+    dot: true
+};
+const $ = "**/.gitignore";
+const H = 10;
+const getReadFileMethod = (t)=>bindFsMethod(t?.promises, "readFile") ?? bindFsMethod(R, "readFile") ?? promisifyFsMethod(t, "readFile");
+const getReadFileSyncMethod = (t)=>bindFsMethod(t, "readFileSync") ?? bindFsMethod(o, "readFileSync");
+const shouldSkipIgnoreFileError = (t, e)=>{
+    if (!t) return Boolean(e);
+    if ("ENOENT" === t.code || "ENOTDIR" === t.code) return true;
+    return Boolean(e);
+};
+const createReadError = (t, e, n)=>{
+    const r = `Failed to read ${t} at ${e}`;
+    if (n instanceof Error) return new Error(`${r}: ${n.message}`, {
+        cause: n
+    });
+    return new Error(`${r}: ${String(n)}`);
+};
+const createIgnoreFileReadError = (t, e)=>createReadError("ignore file", t, e);
+const createGitConfigReadError = (t, e)=>createReadError("git config", t, e);
+const processIgnoreFileCore = (t, e, n)=>{
+    try {
+        const n = e(t, "utf8");
+        return {
+            filePath: t,
+            content: n
+        };
+    } catch (e) {
+        if (shouldSkipIgnoreFileError(e, n)) return;
+        throw createIgnoreFileReadError(t, e);
+    }
+};
+const readIgnoreFilesSafely = async (t, e, n)=>{
+    const r = await Promise.all(t.map(async (t)=>{
+        try {
+            const n = await e(t, "utf8");
+            return {
+                filePath: t,
+                content: n
+            };
+        } catch (e) {
+            if (shouldSkipIgnoreFileError(e, n)) return;
+            throw createIgnoreFileReadError(t, e);
+        }
+    }));
+    return r.filter(Boolean);
+};
+const readIgnoreFilesSafelySync = (t, e, n)=>t.map((t)=>processIgnoreFileCore(t, e, n)).filter(Boolean);
+const dedupePaths = (t)=>{
+    const e = new Set;
+    return t.filter((t)=>{
+        if (e.has(t)) return false;
+        e.add(t);
+        return true;
+    });
+};
+const globIgnoreFiles = (t, e, n)=>t(e, {
+        ...n,
+        ...S
+    });
+const normalizeIgnoreFileLine = (t)=>{
+    t = t.replace(/^\uFEFF/u, "");
+    let e = t.length;
+    while(e > 0 && /\s/u.test(t[e - 1]))e--;
+    if (e === t.length) return t;
+    let n = 0;
+    for(let r = e - 1; r >= 0 && "\\" === t[r]; r--)n++;
+    return n % 2 === 1 ? t.slice(0, e) + " " : t.slice(0, e);
+};
+const readIgnoreFileLines = (t)=>t.split(/\r?\n/).map((t)=>normalizeIgnoreFileLine(t)).filter((t)=>t && !t.startsWith("#"));
+const getIgnoreRules = (t)=>t.flatMap((t)=>{
+        const e = i.dirname(t.filePath);
+        return readIgnoreFileLines(t.content).map((t)=>({
+                pattern: t,
+                directory: e
+            }));
+    });
+const buildIgnoreResult = (t, e, n)=>{
+    const r = n || e.cwd;
+    const s = getPatternsFromIgnoreFiles(t, r);
+    const o = createIgnoreMatcher(s, e.cwd, r);
+    return {
+        patterns: s,
+        rules: getIgnoreRules(t),
+        matcher: o,
+        predicate: (t)=>o(t).ignored,
+        usingGitRoot: Boolean(n && n !== e.cwd)
+    };
+};
+const applyBaseToPattern = (t, e)=>{
+    if (!e) return t;
+    const n = isNegativePattern(t);
+    const r = n ? t.slice(1) : t;
+    const s = r.indexOf("/");
+    const o = -1 !== s && s !== r.length - 1;
+    let a;
+    a = o ? r.startsWith("/") ? i.posix.join(e, r.slice(1)) : i.posix.join(e, r) : i.posix.join(e, "**", r);
+    return n ? "!" + a : a;
+};
+const parseIgnoreFile = (t, e)=>{
+    const n = slash(i.relative(e, i.dirname(t.filePath)));
+    return readIgnoreFileLines(t.content).map((t)=>applyBaseToPattern(t, n));
+};
+const toRelativePath = (t, e)=>{
+    if (i.isAbsolute(t)) {
+        const n = i.relative(e, t);
+        if (n && !isPathInside(t, e)) return;
+        return n;
+    }
+    if (t.startsWith("./")) return t.slice(2);
+    if (t.startsWith("../")) return;
+    return t;
+};
+const T = {
+    ignored: false,
+    unignored: false
+};
+const createIgnoreMatcher = (t, e, n)=>{
+    const r = E().add(t);
+    const s = i.normalize(i.resolve(e));
+    const o = i.normalize(i.resolve(n));
+    return (t)=>{
+        t = toPath(t);
+        const e = /[/\\]$/.test(t);
+        const n = i.normalize(i.resolve(t));
+        if (n === s) return T;
+        let a = toRelativePath(t, o);
+        if (void 0 === a) return T;
+        if (!a) return T;
+        if (e && !a.endsWith(i.sep)) a += i.sep;
+        return r.test(slash(a));
+    };
+};
+const normalizeOptions = (t = {})=>{
+    const e = t.ignore ? Array.isArray(t.ignore) ? t.ignore : [
+        t.ignore
+    ] : [];
+    const n = toPath(t.cwd) ?? s.cwd();
+    const r = "number" == typeof t.deep ? Math.max(0, t.deep) + 1 : 1 / 0;
+    return {
+        cwd: n,
+        suppressErrors: t.suppressErrors ?? false,
+        deep: r,
+        ignore: [
+            ...e,
+            ...v
+        ],
+        followSymbolicLinks: t.followSymbolicLinks ?? true,
+        concurrency: t.concurrency,
+        throwErrorOnBrokenSymbolicLink: t.throwErrorOnBrokenSymbolicLink ?? false,
+        fs: t.fs
+    };
+};
+const unescapeGitQuotedValue = (t)=>t.replaceAll(/\\(["\\abfnrtv])/g, (t, e)=>{
+        switch(e){
+            case "a":
+                return "";
+            case "b":
+                return "\b";
+            case "f":
+                return "\f";
+            case "n":
+                return "\n";
+            case "r":
+                return "\r";
+            case "t":
+                return "\t";
+            case "v":
+                return "\v";
+            default:
+                return e;
+        }
+    });
+const parseGitConfigValue = (t)=>{
+    const e = t.trim();
+    const n = e.match(/^"((?:[^"\\]|\\.)*)"\s*(?:[#;].*)?$/);
+    if (n) return unescapeGitQuotedValue(n[1]);
+    return e.replace(/\s[#;].*$/, "").trim();
+};
+const resolveConfigPath = (t, e)=>{
+    if (e.startsWith("~/")) {
+        const t = m.homedir();
+        const n = i.join(t, e.slice(2));
+        if (!isPathInside(n, t)) return i.join(t, ".globby-invalid-path-traversal");
+        return n;
+    }
+    if (i.isAbsolute(e)) return e;
+    return i.resolve(i.dirname(t), e);
+};
+const parseGitConfigSection = (t)=>{
+    if (!t.startsWith("[")) return;
+    let e = false;
+    let n = false;
+    for(let r = 1; r < t.length; r++){
+        const s = t[r];
+        if (n) {
+            n = false;
+            continue;
+        }
+        if ("\\" === s) {
+            n = true;
+            continue;
+        }
+        if ('"' === s) {
+            e = !e;
+            continue;
+        }
+        if ("]" === s && !e) {
+            const e = t.slice(r + 1).trimStart();
+            if (e && !e.startsWith("#") && !e.startsWith(";")) return;
+            return t.slice(1, r).trim();
+        }
+    }
+};
+const parseGitConfigEntry = (t)=>{
+    const e = t.match(/^([A-Za-z\d-.]+)\s*=\s*(.*)$/);
+    if (!e) return;
+    return {
+        key: e[1].toLowerCase(),
+        value: parseGitConfigValue(e[2])
+    };
+};
+const parseIncludeIfCondition = (t)=>{
+    if (!t) return;
+    const e = t.match(/^includeif\s+"([^"]+)"$/i);
+    return e ? e[1] : void 0;
+};
+const normalizeGitConfigConditionPattern = (t, e)=>{
+    if (t.startsWith("~/")) t = i.join(m.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 += "**";
+    return slash(t);
+};
+const gitConfigGlobToRegex = (t, e)=>{
+    let n = "";
+    for(let e = 0; e < t.length; e++){
+        const r = t[e];
+        const s = t[e + 1];
+        const o = t[e + 2];
+        if ("*" === r && "*" === s && "/" === o) {
+            n += "(?:.*/)?";
+            e += 2;
+            continue;
+        }
+        if ("*" === r && "*" === s) {
+            n += ".*";
+            e += 1;
+            continue;
+        }
+        if ("*" === r) {
+            n += "[^/]*";
+            continue;
+        }
+        if ("?" === r) {
+            n += "[^/]";
+            continue;
+        }
+        if ("[" === r) {
+            const r = t.indexOf("]", e + 1);
+            if (-1 !== r) {
+                const s = t.slice(e + 1, r);
+                if (s) {
+                    const t = "!" === s[0] ? `^${s.slice(1)}` : s;
+                    n += `[${t}]`;
+                    e = r;
+                    continue;
+                }
+            }
+        }
+        n += /[|\\{}()[\]^$+?.]/.test(r) ? `\\${r}` : r;
+    }
+    try {
+        return new RegExp(`^${n}$`, e);
+    } catch  {
+        return /(?!)/;
+    }
+};
+const matchesIncludeIfCondition = (t, e, n)=>{
+    if (!e) return false;
+    const r = t.match(/^(gitdir|gitdir\/i):(.*)$/i);
+    if (!r) return false;
+    const [, s, o] = r;
+    const a = normalizeGitConfigConditionPattern(o.trim(), n);
+    const u = "gitdir/i" === s.toLowerCase();
+    const c = gitConfigGlobToRegex(a, u ? "i" : void 0);
+    const l = slash(i.resolve(e));
+    return c.test(l);
+};
+const shouldIncludeConfigSection = (t, e, n)=>{
+    if (t?.toLowerCase() === "include") return true;
+    const r = parseIncludeIfCondition(t);
+    return r ? matchesIncludeIfCondition(r, e, n) : false;
+};
+const createExcludesFileValue = (t, e)=>({
+        value: t,
+        declaringFilePath: e
+    });
+const parseGitConfigForExcludesFile = (t, e, n)=>{
+    let r;
+    let s;
+    const o = [];
+    for (const i of t.split(/\r?\n/)){
+        const t = i.trim();
+        if (!t || t.startsWith("#") || t.startsWith(";")) continue;
+        if (t.startsWith("[")) {
+            r = parseGitConfigSection(t);
+            continue;
+        }
+        const a = parseGitConfigEntry(t);
+        if (a) {
+            if (r?.toLowerCase() === "core" && "excludesfile" === a.key) {
+                s = createExcludesFileValue(a.value, e);
+                continue;
+            }
+            if (shouldIncludeConfigSection(r, n, e) && "path" === a.key && a.value) o.push(resolveConfigPath(e, a.value));
+        }
+    }
+    return {
+        excludesFile: s,
+        includePaths: o
+    };
+};
+const readGitConfigFile = (t, e, n)=>{
+    try {
+        return e(t, "utf8");
+    } catch (e) {
+        if (shouldSkipIgnoreFileError(e, n)) return;
+        throw createGitConfigReadError(t, e);
+    }
+};
+const getExcludesFileFromGitConfigSync = (t, e, n, r = {})=>{
+    const { suppressErrors: s, includeStack: o = new Set, depth: a = 0 } = r;
+    const u = i.resolve(t);
+    if (o.has(u)) return;
+    if (a >= H) return;
+    o.add(u);
+    const c = readGitConfigFile(u, e, s);
+    if (void 0 === c) return void o.delete(u);
+    let { excludesFile: l, includePaths: f } = parseGitConfigForExcludesFile(c, u, n);
+    for (const t of f){
+        const r = getExcludesFileFromGitConfigSync(t, e, n, {
+            suppressErrors: s,
+            includeStack: o,
+            depth: a + 1
+        });
+        if (void 0 !== r) l = r;
+    }
+    o.delete(u);
+    return l;
+};
+const getExcludesFileFromGitConfigAsync = async (t, e, n, r = {})=>{
+    const { suppressErrors: s, includeStack: o = new Set, depth: a = 0 } = r;
+    const u = i.resolve(t);
+    if (o.has(u)) return;
+    if (a >= H) return;
+    o.add(u);
+    let c;
+    try {
+        c = await e(u, "utf8");
+    } catch (t) {
+        o.delete(u);
+        if (shouldSkipIgnoreFileError(t, s)) return;
+        throw createGitConfigReadError(u, t);
+    }
+    let { excludesFile: l, includePaths: f } = parseGitConfigForExcludesFile(c, u, n);
+    for (const t of f){
+        const r = await getExcludesFileFromGitConfigAsync(t, e, n, {
+            suppressErrors: s,
+            includeStack: o,
+            depth: a + 1
+        });
+        if (void 0 !== r) l = r;
+    }
+    o.delete(u);
+    return l;
+};
+const resolveGitDirectoryFromFile = (t, e)=>{
+    const n = e.match(/^gitdir:\s*(.+?)\s*$/i);
+    if (!n) return t;
+    return i.resolve(i.dirname(t), n[1]);
+};
+const getGitDirectorySync = (t, e)=>{
+    if (!t) return;
+    const n = i.join(t, ".git");
+    try {
+        return resolveGitDirectoryFromFile(n, e(n, "utf8"));
+    } catch  {
+        return n;
+    }
+};
+const getGitDirectoryAsync = async (t, e)=>{
+    if (!t) return;
+    const n = i.join(t, ".git");
+    try {
+        return resolveGitDirectoryFromFile(n, await e(n, "utf8"));
+    } catch  {
+        return n;
+    }
+};
+const getXdgConfigHome = ()=>s.env.XDG_CONFIG_HOME || i.join(m.homedir(), ".config");
+const getGitConfigPaths = ()=>{
+    if ("GIT_CONFIG_GLOBAL" in s.env) {
+        const t = s.env.GIT_CONFIG_GLOBAL;
+        return t ? [
+            t
+        ] : [];
+    }
+    return [
+        i.join(getXdgConfigHome(), "git", "config"),
+        i.join(m.homedir(), ".gitconfig")
+    ];
+};
+const getDefaultGlobalGitignorePath = ()=>i.join(getXdgConfigHome(), "git", "ignore");
+const resolveExcludesFilePath = (t)=>{
+    if (t?.value === "") return;
+    if (void 0 === t) return getDefaultGlobalGitignorePath();
+    return resolveConfigPath(t.declaringFilePath, t.value);
+};
+const readGlobalGitignoreContent = (t, e, n)=>{
+    try {
+        const n = e(t, "utf8");
+        return {
+            filePath: t,
+            content: n
+        };
+    } catch (e) {
+        if (shouldSkipIgnoreFileError(e, n)) return;
+        throw createIgnoreFileReadError(t, e);
+    }
+};
+const getGlobalGitignoreFile = (t = {})=>{
+    const e = toPath(t.cwd) ?? s.cwd();
+    const n = getReadFileSyncMethod(t.fs);
+    const r = findGitRootSync(e, t.fs);
+    const o = getGitDirectorySync(r, n);
+    let i;
+    for (const e of getGitConfigPaths()){
+        const r = getExcludesFileFromGitConfigSync(e, n, o, {
+            suppressErrors: t.suppressErrors
+        });
+        if (void 0 !== r) i = r;
+    }
+    const a = resolveExcludesFilePath(i);
+    return void 0 === a ? void 0 : readGlobalGitignoreContent(a, n, t.suppressErrors);
+};
+const getGlobalGitignoreFileAsync = async (t = {})=>{
+    const e = toPath(t.cwd) ?? s.cwd();
+    const n = getReadFileMethod(t.fs);
+    const r = await findGitRoot(e, t.fs);
+    const o = await getGitDirectoryAsync(r, n);
+    const i = await Promise.all(getGitConfigPaths().map((e)=>getExcludesFileFromGitConfigAsync(e, n, o, {
+            suppressErrors: t.suppressErrors
+        })));
+    const a = i.findLast((t)=>void 0 !== t);
+    const u = resolveExcludesFilePath(a);
+    if (void 0 === u) return;
+    try {
+        const t = await n(u, "utf8");
+        return {
+            filePath: u,
+            content: t
+        };
+    } catch (e) {
+        if (shouldSkipIgnoreFileError(e, t.suppressErrors)) return;
+        throw createIgnoreFileReadError(u, e);
+    }
+};
+const buildGlobalMatcher = (t, e, n = e)=>{
+    const r = parseIgnoreFile(t, i.dirname(t.filePath));
+    return createIgnoreMatcher(r, e, n);
+};
+const getKnownIgnoreFilePaths = (t, e, n)=>{
+    const r = [
+        t
+    ].flat();
+    const s = r.includes($);
+    if (!s) return [];
+    return n ? getParentGitignorePaths(n, e.cwd) : [
+        i.join(e.cwd, ".gitignore")
+    ];
+};
+const getKnownIgnoreFileSearchOptions = (t, e)=>({
+        ...e,
+        ignore: [
+            ...e.ignore,
+            ...[
+                t
+            ].flat().filter((t)=>isNegativePattern(t)).map((t)=>t.slice(1))
+        ]
+    });
+const getKnownIgnoreFilePattern = (t, e)=>{
+    const n = isPathInside(t, e) ? i.relative(e, t) : t;
+    return p["default"].convertPathToPattern(n);
+};
+const getMatchingKnownIgnoreFilePaths = (t, e)=>{
+    const n = new Set(e.map((t)=>i.resolve(t)));
+    return t.filter((t)=>n.has(i.resolve(t)));
+};
+const globKnownIgnoreFilePaths = (t, e, n, r)=>{
+    if (0 === e.length) return [];
+    return globIgnoreFiles(t, e.map((t)=>getKnownIgnoreFilePattern(t, r.cwd)), getKnownIgnoreFileSearchOptions(n, r));
+};
+const filterKnownIgnoreFilePathsAsync = async (t, e, n)=>{
+    const r = await globKnownIgnoreFilePaths(p["default"], t, e, n);
+    return getMatchingKnownIgnoreFilePaths(t, r);
+};
+const filterKnownIgnoreFilePathsSync = (t, e, n)=>{
+    const r = globKnownIgnoreFilePaths(p["default"].sync, t, e, n);
+    return getMatchingKnownIgnoreFilePaths(t, r);
+};
+const getIgnoreFileSearchPrune = (t, e, n, r)=>{
+    if (0 === e.length) return {
+        patterns: [],
+        guardNames: []
+    };
+    const { cwd: s } = n;
+    const o = r || s;
+    const i = getPatternsFromIgnoreFiles(e, o);
+    const a = createIgnoreMatcher(i, s, o);
+    const u = [
+        t
+    ].flat();
+    const c = u.every((t)=>t === $);
+    const l = u.includes($);
+    return buildPrunePatternsAndGuards(getIgnoreRules(e), a, s, {
+        gitignoreOnlySearch: c,
+        searchesForGitignoreFiles: l
+    });
+};
+const withPrunedSearch = (t, e)=>0 === e.length ? t : {
+        ...t,
+        ignore: [
+            ...t.ignore,
+            ...e
+        ]
+    };
+const getUnreadPaths = (t, e)=>{
+    const n = new Set(e.map((t)=>i.resolve(t)));
+    return dedupePaths(t).filter((t)=>!n.has(i.resolve(t)));
+};
+const collectIgnoreFileArtifactsAsync = async (t, e, n)=>{
+    const r = normalizeOptions(e);
+    const s = getReadFileMethod(r.fs);
+    const o = n ? await findGitRoot(r.cwd, r.fs) : void 0;
+    const i = await filterKnownIgnoreFilePathsAsync(getKnownIgnoreFilePaths(t, r, o), t, r);
+    const a = await readIgnoreFilesSafely(i, s, r.suppressErrors);
+    const { patterns: u, guardNames: c } = getIgnoreFileSearchPrune(t, a, r, o);
+    const l = await globIgnoreFiles(p["default"], t, withPrunedSearch(r, u));
+    let f = await readIgnoreFilesSafely(getUnreadPaths(l, i), s, r.suppressErrors);
+    if (negationsCouldRescue(getIgnoreRules(f), c)) {
+        const e = await globIgnoreFiles(p["default"], t, r);
+        f = await readIgnoreFilesSafely(getUnreadPaths(e, i), s, r.suppressErrors);
+    }
+    return {
+        files: [
+            ...a,
+            ...f
+        ],
+        normalizedOptions: r,
+        gitRoot: o
+    };
+};
+const collectIgnoreFileArtifactsSync = (t, e, n)=>{
+    const r = normalizeOptions(e);
+    const s = getReadFileSyncMethod(r.fs);
+    const o = n ? findGitRootSync(r.cwd, r.fs) : void 0;
+    const i = filterKnownIgnoreFilePathsSync(getKnownIgnoreFilePaths(t, r, o), t, r);
+    const a = readIgnoreFilesSafelySync(i, s, r.suppressErrors);
+    const { patterns: u, guardNames: c } = getIgnoreFileSearchPrune(t, a, r, o);
+    const l = globIgnoreFiles(p["default"].sync, t, withPrunedSearch(r, u));
+    let f = readIgnoreFilesSafelySync(getUnreadPaths(l, i), s, r.suppressErrors);
+    if (negationsCouldRescue(getIgnoreRules(f), c)) {
+        const e = globIgnoreFiles(p["default"].sync, t, r);
+        f = readIgnoreFilesSafelySync(getUnreadPaths(e, i), s, r.suppressErrors);
+    }
+    return {
+        files: [
+            ...a,
+            ...f
+        ],
+        normalizedOptions: r,
+        gitRoot: o
+    };
+};
+const isIgnoredByIgnoreFiles = async (t, e)=>{
+    const { files: n, normalizedOptions: r, gitRoot: s } = await collectIgnoreFileArtifactsAsync(t, e, false);
+    return buildIgnoreResult(n, r, s).predicate;
+};
+const isIgnoredByIgnoreFilesSync = (t, e)=>{
+    const { files: n, normalizedOptions: r, gitRoot: s } = collectIgnoreFileArtifactsSync(t, e, false);
+    return buildIgnoreResult(n, r, s).predicate;
+};
+const getPatternsFromIgnoreFiles = (t, e)=>t.flatMap((t)=>parseIgnoreFile(t, e));
+const getIgnorePatternsAndPredicate = async (t, e, n = false)=>{
+    const { files: r, normalizedOptions: s, gitRoot: o } = await collectIgnoreFileArtifactsAsync(t, e, n);
+    return buildIgnoreResult(r, s, o);
+};
+const getIgnorePatternsAndPredicateSync = (t, e, n = false)=>{
+    const { files: r, normalizedOptions: s, gitRoot: o } = collectIgnoreFileArtifactsSync(t, e, n);
+    return buildIgnoreResult(r, s, o);
+};
+const isGitIgnored = (t)=>isIgnoredByIgnoreFiles($, t);
+const isGitIgnoredSync = (t)=>isIgnoredByIgnoreFilesSync($, t);
+const assertPatternsInput = (t)=>{
+    if (t.some((t)=>"string" != typeof t)) throw new TypeError("Patterns must be a string or an array of strings");
+};
+const getStatMethod = (t)=>{
+    if (t) return bindFsMethod(t.promises, "stat") ?? promisifyFsMethod(t, "stat");
+    return bindFsMethod(o.promises, "stat");
+};
+const globby_getStatSyncMethod = (t)=>bindFsMethod(t, "statSync") ?? bindFsMethod(o, "statSync");
+const isDirectory = async (t, e)=>{
+    try {
+        const n = await getStatMethod(e)(t);
+        return n.isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const isDirectorySync = (t, e)=>{
+    try {
+        const n = globby_getStatSyncMethod(e)(t);
+        return n.isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const normalizePathForDirectoryGlob = (t, e)=>{
+    const n = isNegativePattern(t) ? t.slice(1) : t;
+    return i.isAbsolute(n) ? n : i.join(e, n);
+};
+const shouldExpandGlobstarDirectory = (t)=>{
+    const e = t?.match(/\*\*\/([^/]+)$/);
+    if (!e) return false;
+    const n = e[1];
+    const r = /[*?[\]{}]/.test(n);
+    const s = i.extname(n) && !n.startsWith(".");
+    return !r && !s;
+};
+const getDirectoryGlob = ({ directoryPath: t, files: e, extensions: n })=>{
+    const r = n?.length > 0 ? `.${n.length > 1 ? `{${n.join(",")}}` : n[0]}` : "";
+    return e ? e.map((e)=>i.posix.join(t, `**/${i.extname(e) ? e : `${e}${r}`}`)) : [
+        i.posix.join(t, `**${r ? `/*${r}` : ""}`)
+    ];
+};
+const directoryToGlob = async (t, { cwd: e = s.cwd(), files: n, extensions: r, fs: o } = {})=>{
+    const i = await Promise.all(t.map(async (t)=>{
+        const s = isNegativePattern(t) ? t.slice(1) : t;
+        if (shouldExpandGlobstarDirectory(s)) return getDirectoryGlob({
+            directoryPath: t,
+            files: n,
+            extensions: r
+        });
+        const i = normalizePathForDirectoryGlob(t, e);
+        return await isDirectory(i, o) ? getDirectoryGlob({
+            directoryPath: t,
+            files: n,
+            extensions: r
+        }) : t;
+    }));
+    return i.flat();
+};
+const directoryToGlobSync = (t, { cwd: e = s.cwd(), files: n, extensions: r, fs: o } = {})=>t.flatMap((t)=>{
+        const s = isNegativePattern(t) ? t.slice(1) : t;
+        if (shouldExpandGlobstarDirectory(s)) return getDirectoryGlob({
+            directoryPath: t,
+            files: n,
+            extensions: r
+        });
+        const i = normalizePathForDirectoryGlob(t, e);
+        return isDirectorySync(i, o) ? getDirectoryGlob({
+            directoryPath: t,
+            files: n,
+            extensions: r
+        }) : t;
+    });
+const toPatternsArray = (t)=>{
+    t = [
+        ...new Set([
+            t
+        ].flat())
+    ];
+    assertPatternsInput(t);
+    return t;
+};
+const checkCwdOption = (t, e = o)=>{
+    if (!t || !e.statSync) return;
+    let n;
+    try {
+        n = e.statSync(t);
+    } catch  {
+        return;
+    }
+    if (!n.isDirectory()) throw new Error(`The \`cwd\` option must be a path to a directory, got: ${t}`);
+};
+const globby_normalizeOptions = (t = {})=>{
+    const e = t.ignore ? Array.isArray(t.ignore) ? t.ignore : [
+        t.ignore
+    ] : [];
+    t = {
+        ...t,
+        ignore: e,
+        expandDirectories: t.expandDirectories ?? true,
+        cwd: toPath(t.cwd)
+    };
+    checkCwdOption(t.cwd, t.fs);
+    return t;
+};
+const normalizeArguments = (t)=>async (e, n)=>t(toPatternsArray(e), globby_normalizeOptions(n));
+const normalizeArgumentsSync = (t)=>(e, n)=>t(toPatternsArray(e), globby_normalizeOptions(n));
+const getIgnoreFilesPatterns = (t)=>{
+    const { ignoreFiles: e, gitignore: n } = t;
+    const r = e ? toPatternsArray(e) : [];
+    if (n) r.push($);
+    return r;
+};
+const isPathIgnored = (t, e, n)=>{
+    const r = e ? e(n) : void 0;
+    const s = t ? t(n) : void 0;
+    if (s?.unignored) return false;
+    return Boolean(s?.ignored || r?.ignored);
+};
+const hasIgnoredAncestorDirectory = (t, e, n)=>{
+    let r = n;
+    while(true){
+        const n = i.dirname(r);
+        if (n === r) return false;
+        if (isPathIgnored(t, e, `${n}${i.sep}`)) return true;
+        r = n;
+    }
+};
+const combinePredicate = (t, e)=>{
+    if (!t && !e) return false;
+    return (n)=>{
+        const r = t ? t(n) : void 0;
+        if (r?.unignored) {
+            const r = e ? e(n) : void 0;
+            return r?.ignored && hasIgnoredAncestorDirectory(t, e, n);
+        }
+        return isPathIgnored(t, e, n);
+    };
+};
+const buildIgnoreFilterResult = ({ options: t, cwd: e, ignoreResult: { rules: n, matcher: r }, globalMatcher: s, createFilter: o })=>{
+    const i = combinePredicate(r, s);
+    const a = convertPatternsForFastGlob(n, r, e);
+    return {
+        options: t,
+        pruneIgnorePatterns: a,
+        filter: o(i, e, t.fs)
+    };
+};
+const getIgnoreFileSearchOptions = (t, e)=>({
+        ...t,
+        ignore: convertIgnorePatternsForIgnoreFileSearch(t.ignore, e)
+    });
+const applyIgnoreFilesAndGetFilter = async (t)=>{
+    const e = t.cwd ?? s.cwd();
+    const n = getIgnoreFilesPatterns(t);
+    const r = t.globalGitignore ? await getGlobalGitignoreFileAsync(t) : void 0;
+    if (0 === n.length && !r) return {
+        options: t,
+        pruneIgnorePatterns: [],
+        filter: createFilterFunctionAsync(false, e, t.fs)
+    };
+    const o = true === t.gitignore;
+    const i = n.length > 0 ? await getIgnorePatternsAndPredicate(n, getIgnoreFileSearchOptions(t, n), o) : {
+        rules: [],
+        matcher: false
+    };
+    const a = r ? await findGitRoot(e, t.fs) : void 0;
+    const u = r ? buildGlobalMatcher(r, e, a ?? e) : void 0;
+    return buildIgnoreFilterResult({
+        options: t,
+        cwd: e,
+        ignoreResult: i,
+        globalMatcher: u,
+        createFilter: createFilterFunctionAsync
+    });
+};
+const applyIgnoreFilesAndGetFilterSync = (t)=>{
+    const e = t.cwd ?? s.cwd();
+    const n = getIgnoreFilesPatterns(t);
+    const r = t.globalGitignore ? getGlobalGitignoreFile(t) : void 0;
+    if (0 === n.length && !r) return {
+        options: t,
+        pruneIgnorePatterns: [],
+        filter: createFilterFunction(false, e, t.fs)
+    };
+    const o = true === t.gitignore;
+    const i = n.length > 0 ? getIgnorePatternsAndPredicateSync(n, getIgnoreFileSearchOptions(t, n), o) : {
+        rules: [],
+        matcher: false
+    };
+    const a = r ? findGitRootSync(e, t.fs) : void 0;
+    const u = r ? buildGlobalMatcher(r, e, a ?? e) : void 0;
+    return buildIgnoreFilterResult({
+        options: t,
+        cwd: e,
+        ignoreResult: i,
+        globalMatcher: u,
+        createFilter: createFilterFunction
+    });
+};
+const assertGlobalGitignoreSyncSupport = (t)=>{
+    if (t.globalGitignore && t.fs && !t.fs.statSync) throw new Error("The `globalGitignore` option in `globbySync()` requires `fs.statSync` when a custom `fs` is provided.");
+};
+const O = "The `globalGitignore` option in `globby()` and `globbyStream()` requires `fs.promises.stat` or `fs.stat` when a custom `fs` is provided.";
+const assertGlobalGitignoreAsyncSupport = (t)=>{
+    if (!t.globalGitignore || !t.fs) return;
+    if (!t.fs.promises?.stat && !t.fs.stat) throw new Error(O);
+};
+const createPathResolver = (t)=>{
+    const e = t || s.cwd();
+    const n = new Map;
+    return (t)=>{
+        let r = n.get(t);
+        if (void 0 === r) {
+            if (n.size > 1e4) n.clear();
+            r = i.isAbsolute(t) ? t : i.resolve(e, t);
+            n.set(t, r);
+        }
+        return r;
+    };
+};
+const createAsyncDirectoryCheck = (t)=>{
+    const e = new Map;
+    return async (n)=>{
+        let r = e.get(n);
+        if (void 0 !== r) return r;
+        try {
+            const e = await t?.(n);
+            r = Boolean(e?.isDirectory());
+        } catch  {
+            r = false;
+        }
+        if (e.size > 1e4) e.clear();
+        e.set(n, r);
+        return r;
+    };
+};
+const createDirectoryCheck = (t)=>{
+    const e = new Map;
+    return (n)=>{
+        let r = e.get(n);
+        if (void 0 !== r) return r;
+        try {
+            r = Boolean(t?.(n)?.isDirectory());
+        } catch  {
+            r = false;
+        }
+        if (e.size > 1e4) e.clear();
+        e.set(n, r);
+        return r;
+    };
+};
+const createFilterFunctionAsync = (t, e, n)=>{
+    const r = createPathResolver(e);
+    const s = createAsyncDirectoryCheck(getStatMethod(n));
+    return async (e)=>{
+        if (!t) return true;
+        const n = r(i.normalize(e.path ?? e));
+        if (t(n)) return false;
+        return !(await s(n) && t(`${n}${i.sep}`));
+    };
+};
+const createFilterFunction = (t, e, n)=>{
+    const r = new Set;
+    const s = createPathResolver(e);
+    const o = createDirectoryCheck(globby_getStatSyncMethod(n));
+    return (e)=>{
+        const n = i.normalize(e.path ?? e);
+        if (r.has(n)) return false;
+        if (t) {
+            const e = s(n);
+            if (t(e)) return false;
+            if (o(e) && t(`${e}${i.sep}`)) return false;
+        }
+        r.add(n);
+        return true;
+    };
+};
+const unionFastGlobResults = (t, e)=>t.flat().filter((t)=>e(t));
+const unionFastGlobResultsAsync = async (t, e)=>{
+    t = t.flat();
+    const n = await Promise.all(t.map((t)=>e(t)));
+    const r = new Set;
+    return t.filter((t, e)=>{
+        if (!n[e]) return false;
+        const s = i.normalize(t.path ?? t);
+        if (r.has(s)) return false;
+        r.add(s);
+        return true;
+    });
+};
+const convertNegativePatterns = (t, e)=>{
+    if (t.length > 0 && t.every((t)=>isNegativePattern(t))) {
+        if (false === e.expandNegationOnlyPatterns) return [];
+        t = [
+            "**/*",
+            ...t
+        ];
+    }
+    const n = [];
+    let r = false;
+    const s = [];
+    for (const e of t){
+        if (isNegativePattern(e)) {
+            s.push(`!${normalizeNegativePattern(e.slice(1), n, r)}`);
+            continue;
+        }
+        s.push(e);
+        const t = getStaticAbsolutePathPrefix(e);
+        if (void 0 === t) {
+            r = true;
+            continue;
+        }
+        n.push(t);
+    }
+    t = s;
+    const o = [];
+    while(t.length > 0){
+        const n = t.findIndex((t)=>isNegativePattern(t));
+        if (-1 === n) {
+            o.push({
+                patterns: t,
+                options: e
+            });
+            break;
+        }
+        const r = t[n].slice(1);
+        for (const t of o)t.options.ignore.push(r);
+        if (0 !== n) o.push({
+            patterns: t.slice(0, n),
+            options: {
+                ...e,
+                ignore: [
+                    ...e.ignore,
+                    r
+                ]
+            }
+        });
+        t = t.slice(n + 1);
+    }
+    return o;
+};
+const applyParentDirectoryIgnoreAdjustments = (t)=>t.map((t)=>({
+            patterns: t.patterns,
+            options: {
+                ...t.options,
+                ignore: adjustIgnorePatternsForParentDirectories(t.patterns, t.options.ignore)
+            }
+        }));
+const appendPruneIgnorePatterns = (t, e)=>0 === e.length ? t : t.map((t)=>({
+            patterns: t.patterns,
+            options: {
+                ...t.options,
+                ignore: [
+                    ...t.options.ignore,
+                    ...e
+                ]
+            }
+        }));
+const normalizeExpandDirectoriesOption = (t, e)=>({
+        ...e ? {
+            cwd: e
+        } : {},
+        ...Array.isArray(t) ? {
+            files: t
+        } : t
+    });
+const generateTasks = async (t, e, n = [])=>{
+    const r = convertNegativePatterns(t, e);
+    const { cwd: s, expandDirectories: o, fs: i } = e;
+    if (!o) return appendPruneIgnorePatterns(applyParentDirectoryIgnoreAdjustments(r), n);
+    const a = {
+        ...normalizeExpandDirectoriesOption(o, s),
+        fs: i
+    };
+    const u = await Promise.all(r.map(async (t)=>{
+        let { patterns: e, options: n } = t;
+        [e, n.ignore] = await Promise.all([
+            directoryToGlob(e, a),
+            directoryToGlob(n.ignore, {
+                cwd: s,
+                fs: i
+            })
+        ]);
+        n.ignore = adjustIgnorePatternsForParentDirectories(e, n.ignore);
+        return {
+            patterns: e,
+            options: n
+        };
+    }));
+    return appendPruneIgnorePatterns(u, n);
+};
+const generateTasksSync = (t, e, n = [])=>{
+    const r = convertNegativePatterns(t, e);
+    const { cwd: s, expandDirectories: o, fs: i } = e;
+    if (!o) return appendPruneIgnorePatterns(applyParentDirectoryIgnoreAdjustments(r), n);
+    const a = {
+        ...normalizeExpandDirectoriesOption(o, s),
+        fs: i
+    };
+    const u = r.map((t)=>{
+        let { patterns: e, options: n } = t;
+        e = directoryToGlobSync(e, a);
+        n.ignore = directoryToGlobSync(n.ignore, {
+            cwd: s,
+            fs: i
+        });
+        n.ignore = adjustIgnorePatternsForParentDirectories(e, n.ignore);
+        return {
+            patterns: e,
+            options: n
+        };
+    });
+    return appendPruneIgnorePatterns(u, n);
+};
+const L = 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)=>(0, p["default"])(t.patterns, t.options)));
+    return unionFastGlobResultsAsync(i, s);
+});
+const P = 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)=>{
+    assertGlobalGitignoreAsyncSupport(e);
+    const n = new Set;
+    const r = a.Readable.from(async function*() {
+        const { options: r, pruneIgnorePatterns: s, filter: o } = await applyIgnoreFilesAndGetFilter(e);
+        const a = await generateTasks(t, r, s);
+        if (0 === a.length) return;
+        const u = a.map((t)=>p["default"].stream(t.patterns, t.options));
+        for await (const t of mergeStreams(u)){
+            const e = i.normalize(t.path ?? t);
+            if (!n.has(e) && await o(t)) {
+                n.add(e);
+                yield t;
+            }
+        }
+    }());
+    return r;
+});
+const I = normalizeArgumentsSync((t, e)=>t.some((t)=>p["default"].isDynamicPattern(t, e)));
+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 U = r.IK;
+var W = r.AG;
+var K = r.Hz;
+var j = r.ey;
+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 };