lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.111.cjs

@@ -1,20 +1,2176 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const r = require("./Package.internal.102.cjs");
+const t = require("./Package.internal.10.cjs");
 
-var e;
+const s = require("node:url");
 
-var t;
+const e = require("./Package.internal.112.cjs");
 
-function n() {
-    if (t) return e;
-    t = 1;
-    var n = r.requireShams();
-    e = function r() {
-        return n() && !!Symbol.toStringTag;
-    };
-    return e;
+const i = require("./Package.internal.113.cjs");
+
+const n = 1024 * 64;
+
+const r = t => {
+    if (typeof t !== "string") {
+        throw new TypeError("invalid pattern");
+    }
+    if (t.length > n) {
+        throw new TypeError("pattern is too long");
+    }
+};
+
+const o = {
+    "[:alnum:]": [ "\\p{L}\\p{Nl}\\p{Nd}", true ],
+    "[:alpha:]": [ "\\p{L}\\p{Nl}", true ],
+    "[:ascii:]": [ "\\x" + "00-\\x" + "7f", false ],
+    "[:blank:]": [ "\\p{Zs}\\t", true ],
+    "[:cntrl:]": [ "\\p{Cc}", true ],
+    "[:digit:]": [ "\\p{Nd}", true ],
+    "[:graph:]": [ "\\p{Z}\\p{C}", true, true ],
+    "[:lower:]": [ "\\p{Ll}", true ],
+    "[:print:]": [ "\\p{C}", true ],
+    "[:punct:]": [ "\\p{P}", true ],
+    "[:space:]": [ "\\p{Z}\\t\\r\\n\\v\\f", true ],
+    "[:upper:]": [ "\\p{Lu}", true ],
+    "[:word:]": [ "\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true ],
+    "[:xdigit:]": [ "A-Fa-f0-9", false ]
+};
+
+const a = t => t.replace(/[[\]\\-]/g, "\\$&");
+
+const h = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+
+const l = t => t.join("");
+
+const c = (t, s) => {
+    const e = s;
+    if (t.charAt(e) !== "[") {
+        throw new Error("not in a brace expression");
+    }
+    const i = [];
+    const n = [];
+    let r = e + 1;
+    let c = false;
+    let p = false;
+    let f = false;
+    let u = false;
+    let d = e;
+    let g = "";
+    t: while (r < t.length) {
+        const s = t.charAt(r);
+        if ((s === "!" || s === "^") && r === e + 1) {
+            u = true;
+            r++;
+            continue;
+        }
+        if (s === "]" && c && !f) {
+            d = r + 1;
+            break;
+        }
+        c = true;
+        if (s === "\\") {
+            if (!f) {
+                f = true;
+                r++;
+                continue;
+            }
+        }
+        if (s === "[" && !f) {
+            for (const [s, [a, h, l]] of Object.entries(o)) {
+                if (t.startsWith(s, r)) {
+                    if (g) {
+                        return [ "$.", false, t.length - e, true ];
+                    }
+                    r += s.length;
+                    if (l) n.push(a); else i.push(a);
+                    p = p || h;
+                    continue t;
+                }
+            }
+        }
+        f = false;
+        if (g) {
+            if (s > g) {
+                i.push(a(g) + "-" + a(s));
+            } else if (s === g) {
+                i.push(a(s));
+            }
+            g = "";
+            r++;
+            continue;
+        }
+        if (t.startsWith("-]", r + 1)) {
+            i.push(a(s + "-"));
+            r += 2;
+            continue;
+        }
+        if (t.startsWith("-", r + 1)) {
+            g = s;
+            r += 2;
+            continue;
+        }
+        i.push(a(s));
+        r++;
+    }
+    if (d < r) {
+        return [ "", false, 0, false ];
+    }
+    if (!i.length && !n.length) {
+        return [ "$.", false, t.length - e, true ];
+    }
+    if (n.length === 0 && i.length === 1 && /^\\?.$/.test(i[0]) && !u) {
+        const t = i[0].length === 2 ? i[0].slice(-1) : i[0];
+        return [ h(t), false, d - e, false ];
+    }
+    const m = "[" + (u ? "^" : "") + l(i) + "]";
+    const w = "[" + (u ? "" : "^") + l(n) + "]";
+    const b = i.length && n.length ? "(" + m + "|" + w + ")" : i.length ? m : w;
+    return [ b, p, d - e, true ];
+};
+
+const p = (t, {windowsPathsNoEscape: s = false, magicalBraces: e = true} = {}) => {
+    if (e) {
+        return s ? t.replace(/\[([^\/\\])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+    }
+    return s ? t.replace(/\[([^\/\\{}])\]/g, "$1") : t.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+};
+
+const f = new Set([ "!", "?", "+", "*", "@" ]);
+
+const u = t => f.has(t);
+
+const d = "(?!(?:^|/)\\.\\.?(?:$|/))";
+
+const g = "(?!\\.)";
+
+const m = new Set([ "[", "." ]);
+
+const w = new Set([ "..", "." ]);
+
+const b = new Set("().*{}+?[]^$\\!");
+
+const y = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+
+const S = "[^/]";
+
+const x = S + "*?";
+
+const k = S + "+?";
+
+class AST {
+    type;
+    #t;
+    #s;
+    #e=false;
+    #i=[];
+    #n;
+    #r;
+    #o;
+    #a=false;
+    #h;
+    #l;
+    #c=false;
+    constructor(t, s, e = {}) {
+        this.type = t;
+        if (t) this.#s = true;
+        this.#n = s;
+        this.#t = this.#n ? this.#n.#t : this;
+        this.#h = this.#t === this ? e : this.#t.#h;
+        this.#o = this.#t === this ? [] : this.#t.#o;
+        if (t === "!" && !this.#t.#a) this.#o.push(this);
+        this.#r = this.#n ? this.#n.#i.length : 0;
+    }
+    get hasMagic() {
+        if (this.#s !== undefined) return this.#s;
+        for (const t of this.#i) {
+            if (typeof t === "string") continue;
+            if (t.type || t.hasMagic) return this.#s = true;
+        }
+        return this.#s;
+    }
+    toString() {
+        if (this.#l !== undefined) return this.#l;
+        if (!this.type) {
+            return this.#l = this.#i.map(t => String(t)).join("");
+        } else {
+            return this.#l = this.type + "(" + this.#i.map(t => String(t)).join("|") + ")";
+        }
+    }
+    #p() {
+        if (this !== this.#t) throw new Error("should only call on root");
+        if (this.#a) return this;
+        this.toString();
+        this.#a = true;
+        let t;
+        while (t = this.#o.pop()) {
+            if (t.type !== "!") continue;
+            let s = t;
+            let e = s.#n;
+            while (e) {
+                for (let i = s.#r + 1; !e.type && i < e.#i.length; i++) {
+                    for (const s of t.#i) {
+                        if (typeof s === "string") {
+                            throw new Error("string part in extglob AST??");
+                        }
+                        s.copyIn(e.#i[i]);
+                    }
+                }
+                s = e;
+                e = s.#n;
+            }
+        }
+        return this;
+    }
+    push(...t) {
+        for (const s of t) {
+            if (s === "") continue;
+            if (typeof s !== "string" && !(s instanceof AST && s.#n === this)) {
+                throw new Error("invalid part: " + s);
+            }
+            this.#i.push(s);
+        }
+    }
+    toJSON() {
+        const t = this.type === null ? this.#i.slice().map(t => typeof t === "string" ? t : t.toJSON()) : [ this.type, ...this.#i.map(t => t.toJSON()) ];
+        if (this.isStart() && !this.type) t.unshift([]);
+        if (this.isEnd() && (this === this.#t || this.#t.#a && this.#n?.type === "!")) {
+            t.push({});
+        }
+        return t;
+    }
+    isStart() {
+        if (this.#t === this) return true;
+        if (!this.#n?.isStart()) return false;
+        if (this.#r === 0) return true;
+        const t = this.#n;
+        for (let s = 0; s < this.#r; s++) {
+            const e = t.#i[s];
+            if (!(e instanceof AST && e.type === "!")) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isEnd() {
+        if (this.#t === this) return true;
+        if (this.#n?.type === "!") return true;
+        if (!this.#n?.isEnd()) return false;
+        if (!this.type) return this.#n?.isEnd();
+        const t = this.#n ? this.#n.#i.length : 0;
+        return this.#r === t - 1;
+    }
+    copyIn(t) {
+        if (typeof t === "string") this.push(t); else this.push(t.clone(this));
+    }
+    clone(t) {
+        const s = new AST(this.type, t);
+        for (const t of this.#i) {
+            s.copyIn(t);
+        }
+        return s;
+    }
+    static #f(t, s, e, i) {
+        let n = false;
+        let r = false;
+        let o = -1;
+        let a = false;
+        if (s.type === null) {
+            let h = e;
+            let l = "";
+            while (h < t.length) {
+                const e = t.charAt(h++);
+                if (n || e === "\\") {
+                    n = !n;
+                    l += e;
+                    continue;
+                }
+                if (r) {
+                    if (h === o + 1) {
+                        if (e === "^" || e === "!") {
+                            a = true;
+                        }
+                    } else if (e === "]" && !(h === o + 2 && a)) {
+                        r = false;
+                    }
+                    l += e;
+                    continue;
+                } else if (e === "[") {
+                    r = true;
+                    o = h;
+                    a = false;
+                    l += e;
+                    continue;
+                }
+                if (!i.noext && u(e) && t.charAt(h) === "(") {
+                    s.push(l);
+                    l = "";
+                    const n = new AST(e, s);
+                    h = AST.#f(t, n, h, i);
+                    s.push(n);
+                    continue;
+                }
+                l += e;
+            }
+            s.push(l);
+            return h;
+        }
+        let h = e + 1;
+        let l = new AST(null, s);
+        const c = [];
+        let p = "";
+        while (h < t.length) {
+            const e = t.charAt(h++);
+            if (n || e === "\\") {
+                n = !n;
+                p += e;
+                continue;
+            }
+            if (r) {
+                if (h === o + 1) {
+                    if (e === "^" || e === "!") {
+                        a = true;
+                    }
+                } else if (e === "]" && !(h === o + 2 && a)) {
+                    r = false;
+                }
+                p += e;
+                continue;
+            } else if (e === "[") {
+                r = true;
+                o = h;
+                a = false;
+                p += e;
+                continue;
+            }
+            if (u(e) && t.charAt(h) === "(") {
+                l.push(p);
+                p = "";
+                const s = new AST(e, l);
+                l.push(s);
+                h = AST.#f(t, s, h, i);
+                continue;
+            }
+            if (e === "|") {
+                l.push(p);
+                p = "";
+                c.push(l);
+                l = new AST(null, s);
+                continue;
+            }
+            if (e === ")") {
+                if (p === "" && s.#i.length === 0) {
+                    s.#c = true;
+                }
+                l.push(p);
+                p = "";
+                s.push(...c, l);
+                return h;
+            }
+            p += e;
+        }
+        s.type = null;
+        s.#s = undefined;
+        s.#i = [ t.substring(e - 1) ];
+        return h;
+    }
+    static fromGlob(t, s = {}) {
+        const e = new AST(null, undefined, s);
+        AST.#f(t, e, 0, s);
+        return e;
+    }
+    toMMPattern() {
+        if (this !== this.#t) return this.#t.toMMPattern();
+        const t = this.toString();
+        const [s, e, i, n] = this.toRegExpSource();
+        const r = i || this.#s || this.#h.nocase && !this.#h.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase();
+        if (!r) {
+            return e;
+        }
+        const o = (this.#h.nocase ? "i" : "") + (n ? "u" : "");
+        return Object.assign(new RegExp(`^${s}$`, o), {
+            _src: s,
+            _glob: t
+        });
+    }
+    get options() {
+        return this.#h;
+    }
+    toRegExpSource(t) {
+        const s = t ?? !!this.#h.dot;
+        if (this.#t === this) this.#p();
+        if (!this.type) {
+            const e = this.isStart() && this.isEnd() && !this.#i.some(t => typeof t !== "string");
+            const i = this.#i.map(s => {
+                const [i, n, r, o] = typeof s === "string" ? AST.#u(s, this.#s, e) : s.toRegExpSource(t);
+                this.#s = this.#s || r;
+                this.#e = this.#e || o;
+                return i;
+            }).join("");
+            let n = "";
+            if (this.isStart()) {
+                if (typeof this.#i[0] === "string") {
+                    const e = this.#i.length === 1 && w.has(this.#i[0]);
+                    if (!e) {
+                        const e = m;
+                        const r = s && e.has(i.charAt(0)) || i.startsWith("\\.") && e.has(i.charAt(2)) || i.startsWith("\\.\\.") && e.has(i.charAt(4));
+                        const o = !s && !t && e.has(i.charAt(0));
+                        n = r ? d : o ? g : "";
+                    }
+                }
+            }
+            let r = "";
+            if (this.isEnd() && this.#t.#a && this.#n?.type === "!") {
+                r = "(?:$|\\/)";
+            }
+            const o = n + i + r;
+            return [ o, p(i), this.#s = !!this.#s, this.#e ];
+        }
+        const e = this.type === "*" || this.type === "+";
+        const i = this.type === "!" ? "(?:(?!(?:" : "(?:";
+        let n = this.#d(s);
+        if (this.isStart() && this.isEnd() && !n && this.type !== "!") {
+            const t = this.toString();
+            this.#i = [ t ];
+            this.type = null;
+            this.#s = undefined;
+            return [ t, p(this.toString()), false, false ];
+        }
+        let r = !e || t || s || !g ? "" : this.#d(true);
+        if (r === n) {
+            r = "";
+        }
+        if (r) {
+            n = `(?:${n})(?:${r})*?`;
+        }
+        let o = "";
+        if (this.type === "!" && this.#c) {
+            o = (this.isStart() && !s ? g : "") + k;
+        } else {
+            const e = this.type === "!" ? "))" + (this.isStart() && !s && !t ? g : "") + x + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && r ? ")" : this.type === "*" && r ? `)?` : `)${this.type}`;
+            o = i + n + e;
+        }
+        return [ o, p(n), this.#s = !!this.#s, this.#e ];
+    }
+    #d(t) {
+        return this.#i.map(s => {
+            if (typeof s === "string") {
+                throw new Error("string type in extglob ast??");
+            }
+            const [e, i, n, r] = s.toRegExpSource(t);
+            this.#e = this.#e || r;
+            return e;
+        }).filter(t => !(this.isStart() && this.isEnd()) || !!t).join("|");
+    }
+    static #u(t, s, e = false) {
+        let i = false;
+        let n = "";
+        let r = false;
+        for (let o = 0; o < t.length; o++) {
+            const a = t.charAt(o);
+            if (i) {
+                i = false;
+                n += (b.has(a) ? "\\" : "") + a;
+                continue;
+            }
+            if (a === "\\") {
+                if (o === t.length - 1) {
+                    n += "\\\\";
+                } else {
+                    i = true;
+                }
+                continue;
+            }
+            if (a === "[") {
+                const [e, i, a, h] = c(t, o);
+                if (a) {
+                    n += e;
+                    r = r || i;
+                    o += a - 1;
+                    s = s || h;
+                    continue;
+                }
+            }
+            if (a === "*") {
+                n += e && t === "*" ? k : x;
+                s = true;
+                continue;
+            }
+            if (a === "?") {
+                n += S;
+                s = true;
+                continue;
+            }
+            n += y(a);
+        }
+        return [ n, p(t), !!s, r ];
+    }
+}
+
+const C = (t, {windowsPathsNoEscape: s = false, magicalBraces: e = false} = {}) => {
+    if (e) {
+        return s ? t.replace(/[?*()[\]{}]/g, "[$&]") : t.replace(/[?*()[\]\\{}]/g, "\\$&");
+    }
+    return s ? t.replace(/[?*()[\]]/g, "[$&]") : t.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+const M = (t, s, e = {}) => {
+    r(s);
+    if (!e.nocomment && s.charAt(0) === "#") {
+        return false;
+    }
+    return new Minimatch(s, e).match(t);
+};
+
+const E = /^\*+([^+@!?\*\[\(]*)$/;
+
+const A = t => s => !s.startsWith(".") && s.endsWith(t);
+
+const P = t => s => s.endsWith(t);
+
+const v = t => {
+    t = t.toLowerCase();
+    return s => !s.startsWith(".") && s.toLowerCase().endsWith(t);
+};
+
+const L = t => {
+    t = t.toLowerCase();
+    return s => s.toLowerCase().endsWith(t);
+};
+
+const T = /^\*+\.\*+$/;
+
+const W = t => !t.startsWith(".") && t.includes(".");
+
+const R = t => t !== "." && t !== ".." && t.includes(".");
+
+const N = /^\.\*+$/;
+
+const $ = t => t !== "." && t !== ".." && t.startsWith(".");
+
+const G = /^\*+$/;
+
+const j = t => t.length !== 0 && !t.startsWith(".");
+
+const D = t => t.length !== 0 && t !== "." && t !== "..";
+
+const O = /^\?+([^+@!?\*\[\(]*)?$/;
+
+const B = ([t, s = ""]) => {
+    const e = z([ t ]);
+    if (!s) return e;
+    s = s.toLowerCase();
+    return t => e(t) && t.toLowerCase().endsWith(s);
+};
+
+const I = ([t, s = ""]) => {
+    const e = _([ t ]);
+    if (!s) return e;
+    s = s.toLowerCase();
+    return t => e(t) && t.toLowerCase().endsWith(s);
+};
+
+const U = ([t, s = ""]) => {
+    const e = _([ t ]);
+    return !s ? e : t => e(t) && t.endsWith(s);
+};
+
+const F = ([t, s = ""]) => {
+    const e = z([ t ]);
+    return !s ? e : t => e(t) && t.endsWith(s);
+};
+
+const z = ([t]) => {
+    const s = t.length;
+    return t => t.length === s && !t.startsWith(".");
+};
+
+const _ = ([t]) => {
+    const s = t.length;
+    return t => t.length === s && t !== "." && t !== "..";
+};
+
+const q = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+
+const H = {
+    win32: {
+        sep: "\\"
+    },
+    posix: {
+        sep: "/"
+    }
+};
+
+const J = q === "win32" ? H.win32.sep : H.posix.sep;
+
+M.sep = J;
+
+const Z = Symbol("globstar **");
+
+M.GLOBSTAR = Z;
+
+const K = "[^/]";
+
+const Q = K + "*?";
+
+const V = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+
+const X = "(?:(?!(?:\\/|^)\\.).)*?";
+
+const Y = (t, s = {}) => e => M(e, t, s);
+
+M.filter = Y;
+
+const tt = (t, s = {}) => Object.assign({}, t, s);
+
+const st = t => {
+    if (!t || typeof t !== "object" || !Object.keys(t).length) {
+        return M;
+    }
+    const s = M;
+    const e = (e, i, n = {}) => s(e, i, tt(t, n));
+    return Object.assign(e, {
+        Minimatch: class Minimatch extends s.Minimatch {
+            constructor(s, e = {}) {
+                super(s, tt(t, e));
+            }
+            static defaults(e) {
+                return s.defaults(tt(t, e)).Minimatch;
+            }
+        },
+        AST: class AST extends s.AST {
+            constructor(s, e, i = {}) {
+                super(s, e, tt(t, i));
+            }
+            static fromGlob(e, i = {}) {
+                return s.AST.fromGlob(e, tt(t, i));
+            }
+        },
+        unescape: (e, i = {}) => s.unescape(e, tt(t, i)),
+        escape: (e, i = {}) => s.escape(e, tt(t, i)),
+        filter: (e, i = {}) => s.filter(e, tt(t, i)),
+        defaults: e => s.defaults(tt(t, e)),
+        makeRe: (e, i = {}) => s.makeRe(e, tt(t, i)),
+        braceExpand: (e, i = {}) => s.braceExpand(e, tt(t, i)),
+        match: (e, i, n = {}) => s.match(e, i, tt(t, n)),
+        sep: s.sep,
+        GLOBSTAR: Z
+    });
+};
+
+M.defaults = st;
+
+const et = (s, e = {}) => {
+    r(s);
+    if (e.nobrace || !/\{(?:(?!\{).)*\}/.test(s)) {
+        return [ s ];
+    }
+    return t.expand(s);
+};
+
+M.braceExpand = et;
+
+const it = (t, s = {}) => new Minimatch(t, s).makeRe();
+
+M.makeRe = it;
+
+const nt = (t, s, e = {}) => {
+    const i = new Minimatch(s, e);
+    t = t.filter(t => i.match(t));
+    if (i.options.nonull && !t.length) {
+        t.push(s);
+    }
+    return t;
+};
+
+M.match = nt;
+
+const rt = /[?*]|[+@!]\(.*?\)|\[|\]/;
+
+const ot = t => t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+
+class Minimatch {
+    options;
+    set;
+    pattern;
+    windowsPathsNoEscape;
+    nonegate;
+    negate;
+    comment;
+    empty;
+    preserveMultipleSlashes;
+    partial;
+    globSet;
+    globParts;
+    nocase;
+    isWindows;
+    platform;
+    windowsNoMagicRoot;
+    regexp;
+    constructor(t, s = {}) {
+        r(t);
+        s = s || {};
+        this.options = s;
+        this.pattern = t;
+        this.platform = s.platform || q;
+        this.isWindows = this.platform === "win32";
+        this.windowsPathsNoEscape = !!s.windowsPathsNoEscape || s.allowWindowsEscape === false;
+        if (this.windowsPathsNoEscape) {
+            this.pattern = this.pattern.replace(/\\/g, "/");
+        }
+        this.preserveMultipleSlashes = !!s.preserveMultipleSlashes;
+        this.regexp = null;
+        this.negate = false;
+        this.nonegate = !!s.nonegate;
+        this.comment = false;
+        this.empty = false;
+        this.partial = !!s.partial;
+        this.nocase = !!this.options.nocase;
+        this.windowsNoMagicRoot = s.windowsNoMagicRoot !== undefined ? s.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+        this.globSet = [];
+        this.globParts = [];
+        this.set = [];
+        this.make();
+    }
+    hasMagic() {
+        if (this.options.magicalBraces && this.set.length > 1) {
+            return true;
+        }
+        for (const t of this.set) {
+            for (const s of t) {
+                if (typeof s !== "string") return true;
+            }
+        }
+        return false;
+    }
+    debug(...t) {}
+    make() {
+        const t = this.pattern;
+        const s = this.options;
+        if (!s.nocomment && t.charAt(0) === "#") {
+            this.comment = true;
+            return;
+        }
+        if (!t) {
+            this.empty = true;
+            return;
+        }
+        this.parseNegate();
+        this.globSet = [ ...new Set(this.braceExpand()) ];
+        if (s.debug) {
+            this.debug = (...t) => console.error(...t);
+        }
+        this.debug(this.pattern, this.globSet);
+        const e = this.globSet.map(t => this.slashSplit(t));
+        this.globParts = this.preprocess(e);
+        this.debug(this.pattern, this.globParts);
+        let i = this.globParts.map((t, s, e) => {
+            if (this.isWindows && this.windowsNoMagicRoot) {
+                const s = t[0] === "" && t[1] === "" && (t[2] === "?" || !rt.test(t[2])) && !rt.test(t[3]);
+                const e = /^[a-z]:/i.test(t[0]);
+                if (s) {
+                    return [ ...t.slice(0, 4), ...t.slice(4).map(t => this.parse(t)) ];
+                } else if (e) {
+                    return [ t[0], ...t.slice(1).map(t => this.parse(t)) ];
+                }
+            }
+            return t.map(t => this.parse(t));
+        });
+        this.debug(this.pattern, i);
+        this.set = i.filter(t => t.indexOf(false) === -1);
+        if (this.isWindows) {
+            for (let t = 0; t < this.set.length; t++) {
+                const s = this.set[t];
+                if (s[0] === "" && s[1] === "" && this.globParts[t][2] === "?" && typeof s[3] === "string" && /^[a-z]:$/i.test(s[3])) {
+                    s[2] = "?";
+                }
+            }
+        }
+        this.debug(this.pattern, this.set);
+    }
+    preprocess(t) {
+        if (this.options.noglobstar) {
+            for (let s = 0; s < t.length; s++) {
+                for (let e = 0; e < t[s].length; e++) {
+                    if (t[s][e] === "**") {
+                        t[s][e] = "*";
+                    }
+                }
+            }
+        }
+        const {optimizationLevel: s = 1} = this.options;
+        if (s >= 2) {
+            t = this.firstPhasePreProcess(t);
+            t = this.secondPhasePreProcess(t);
+        } else if (s >= 1) {
+            t = this.levelOneOptimize(t);
+        } else {
+            t = this.adjascentGlobstarOptimize(t);
+        }
+        return t;
+    }
+    adjascentGlobstarOptimize(t) {
+        return t.map(t => {
+            let s = -1;
+            while (-1 !== (s = t.indexOf("**", s + 1))) {
+                let e = s;
+                while (t[e + 1] === "**") {
+                    e++;
+                }
+                if (e !== s) {
+                    t.splice(s, e - s);
+                }
+            }
+            return t;
+        });
+    }
+    levelOneOptimize(t) {
+        return t.map(t => {
+            t = t.reduce((t, s) => {
+                const e = t[t.length - 1];
+                if (s === "**" && e === "**") {
+                    return t;
+                }
+                if (s === "..") {
+                    if (e && e !== ".." && e !== "." && e !== "**") {
+                        t.pop();
+                        return t;
+                    }
+                }
+                t.push(s);
+                return t;
+            }, []);
+            return t.length === 0 ? [ "" ] : t;
+        });
+    }
+    levelTwoFileOptimize(t) {
+        if (!Array.isArray(t)) {
+            t = this.slashSplit(t);
+        }
+        let s = false;
+        do {
+            s = false;
+            if (!this.preserveMultipleSlashes) {
+                for (let e = 1; e < t.length - 1; e++) {
+                    const i = t[e];
+                    if (e === 1 && i === "" && t[0] === "") continue;
+                    if (i === "." || i === "") {
+                        s = true;
+                        t.splice(e, 1);
+                        e--;
+                    }
+                }
+                if (t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "")) {
+                    s = true;
+                    t.pop();
+                }
+            }
+            let e = 0;
+            while (-1 !== (e = t.indexOf("..", e + 1))) {
+                const i = t[e - 1];
+                if (i && i !== "." && i !== ".." && i !== "**") {
+                    s = true;
+                    t.splice(e - 1, 2);
+                    e -= 2;
+                }
+            }
+        } while (s);
+        return t.length === 0 ? [ "" ] : t;
+    }
+    firstPhasePreProcess(t) {
+        let s = false;
+        do {
+            s = false;
+            for (let e of t) {
+                let i = -1;
+                while (-1 !== (i = e.indexOf("**", i + 1))) {
+                    let n = i;
+                    while (e[n + 1] === "**") {
+                        n++;
+                    }
+                    if (n > i) {
+                        e.splice(i + 1, n - i);
+                    }
+                    let r = e[i + 1];
+                    const o = e[i + 2];
+                    const a = e[i + 3];
+                    if (r !== "..") continue;
+                    if (!o || o === "." || o === ".." || !a || a === "." || a === "..") {
+                        continue;
+                    }
+                    s = true;
+                    e.splice(i, 1);
+                    const h = e.slice(0);
+                    h[i] = "**";
+                    t.push(h);
+                    i--;
+                }
+                if (!this.preserveMultipleSlashes) {
+                    for (let t = 1; t < e.length - 1; t++) {
+                        const i = e[t];
+                        if (t === 1 && i === "" && e[0] === "") continue;
+                        if (i === "." || i === "") {
+                            s = true;
+                            e.splice(t, 1);
+                            t--;
+                        }
+                    }
+                    if (e[0] === "." && e.length === 2 && (e[1] === "." || e[1] === "")) {
+                        s = true;
+                        e.pop();
+                    }
+                }
+                let n = 0;
+                while (-1 !== (n = e.indexOf("..", n + 1))) {
+                    const t = e[n - 1];
+                    if (t && t !== "." && t !== ".." && t !== "**") {
+                        s = true;
+                        const t = n === 1 && e[n + 1] === "**";
+                        const i = t ? [ "." ] : [];
+                        e.splice(n - 1, 2, ...i);
+                        if (e.length === 0) e.push("");
+                        n -= 2;
+                    }
+                }
+            }
+        } while (s);
+        return t;
+    }
+    secondPhasePreProcess(t) {
+        for (let s = 0; s < t.length - 1; s++) {
+            for (let e = s + 1; e < t.length; e++) {
+                const i = this.partsMatch(t[s], t[e], !this.preserveMultipleSlashes);
+                if (i) {
+                    t[s] = [];
+                    t[e] = i;
+                    break;
+                }
+            }
+        }
+        return t.filter(t => t.length);
+    }
+    partsMatch(t, s, e = false) {
+        let i = 0;
+        let n = 0;
+        let r = [];
+        let o = "";
+        while (i < t.length && n < s.length) {
+            if (t[i] === s[n]) {
+                r.push(o === "b" ? s[n] : t[i]);
+                i++;
+                n++;
+            } else if (e && t[i] === "**" && s[n] === t[i + 1]) {
+                r.push(t[i]);
+                i++;
+            } else if (e && s[n] === "**" && t[i] === s[n + 1]) {
+                r.push(s[n]);
+                n++;
+            } else if (t[i] === "*" && s[n] && (this.options.dot || !s[n].startsWith(".")) && s[n] !== "**") {
+                if (o === "b") return false;
+                o = "a";
+                r.push(t[i]);
+                i++;
+                n++;
+            } else if (s[n] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+                if (o === "a") return false;
+                o = "b";
+                r.push(s[n]);
+                i++;
+                n++;
+            } else {
+                return false;
+            }
+        }
+        return t.length === s.length && r;
+    }
+    parseNegate() {
+        if (this.nonegate) return;
+        const t = this.pattern;
+        let s = false;
+        let e = 0;
+        for (let i = 0; i < t.length && t.charAt(i) === "!"; i++) {
+            s = !s;
+            e++;
+        }
+        if (e) this.pattern = t.slice(e);
+        this.negate = s;
+    }
+    matchOne(t, s, e = false) {
+        const i = this.options;
+        if (this.isWindows) {
+            const e = typeof t[0] === "string" && /^[a-z]:$/i.test(t[0]);
+            const i = !e && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]);
+            const n = typeof s[0] === "string" && /^[a-z]:$/i.test(s[0]);
+            const r = !n && s[0] === "" && s[1] === "" && s[2] === "?" && typeof s[3] === "string" && /^[a-z]:$/i.test(s[3]);
+            const o = i ? 3 : e ? 0 : undefined;
+            const a = r ? 3 : n ? 0 : undefined;
+            if (typeof o === "number" && typeof a === "number") {
+                const [e, i] = [ t[o], s[a] ];
+                if (e.toLowerCase() === i.toLowerCase()) {
+                    s[a] = e;
+                    if (a > o) {
+                        s = s.slice(a);
+                    } else if (o > a) {
+                        t = t.slice(o);
+                    }
+                }
+            }
+        }
+        const {optimizationLevel: n = 1} = this.options;
+        if (n >= 2) {
+            t = this.levelTwoFileOptimize(t);
+        }
+        this.debug("matchOne", this, {
+            file: t,
+            pattern: s
+        });
+        this.debug("matchOne", t.length, s.length);
+        for (var r = 0, o = 0, a = t.length, h = s.length; r < a && o < h; r++, o++) {
+            this.debug("matchOne loop");
+            var l = s[o];
+            var c = t[r];
+            this.debug(s, l, c);
+            if (l === false) {
+                return false;
+            }
+            if (l === Z) {
+                this.debug("GLOBSTAR", [ s, l, c ]);
+                var p = r;
+                var f = o + 1;
+                if (f === h) {
+                    this.debug("** at the end");
+                    for (;r < a; r++) {
+                        if (t[r] === "." || t[r] === ".." || !i.dot && t[r].charAt(0) === ".") return false;
+                    }
+                    return true;
+                }
+                while (p < a) {
+                    var u = t[p];
+                    this.debug("\nglobstar while", t, p, s, f, u);
+                    if (this.matchOne(t.slice(p), s.slice(f), e)) {
+                        this.debug("globstar found match!", p, a, u);
+                        return true;
+                    } else {
+                        if (u === "." || u === ".." || !i.dot && u.charAt(0) === ".") {
+                            this.debug("dot detected!", t, p, s, f);
+                            break;
+                        }
+                        this.debug("globstar swallow a segment, and continue");
+                        p++;
+                    }
+                }
+                if (e) {
+                    this.debug("\n>>> no match, partial?", t, p, s, f);
+                    if (p === a) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            let n;
+            if (typeof l === "string") {
+                n = c === l;
+                this.debug("string match", l, c, n);
+            } else {
+                n = l.test(c);
+                this.debug("pattern match", l, c, n);
+            }
+            if (!n) return false;
+        }
+        if (r === a && o === h) {
+            return true;
+        } else if (r === a) {
+            return e;
+        } else if (o === h) {
+            return r === a - 1 && t[r] === "";
+        } else {
+            throw new Error("wtf?");
+        }
+    }
+    braceExpand() {
+        return et(this.pattern, this.options);
+    }
+    parse(t) {
+        r(t);
+        const s = this.options;
+        if (t === "**") return Z;
+        if (t === "") return "";
+        let e;
+        let i = null;
+        if (e = t.match(G)) {
+            i = s.dot ? D : j;
+        } else if (e = t.match(E)) {
+            i = (s.nocase ? s.dot ? L : v : s.dot ? P : A)(e[1]);
+        } else if (e = t.match(O)) {
+            i = (s.nocase ? s.dot ? I : B : s.dot ? U : F)(e);
+        } else if (e = t.match(T)) {
+            i = s.dot ? R : W;
+        } else if (e = t.match(N)) {
+            i = $;
+        }
+        const n = AST.fromGlob(t, this.options).toMMPattern();
+        if (i && typeof n === "object") {
+            Reflect.defineProperty(n, "test", {
+                value: i
+            });
+        }
+        return n;
+    }
+    makeRe() {
+        if (this.regexp || this.regexp === false) return this.regexp;
+        const t = this.set;
+        if (!t.length) {
+            this.regexp = false;
+            return this.regexp;
+        }
+        const s = this.options;
+        const e = s.noglobstar ? Q : s.dot ? V : X;
+        const i = new Set(s.nocase ? [ "i" ] : []);
+        let n = t.map(t => {
+            const s = t.map(t => {
+                if (t instanceof RegExp) {
+                    for (const s of t.flags.split("")) i.add(s);
+                }
+                return typeof t === "string" ? ot(t) : t === Z ? Z : t._src;
+            });
+            s.forEach((t, i) => {
+                const n = s[i + 1];
+                const r = s[i - 1];
+                if (t !== Z || r === Z) {
+                    return;
+                }
+                if (r === undefined) {
+                    if (n !== undefined && n !== Z) {
+                        s[i + 1] = "(?:\\/|" + e + "\\/)?" + n;
+                    } else {
+                        s[i] = e;
+                    }
+                } else if (n === undefined) {
+                    s[i - 1] = r + "(?:\\/|\\/" + e + ")?";
+                } else if (n !== Z) {
+                    s[i - 1] = r + "(?:\\/|\\/" + e + "\\/)" + n;
+                    s[i + 1] = Z;
+                }
+            });
+            const n = s.filter(t => t !== Z);
+            if (this.partial && n.length >= 1) {
+                const t = [];
+                for (let s = 1; s <= n.length; s++) {
+                    t.push(n.slice(0, s).join("/"));
+                }
+                return "(?:" + t.join("|") + ")";
+            }
+            return n.join("/");
+        }).join("|");
+        const [r, o] = t.length > 1 ? [ "(?:", ")" ] : [ "", "" ];
+        n = "^" + r + n + o + "$";
+        if (this.partial) {
+            n = "^(?:\\/|" + r + n.slice(1, -1) + o + ")$";
+        }
+        if (this.negate) n = "^(?!" + n + ").+$";
+        try {
+            this.regexp = new RegExp(n, [ ...i ].join(""));
+        } catch (t) {
+            this.regexp = false;
+        }
+        return this.regexp;
+    }
+    slashSplit(t) {
+        if (this.preserveMultipleSlashes) {
+            return t.split("/");
+        } else if (this.isWindows && /^\/\/[^\/]+/.test(t)) {
+            return [ "", ...t.split(/\/+/) ];
+        } else {
+            return t.split(/\/+/);
+        }
+    }
+    match(t, s = this.partial) {
+        this.debug("match", t, this.pattern);
+        if (this.comment) {
+            return false;
+        }
+        if (this.empty) {
+            return t === "";
+        }
+        if (t === "/" && s) {
+            return true;
+        }
+        const e = this.options;
+        if (this.isWindows) {
+            t = t.split("\\").join("/");
+        }
+        const i = this.slashSplit(t);
+        this.debug(this.pattern, "split", i);
+        const n = this.set;
+        this.debug(this.pattern, "set", n);
+        let r = i[i.length - 1];
+        if (!r) {
+            for (let t = i.length - 2; !r && t >= 0; t--) {
+                r = i[t];
+            }
+        }
+        for (let t = 0; t < n.length; t++) {
+            const o = n[t];
+            let a = i;
+            if (e.matchBase && o.length === 1) {
+                a = [ r ];
+            }
+            const h = this.matchOne(a, o, s);
+            if (h) {
+                if (e.flipNegate) {
+                    return true;
+                }
+                return !this.negate;
+            }
+        }
+        if (e.flipNegate) {
+            return false;
+        }
+        return this.negate;
+    }
+    static defaults(t) {
+        return M.defaults(t).Minimatch;
+    }
+}
+
+M.AST = AST;
+
+M.Minimatch = Minimatch;
+
+M.escape = C;
+
+M.unescape = p;
+
+const at = t => t.length >= 1;
+
+const ht = t => t.length >= 1;
+
+class Pattern {
+    #g;
+    #m;
+    #w;
+    length;
+    #b;
+    #y;
+    #S;
+    #x;
+    #k;
+    #C;
+    #M=true;
+    constructor(t, s, e, i) {
+        if (!at(t)) {
+            throw new TypeError("empty pattern list");
+        }
+        if (!ht(s)) {
+            throw new TypeError("empty glob list");
+        }
+        if (s.length !== t.length) {
+            throw new TypeError("mismatched pattern list and glob list lengths");
+        }
+        this.length = t.length;
+        if (e < 0 || e >= this.length) {
+            throw new TypeError("index out of range");
+        }
+        this.#g = t;
+        this.#m = s;
+        this.#w = e;
+        this.#b = i;
+        if (this.#w === 0) {
+            if (this.isUNC()) {
+                const [t, s, e, i, ...n] = this.#g;
+                const [r, o, a, h, ...l] = this.#m;
+                if (n[0] === "") {
+                    n.shift();
+                    l.shift();
+                }
+                const c = [ t, s, e, i, "" ].join("/");
+                const p = [ r, o, a, h, "" ].join("/");
+                this.#g = [ c, ...n ];
+                this.#m = [ p, ...l ];
+                this.length = this.#g.length;
+            } else if (this.isDrive() || this.isAbsolute()) {
+                const [t, ...s] = this.#g;
+                const [e, ...i] = this.#m;
+                if (s[0] === "") {
+                    s.shift();
+                    i.shift();
+                }
+                const n = t + "/";
+                const r = e + "/";
+                this.#g = [ n, ...s ];
+                this.#m = [ r, ...i ];
+                this.length = this.#g.length;
+            }
+        }
+    }
+    pattern() {
+        return this.#g[this.#w];
+    }
+    isString() {
+        return typeof this.#g[this.#w] === "string";
+    }
+    isGlobstar() {
+        return this.#g[this.#w] === Z;
+    }
+    isRegExp() {
+        return this.#g[this.#w] instanceof RegExp;
+    }
+    globString() {
+        return this.#S = this.#S || (this.#w === 0 ? this.isAbsolute() ? this.#m[0] + this.#m.slice(1).join("/") : this.#m.join("/") : this.#m.slice(this.#w).join("/"));
+    }
+    hasMore() {
+        return this.length > this.#w + 1;
+    }
+    rest() {
+        if (this.#y !== undefined) return this.#y;
+        if (!this.hasMore()) return this.#y = null;
+        this.#y = new Pattern(this.#g, this.#m, this.#w + 1, this.#b);
+        this.#y.#C = this.#C;
+        this.#y.#k = this.#k;
+        this.#y.#x = this.#x;
+        return this.#y;
+    }
+    isUNC() {
+        const t = this.#g;
+        return this.#k !== undefined ? this.#k : this.#k = this.#b === "win32" && this.#w === 0 && t[0] === "" && t[1] === "" && typeof t[2] === "string" && !!t[2] && typeof t[3] === "string" && !!t[3];
+    }
+    isDrive() {
+        const t = this.#g;
+        return this.#x !== undefined ? this.#x : this.#x = this.#b === "win32" && this.#w === 0 && this.length > 1 && typeof t[0] === "string" && /^[a-z]:$/i.test(t[0]);
+    }
+    isAbsolute() {
+        const t = this.#g;
+        return this.#C !== undefined ? this.#C : this.#C = t[0] === "" && t.length > 1 || this.isDrive() || this.isUNC();
+    }
+    root() {
+        const t = this.#g[0];
+        return typeof t === "string" && this.isAbsolute() && this.#w === 0 ? t : "";
+    }
+    checkFollowGlobstar() {
+        return !(this.#w === 0 || !this.isGlobstar() || !this.#M);
+    }
+    markFollowGlobstar() {
+        if (this.#w === 0 || !this.isGlobstar() || !this.#M) return false;
+        this.#M = false;
+        return true;
+    }
+}
+
+const lt = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+
+class Ignore {
+    relative;
+    relativeChildren;
+    absolute;
+    absoluteChildren;
+    platform;
+    mmopts;
+    constructor(t, {nobrace: s, nocase: e, noext: i, noglobstar: n, platform: r = lt}) {
+        this.relative = [];
+        this.absolute = [];
+        this.relativeChildren = [];
+        this.absoluteChildren = [];
+        this.platform = r;
+        this.mmopts = {
+            dot: true,
+            nobrace: s,
+            nocase: e,
+            noext: i,
+            noglobstar: n,
+            optimizationLevel: 2,
+            platform: r,
+            nocomment: true,
+            nonegate: true
+        };
+        for (const s of t) this.add(s);
+    }
+    add(t) {
+        const s = new Minimatch(t, this.mmopts);
+        for (let t = 0; t < s.set.length; t++) {
+            const e = s.set[t];
+            const i = s.globParts[t];
+            if (!e || !i) {
+                throw new Error("invalid pattern object");
+            }
+            while (e[0] === "." && i[0] === ".") {
+                e.shift();
+                i.shift();
+            }
+            const n = new Pattern(e, i, 0, this.platform);
+            const r = new Minimatch(n.globString(), this.mmopts);
+            const o = i[i.length - 1] === "**";
+            const a = n.isAbsolute();
+            if (a) this.absolute.push(r); else this.relative.push(r);
+            if (o) {
+                if (a) this.absoluteChildren.push(r); else this.relativeChildren.push(r);
+            }
+        }
+    }
+    ignored(t) {
+        const s = t.fullpath();
+        const e = `${s}/`;
+        const i = t.relative() || ".";
+        const n = `${i}/`;
+        for (const t of this.relative) {
+            if (t.match(i) || t.match(n)) return true;
+        }
+        for (const t of this.absolute) {
+            if (t.match(s) || t.match(e)) return true;
+        }
+        return false;
+    }
+    childrenIgnored(t) {
+        const s = t.fullpath() + "/";
+        const e = (t.relative() || ".") + "/";
+        for (const t of this.relativeChildren) {
+            if (t.match(e)) return true;
+        }
+        for (const t of this.absoluteChildren) {
+            if (t.match(s)) return true;
+        }
+        return false;
+    }
+}
+
+class HasWalkedCache {
+    store;
+    constructor(t = new Map) {
+        this.store = t;
+    }
+    copy() {
+        return new HasWalkedCache(new Map(this.store));
+    }
+    hasWalked(t, s) {
+        return this.store.get(t.fullpath())?.has(s.globString());
+    }
+    storeWalked(t, s) {
+        const e = t.fullpath();
+        const i = this.store.get(e);
+        if (i) i.add(s.globString()); else this.store.set(e, new Set([ s.globString() ]));
+    }
+}
+
+class MatchRecord {
+    store=new Map;
+    add(t, s, e) {
+        const i = (s ? 2 : 0) | (e ? 1 : 0);
+        const n = this.store.get(t);
+        this.store.set(t, n === undefined ? i : i & n);
+    }
+    entries() {
+        return [ ...this.store.entries() ].map(([t, s]) => [ t, !!(s & 2), !!(s & 1) ]);
+    }
+}
+
+class SubWalks {
+    store=new Map;
+    add(t, s) {
+        if (!t.canReaddir()) {
+            return;
+        }
+        const e = this.store.get(t);
+        if (e) {
+            if (!e.find(t => t.globString() === s.globString())) {
+                e.push(s);
+            }
+        } else this.store.set(t, [ s ]);
+    }
+    get(t) {
+        const s = this.store.get(t);
+        if (!s) {
+            throw new Error("attempting to walk unknown path");
+        }
+        return s;
+    }
+    entries() {
+        return this.keys().map(t => [ t, this.store.get(t) ]);
+    }
+    keys() {
+        return [ ...this.store.keys() ].filter(t => t.canReaddir());
+    }
+}
+
+class Processor {
+    hasWalkedCache;
+    matches=new MatchRecord;
+    subwalks=new SubWalks;
+    patterns;
+    follow;
+    dot;
+    opts;
+    constructor(t, s) {
+        this.opts = t;
+        this.follow = !!t.follow;
+        this.dot = !!t.dot;
+        this.hasWalkedCache = s ? s.copy() : new HasWalkedCache;
+    }
+    processPatterns(t, s) {
+        this.patterns = s;
+        const e = s.map(s => [ t, s ]);
+        for (let [t, s] of e) {
+            this.hasWalkedCache.storeWalked(t, s);
+            const e = s.root();
+            const i = s.isAbsolute() && this.opts.absolute !== false;
+            if (e) {
+                t = t.resolve(e === "/" && this.opts.root !== undefined ? this.opts.root : e);
+                const i = s.rest();
+                if (!i) {
+                    this.matches.add(t, true, false);
+                    continue;
+                } else {
+                    s = i;
+                }
+            }
+            if (t.isENOENT()) continue;
+            let n;
+            let r;
+            let o = false;
+            while (typeof (n = s.pattern()) === "string" && (r = s.rest())) {
+                const e = t.resolve(n);
+                t = e;
+                s = r;
+                o = true;
+            }
+            n = s.pattern();
+            r = s.rest();
+            if (o) {
+                if (this.hasWalkedCache.hasWalked(t, s)) continue;
+                this.hasWalkedCache.storeWalked(t, s);
+            }
+            if (typeof n === "string") {
+                const s = n === ".." || n === "" || n === ".";
+                this.matches.add(t.resolve(n), i, s);
+                continue;
+            } else if (n === Z) {
+                if (!t.isSymbolicLink() || this.follow || s.checkFollowGlobstar()) {
+                    this.subwalks.add(t, s);
+                }
+                const e = r?.pattern();
+                const n = r?.rest();
+                if (!r || (e === "" || e === ".") && !n) {
+                    this.matches.add(t, i, e === "" || e === ".");
+                } else {
+                    if (e === "..") {
+                        const s = t.parent || t;
+                        if (!n) this.matches.add(s, i, true); else if (!this.hasWalkedCache.hasWalked(s, n)) {
+                            this.subwalks.add(s, n);
+                        }
+                    }
+                }
+            } else if (n instanceof RegExp) {
+                this.subwalks.add(t, s);
+            }
+        }
+        return this;
+    }
+    subwalkTargets() {
+        return this.subwalks.keys();
+    }
+    child() {
+        return new Processor(this.opts, this.hasWalkedCache);
+    }
+    filterEntries(t, s) {
+        const e = this.subwalks.get(t);
+        const i = this.child();
+        for (const t of s) {
+            for (const s of e) {
+                const e = s.isAbsolute();
+                const n = s.pattern();
+                const r = s.rest();
+                if (n === Z) {
+                    i.testGlobstar(t, s, r, e);
+                } else if (n instanceof RegExp) {
+                    i.testRegExp(t, n, r, e);
+                } else {
+                    i.testString(t, n, r, e);
+                }
+            }
+        }
+        return i;
+    }
+    testGlobstar(t, s, e, i) {
+        if (this.dot || !t.name.startsWith(".")) {
+            if (!s.hasMore()) {
+                this.matches.add(t, i, false);
+            }
+            if (t.canReaddir()) {
+                if (this.follow || !t.isSymbolicLink()) {
+                    this.subwalks.add(t, s);
+                } else if (t.isSymbolicLink()) {
+                    if (e && s.checkFollowGlobstar()) {
+                        this.subwalks.add(t, e);
+                    } else if (s.markFollowGlobstar()) {
+                        this.subwalks.add(t, s);
+                    }
+                }
+            }
+        }
+        if (e) {
+            const s = e.pattern();
+            if (typeof s === "string" && s !== ".." && s !== "" && s !== ".") {
+                this.testString(t, s, e.rest(), i);
+            } else if (s === "..") {
+                const s = t.parent || t;
+                this.subwalks.add(s, e);
+            } else if (s instanceof RegExp) {
+                this.testRegExp(t, s, e.rest(), i);
+            }
+        }
+    }
+    testRegExp(t, s, e, i) {
+        if (!s.test(t.name)) return;
+        if (!e) {
+            this.matches.add(t, i, false);
+        } else {
+            this.subwalks.add(t, e);
+        }
+    }
+    testString(t, s, e, i) {
+        if (!t.isNamed(s)) return;
+        if (!e) {
+            this.matches.add(t, i, false);
+        } else {
+            this.subwalks.add(t, e);
+        }
+    }
+}
+
+const ct = (t, s) => typeof t === "string" ? new Ignore([ t ], s) : Array.isArray(t) ? new Ignore(t, s) : t;
+
+class GlobUtil {
+    path;
+    patterns;
+    opts;
+    seen=new Set;
+    paused=false;
+    aborted=false;
+    #E=[];
+    #A;
+    #P;
+    signal;
+    maxDepth;
+    includeChildMatches;
+    constructor(t, s, e) {
+        this.patterns = t;
+        this.path = s;
+        this.opts = e;
+        this.#P = !e.posix && e.platform === "win32" ? "\\" : "/";
+        this.includeChildMatches = e.includeChildMatches !== false;
+        if (e.ignore || !this.includeChildMatches) {
+            this.#A = ct(e.ignore ?? [], e);
+            if (!this.includeChildMatches && typeof this.#A.add !== "function") {
+                const t = "cannot ignore child matches, ignore lacks add() method.";
+                throw new Error(t);
+            }
+        }
+        this.maxDepth = e.maxDepth || Infinity;
+        if (e.signal) {
+            this.signal = e.signal;
+            this.signal.addEventListener("abort", () => {
+                this.#E.length = 0;
+            });
+        }
+    }
+    #v(t) {
+        return this.seen.has(t) || !!this.#A?.ignored?.(t);
+    }
+    #L(t) {
+        return !!this.#A?.childrenIgnored?.(t);
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        if (this.signal?.aborted) return;
+        this.paused = false;
+        let t = undefined;
+        while (!this.paused && (t = this.#E.shift())) {
+            t();
+        }
+    }
+    onResume(t) {
+        if (this.signal?.aborted) return;
+        if (!this.paused) {
+            t();
+        } else {
+            this.#E.push(t);
+        }
+    }
+    async matchCheck(t, s) {
+        if (s && this.opts.nodir) return undefined;
+        let e;
+        if (this.opts.realpath) {
+            e = t.realpathCached() || await t.realpath();
+            if (!e) return undefined;
+            t = e;
+        }
+        const i = t.isUnknown() || this.opts.stat;
+        const n = i ? await t.lstat() : t;
+        if (this.opts.follow && this.opts.nodir && n?.isSymbolicLink()) {
+            const t = await n.realpath();
+            if (t && (t.isUnknown() || this.opts.stat)) {
+                await t.lstat();
+            }
+        }
+        return this.matchCheckTest(n, s);
+    }
+    matchCheckTest(t, s) {
+        return t && (this.maxDepth === Infinity || t.depth() <= this.maxDepth) && (!s || t.canReaddir()) && (!this.opts.nodir || !t.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !t.isSymbolicLink() || !t.realpathCached()?.isDirectory()) && !this.#v(t) ? t : undefined;
+    }
+    matchCheckSync(t, s) {
+        if (s && this.opts.nodir) return undefined;
+        let e;
+        if (this.opts.realpath) {
+            e = t.realpathCached() || t.realpathSync();
+            if (!e) return undefined;
+            t = e;
+        }
+        const i = t.isUnknown() || this.opts.stat;
+        const n = i ? t.lstatSync() : t;
+        if (this.opts.follow && this.opts.nodir && n?.isSymbolicLink()) {
+            const t = n.realpathSync();
+            if (t && (t?.isUnknown() || this.opts.stat)) {
+                t.lstatSync();
+            }
+        }
+        return this.matchCheckTest(n, s);
+    }
+    matchFinish(t, s) {
+        if (this.#v(t)) return;
+        if (!this.includeChildMatches && this.#A?.add) {
+            const s = `${t.relativePosix()}/**`;
+            this.#A.add(s);
+        }
+        const e = this.opts.absolute === undefined ? s : this.opts.absolute;
+        this.seen.add(t);
+        const i = this.opts.mark && t.isDirectory() ? this.#P : "";
+        if (this.opts.withFileTypes) {
+            this.matchEmit(t);
+        } else if (e) {
+            const s = this.opts.posix ? t.fullpathPosix() : t.fullpath();
+            this.matchEmit(s + i);
+        } else {
+            const s = this.opts.posix ? t.relativePosix() : t.relative();
+            const e = this.opts.dotRelative && !s.startsWith(".." + this.#P) ? "." + this.#P : "";
+            this.matchEmit(!s ? "." + i : e + s + i);
+        }
+    }
+    async match(t, s, e) {
+        const i = await this.matchCheck(t, e);
+        if (i) this.matchFinish(i, s);
+    }
+    matchSync(t, s, e) {
+        const i = this.matchCheckSync(t, e);
+        if (i) this.matchFinish(i, s);
+    }
+    walkCB(t, s, e) {
+        if (this.signal?.aborted) e();
+        this.walkCB2(t, s, new Processor(this.opts), e);
+    }
+    walkCB2(t, s, e, i) {
+        if (this.#L(t)) return i();
+        if (this.signal?.aborted) i();
+        if (this.paused) {
+            this.onResume(() => this.walkCB2(t, s, e, i));
+            return;
+        }
+        e.processPatterns(t, s);
+        let n = 1;
+        const r = () => {
+            if (--n === 0) i();
+        };
+        for (const [t, s, i] of e.matches.entries()) {
+            if (this.#v(t)) continue;
+            n++;
+            this.match(t, s, i).then(() => r());
+        }
+        for (const t of e.subwalkTargets()) {
+            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+                continue;
+            }
+            n++;
+            const s = t.readdirCached();
+            if (t.calledReaddir()) this.walkCB3(t, s, e, r); else {
+                t.readdirCB((s, i) => this.walkCB3(t, i, e, r), true);
+            }
+        }
+        r();
+    }
+    walkCB3(t, s, e, i) {
+        e = e.filterEntries(t, s);
+        let n = 1;
+        const r = () => {
+            if (--n === 0) i();
+        };
+        for (const [t, s, i] of e.matches.entries()) {
+            if (this.#v(t)) continue;
+            n++;
+            this.match(t, s, i).then(() => r());
+        }
+        for (const [t, s] of e.subwalks.entries()) {
+            n++;
+            this.walkCB2(t, s, e.child(), r);
+        }
+        r();
+    }
+    walkCBSync(t, s, e) {
+        if (this.signal?.aborted) e();
+        this.walkCB2Sync(t, s, new Processor(this.opts), e);
+    }
+    walkCB2Sync(t, s, e, i) {
+        if (this.#L(t)) return i();
+        if (this.signal?.aborted) i();
+        if (this.paused) {
+            this.onResume(() => this.walkCB2Sync(t, s, e, i));
+            return;
+        }
+        e.processPatterns(t, s);
+        let n = 1;
+        const r = () => {
+            if (--n === 0) i();
+        };
+        for (const [t, s, i] of e.matches.entries()) {
+            if (this.#v(t)) continue;
+            this.matchSync(t, s, i);
+        }
+        for (const t of e.subwalkTargets()) {
+            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+                continue;
+            }
+            n++;
+            const s = t.readdirSync();
+            this.walkCB3Sync(t, s, e, r);
+        }
+        r();
+    }
+    walkCB3Sync(t, s, e, i) {
+        e = e.filterEntries(t, s);
+        let n = 1;
+        const r = () => {
+            if (--n === 0) i();
+        };
+        for (const [t, s, i] of e.matches.entries()) {
+            if (this.#v(t)) continue;
+            this.matchSync(t, s, i);
+        }
+        for (const [t, s] of e.subwalks.entries()) {
+            n++;
+            this.walkCB2Sync(t, s, e.child(), r);
+        }
+        r();
+    }
+}
+
+class GlobWalker extends GlobUtil {
+    matches=new Set;
+    constructor(t, s, e) {
+        super(t, s, e);
+    }
+    matchEmit(t) {
+        this.matches.add(t);
+    }
+    async walk() {
+        if (this.signal?.aborted) throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            await this.path.lstat();
+        }
+        await new Promise((t, s) => {
+            this.walkCB(this.path, this.patterns, () => {
+                if (this.signal?.aborted) {
+                    s(this.signal.reason);
+                } else {
+                    t(this.matches);
+                }
+            });
+        });
+        return this.matches;
+    }
+    walkSync() {
+        if (this.signal?.aborted) throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
+        }
+        this.walkCBSync(this.path, this.patterns, () => {
+            if (this.signal?.aborted) throw this.signal.reason;
+        });
+        return this.matches;
+    }
 }
 
-exports.requireShams = n;
+class GlobStream extends GlobUtil {
+    results;
+    constructor(t, s, e) {
+        super(t, s, e);
+        this.results = new i.Minipass({
+            signal: this.signal,
+            objectMode: true
+        });
+        this.results.on("drain", () => this.resume());
+        this.results.on("resume", () => this.resume());
+    }
+    matchEmit(t) {
+        this.results.write(t);
+        if (!this.results.flowing) this.pause();
+    }
+    stream() {
+        const t = this.path;
+        if (t.isUnknown()) {
+            t.lstat().then(() => {
+                this.walkCB(t, this.patterns, () => this.results.end());
+            });
+        } else {
+            this.walkCB(t, this.patterns, () => this.results.end());
+        }
+        return this.results;
+    }
+    streamSync() {
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
+        }
+        this.walkCBSync(this.path, this.patterns, () => this.results.end());
+        return this.results;
+    }
+}
+
+const pt = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+
+class Glob {
+    absolute;
+    cwd;
+    root;
+    dot;
+    dotRelative;
+    follow;
+    ignore;
+    magicalBraces;
+    mark;
+    matchBase;
+    maxDepth;
+    nobrace;
+    nocase;
+    nodir;
+    noext;
+    noglobstar;
+    pattern;
+    platform;
+    realpath;
+    scurry;
+    stat;
+    signal;
+    windowsPathsNoEscape;
+    withFileTypes;
+    includeChildMatches;
+    opts;
+    patterns;
+    constructor(t, i) {
+        if (!i) throw new TypeError("glob options required");
+        this.withFileTypes = !!i.withFileTypes;
+        this.signal = i.signal;
+        this.follow = !!i.follow;
+        this.dot = !!i.dot;
+        this.dotRelative = !!i.dotRelative;
+        this.nodir = !!i.nodir;
+        this.mark = !!i.mark;
+        if (!i.cwd) {
+            this.cwd = "";
+        } else if (i.cwd instanceof URL || i.cwd.startsWith("file://")) {
+            i.cwd = s.fileURLToPath(i.cwd);
+        }
+        this.cwd = i.cwd || "";
+        this.root = i.root;
+        this.magicalBraces = !!i.magicalBraces;
+        this.nobrace = !!i.nobrace;
+        this.noext = !!i.noext;
+        this.realpath = !!i.realpath;
+        this.absolute = i.absolute;
+        this.includeChildMatches = i.includeChildMatches !== false;
+        this.noglobstar = !!i.noglobstar;
+        this.matchBase = !!i.matchBase;
+        this.maxDepth = typeof i.maxDepth === "number" ? i.maxDepth : Infinity;
+        this.stat = !!i.stat;
+        this.ignore = i.ignore;
+        if (this.withFileTypes && this.absolute !== undefined) {
+            throw new Error("cannot set absolute and withFileTypes:true");
+        }
+        if (typeof t === "string") {
+            t = [ t ];
+        }
+        this.windowsPathsNoEscape = !!i.windowsPathsNoEscape || i.allowWindowsEscape === false;
+        if (this.windowsPathsNoEscape) {
+            t = t.map(t => t.replace(/\\/g, "/"));
+        }
+        if (this.matchBase) {
+            if (i.noglobstar) {
+                throw new TypeError("base matching requires globstar");
+            }
+            t = t.map(t => t.includes("/") ? t : `./**/${t}`);
+        }
+        this.pattern = t;
+        this.platform = i.platform || pt;
+        this.opts = {
+            ...i,
+            platform: this.platform
+        };
+        if (i.scurry) {
+            this.scurry = i.scurry;
+            if (i.nocase !== undefined && i.nocase !== i.scurry.nocase) {
+                throw new Error("nocase option contradicts provided scurry option");
+            }
+        } else {
+            const t = i.platform === "win32" ? e.PathScurryWin32 : i.platform === "darwin" ? e.PathScurryDarwin : i.platform ? e.PathScurryPosix : e.PathScurry;
+            this.scurry = new t(this.cwd, {
+                nocase: i.nocase,
+                fs: i.fs
+            });
+        }
+        this.nocase = this.scurry.nocase;
+        const n = this.platform === "darwin" || this.platform === "win32";
+        const r = {
+            ...i,
+            dot: this.dot,
+            matchBase: this.matchBase,
+            nobrace: this.nobrace,
+            nocase: this.nocase,
+            nocaseMagicOnly: n,
+            nocomment: true,
+            noext: this.noext,
+            nonegate: true,
+            optimizationLevel: 2,
+            platform: this.platform,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            debug: !!this.opts.debug
+        };
+        const o = this.pattern.map(t => new Minimatch(t, r));
+        const [a, h] = o.reduce((t, s) => {
+            t[0].push(...s.set);
+            t[1].push(...s.globParts);
+            return t;
+        }, [ [], [] ]);
+        this.patterns = a.map((t, s) => {
+            const e = h[s];
+            if (!e) throw new Error("invalid pattern object");
+            return new Pattern(t, e, 0, this.platform);
+        });
+    }
+    async walk() {
+        return [ ...await new GlobWalker(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches
+        }).walk() ];
+    }
+    walkSync() {
+        return [ ...new GlobWalker(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches
+        }).walkSync() ];
+    }
+    stream() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches
+        }).stream();
+    }
+    streamSync() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches
+        }).streamSync();
+    }
+    iterateSync() {
+        return this.streamSync()[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    iterate() {
+        return this.stream()[Symbol.asyncIterator]();
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+}
+
+const ft = (t, s = {}) => {
+    if (!Array.isArray(t)) {
+        t = [ t ];
+    }
+    for (const e of t) {
+        if (new Minimatch(e, s).hasMagic()) return true;
+    }
+    return false;
+};
+
+function ut(t, s = {}) {
+    return new Glob(t, s).streamSync();
+}
+
+function dt(t, s = {}) {
+    return new Glob(t, s).stream();
+}
+
+function gt(t, s = {}) {
+    return new Glob(t, s).walkSync();
+}
+
+async function mt(t, s = {}) {
+    return new Glob(t, s).walk();
+}
+
+function wt(t, s = {}) {
+    return new Glob(t, s).iterateSync();
+}
+
+function bt(t, s = {}) {
+    return new Glob(t, s).iterate();
+}
+
+const yt = ut;
+
+const St = Object.assign(dt, {
+    sync: ut
+});
+
+const xt = wt;
+
+const kt = Object.assign(bt, {
+    sync: wt
+});
+
+const Ct = Object.assign(gt, {
+    stream: ut,
+    iterate: wt
+});
+
+const Mt = Object.assign(mt, {
+    glob: mt,
+    globSync: gt,
+    sync: Ct,
+    globStream: dt,
+    stream: St,
+    globStreamSync: ut,
+    streamSync: yt,
+    globIterate: bt,
+    iterate: kt,
+    globIterateSync: wt,
+    iterateSync: xt,
+    Glob: Glob,
+    hasMagic: ft,
+    escape: C,
+    unescape: p
+});
+
+Mt.glob = Mt;
+
+exports.glob = Mt;