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

package/dist/compiled/glob/index.mjs

@@ -0,0 +1,3467 @@
+import { createRequire } from 'node:module';
+createRequire(import.meta.url);
+import { createRequire as i } from "module";
+var p = {};
+var f = {};
+function __nccwpck_require__(i) {
+    var g = f[i];
+    if (void 0 !== g) return g.exports;
+    var y = f[i] = {
+        exports: {}
+    };
+    var b = true;
+    try {
+        p[i](y, y.exports, __nccwpck_require__);
+        b = false;
+    } finally{
+        if (b) delete f[i];
+    }
+    return y.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) + "/";
+(()=>{
+    var i = Object.getPrototypeOf ? (i)=>Object.getPrototypeOf(i) : (i)=>i.__proto__;
+    var p;
+    __nccwpck_require__.t = function(f, g) {
+        if (1 & g) f = this(f);
+        if (8 & g) return f;
+        if ("object" == typeof f && f) {
+            if (4 & g && f.__esModule) return f;
+            if (16 & g && "function" == typeof f.then) return f;
+        }
+        var y = Object.create(null);
+        __nccwpck_require__.r(y);
+        var b = {};
+        p = p || [
+            null,
+            i({}),
+            i([]),
+            i(i)
+        ];
+        for(var v = 2 & g && f; "object" == typeof v && !~p.indexOf(v); v = i(v))Object.getOwnPropertyNames(v).forEach((i)=>b[i] = ()=>f[i]);
+        b["default"] = ()=>f;
+        __nccwpck_require__.d(y, b);
+        return y;
+    };
+})();
+(()=>{
+    __nccwpck_require__.d = (i, p)=>{
+        for(var f in p)if (__nccwpck_require__.o(p, f) && !__nccwpck_require__.o(i, f)) Object.defineProperty(i, f, {
+            enumerable: true,
+            get: p[f]
+        });
+    };
+})();
+(()=>{
+    __nccwpck_require__.o = (i, p)=>Object.prototype.hasOwnProperty.call(i, p);
+})();
+(()=>{
+    __nccwpck_require__.r = (i)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(i, Symbol.toStringTag, {
+            value: "Module"
+        });
+        Object.defineProperty(i, "__esModule", {
+            value: true
+        });
+    };
+})();
+var g = {};
+__nccwpck_require__.d(g, {
+    fo: ()=>Zi,
+    Nt: ()=>zi,
+    ih: ()=>tt,
+    TI: ()=>Xi,
+    nk: ()=>es,
+    ue: ()=>Ut,
+    lj: ()=>Qe,
+    CK: ()=>Bt,
+    AZ: ()=>ts,
+    qt: ()=>le,
+    nl: ()=>Vi,
+    qD: ()=>Ki,
+    Td: ()=>Qi,
+    Qo: ()=>Ji,
+    OH: ()=>Yi,
+    x4: ()=>W
+});
+const y = i(import.meta.url)("node:url");
+const b = i(import.meta.url)("node:path");
+const v = i(import.meta.url)("fs");
+const S = i(import.meta.url)("node:fs");
+var E = __nccwpck_require__.t(S, 2);
+const k = i(import.meta.url)("node:fs/promises");
+const x = i(import.meta.url)("node:events");
+const _ = i(import.meta.url)("node:stream");
+const C = i(import.meta.url)("node:string_decoder");
+var Gt = (i, p, f)=>{
+    let g = i instanceof RegExp ? ce(i, f) : i, y = p instanceof RegExp ? ce(p, f) : p, b = null !== g && null != y && ss(g, y, f);
+    return b && {
+        start: b[0],
+        end: b[1],
+        pre: f.slice(0, b[0]),
+        body: f.slice(b[0] + g.length, b[1]),
+        post: f.slice(b[1] + y.length)
+    };
+}, ce = (i, p)=>{
+    let f = p.match(i);
+    return f ? f[0] : null;
+}, ss = (i, p, f)=>{
+    let g, y, b, v, S, E = f.indexOf(i), k = f.indexOf(p, E + 1), x = E;
+    if (E >= 0 && k > 0) {
+        if (i === p) return [
+            E,
+            k
+        ];
+        for(g = [], b = f.length; x >= 0 && !S;){
+            if (x === E) g.push(x), E = f.indexOf(i, x + 1);
+            else if (1 === g.length) {
+                let i = g.pop();
+                void 0 !== i && (S = [
+                    i,
+                    k
+                ]);
+            } else y = g.pop(), void 0 !== y && y < b && (b = y, v = k), k = f.indexOf(p, x + 1);
+            x = E < k && E >= 0 ? E : k;
+        }
+        g.length && void 0 !== v && (S = [
+            b,
+            v
+        ]);
+    }
+    return S;
+};
+var A = "\0SLASH" + Math.random() + "\0", T = "\0OPEN" + Math.random() + "\0", R = "\0CLOSE" + Math.random() + "\0", F = "\0COMMA" + Math.random() + "\0", M = "\0PERIOD" + Math.random() + "\0", P = new RegExp(A, "g"), j = new RegExp(T, "g"), D = new RegExp(R, "g"), L = new RegExp(F, "g"), z = new RegExp(M, "g"), B = /\\\\/g, $ = /\\{/g, U = /\\}/g, I = /\\,/g, G = /\\./g, H = 1e5;
+function Ht(i) {
+    return isNaN(i) ? i.charCodeAt(0) : parseInt(i, 10);
+}
+function ps(i) {
+    return i.replace(B, A).replace($, T).replace(U, R).replace(I, F).replace(G, M);
+}
+function ms(i) {
+    return i.replace(P, "\\").replace(j, "{").replace(D, "}").replace(L, ",").replace(z, ".");
+}
+function me(i) {
+    if (!i) return [
+        ""
+    ];
+    let p = [], f = Gt("{", "}", i);
+    if (!f) return i.split(",");
+    let { pre: g, body: y, post: b } = f, v = g.split(",");
+    v[v.length - 1] += "{" + y + "}";
+    let S = me(b);
+    return b.length && (v[v.length - 1] += S.shift(), v.push.apply(v, S)), p.push.apply(p, v), p;
+}
+function ge(i, p = {}) {
+    if (!i) return [];
+    let { max: f = H } = p;
+    return "{}" === i.slice(0, 2) && (i = "\\{\\}" + i.slice(2)), ht(ps(i), f, !0).map(ms);
+}
+function gs(i) {
+    return "{" + i + "}";
+}
+function ws(i) {
+    return /^-?0\d/.test(i);
+}
+function ys(i, p) {
+    return i <= p;
+}
+function bs(i, p) {
+    return i >= p;
+}
+function ht(i, p, f) {
+    let g = [], y = Gt("{", "}", i);
+    if (!y) return [
+        i
+    ];
+    let b = y.pre, v = y.post.length ? ht(y.post, p, !1) : [
+        ""
+    ];
+    if (/\$$/.test(y.pre)) for(let i = 0; i < v.length && i < p; i++){
+        let p = b + "{" + y.body + "}" + v[i];
+        g.push(p);
+    }
+    else {
+        let S = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(y.body), E = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(y.body), k = S || E, x = y.body.indexOf(",") >= 0;
+        if (!k && !x) return y.post.match(/,(?!,).*\}/) ? (i = y.pre + "{" + y.body + R + y.post, ht(i, p, !0)) : [
+            i
+        ];
+        let _;
+        if (k) _ = y.body.split(/\.\./);
+        else if (_ = me(y.body), 1 === _.length && void 0 !== _[0] && (_ = ht(_[0], p, !1).map(gs), 1 === _.length)) return v.map((i)=>y.pre + _[0] + i);
+        let C;
+        if (k && void 0 !== _[0] && void 0 !== _[1]) {
+            let i = Ht(_[0]), p = Ht(_[1]), f = Math.max(_[0].length, _[1].length), g = 3 === _.length && void 0 !== _[2] ? Math.abs(Ht(_[2])) : 1, y = ys;
+            p < i && (g *= -1, y = bs);
+            let b = _.some(ws);
+            C = [];
+            for(let v = i; y(v, p); v += g){
+                let i;
+                if (E) i = String.fromCharCode(v), "\\" === i && (i = "");
+                else if (i = String(v), b) {
+                    let p = f - i.length;
+                    if (p > 0) {
+                        let f = new Array(p + 1).join("0");
+                        v < 0 ? i = "-" + f + i.slice(1) : i = f + i;
+                    }
+                }
+                C.push(i);
+            }
+        } else {
+            C = [];
+            for(let i = 0; i < _.length; i++)C.push.apply(C, ht(_[i], p, !1));
+        }
+        for(let i = 0; i < C.length; i++)for(let y = 0; y < v.length && g.length < p; y++){
+            let p = b + C[i] + v[y];
+            (!f || k || p) && g.push(p);
+        }
+    }
+    return g;
+}
+var at = (i)=>{
+    if ("string" != typeof i) throw new TypeError("invalid pattern");
+    if (i.length > 65536) throw new TypeError("pattern is too long");
+};
+var Z = {
+    "[:alnum:]": [
+        "\\p{L}\\p{Nl}\\p{Nd}",
+        !0
+    ],
+    "[:alpha:]": [
+        "\\p{L}\\p{Nl}",
+        !0
+    ],
+    "[:ascii:]": [
+        "\\x00-\\x7f",
+        !1
+    ],
+    "[:blank:]": [
+        "\\p{Zs}\\t",
+        !0
+    ],
+    "[:cntrl:]": [
+        "\\p{Cc}",
+        !0
+    ],
+    "[:digit:]": [
+        "\\p{Nd}",
+        !0
+    ],
+    "[:graph:]": [
+        "\\p{Z}\\p{C}",
+        !0,
+        !0
+    ],
+    "[:lower:]": [
+        "\\p{Ll}",
+        !0
+    ],
+    "[:print:]": [
+        "\\p{C}",
+        !0
+    ],
+    "[:punct:]": [
+        "\\p{P}",
+        !0
+    ],
+    "[:space:]": [
+        "\\p{Z}\\t\\r\\n\\v\\f",
+        !0
+    ],
+    "[:upper:]": [
+        "\\p{Lu}",
+        !0
+    ],
+    "[:word:]": [
+        "\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}",
+        !0
+    ],
+    "[:xdigit:]": [
+        "A-Fa-f0-9",
+        !1
+    ]
+}, lt = (i)=>i.replace(/[[\]\\-]/g, "\\$&"), Es = (i)=>i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), we = (i)=>i.join(""), ye = (i, p)=>{
+    let f = p;
+    if ("[" !== i.charAt(f)) throw new Error("not in a brace expression");
+    let g = [], y = [], b = f + 1, v = !1, S = !1, E = !1, k = !1, x = f, _ = "";
+    t: for(; b < i.length;){
+        let p = i.charAt(b);
+        if (("!" === p || "^" === p) && b === f + 1) {
+            k = !0, b++;
+            continue;
+        }
+        if ("]" === p && v && !E) {
+            x = b + 1;
+            break;
+        }
+        if (v = !0, "\\" === p && !E) {
+            E = !0, b++;
+            continue;
+        }
+        if ("[" === p && !E) {
+            for (let [p, [v, E, k]] of Object.entries(Z))if (i.startsWith(p, b)) {
+                if (_) return [
+                    "$.",
+                    !1,
+                    i.length - f,
+                    !0
+                ];
+                b += p.length, k ? y.push(v) : g.push(v), S = S || E;
+                continue t;
+            }
+        }
+        if (E = !1, _) {
+            p > _ ? g.push(lt(_) + "-" + lt(p)) : p === _ && g.push(lt(p)), _ = "", b++;
+            continue;
+        }
+        if (i.startsWith("-]", b + 1)) {
+            g.push(lt(p + "-")), b += 2;
+            continue;
+        }
+        if (i.startsWith("-", b + 1)) {
+            _ = p, b += 2;
+            continue;
+        }
+        g.push(lt(p)), b++;
+    }
+    if (x < b) return [
+        "",
+        !1,
+        0,
+        !1
+    ];
+    if (!g.length && !y.length) return [
+        "$.",
+        !1,
+        i.length - f,
+        !0
+    ];
+    if (0 === y.length && 1 === g.length && /^\\?.$/.test(g[0]) && !k) {
+        let i = 2 === g[0].length ? g[0].slice(-1) : g[0];
+        return [
+            Es(i),
+            !1,
+            x - f,
+            !1
+        ];
+    }
+    let C = "[" + (k ? "^" : "") + we(g) + "]", A = "[" + (k ? "" : "^") + we(y) + "]";
+    return [
+        g.length && y.length ? "(" + C + "|" + A + ")" : g.length ? C : A,
+        S,
+        x - f,
+        !0
+    ];
+};
+var W = (i, { windowsPathsNoEscape: p = !1, magicalBraces: f = !0 } = {})=>f ? p ? i.replace(/\[([^\/\\])\]/g, "$1") : i.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1") : p ? i.replace(/\[([^\/\\{}])\]/g, "$1") : i.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+var J = new Set([
+    "!",
+    "?",
+    "+",
+    "*",
+    "@"
+]), be = (i)=>J.has(i), Q = "(?!(?:^|/)\\.\\.?(?:$|/))", K = "(?!\\.)", V = new Set([
+    "[",
+    "."
+]), Y = new Set([
+    "..",
+    "."
+]), X = new Set("().*{}+?[]^$\\!"), ks = (i)=>i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), et = "[^/]", it = et + "*?", st = et + "+?", rt = class n {
+    type;
+    #t;
+    #e;
+    #i = !1;
+    #s = [];
+    #r;
+    #h;
+    #n;
+    #o = !1;
+    #a;
+    #l;
+    #c = !1;
+    constructor(i, p, f = {}){
+        this.type = i, i && (this.#e = !0), this.#r = p, this.#t = this.#r ? this.#r.#t : this, this.#a = this.#t === this ? f : this.#t.#a, this.#n = this.#t === this ? [] : this.#t.#n, "!" !== i || this.#t.#o || this.#n.push(this), this.#h = this.#r ? this.#r.#s.length : 0;
+    }
+    get hasMagic() {
+        if (void 0 !== this.#e) return this.#e;
+        for (let i of this.#s)if ("string" != typeof i && (i.type || i.hasMagic)) return this.#e = !0;
+        return this.#e;
+    }
+    toString() {
+        return void 0 !== this.#l ? this.#l : this.type ? this.#l = this.type + "(" + this.#s.map((i)=>String(i)).join("|") + ")" : this.#l = this.#s.map((i)=>String(i)).join("");
+    }
+    #u() {
+        if (this !== this.#t) throw new Error("should only call on root");
+        if (this.#o) return this;
+        this.toString(), this.#o = !0;
+        let i;
+        for(; i = this.#n.pop();){
+            if ("!" !== i.type) continue;
+            let p = i, f = p.#r;
+            for(; f;){
+                for(let g = p.#h + 1; !f.type && g < f.#s.length; g++)for (let p of i.#s){
+                    if ("string" == typeof p) throw new Error("string part in extglob AST??");
+                    p.copyIn(f.#s[g]);
+                }
+                p = f, f = p.#r;
+            }
+        }
+        return this;
+    }
+    push(...i) {
+        for (let p of i)if ("" !== p) {
+            if ("string" != typeof p && !(p instanceof n && p.#r === this)) throw new Error("invalid part: " + p);
+            this.#s.push(p);
+        }
+    }
+    toJSON() {
+        let i = null === this.type ? this.#s.slice().map((i)=>"string" == typeof i ? i : i.toJSON()) : [
+            this.type,
+            ...this.#s.map((i)=>i.toJSON())
+        ];
+        return this.isStart() && !this.type && i.unshift([]), this.isEnd() && (this === this.#t || this.#t.#o && this.#r?.type === "!") && i.push({}), i;
+    }
+    isStart() {
+        if (this.#t === this) return !0;
+        if (!this.#r?.isStart()) return !1;
+        if (0 === this.#h) return !0;
+        let i = this.#r;
+        for(let p = 0; p < this.#h; p++){
+            let f = i.#s[p];
+            if (!(f instanceof n && "!" === f.type)) return !1;
+        }
+        return !0;
+    }
+    isEnd() {
+        if (this.#t === this || this.#r?.type === "!") return !0;
+        if (!this.#r?.isEnd()) return !1;
+        if (!this.type) return this.#r?.isEnd();
+        let i = this.#r ? this.#r.#s.length : 0;
+        return this.#h === i - 1;
+    }
+    copyIn(i) {
+        "string" == typeof i ? this.push(i) : this.push(i.clone(this));
+    }
+    clone(i) {
+        let p = new n(this.type, i);
+        for (let i of this.#s)p.copyIn(i);
+        return p;
+    }
+    static #p(i, p, f, g) {
+        let y = !1, b = !1, v = -1, S = !1;
+        if (null === p.type) {
+            let E = f, k = "";
+            for(; E < i.length;){
+                let f = i.charAt(E++);
+                if (y || "\\" === f) {
+                    y = !y, k += f;
+                    continue;
+                }
+                if (b) {
+                    E === v + 1 ? ("^" === f || "!" === f) && (S = !0) : "]" !== f || E === v + 2 && S || (b = !1), k += f;
+                    continue;
+                } else if ("[" === f) {
+                    b = !0, v = E, S = !1, k += f;
+                    continue;
+                }
+                if (!g.noext && be(f) && "(" === i.charAt(E)) {
+                    p.push(k), k = "";
+                    let y = new n(f, p);
+                    E = n.#p(i, y, E, g), p.push(y);
+                    continue;
+                }
+                k += f;
+            }
+            return p.push(k), E;
+        }
+        let E = f + 1, k = new n(null, p), x = [], _ = "";
+        for(; E < i.length;){
+            let f = i.charAt(E++);
+            if (y || "\\" === f) {
+                y = !y, _ += f;
+                continue;
+            }
+            if (b) {
+                E === v + 1 ? ("^" === f || "!" === f) && (S = !0) : "]" !== f || E === v + 2 && S || (b = !1), _ += f;
+                continue;
+            } else if ("[" === f) {
+                b = !0, v = E, S = !1, _ += f;
+                continue;
+            }
+            if (be(f) && "(" === i.charAt(E)) {
+                k.push(_), _ = "";
+                let p = new n(f, k);
+                k.push(p), E = n.#p(i, p, E, g);
+                continue;
+            }
+            if ("|" === f) {
+                k.push(_), _ = "", x.push(k), k = new n(null, p);
+                continue;
+            }
+            if (")" === f) return "" === _ && 0 === p.#s.length && (p.#c = !0), k.push(_), _ = "", p.push(...x, k), E;
+            _ += f;
+        }
+        return p.type = null, p.#e = void 0, p.#s = [
+            i.substring(f - 1)
+        ], E;
+    }
+    static fromGlob(i, p = {}) {
+        let f = new n(null, void 0, p);
+        return n.#p(i, f, 0, p), f;
+    }
+    toMMPattern() {
+        if (this !== this.#t) return this.#t.toMMPattern();
+        let i = this.toString(), [p, f, g, y] = this.toRegExpSource();
+        if (!(g || this.#e || this.#a.nocase && !this.#a.nocaseMagicOnly && i.toUpperCase() !== i.toLowerCase())) return f;
+        let b = (this.#a.nocase ? "i" : "") + (y ? "u" : "");
+        return Object.assign(new RegExp(`^${p}$`, b), {
+            _src: p,
+            _glob: i
+        });
+    }
+    get options() {
+        return this.#a;
+    }
+    toRegExpSource(i) {
+        let p = i ?? !!this.#a.dot;
+        if (this.#t === this && this.#u(), !this.type) {
+            let f = this.isStart() && this.isEnd() && !this.#s.some((i)=>"string" != typeof i), g = this.#s.map((p)=>{
+                let [g, y, b, v] = "string" == typeof p ? n.#f(p, this.#e, f) : p.toRegExpSource(i);
+                return this.#e = this.#e || b, this.#i = this.#i || v, g;
+            }).join(""), y = "";
+            if (this.isStart() && "string" == typeof this.#s[0] && !(1 === this.#s.length && Y.has(this.#s[0]))) {
+                let f = V, b = p && f.has(g.charAt(0)) || g.startsWith("\\.") && f.has(g.charAt(2)) || g.startsWith("\\.\\.") && f.has(g.charAt(4)), v = !p && !i && f.has(g.charAt(0));
+                y = b ? Q : v ? K : "";
+            }
+            let b = "";
+            return this.isEnd() && this.#t.#o && this.#r?.type === "!" && (b = "(?:$|\\/)"), [
+                y + g + b,
+                W(g),
+                this.#e = !!this.#e,
+                this.#i
+            ];
+        }
+        let f = "*" === this.type || "+" === this.type, g = "!" === this.type ? "(?:(?!(?:" : "(?:", y = this.#d(p);
+        if (this.isStart() && this.isEnd() && !y && "!" !== this.type) {
+            let i = this.toString();
+            return this.#s = [
+                i
+            ], this.type = null, this.#e = void 0, [
+                i,
+                W(this.toString()),
+                !1,
+                !1
+            ];
+        }
+        let b = !f || i || p || !K ? "" : this.#d(!0);
+        b === y && (b = ""), b && (y = `(?:${y})(?:${b})*?`);
+        let v = "";
+        if ("!" === this.type && this.#c) v = (this.isStart() && !p ? K : "") + st;
+        else {
+            let f = "!" === this.type ? "))" + (!this.isStart() || p || i ? "" : K) + it + ")" : "@" === this.type ? ")" : "?" === this.type ? ")?" : "+" === this.type && b ? ")" : "*" === this.type && b ? ")?" : `)${this.type}`;
+            v = g + y + f;
+        }
+        return [
+            v,
+            W(y),
+            this.#e = !!this.#e,
+            this.#i
+        ];
+    }
+    #d(i) {
+        return this.#s.map((p)=>{
+            if ("string" == typeof p) throw new Error("string type in extglob ast??");
+            let [f, g, y, b] = p.toRegExpSource(i);
+            return this.#i = this.#i || b, f;
+        }).filter((i)=>!(this.isStart() && this.isEnd()) || !!i).join("|");
+    }
+    static #f(i, p, f = !1) {
+        let g = !1, y = "", b = !1, v = !1;
+        for(let S = 0; S < i.length; S++){
+            let E = i.charAt(S);
+            if (g) {
+                g = !1, y += (X.has(E) ? "\\" : "") + E;
+                continue;
+            }
+            if ("*" === E) {
+                if (v) continue;
+                v = !0, y += f && /^[*]+$/.test(i) ? st : it, p = !0;
+                continue;
+            } else v = !1;
+            if ("\\" === E) {
+                S === i.length - 1 ? y += "\\\\" : g = !0;
+                continue;
+            }
+            if ("[" === E) {
+                let [f, g, v, E] = ye(i, S);
+                if (v) {
+                    y += f, b = b || g, S += v - 1, p = p || E;
+                    continue;
+                }
+            }
+            if ("?" === E) {
+                y += et, p = !0;
+                continue;
+            }
+            y += ks(E);
+        }
+        return [
+            y,
+            W(i),
+            !!p,
+            b
+        ];
+    }
+};
+var tt = (i, { windowsPathsNoEscape: p = !1, magicalBraces: f = !1 } = {})=>f ? p ? i.replace(/[?*()[\]{}]/g, "[$&]") : i.replace(/[?*()[\]\\{}]/g, "\\$&") : p ? i.replace(/[?*()[\]]/g, "[$&]") : i.replace(/[?*()[\]\\]/g, "\\$&");
+var O = (i, p, f = {})=>(at(p), f.nocomment || "#" !== p.charAt(0) ? new Ct(p, f).match(i) : !1), nt = /^\*+([^+@!?\*\[\(]*)$/, Os = (i)=>(p)=>!p.startsWith(".") && p.endsWith(i), Fs = (i)=>(p)=>p.endsWith(i), Ds = (i)=>(i = i.toLowerCase(), (p)=>!p.startsWith(".") && p.toLowerCase().endsWith(i)), Ms = (i)=>(i = i.toLowerCase(), (p)=>p.toLowerCase().endsWith(i)), ot = /^\*+\.\*+$/, _s = (i)=>!i.startsWith(".") && i.includes("."), Ls = (i)=>"." !== i && ".." !== i && i.includes("."), ut = /^\.\*+$/, Ps = (i)=>"." !== i && ".." !== i && i.startsWith("."), pt = /^\*+$/, Is = (i)=>0 !== i.length && !i.startsWith("."), zs = (i)=>0 !== i.length && "." !== i && ".." !== i, ft = /^\?+([^+@!?\*\[\(]*)?$/, Us = ([i, p = ""])=>{
+    let f = Ce([
+        i
+    ]);
+    return p ? (p = p.toLowerCase(), (i)=>f(i) && i.toLowerCase().endsWith(p)) : f;
+}, $s = ([i, p = ""])=>{
+    let f = Te([
+        i
+    ]);
+    return p ? (p = p.toLowerCase(), (i)=>f(i) && i.toLowerCase().endsWith(p)) : f;
+}, Gs = ([i, p = ""])=>{
+    let f = Te([
+        i
+    ]);
+    return p ? (i)=>f(i) && i.endsWith(p) : f;
+}, Hs = ([i, p = ""])=>{
+    let f = Ce([
+        i
+    ]);
+    return p ? (i)=>f(i) && i.endsWith(p) : f;
+}, Ce = ([i])=>{
+    let p = i.length;
+    return (i)=>i.length === p && !i.startsWith(".");
+}, Te = ([i])=>{
+    let p = i.length;
+    return (i)=>i.length === p && "." !== i && ".." !== i;
+}, dt = "object" == typeof process && process ? "object" == typeof process.env && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", gt = {
+    win32: {
+        sep: "\\"
+    },
+    posix: {
+        sep: "/"
+    }
+}, wt = "win32" === dt ? gt.win32.sep : gt.posix.sep;
+O.sep = wt;
+var yt = Symbol("globstar **");
+O.GLOBSTAR = yt;
+var vt = "[^/]", St = vt + "*?", Et = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", kt = "(?:(?!(?:\\/|^)\\.).)*?", Js = (i, p = {})=>(f)=>O(f, i, p);
+O.filter = Js;
+var N = (i, p = {})=>Object.assign({}, i, p), Zs = (i)=>{
+    if (!i || "object" != typeof i || !Object.keys(i).length) return O;
+    let p = O;
+    return Object.assign((f, g, y = {})=>p(f, g, N(i, y)), {
+        Minimatch: class extends p.Minimatch {
+            constructor(p, f = {}){
+                super(p, N(i, f));
+            }
+            static defaults(f) {
+                return p.defaults(N(i, f)).Minimatch;
+            }
+        },
+        AST: class extends p.AST {
+            constructor(p, f, g = {}){
+                super(p, f, N(i, g));
+            }
+            static fromGlob(f, g = {}) {
+                return p.AST.fromGlob(f, N(i, g));
+            }
+        },
+        unescape: (f, g = {})=>p.unescape(f, N(i, g)),
+        escape: (f, g = {})=>p.escape(f, N(i, g)),
+        filter: (f, g = {})=>p.filter(f, N(i, g)),
+        defaults: (f)=>p.defaults(N(i, f)),
+        makeRe: (f, g = {})=>p.makeRe(f, N(i, g)),
+        braceExpand: (f, g = {})=>p.braceExpand(f, N(i, g)),
+        match: (f, g, y = {})=>p.match(f, g, N(i, y)),
+        sep: p.sep,
+        GLOBSTAR: yt
+    });
+};
+O.defaults = Zs;
+var ke = (i, p = {})=>(at(i), p.nobrace || !/\{(?:(?!\{).)*\}/.test(i) ? [
+        i
+    ] : ge(i, {
+        max: p.braceExpandMax
+    }));
+O.braceExpand = ke;
+var Qs = (i, p = {})=>new Ct(i, p).makeRe();
+O.makeRe = Qs;
+var ti = (i, p, f = {})=>{
+    let g = new Ct(p, f);
+    return i = i.filter((i)=>g.match(i)), g.options.nonull && !i.length && i.push(p), i;
+};
+O.match = ti;
+var xt = /[?*]|[+@!]\(.*?\)|\[|\]/, ei = (i)=>i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), Ct = class {
+    options;
+    set;
+    pattern;
+    windowsPathsNoEscape;
+    nonegate;
+    negate;
+    comment;
+    empty;
+    preserveMultipleSlashes;
+    partial;
+    globSet;
+    globParts;
+    nocase;
+    isWindows;
+    platform;
+    windowsNoMagicRoot;
+    regexp;
+    constructor(i, p = {}){
+        at(i), p = p || {}, this.options = p, this.pattern = i, this.platform = p.platform || dt, this.isWindows = "win32" === this.platform;
+        let f = "allowWindowsEscape";
+        this.windowsPathsNoEscape = !!p.windowsPathsNoEscape || !1 === p[f], this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!p.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!p.nonegate, this.comment = !1, this.empty = !1, this.partial = !!p.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = void 0 !== p.windowsNoMagicRoot ? p.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+    }
+    hasMagic() {
+        if (this.options.magicalBraces && this.set.length > 1) return !0;
+        for (let i of this.set)for (let p of i)if ("string" != typeof p) return !0;
+        return !1;
+    }
+    debug() {}
+    make() {
+        let i = this.pattern, p = this.options;
+        if (!p.nocomment && "#" === i.charAt(0)) {
+            this.comment = !0;
+            return;
+        }
+        if (!i) {
+            this.empty = !0;
+            return;
+        }
+        this.parseNegate(), this.globSet = [
+            ...new Set(this.braceExpand())
+        ], p.debug && (this.debug = (...i)=>console.error(...i)), this.debug(this.pattern, this.globSet);
+        let f = this.globSet.map((i)=>this.slashSplit(i));
+        this.globParts = this.preprocess(f), this.debug(this.pattern, this.globParts);
+        let g = this.globParts.map((i, p, f)=>{
+            if (this.isWindows && this.windowsNoMagicRoot) {
+                let p = "" === i[0] && "" === i[1] && ("?" === i[2] || !xt.test(i[2])) && !xt.test(i[3]), f = /^[a-z]:/i.test(i[0]);
+                if (p) return [
+                    ...i.slice(0, 4),
+                    ...i.slice(4).map((i)=>this.parse(i))
+                ];
+                if (f) return [
+                    i[0],
+                    ...i.slice(1).map((i)=>this.parse(i))
+                ];
+            }
+            return i.map((i)=>this.parse(i));
+        });
+        if (this.debug(this.pattern, g), this.set = g.filter((i)=>-1 === i.indexOf(!1)), this.isWindows) for(let i = 0; i < this.set.length; i++){
+            let p = this.set[i];
+            "" === p[0] && "" === p[1] && "?" === this.globParts[i][2] && "string" == typeof p[3] && /^[a-z]:$/i.test(p[3]) && (p[2] = "?");
+        }
+        this.debug(this.pattern, this.set);
+    }
+    preprocess(i) {
+        if (this.options.noglobstar) for(let p = 0; p < i.length; p++)for(let f = 0; f < i[p].length; f++)"**" === i[p][f] && (i[p][f] = "*");
+        let { optimizationLevel: p = 1 } = this.options;
+        return p >= 2 ? (i = this.firstPhasePreProcess(i), i = this.secondPhasePreProcess(i)) : p >= 1 ? i = this.levelOneOptimize(i) : i = this.adjascentGlobstarOptimize(i), i;
+    }
+    adjascentGlobstarOptimize(i) {
+        return i.map((i)=>{
+            let p = -1;
+            for(; -1 !== (p = i.indexOf("**", p + 1));){
+                let f = p;
+                for(; "**" === i[f + 1];)f++;
+                f !== p && i.splice(p, f - p);
+            }
+            return i;
+        });
+    }
+    levelOneOptimize(i) {
+        return i.map((i)=>(i = i.reduce((i, p)=>{
+                let f = i[i.length - 1];
+                return "**" === p && "**" === f ? i : ".." === p && f && ".." !== f && "." !== f && "**" !== f ? (i.pop(), i) : (i.push(p), i);
+            }, []), 0 === i.length ? [
+                ""
+            ] : i));
+    }
+    levelTwoFileOptimize(i) {
+        Array.isArray(i) || (i = this.slashSplit(i));
+        let p = !1;
+        do {
+            if (p = !1, !this.preserveMultipleSlashes) {
+                for(let f = 1; f < i.length - 1; f++){
+                    let g = i[f];
+                    1 === f && "" === g && "" === i[0] || ("." === g || "" === g) && (p = !0, i.splice(f, 1), f--);
+                }
+                "." === i[0] && 2 === i.length && ("." === i[1] || "" === i[1]) && (p = !0, i.pop());
+            }
+            let f = 0;
+            for(; -1 !== (f = i.indexOf("..", f + 1));){
+                let g = i[f - 1];
+                g && "." !== g && ".." !== g && "**" !== g && (p = !0, i.splice(f - 1, 2), f -= 2);
+            }
+        }while (p);
+        return 0 === i.length ? [
+            ""
+        ] : i;
+    }
+    firstPhasePreProcess(i) {
+        let p = !1;
+        do {
+            p = !1;
+            for (let f of i){
+                let g = -1;
+                for(; -1 !== (g = f.indexOf("**", g + 1));){
+                    let y = g;
+                    for(; "**" === f[y + 1];)y++;
+                    y > g && f.splice(g + 1, y - g);
+                    let b = f[g + 1], v = f[g + 2], S = f[g + 3];
+                    if (".." !== b || !v || "." === v || ".." === v || !S || "." === S || ".." === S) continue;
+                    p = !0, f.splice(g, 1);
+                    let E = f.slice(0);
+                    E[g] = "**", i.push(E), g--;
+                }
+                if (!this.preserveMultipleSlashes) {
+                    for(let i = 1; i < f.length - 1; i++){
+                        let g = f[i];
+                        1 === i && "" === g && "" === f[0] || ("." === g || "" === g) && (p = !0, f.splice(i, 1), i--);
+                    }
+                    "." === f[0] && 2 === f.length && ("." === f[1] || "" === f[1]) && (p = !0, f.pop());
+                }
+                let y = 0;
+                for(; -1 !== (y = f.indexOf("..", y + 1));){
+                    let i = f[y - 1];
+                    if (i && "." !== i && ".." !== i && "**" !== i) {
+                        p = !0;
+                        let i = 1 === y && "**" === f[y + 1] ? [
+                            "."
+                        ] : [];
+                        f.splice(y - 1, 2, ...i), 0 === f.length && f.push(""), y -= 2;
+                    }
+                }
+            }
+        }while (p);
+        return i;
+    }
+    secondPhasePreProcess(i) {
+        for(let p = 0; p < i.length - 1; p++)for(let f = p + 1; f < i.length; f++){
+            let g = this.partsMatch(i[p], i[f], !this.preserveMultipleSlashes);
+            if (g) {
+                i[p] = [], i[f] = g;
+                break;
+            }
+        }
+        return i.filter((i)=>i.length);
+    }
+    partsMatch(i, p, f = !1) {
+        let g = 0, y = 0, b = [], v = "";
+        for(; g < i.length && y < p.length;)if (i[g] === p[y]) b.push("b" === v ? p[y] : i[g]), g++, y++;
+        else if (f && "**" === i[g] && p[y] === i[g + 1]) b.push(i[g]), g++;
+        else if (f && "**" === p[y] && i[g] === p[y + 1]) b.push(p[y]), y++;
+        else if ("*" === i[g] && p[y] && (this.options.dot || !p[y].startsWith(".")) && "**" !== p[y]) {
+            if ("b" === v) return !1;
+            v = "a", b.push(i[g]), g++, y++;
+        } else {
+            if ("*" !== p[y] || !i[g] || !this.options.dot && !!i[g].startsWith(".") || "**" === i[g]) return !1;
+            if ("a" === v) return !1;
+            v = "b", b.push(p[y]), g++, y++;
+        }
+        return i.length === p.length && b;
+    }
+    parseNegate() {
+        if (this.nonegate) return;
+        let i = this.pattern, p = !1, f = 0;
+        for(let g = 0; g < i.length && "!" === i.charAt(g); g++)p = !p, f++;
+        f && (this.pattern = i.slice(f)), this.negate = p;
+    }
+    matchOne(i, p, f = !1) {
+        let g = this.options;
+        if (this.isWindows) {
+            let f = "string" == typeof i[0] && /^[a-z]:$/i.test(i[0]), g = !f && "" === i[0] && "" === i[1] && "?" === i[2] && /^[a-z]:$/i.test(i[3]), y = "string" == typeof p[0] && /^[a-z]:$/i.test(p[0]), b = !y && "" === p[0] && "" === p[1] && "?" === p[2] && "string" == typeof p[3] && /^[a-z]:$/i.test(p[3]), v = g ? 3 : f ? 0 : void 0, S = b ? 3 : y ? 0 : void 0;
+            if ("number" == typeof v && "number" == typeof S) {
+                let [f, g] = [
+                    i[v],
+                    p[S]
+                ];
+                f.toLowerCase() === g.toLowerCase() && (p[S] = f, S > v ? p = p.slice(S) : v > S && (i = i.slice(v)));
+            }
+        }
+        let { optimizationLevel: y = 1 } = this.options;
+        y >= 2 && (i = this.levelTwoFileOptimize(i)), this.debug("matchOne", this, {
+            file: i,
+            pattern: p
+        }), this.debug("matchOne", i.length, p.length);
+        for(var b = 0, v = 0, S = i.length, E = p.length; b < S && v < E; b++, v++){
+            this.debug("matchOne loop");
+            var k = p[v], x = i[b];
+            if (this.debug(p, k, x), !1 === k) return !1;
+            if (k === yt) {
+                this.debug("GLOBSTAR", [
+                    p,
+                    k,
+                    x
+                ]);
+                var _ = b, C = v + 1;
+                if (C === E) {
+                    for(this.debug("** at the end"); b < S; b++)if ("." === i[b] || ".." === i[b] || !g.dot && "." === i[b].charAt(0)) return !1;
+                    return !0;
+                }
+                for(; _ < S;){
+                    var A = i[_];
+                    if (this.debug(`\nglobstar while`, i, _, p, C, A), this.matchOne(i.slice(_), p.slice(C), f)) return this.debug("globstar found match!", _, S, A), !0;
+                    if ("." === A || ".." === A || !g.dot && "." === A.charAt(0)) {
+                        this.debug("dot detected!", i, _, p, C);
+                        break;
+                    }
+                    this.debug("globstar swallow a segment, and continue"), _++;
+                }
+                return !!(f && (this.debug(`\n>>> no match, partial?`, i, _, p, C), _ === S));
+            }
+            let y;
+            if ("string" == typeof k ? (y = x === k, this.debug("string match", k, x, y)) : (y = k.test(x), this.debug("pattern match", k, x, y)), !y) return !1;
+        }
+        if (b === S && v === E) return !0;
+        if (b === S) return f;
+        if (v === E) return b === S - 1 && "" === i[b];
+        throw new Error("wtf?");
+    }
+    braceExpand() {
+        return ke(this.pattern, this.options);
+    }
+    parse(i) {
+        at(i);
+        let p = this.options;
+        if ("**" === i) return yt;
+        if ("" === i) return "";
+        let f, g = null;
+        (f = i.match(pt)) ? g = p.dot ? zs : Is : (f = i.match(nt)) ? g = (p.nocase ? p.dot ? Ms : Ds : p.dot ? Fs : Os)(f[1]) : (f = i.match(ft)) ? g = (p.nocase ? p.dot ? $s : Us : p.dot ? Gs : Hs)(f) : (f = i.match(ot)) ? g = p.dot ? Ls : _s : (f = i.match(ut)) && (g = Ps);
+        let y = rt.fromGlob(i, this.options).toMMPattern();
+        return g && "object" == typeof y && Reflect.defineProperty(y, "test", {
+            value: g
+        }), y;
+    }
+    makeRe() {
+        if (this.regexp || !1 === this.regexp) return this.regexp;
+        let i = this.set;
+        if (!i.length) return this.regexp = !1, this.regexp;
+        let p = this.options, f = p.noglobstar ? St : p.dot ? Et : kt, g = new Set(p.nocase ? [
+            "i"
+        ] : []), y = i.map((i)=>{
+            let p = i.map((i)=>{
+                if (i instanceof RegExp) for (let p of i.flags.split(""))g.add(p);
+                return "string" == typeof i ? ei(i) : i === yt ? yt : i._src;
+            });
+            p.forEach((i, g)=>{
+                let y = p[g + 1], b = p[g - 1];
+                i !== yt || b === yt || (void 0 === b ? void 0 !== y && y !== yt ? p[g + 1] = "(?:\\/|" + f + "\\/)?" + y : p[g] = f : void 0 === y ? p[g - 1] = b + "(?:\\/|\\/" + f + ")?" : y !== yt && (p[g - 1] = b + "(?:\\/|\\/" + f + "\\/)" + y, p[g + 1] = yt));
+            });
+            let y = p.filter((i)=>i !== yt);
+            if (this.partial && y.length >= 1) {
+                let i = [];
+                for(let p = 1; p <= y.length; p++)i.push(y.slice(0, p).join("/"));
+                return "(?:" + i.join("|") + ")";
+            }
+            return y.join("/");
+        }).join("|"), [b, v] = i.length > 1 ? [
+            "(?:",
+            ")"
+        ] : [
+            "",
+            ""
+        ];
+        y = "^" + b + y + v + "$", this.partial && (y = "^(?:\\/|" + b + y.slice(1, -1) + v + ")$"), this.negate && (y = "^(?!" + y + ").+$");
+        try {
+            this.regexp = new RegExp(y, [
+                ...g
+            ].join(""));
+        } catch  {
+            this.regexp = !1;
+        }
+        return this.regexp;
+    }
+    slashSplit(i) {
+        return this.preserveMultipleSlashes ? i.split("/") : this.isWindows && /^\/\/[^\/]+/.test(i) ? [
+            "",
+            ...i.split(/\/+/)
+        ] : i.split(/\/+/);
+    }
+    match(i, p = this.partial) {
+        if (this.debug("match", i, this.pattern), this.comment) return !1;
+        if (this.empty) return "" === i;
+        if ("/" === i && p) return !0;
+        let f = this.options;
+        this.isWindows && (i = i.split("\\").join("/"));
+        let g = this.slashSplit(i);
+        this.debug(this.pattern, "split", g);
+        let y = this.set;
+        this.debug(this.pattern, "set", y);
+        let b = g[g.length - 1];
+        if (!b) for(let i = g.length - 2; !b && i >= 0; i--)b = g[i];
+        for(let i = 0; i < y.length; i++){
+            let v = y[i], S = g;
+            if (f.matchBase && 1 === v.length && (S = [
+                b
+            ]), this.matchOne(S, v, p)) return f.flipNegate ? !0 : !this.negate;
+        }
+        return f.flipNegate ? !1 : this.negate;
+    }
+    static defaults(i) {
+        return O.defaults(i).Minimatch;
+    }
+};
+O.AST = rt;
+O.Minimatch = Ct;
+O.escape = tt;
+O.unescape = W;
+var Ot = "object" == typeof performance && performance && "function" == typeof performance.now ? performance : Date, At = new Set, Tt = "object" == typeof process && process ? process : {}, Fe = (i, p, f, g)=>{
+    "function" == typeof Tt.emitWarning ? Tt.emitWarning(i, p, f, g) : console.error(`[${f}] ${p}: ${i}`);
+}, Rt = globalThis.AbortController, Ft = globalThis.AbortSignal;
+if (typeof Rt > "u") {
+    Ft = class {
+        onabort;
+        _onabort = [];
+        reason;
+        aborted = !1;
+        addEventListener(i, p) {
+            this._onabort.push(p);
+        }
+    }, Rt = class {
+        constructor(){
+            t();
+        }
+        signal = new Ft;
+        abort(i) {
+            if (!this.signal.aborted) {
+                this.signal.reason = i, this.signal.aborted = !0;
+                for (let p of this.signal._onabort)p(i);
+                this.signal.onabort?.(i);
+            }
+        }
+    };
+    let i = Tt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = ()=>{
+        i && (i = !1, Fe("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+    };
+}
+var ii = (i)=>!At.has(i);
+var q = (i)=>i && i === Math.floor(i) && i > 0 && isFinite(i), De = (i)=>q(i) ? i <= Math.pow(2, 8) ? Uint8Array : i <= Math.pow(2, 16) ? Uint16Array : i <= Math.pow(2, 32) ? Uint32Array : i <= Number.MAX_SAFE_INTEGER ? Mt : null : null, Mt = class extends Array {
+    constructor(i){
+        super(i), this.fill(0);
+    }
+}, Pt = class ct {
+    heap;
+    length;
+    static #t = !1;
+    static create(i) {
+        let p = De(i);
+        if (!p) return [];
+        ct.#t = !0;
+        let f = new ct(i, p);
+        return ct.#t = !1, f;
+    }
+    constructor(i, p){
+        if (!ct.#t) throw new TypeError("instantiate Stack using Stack.create(n)");
+        this.heap = new p(i), this.length = 0;
+    }
+    push(i) {
+        this.heap[this.length++] = i;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}, Wt = class Me {
+    #t;
+    #e;
+    #i;
+    #s;
+    #r;
+    #h;
+    #n;
+    #o;
+    get perf() {
+        return this.#o;
+    }
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #a;
+    #l;
+    #c;
+    #u;
+    #p;
+    #d;
+    #f;
+    #g;
+    #m;
+    #w;
+    #y;
+    #b;
+    #v;
+    #S;
+    #E;
+    #k;
+    #x;
+    #_;
+    #C;
+    static unsafeExposeInternals(i) {
+        return {
+            starts: i.#v,
+            ttls: i.#S,
+            autopurgeTimers: i.#E,
+            sizes: i.#b,
+            keyMap: i.#c,
+            keyList: i.#u,
+            valList: i.#p,
+            next: i.#d,
+            prev: i.#f,
+            get head () {
+                return i.#g;
+            },
+            get tail () {
+                return i.#m;
+            },
+            free: i.#w,
+            isBackgroundFetch: (p)=>i.#O(p),
+            backgroundFetch: (p, f, g, y)=>i.#A(p, f, g, y),
+            moveToTail: (p)=>i.#T(p),
+            indexes: (p)=>i.#R(p),
+            rindexes: (p)=>i.#F(p),
+            isStale: (p)=>i.#M(p)
+        };
+    }
+    get max() {
+        return this.#t;
+    }
+    get maxSize() {
+        return this.#e;
+    }
+    get calculatedSize() {
+        return this.#l;
+    }
+    get size() {
+        return this.#a;
+    }
+    get fetchMethod() {
+        return this.#h;
+    }
+    get memoMethod() {
+        return this.#n;
+    }
+    get dispose() {
+        return this.#i;
+    }
+    get onInsert() {
+        return this.#s;
+    }
+    get disposeAfter() {
+        return this.#r;
+    }
+    constructor(i){
+        let { max: p = 0, ttl: f, ttlResolution: g = 1, ttlAutopurge: y, updateAgeOnGet: b, updateAgeOnHas: v, allowStale: S, dispose: E, onInsert: k, disposeAfter: x, noDisposeOnSet: _, noUpdateTTL: C, maxSize: A = 0, maxEntrySize: T = 0, sizeCalculation: R, fetchMethod: F, memoMethod: M, noDeleteOnFetchRejection: P, noDeleteOnStaleGet: j, allowStaleOnFetchRejection: D, allowStaleOnFetchAbort: L, ignoreFetchAbort: z, perf: B } = i;
+        if (void 0 !== B && "function" != typeof B?.now) throw new TypeError("perf option must have a now() method if specified");
+        if (this.#o = B ?? Ot, 0 !== p && !q(p)) throw new TypeError("max option must be a nonnegative integer");
+        let $ = p ? De(p) : Array;
+        if (!$) throw new Error("invalid max value: " + p);
+        if (this.#t = p, this.#e = A, this.maxEntrySize = T || this.#e, this.sizeCalculation = R, this.sizeCalculation) {
+            if (!this.#e && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+            if ("function" != typeof this.sizeCalculation) throw new TypeError("sizeCalculation set to non-function");
+        }
+        if (void 0 !== M && "function" != typeof M) throw new TypeError("memoMethod must be a function if defined");
+        if (this.#n = M, void 0 !== F && "function" != typeof F) throw new TypeError("fetchMethod must be a function if specified");
+        if (this.#h = F, this.#x = !!F, this.#c = new Map, this.#u = new Array(p).fill(void 0), this.#p = new Array(p).fill(void 0), this.#d = new $(p), this.#f = new $(p), this.#g = 0, this.#m = 0, this.#w = Pt.create(p), this.#a = 0, this.#l = 0, "function" == typeof E && (this.#i = E), "function" == typeof k && (this.#s = k), "function" == typeof x ? (this.#r = x, this.#y = []) : (this.#r = void 0, this.#y = void 0), this.#k = !!this.#i, this.#C = !!this.#s, this.#_ = !!this.#r, this.noDisposeOnSet = !!_, this.noUpdateTTL = !!C, this.noDeleteOnFetchRejection = !!P, this.allowStaleOnFetchRejection = !!D, this.allowStaleOnFetchAbort = !!L, this.ignoreFetchAbort = !!z, 0 !== this.maxEntrySize) {
+            if (0 !== this.#e && !q(this.#e)) throw new TypeError("maxSize must be a positive integer if specified");
+            if (!q(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+            this.#P();
+        }
+        if (this.allowStale = !!S, this.noDeleteOnStaleGet = !!j, this.updateAgeOnGet = !!b, this.updateAgeOnHas = !!v, this.ttlResolution = q(g) || 0 === g ? g : 1, this.ttlAutopurge = !!y, this.ttl = f || 0, this.ttl) {
+            if (!q(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+            this.#W();
+        }
+        if (0 === this.#t && 0 === this.ttl && 0 === this.#e) throw new TypeError("At least one of max, maxSize, or ttl is required");
+        if (!this.ttlAutopurge && !this.#t && !this.#e) {
+            let i = "LRU_CACHE_UNBOUNDED";
+            ii(i) && (At.add(i), Fe("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", i, Me));
+        }
+    }
+    getRemainingTTL(i) {
+        return this.#c.has(i) ? 1 / 0 : 0;
+    }
+    #W() {
+        let i = new Mt(this.#t), p = new Mt(this.#t);
+        this.#S = i, this.#v = p;
+        let f = this.ttlAutopurge ? new Array(this.#t) : void 0;
+        this.#E = f, this.#j = (g, y, b = this.#o.now())=>{
+            if (p[g] = 0 !== y ? b : 0, i[g] = y, f?.[g] && (clearTimeout(f[g]), f[g] = void 0), 0 !== y && f) {
+                let i = setTimeout(()=>{
+                    this.#M(g) && this.#D(this.#u[g], "expire");
+                }, y + 1);
+                i.unref && i.unref(), f[g] = i;
+            }
+        }, this.#L = (f)=>{
+            p[f] = 0 !== i[f] ? this.#o.now() : 0;
+        }, this.#z = (f, y)=>{
+            if (i[y]) {
+                let b = i[y], v = p[y];
+                if (!b || !v) return;
+                f.ttl = b, f.start = v, f.now = g || r();
+                let S = f.now - v;
+                f.remainingTTL = b - S;
+            }
+        };
+        let g = 0, r = ()=>{
+            let i = this.#o.now();
+            if (this.ttlResolution > 0) {
+                g = i;
+                let p = setTimeout(()=>g = 0, this.ttlResolution);
+                p.unref && p.unref();
+            }
+            return i;
+        };
+        this.getRemainingTTL = (f)=>{
+            let y = this.#c.get(f);
+            if (void 0 === y) return 0;
+            let b = i[y], v = p[y];
+            if (!b || !v) return 1 / 0;
+            let S = (g || r()) - v;
+            return b - S;
+        }, this.#M = (f)=>{
+            let y = p[f], b = i[f];
+            return !!b && !!y && (g || r()) - y > b;
+        };
+    }
+    #L = ()=>{};
+    #z = ()=>{};
+    #j = ()=>{};
+    #M = ()=>!1;
+    #P() {
+        let i = new Mt(this.#t);
+        this.#l = 0, this.#b = i, this.#N = (p)=>{
+            this.#l -= i[p], i[p] = 0;
+        }, this.#B = (i, p, f, g)=>{
+            if (this.#O(p)) return 0;
+            if (!q(f)) if (g) {
+                if ("function" != typeof g) throw new TypeError("sizeCalculation must be a function");
+                if (f = g(p, i), !q(f)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+            } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+            return f;
+        }, this.#$ = (p, f, g)=>{
+            if (i[p] = f, this.#e) {
+                let f = this.#e - i[p];
+                for(; this.#l > f;)this.#U(!0);
+            }
+            this.#l += i[p], g && (g.entrySize = f, g.totalCalculatedSize = this.#l);
+        };
+    }
+    #N = (i)=>{};
+    #$ = (i, p, f)=>{};
+    #B = (i, p, f, g)=>{
+        if (f || g) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+        return 0;
+    };
+    *#R({ allowStale: i = this.allowStale } = {}) {
+        if (this.#a) for(let p = this.#m; !(!this.#I(p) || ((i || !this.#M(p)) && (yield p), p === this.#g));)p = this.#f[p];
+    }
+    *#F({ allowStale: i = this.allowStale } = {}) {
+        if (this.#a) for(let p = this.#g; !(!this.#I(p) || ((i || !this.#M(p)) && (yield p), p === this.#m));)p = this.#d[p];
+    }
+    #I(i) {
+        return void 0 !== i && this.#c.get(this.#u[i]) === i;
+    }
+    *entries() {
+        for (let i of this.#R())void 0 === this.#p[i] || void 0 === this.#u[i] || this.#O(this.#p[i]) || (yield [
+            this.#u[i],
+            this.#p[i]
+        ]);
+    }
+    *rentries() {
+        for (let i of this.#F())void 0 === this.#p[i] || void 0 === this.#u[i] || this.#O(this.#p[i]) || (yield [
+            this.#u[i],
+            this.#p[i]
+        ]);
+    }
+    *keys() {
+        for (let i of this.#R()){
+            let p = this.#u[i];
+            void 0 === p || this.#O(this.#p[i]) || (yield p);
+        }
+    }
+    *rkeys() {
+        for (let i of this.#F()){
+            let p = this.#u[i];
+            void 0 === p || this.#O(this.#p[i]) || (yield p);
+        }
+    }
+    *values() {
+        for (let i of this.#R())void 0 === this.#p[i] || this.#O(this.#p[i]) || (yield this.#p[i]);
+    }
+    *rvalues() {
+        for (let i of this.#F())void 0 === this.#p[i] || this.#O(this.#p[i]) || (yield this.#p[i]);
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = "LRUCache";
+    find(i, p = {}) {
+        for (let f of this.#R()){
+            let g = this.#p[f], y = this.#O(g) ? g.__staleWhileFetching : g;
+            if (void 0 !== y && i(y, this.#u[f], this)) return this.get(this.#u[f], p);
+        }
+    }
+    forEach(i, p = this) {
+        for (let f of this.#R()){
+            let g = this.#p[f], y = this.#O(g) ? g.__staleWhileFetching : g;
+            void 0 !== y && i.call(p, y, this.#u[f], this);
+        }
+    }
+    rforEach(i, p = this) {
+        for (let f of this.#F()){
+            let g = this.#p[f], y = this.#O(g) ? g.__staleWhileFetching : g;
+            void 0 !== y && i.call(p, y, this.#u[f], this);
+        }
+    }
+    purgeStale() {
+        let i = !1;
+        for (let p of this.#F({
+            allowStale: !0
+        }))this.#M(p) && (this.#D(this.#u[p], "expire"), i = !0);
+        return i;
+    }
+    info(i) {
+        let p = this.#c.get(i);
+        if (void 0 === p) return;
+        let f = this.#p[p], g = this.#O(f) ? f.__staleWhileFetching : f;
+        if (void 0 === g) return;
+        let y = {
+            value: g
+        };
+        if (this.#S && this.#v) {
+            let i = this.#S[p], f = this.#v[p];
+            if (i && f) {
+                let p = i - (this.#o.now() - f);
+                y.ttl = p, y.start = Date.now();
+            }
+        }
+        return this.#b && (y.size = this.#b[p]), y;
+    }
+    dump() {
+        let i = [];
+        for (let p of this.#R({
+            allowStale: !0
+        })){
+            let f = this.#u[p], g = this.#p[p], y = this.#O(g) ? g.__staleWhileFetching : g;
+            if (void 0 === y || void 0 === f) continue;
+            let b = {
+                value: y
+            };
+            if (this.#S && this.#v) {
+                b.ttl = this.#S[p];
+                let i = this.#o.now() - this.#v[p];
+                b.start = Math.floor(Date.now() - i);
+            }
+            this.#b && (b.size = this.#b[p]), i.unshift([
+                f,
+                b
+            ]);
+        }
+        return i;
+    }
+    load(i) {
+        this.clear();
+        for (let [p, f] of i){
+            if (f.start) {
+                let i = Date.now() - f.start;
+                f.start = this.#o.now() - i;
+            }
+            this.set(p, f.value, f);
+        }
+    }
+    set(i, p, f = {}) {
+        if (void 0 === p) return this.delete(i), this;
+        let { ttl: g = this.ttl, start: y, noDisposeOnSet: b = this.noDisposeOnSet, sizeCalculation: v = this.sizeCalculation, status: S } = f, { noUpdateTTL: E = this.noUpdateTTL } = f, k = this.#B(i, p, f.size || 0, v);
+        if (this.maxEntrySize && k > this.maxEntrySize) return S && (S.set = "miss", S.maxEntrySizeExceeded = !0), this.#D(i, "set"), this;
+        let x = 0 === this.#a ? void 0 : this.#c.get(i);
+        if (void 0 === x) x = 0 === this.#a ? this.#m : 0 !== this.#w.length ? this.#w.pop() : this.#a === this.#t ? this.#U(!1) : this.#a, this.#u[x] = i, this.#p[x] = p, this.#c.set(i, x), this.#d[this.#m] = x, this.#f[x] = this.#m, this.#m = x, this.#a++, this.#$(x, k, S), S && (S.set = "add"), E = !1, this.#C && this.#s?.(p, i, "add");
+        else {
+            this.#T(x);
+            let f = this.#p[x];
+            if (p !== f) {
+                if (this.#x && this.#O(f)) {
+                    f.__abortController.abort(new Error("replaced"));
+                    let { __staleWhileFetching: p } = f;
+                    void 0 !== p && !b && (this.#k && this.#i?.(p, i, "set"), this.#_ && this.#y?.push([
+                        p,
+                        i,
+                        "set"
+                    ]));
+                } else b || (this.#k && this.#i?.(f, i, "set"), this.#_ && this.#y?.push([
+                    f,
+                    i,
+                    "set"
+                ]));
+                if (this.#N(x), this.#$(x, k, S), this.#p[x] = p, S) {
+                    S.set = "replace";
+                    let i = f && this.#O(f) ? f.__staleWhileFetching : f;
+                    void 0 !== i && (S.oldValue = i);
+                }
+            } else S && (S.set = "update");
+            this.#C && this.onInsert?.(p, i, p === f ? "update" : "replace");
+        }
+        if (0 === g || this.#S || this.#W(), this.#S && (E || this.#j(x, g, y), S && this.#z(S, x)), !b && this.#_ && this.#y) {
+            let i = this.#y, p;
+            for(; p = i?.shift();)this.#r?.(...p);
+        }
+        return this;
+    }
+    pop() {
+        try {
+            for(; this.#a;){
+                let i = this.#p[this.#g];
+                if (this.#U(!0), this.#O(i)) {
+                    if (i.__staleWhileFetching) return i.__staleWhileFetching;
+                } else if (void 0 !== i) return i;
+            }
+        } finally{
+            if (this.#_ && this.#y) {
+                let i = this.#y, p;
+                for(; p = i?.shift();)this.#r?.(...p);
+            }
+        }
+    }
+    #U(i) {
+        let p = this.#g, f = this.#u[p], g = this.#p[p];
+        return this.#x && this.#O(g) ? g.__abortController.abort(new Error("evicted")) : (this.#k || this.#_) && (this.#k && this.#i?.(g, f, "evict"), this.#_ && this.#y?.push([
+            g,
+            f,
+            "evict"
+        ])), this.#N(p), this.#E?.[p] && (clearTimeout(this.#E[p]), this.#E[p] = void 0), i && (this.#u[p] = void 0, this.#p[p] = void 0, this.#w.push(p)), 1 === this.#a ? (this.#g = this.#m = 0, this.#w.length = 0) : this.#g = this.#d[p], this.#c.delete(f), this.#a--, p;
+    }
+    has(i, p = {}) {
+        let { updateAgeOnHas: f = this.updateAgeOnHas, status: g } = p, y = this.#c.get(i);
+        if (void 0 !== y) {
+            let i = this.#p[y];
+            if (this.#O(i) && void 0 === i.__staleWhileFetching) return !1;
+            if (!this.#M(y)) return f && this.#L(y), g && (g.has = "hit", this.#z(g, y)), !0;
+            else g && (g.has = "stale", this.#z(g, y));
+        } else g && (g.has = "miss");
+        return !1;
+    }
+    peek(i, p = {}) {
+        let { allowStale: f = this.allowStale } = p, g = this.#c.get(i);
+        if (void 0 === g || !f && this.#M(g)) return;
+        let y = this.#p[g];
+        return this.#O(y) ? y.__staleWhileFetching : y;
+    }
+    #A(i, p, f, g) {
+        let y = void 0 === p ? void 0 : this.#p[p];
+        if (this.#O(y)) return y;
+        let b = new Rt, { signal: v } = f;
+        v?.addEventListener("abort", ()=>b.abort(v.reason), {
+            signal: b.signal
+        });
+        let S = {
+            signal: b.signal,
+            options: f,
+            context: g
+        }, l = (g, y = !1)=>{
+            let { aborted: v } = b.signal, k = f.ignoreFetchAbort && void 0 !== g, x = f.ignoreFetchAbort || !!(f.allowStaleOnFetchAbort && void 0 !== g);
+            if (f.status && (v && !y ? (f.status.fetchAborted = !0, f.status.fetchError = b.signal.reason, k && (f.status.fetchAbortIgnored = !0)) : f.status.fetchResolved = !0), v && !k && !y) return c(b.signal.reason, x);
+            let _ = E, C = this.#p[p];
+            return (C === E || k && y && void 0 === C) && (void 0 === g ? void 0 !== _.__staleWhileFetching ? this.#p[p] = _.__staleWhileFetching : this.#D(i, "fetch") : (f.status && (f.status.fetchUpdated = !0), this.set(i, g, S.options))), g;
+        }, u = (i)=>(f.status && (f.status.fetchRejected = !0, f.status.fetchError = i), c(i, !1)), c = (g, y)=>{
+            let { aborted: v } = b.signal, S = v && f.allowStaleOnFetchAbort, k = S || f.allowStaleOnFetchRejection, x = k || f.noDeleteOnFetchRejection, _ = E;
+            if (this.#p[p] === E && (x && (y || void 0 !== _.__staleWhileFetching) ? S || (this.#p[p] = _.__staleWhileFetching) : this.#D(i, "fetch")), k) return f.status && void 0 !== _.__staleWhileFetching && (f.status.returnedStale = !0), _.__staleWhileFetching;
+            if (_.__returned === _) throw g;
+        }, d = (p, g)=>{
+            let v = this.#h?.(i, y, S);
+            v && v instanceof Promise && v.then((i)=>p(void 0 === i ? void 0 : i), g), b.signal.addEventListener("abort", ()=>{
+                (!f.ignoreFetchAbort || f.allowStaleOnFetchAbort) && (p(void 0), f.allowStaleOnFetchAbort && (p = (i)=>l(i, !0)));
+            });
+        };
+        f.status && (f.status.fetchDispatched = !0);
+        let E = new Promise(d).then(l, u), k = Object.assign(E, {
+            __abortController: b,
+            __staleWhileFetching: y,
+            __returned: void 0
+        });
+        return void 0 === p ? (this.set(i, k, {
+            ...S.options,
+            status: void 0
+        }), p = this.#c.get(i)) : this.#p[p] = k, k;
+    }
+    #O(i) {
+        if (!this.#x) return !1;
+        let p = i;
+        return !!p && p instanceof Promise && p.hasOwnProperty("__staleWhileFetching") && p.__abortController instanceof Rt;
+    }
+    async fetch(i, p = {}) {
+        let { allowStale: f = this.allowStale, updateAgeOnGet: g = this.updateAgeOnGet, noDeleteOnStaleGet: y = this.noDeleteOnStaleGet, ttl: b = this.ttl, noDisposeOnSet: v = this.noDisposeOnSet, size: S = 0, sizeCalculation: E = this.sizeCalculation, noUpdateTTL: k = this.noUpdateTTL, noDeleteOnFetchRejection: x = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: _ = this.allowStaleOnFetchRejection, ignoreFetchAbort: C = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: T, forceRefresh: R = !1, status: F, signal: M } = p;
+        if (!this.#x) return F && (F.fetch = "get"), this.get(i, {
+            allowStale: f,
+            updateAgeOnGet: g,
+            noDeleteOnStaleGet: y,
+            status: F
+        });
+        let P = {
+            allowStale: f,
+            updateAgeOnGet: g,
+            noDeleteOnStaleGet: y,
+            ttl: b,
+            noDisposeOnSet: v,
+            size: S,
+            sizeCalculation: E,
+            noUpdateTTL: k,
+            noDeleteOnFetchRejection: x,
+            allowStaleOnFetchRejection: _,
+            allowStaleOnFetchAbort: A,
+            ignoreFetchAbort: C,
+            status: F,
+            signal: M
+        }, j = this.#c.get(i);
+        if (void 0 === j) {
+            F && (F.fetch = "miss");
+            let p = this.#A(i, j, P, T);
+            return p.__returned = p;
+        } else {
+            let p = this.#p[j];
+            if (this.#O(p)) {
+                let i = f && void 0 !== p.__staleWhileFetching;
+                return F && (F.fetch = "inflight", i && (F.returnedStale = !0)), i ? p.__staleWhileFetching : p.__returned = p;
+            }
+            let y = this.#M(j);
+            if (!R && !y) return F && (F.fetch = "hit"), this.#T(j), g && this.#L(j), F && this.#z(F, j), p;
+            let b = this.#A(i, j, P, T), v = void 0 !== b.__staleWhileFetching && f;
+            return F && (F.fetch = y ? "stale" : "refresh", v && y && (F.returnedStale = !0)), v ? b.__staleWhileFetching : b.__returned = b;
+        }
+    }
+    async forceFetch(i, p = {}) {
+        let f = await this.fetch(i, p);
+        if (void 0 === f) throw new Error("fetch() returned undefined");
+        return f;
+    }
+    memo(i, p = {}) {
+        let f = this.#n;
+        if (!f) throw new Error("no memoMethod provided to constructor");
+        let { context: g, forceRefresh: y, ...b } = p, v = this.get(i, b);
+        if (!y && void 0 !== v) return v;
+        let S = f(i, v, {
+            options: b,
+            context: g
+        });
+        return this.set(i, S, b), S;
+    }
+    get(i, p = {}) {
+        let { allowStale: f = this.allowStale, updateAgeOnGet: g = this.updateAgeOnGet, noDeleteOnStaleGet: y = this.noDeleteOnStaleGet, status: b } = p, v = this.#c.get(i);
+        if (void 0 !== v) {
+            let p = this.#p[v], S = this.#O(p);
+            return b && this.#z(b, v), this.#M(v) ? (b && (b.get = "stale"), S ? (b && f && void 0 !== p.__staleWhileFetching && (b.returnedStale = !0), f ? p.__staleWhileFetching : void 0) : (y || this.#D(i, "expire"), b && f && (b.returnedStale = !0), f ? p : void 0)) : (b && (b.get = "hit"), S ? p.__staleWhileFetching : (this.#T(v), g && this.#L(v), p));
+        } else b && (b.get = "miss");
+    }
+    #G(i, p) {
+        this.#f[p] = i, this.#d[i] = p;
+    }
+    #T(i) {
+        i !== this.#m && (i === this.#g ? this.#g = this.#d[i] : this.#G(this.#f[i], this.#d[i]), this.#G(this.#m, i), this.#m = i);
+    }
+    delete(i) {
+        return this.#D(i, "delete");
+    }
+    #D(i, p) {
+        let f = !1;
+        if (0 !== this.#a) {
+            let g = this.#c.get(i);
+            if (void 0 !== g) if (this.#E?.[g] && (clearTimeout(this.#E?.[g]), this.#E[g] = void 0), f = !0, 1 === this.#a) this.#q(p);
+            else {
+                this.#N(g);
+                let f = this.#p[g];
+                if (this.#O(f) ? f.__abortController.abort(new Error("deleted")) : (this.#k || this.#_) && (this.#k && this.#i?.(f, i, p), this.#_ && this.#y?.push([
+                    f,
+                    i,
+                    p
+                ])), this.#c.delete(i), this.#u[g] = void 0, this.#p[g] = void 0, g === this.#m) this.#m = this.#f[g];
+                else if (g === this.#g) this.#g = this.#d[g];
+                else {
+                    let i = this.#f[g];
+                    this.#d[i] = this.#d[g];
+                    let p = this.#d[g];
+                    this.#f[p] = this.#f[g];
+                }
+                this.#a--, this.#w.push(g);
+            }
+        }
+        if (this.#_ && this.#y?.length) {
+            let i = this.#y, p;
+            for(; p = i?.shift();)this.#r?.(...p);
+        }
+        return f;
+    }
+    clear() {
+        return this.#q("delete");
+    }
+    #q(i) {
+        for (let p of this.#F({
+            allowStale: !0
+        })){
+            let f = this.#p[p];
+            if (this.#O(f)) f.__abortController.abort(new Error("deleted"));
+            else {
+                let g = this.#u[p];
+                this.#k && this.#i?.(f, g, i), this.#_ && this.#y?.push([
+                    f,
+                    g,
+                    i
+                ]);
+            }
+        }
+        if (this.#c.clear(), this.#p.fill(void 0), this.#u.fill(void 0), this.#S && this.#v) {
+            this.#S.fill(0), this.#v.fill(0);
+            for (let i of this.#E ?? [])void 0 !== i && clearTimeout(i);
+            this.#E?.fill(void 0);
+        }
+        if (this.#b && this.#b.fill(0), this.#g = 0, this.#m = 0, this.#w.length = 0, this.#l = 0, this.#a = 0, this.#_ && this.#y) {
+            let i = this.#y, p;
+            for(; p = i?.shift();)this.#r?.(...p);
+        }
+    }
+};
+var jt = "object" == typeof process && process ? process : {
+    stdout: null,
+    stderr: null
+}, oi = (i)=>!!i && "object" == typeof i && (i instanceof Re || i instanceof _ || hi(i) || ai(i)), hi = (i)=>!!i && "object" == typeof i && i instanceof x.EventEmitter && "function" == typeof i.pipe && i.pipe !== _.Writable.prototype.pipe, ai = (i)=>!!i && "object" == typeof i && i instanceof x.EventEmitter && "function" == typeof i.write && "function" == typeof i.end, Dt = Symbol("EOF"), Lt = Symbol("maybeEmitEnd"), zt = Symbol("emittedEnd"), Nt = Symbol("emittingEnd"), $t = Symbol("emittedError"), It = Symbol("closed"), qt = Symbol("read"), Zt = Symbol("flush"), Jt = Symbol("flushChunk"), Qt = Symbol("encoding"), Kt = Symbol("decoder"), Vt = Symbol("flowing"), Yt = Symbol("paused"), Xt = Symbol("resume"), te = Symbol("buffer"), ee = Symbol("pipes"), se = Symbol("bufferLength"), re = Symbol("bufferPush"), he = Symbol("bufferShift"), ne = Symbol("objectMode"), oe = Symbol("destroyed"), ae = Symbol("error"), ue = Symbol("emitData"), pe = Symbol("emitEnd"), fe = Symbol("emitEnd2"), de = Symbol("async"), ve = Symbol("abort"), Se = Symbol("aborted"), Ee = Symbol("signal"), xe = Symbol("dataListeners"), _e = Symbol("discarded"), mt = (i)=>Promise.resolve().then(i), li = (i)=>i(), ci = (i)=>"end" === i || "finish" === i || "prefinish" === i, fi = (i)=>i instanceof ArrayBuffer || !!i && "object" == typeof i && i.constructor && "ArrayBuffer" === i.constructor.name && i.byteLength >= 0, ui = (i)=>!Buffer.isBuffer(i) && ArrayBuffer.isView(i), Oe = class {
+    src;
+    dest;
+    opts;
+    ondrain;
+    constructor(i, p, f){
+        this.src = i, this.dest = p, this.opts = f, this.ondrain = ()=>i[Xt](), this.dest.on("drain", this.ondrain);
+    }
+    unpipe() {
+        this.dest.removeListener("drain", this.ondrain);
+    }
+    proxyErrors(i) {}
+    end() {
+        this.unpipe(), this.opts.end && this.dest.end();
+    }
+}, Ae = class extends Oe {
+    unpipe() {
+        this.src.removeListener("error", this.proxyErrors), super.unpipe();
+    }
+    constructor(i, p, f){
+        super(i, p, f), this.proxyErrors = (i)=>this.dest.emit("error", i), i.on("error", this.proxyErrors);
+    }
+}, di = (i)=>!!i.objectMode, pi = (i)=>!i.objectMode && !!i.encoding && "buffer" !== i.encoding, Re = class extends x.EventEmitter {
+    [Vt] = !1;
+    [Yt] = !1;
+    [ee] = [];
+    [te] = [];
+    [ne];
+    [Qt];
+    [de];
+    [Kt];
+    [Dt] = !1;
+    [zt] = !1;
+    [Nt] = !1;
+    [It] = !1;
+    [$t] = null;
+    [se] = 0;
+    [oe] = !1;
+    [Ee];
+    [Se] = !1;
+    [xe] = 0;
+    [_e] = !1;
+    writable = !0;
+    readable = !0;
+    constructor(...i){
+        let p = i[0] || {};
+        if (super(), p.objectMode && "string" == typeof p.encoding) throw new TypeError("Encoding and objectMode may not be used together");
+        di(p) ? (this[ne] = !0, this[Qt] = null) : pi(p) ? (this[Qt] = p.encoding, this[ne] = !1) : (this[ne] = !1, this[Qt] = null), this[de] = !!p.async, this[Kt] = this[Qt] ? new C.StringDecoder(this[Qt]) : null, p && !0 === p.debugExposeBuffer && Object.defineProperty(this, "buffer", {
+            get: ()=>this[te]
+        }), p && !0 === p.debugExposePipes && Object.defineProperty(this, "pipes", {
+            get: ()=>this[ee]
+        });
+        let { signal: f } = p;
+        f && (this[Ee] = f, f.aborted ? this[ve]() : f.addEventListener("abort", ()=>this[ve]()));
+    }
+    get bufferLength() {
+        return this[se];
+    }
+    get encoding() {
+        return this[Qt];
+    }
+    set encoding(i) {
+        throw new Error("Encoding must be set at instantiation time");
+    }
+    setEncoding(i) {
+        throw new Error("Encoding must be set at instantiation time");
+    }
+    get objectMode() {
+        return this[ne];
+    }
+    set objectMode(i) {
+        throw new Error("objectMode must be set at instantiation time");
+    }
+    get async() {
+        return this[de];
+    }
+    set async(i) {
+        this[de] = this[de] || !!i;
+    }
+    [ve]() {
+        this[Se] = !0, this.emit("abort", this[Ee]?.reason), this.destroy(this[Ee]?.reason);
+    }
+    get aborted() {
+        return this[Se];
+    }
+    set aborted(i) {}
+    write(i, p, f) {
+        if (this[Se]) return !1;
+        if (this[Dt]) throw new Error("write after end");
+        if (this[oe]) return this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
+            code: "ERR_STREAM_DESTROYED"
+        })), !0;
+        "function" == typeof p && (f = p, p = "utf8"), p || (p = "utf8");
+        let g = this[de] ? mt : li;
+        if (!this[ne] && !Buffer.isBuffer(i)) {
+            if (ui(i)) i = Buffer.from(i.buffer, i.byteOffset, i.byteLength);
+            else if (fi(i)) i = Buffer.from(i);
+            else if ("string" != typeof i) throw new Error("Non-contiguous data written to non-objectMode stream");
+        }
+        return this[ne] ? (this[Vt] && 0 !== this[se] && this[Zt](!0), this[Vt] ? this.emit("data", i) : this[re](i), 0 !== this[se] && this.emit("readable"), f && g(f), this[Vt]) : i.length ? ("string" == typeof i && (p !== this[Qt] || this[Kt]?.lastNeed) && (i = Buffer.from(i, p)), Buffer.isBuffer(i) && this[Qt] && (i = this[Kt].write(i)), this[Vt] && 0 !== this[se] && this[Zt](!0), this[Vt] ? this.emit("data", i) : this[re](i), 0 !== this[se] && this.emit("readable"), f && g(f), this[Vt]) : (0 !== this[se] && this.emit("readable"), f && g(f), this[Vt]);
+    }
+    read(i) {
+        if (this[oe]) return null;
+        if (this[_e] = !1, 0 === this[se] || 0 === i || i && i > this[se]) return this[Lt](), null;
+        this[ne] && (i = null), this[te].length > 1 && !this[ne] && (this[te] = [
+            this[Qt] ? this[te].join("") : Buffer.concat(this[te], this[se])
+        ]);
+        let p = this[qt](i || null, this[te][0]);
+        return this[Lt](), p;
+    }
+    [qt](i, p) {
+        if (this[ne]) this[he]();
+        else {
+            let f = p;
+            i === f.length || null === i ? this[he]() : "string" == typeof f ? (this[te][0] = f.slice(i), p = f.slice(0, i), this[se] -= i) : (this[te][0] = f.subarray(i), p = f.subarray(0, i), this[se] -= i);
+        }
+        return this.emit("data", p), this[te].length || this[Dt] || this.emit("drain"), p;
+    }
+    end(i, p, f) {
+        return "function" == typeof i && (f = i, i = void 0), "function" == typeof p && (f = p, p = "utf8"), void 0 !== i && this.write(i, p), f && this.once("end", f), this[Dt] = !0, this.writable = !1, (this[Vt] || !this[Yt]) && this[Lt](), this;
+    }
+    [Xt]() {
+        this[oe] || (this[xe] || this[ee].length || (this[_e] = !0), this[Yt] = !1, this[Vt] = !0, this.emit("resume"), this[te].length ? this[Zt]() : this[Dt] ? this[Lt]() : this.emit("drain"));
+    }
+    resume() {
+        return this[Xt]();
+    }
+    pause() {
+        this[Vt] = !1, this[Yt] = !0, this[_e] = !1;
+    }
+    get destroyed() {
+        return this[oe];
+    }
+    get flowing() {
+        return this[Vt];
+    }
+    get paused() {
+        return this[Yt];
+    }
+    [re](i) {
+        this[ne] ? this[se] += 1 : this[se] += i.length, this[te].push(i);
+    }
+    [he]() {
+        return this[ne] ? this[se] -= 1 : this[se] -= this[te][0].length, this[te].shift();
+    }
+    [Zt](i = !1) {
+        do ;
+        while (this[Jt](this[he]()) && this[te].length);
+        i || this[te].length || this[Dt] || this.emit("drain");
+    }
+    [Jt](i) {
+        return this.emit("data", i), this[Vt];
+    }
+    pipe(i, p) {
+        if (this[oe]) return i;
+        this[_e] = !1;
+        let f = this[zt];
+        return p = p || {}, i === jt.stdout || i === jt.stderr ? p.end = !1 : p.end = !1 !== p.end, p.proxyErrors = !!p.proxyErrors, f ? p.end && i.end() : (this[ee].push(p.proxyErrors ? new Ae(this, i, p) : new Oe(this, i, p)), this[de] ? mt(()=>this[Xt]()) : this[Xt]()), i;
+    }
+    unpipe(i) {
+        let p = this[ee].find((p)=>p.dest === i);
+        p && (1 === this[ee].length ? (this[Vt] && 0 === this[xe] && (this[Vt] = !1), this[ee] = []) : this[ee].splice(this[ee].indexOf(p), 1), p.unpipe());
+    }
+    addListener(i, p) {
+        return this.on(i, p);
+    }
+    on(i, p) {
+        let f = super.on(i, p);
+        if ("data" === i) this[_e] = !1, this[xe]++, this[ee].length || this[Vt] || this[Xt]();
+        else if ("readable" === i && 0 !== this[se]) super.emit("readable");
+        else if (ci(i) && this[zt]) super.emit(i), this.removeAllListeners(i);
+        else if ("error" === i && this[$t]) {
+            let i = p;
+            this[de] ? mt(()=>i.call(this, this[$t])) : i.call(this, this[$t]);
+        }
+        return f;
+    }
+    removeListener(i, p) {
+        return this.off(i, p);
+    }
+    off(i, p) {
+        let f = super.off(i, p);
+        return "data" === i && (this[xe] = this.listeners("data").length, 0 !== this[xe] || this[_e] || this[ee].length || (this[Vt] = !1)), f;
+    }
+    removeAllListeners(i) {
+        let p = super.removeAllListeners(i);
+        return ("data" === i || void 0 === i) && (this[xe] = 0, this[_e] || this[ee].length || (this[Vt] = !1)), p;
+    }
+    get emittedEnd() {
+        return this[zt];
+    }
+    [Lt]() {
+        this[Nt] || this[zt] || this[oe] || 0 !== this[te].length || !this[Dt] || (this[Nt] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[It] && this.emit("close"), this[Nt] = !1);
+    }
+    emit(i, ...p) {
+        let f = p[0];
+        if ("error" !== i && "close" !== i && i !== oe && this[oe]) return !1;
+        if ("data" === i) return this[ne] || f ? this[de] ? (mt(()=>this[ue](f)), !0) : this[ue](f) : !1;
+        if ("end" === i) return this[pe]();
+        if ("close" === i) {
+            if (this[It] = !0, !this[zt] && !this[oe]) return !1;
+            let i = super.emit("close");
+            return this.removeAllListeners("close"), i;
+        } else if ("error" === i) {
+            this[$t] = f, super.emit(ae, f);
+            let i = !this[Ee] || this.listeners("error").length ? super.emit("error", f) : !1;
+            return this[Lt](), i;
+        } else if ("resume" === i) {
+            let i = super.emit("resume");
+            return this[Lt](), i;
+        } else if ("finish" === i || "prefinish" === i) {
+            let p = super.emit(i);
+            return this.removeAllListeners(i), p;
+        }
+        let g = super.emit(i, ...p);
+        return this[Lt](), g;
+    }
+    [ue](i) {
+        for (let p of this[ee])!1 === p.dest.write(i) && this.pause();
+        let p = this[_e] ? !1 : super.emit("data", i);
+        return this[Lt](), p;
+    }
+    [pe]() {
+        return this[zt] ? !1 : (this[zt] = !0, this.readable = !1, this[de] ? (mt(()=>this[fe]()), !0) : this[fe]());
+    }
+    [fe]() {
+        if (this[Kt]) {
+            let i = this[Kt].end();
+            if (i) {
+                for (let p of this[ee])p.dest.write(i);
+                this[_e] || super.emit("data", i);
+            }
+        }
+        for (let i of this[ee])i.end();
+        let i = super.emit("end");
+        return this.removeAllListeners("end"), i;
+    }
+    async collect() {
+        let i = Object.assign([], {
+            dataLength: 0
+        });
+        this[ne] || (i.dataLength = 0);
+        let p = this.promise();
+        return this.on("data", (p)=>{
+            i.push(p), this[ne] || (i.dataLength += p.length);
+        }), await p, i;
+    }
+    async concat() {
+        if (this[ne]) throw new Error("cannot concat in objectMode");
+        let i = await this.collect();
+        return this[Qt] ? i.join("") : Buffer.concat(i, i.dataLength);
+    }
+    async promise() {
+        return new Promise((i, p)=>{
+            this.on(oe, ()=>p(new Error("stream destroyed"))), this.on("error", (i)=>p(i)), this.on("end", ()=>i());
+        });
+    }
+    [Symbol.asyncIterator]() {
+        this[_e] = !1;
+        let i = !1, e = async ()=>(this.pause(), i = !0, {
+                value: void 0,
+                done: !0
+            });
+        return {
+            next: ()=>{
+                if (i) return e();
+                let p = this.read();
+                if (null !== p) return Promise.resolve({
+                    done: !1,
+                    value: p
+                });
+                if (this[Dt]) return e();
+                let f, g, h = (i)=>{
+                    this.off("data", a), this.off("end", l), this.off(oe, u), e(), g(i);
+                }, a = (i)=>{
+                    this.off("error", h), this.off("end", l), this.off(oe, u), this.pause(), f({
+                        value: i,
+                        done: !!this[Dt]
+                    });
+                }, l = ()=>{
+                    this.off("error", h), this.off("data", a), this.off(oe, u), e(), f({
+                        done: !0,
+                        value: void 0
+                    });
+                }, u = ()=>h(new Error("stream destroyed"));
+                return new Promise((i, p)=>{
+                    g = p, f = i, this.once(oe, u), this.once("error", h), this.once("end", l), this.once("data", a);
+                });
+            },
+            throw: e,
+            return: e,
+            [Symbol.asyncIterator] () {
+                return this;
+            },
+            [Symbol.asyncDispose]: async ()=>{}
+        };
+    }
+    [Symbol.iterator]() {
+        this[_e] = !1;
+        let i = !1, e = ()=>(this.pause(), this.off(ae, e), this.off(oe, e), this.off("end", e), i = !0, {
+                done: !0,
+                value: void 0
+            }), s = ()=>{
+            if (i) return e();
+            let p = this.read();
+            return null === p ? e() : {
+                done: !1,
+                value: p
+            };
+        };
+        return this.once("end", e), this.once(ae, e), this.once(oe, e), {
+            next: s,
+            throw: e,
+            return: e,
+            [Symbol.iterator] () {
+                return this;
+            },
+            [Symbol.dispose]: ()=>{}
+        };
+    }
+    destroy(i) {
+        if (this[oe]) return i ? this.emit("error", i) : this.emit(oe), this;
+        this[oe] = !0, this[_e] = !0, this[te].length = 0, this[se] = 0;
+        let p = this;
+        return "function" != typeof p.close || this[It] || p.close(), i ? this.emit("error", i) : this.emit(oe), this;
+    }
+    static get isStream() {
+        return oi;
+    }
+};
+var Pe = v.realpathSync.native, We = {
+    lstatSync: v.lstatSync,
+    readdir: v.readdir,
+    readdirSync: v.readdirSync,
+    readlinkSync: v.readlinkSync,
+    realpathSync: Pe,
+    promises: {
+        lstat: k.lstat,
+        readdir: k.readdir,
+        readlink: k.readlink,
+        realpath: k.realpath
+    }
+}, Ue = (i)=>i && i !== We && i !== E ? {
+        ...We,
+        ...i,
+        promises: {
+            ...We.promises,
+            ...i.promises || {}
+        }
+    } : We, je = /^\\\\\?\\([a-z]:)\\?$/i, Ri = (i)=>i.replace(/\//g, "\\").replace(je, "$1\\"), Le = /[\\\/]/, ze = 0, Ne = 1, Be = 2, $e = 4, Ie = 6, Ge = 8, qe = 10, He = 12, Ze = 15, Ke = ~Ze, Ve = 16, Ye = 32, Xe = 64, si = 128, ri = 256, ni = 512, gi = Xe | si | ni, mi = 1023, ie = (i)=>i.isFile() ? Ge : i.isDirectory() ? $e : i.isSymbolicLink() ? qe : i.isCharacterDevice() ? Be : i.isBlockDevice() ? Ie : i.isSocket() ? He : i.isFIFO() ? Ne : ze, wi = new Wt({
+    max: 4096
+}), bt = (i)=>{
+    let p = wi.get(i);
+    if (p) return p;
+    let f = i.normalize("NFKD");
+    return wi.set(i, f), f;
+}, yi = new Wt({
+    max: 4096
+}), _t = (i)=>{
+    let p = yi.get(i);
+    if (p) return p;
+    let f = bt(i.toLowerCase());
+    return yi.set(i, f), f;
+}, bi = class extends Wt {
+    constructor(){
+        super({
+            max: 256
+        });
+    }
+}, vi = class extends Wt {
+    constructor(i = 16384){
+        super({
+            maxSize: i,
+            sizeCalculation: (i)=>i.length + 1
+        });
+    }
+}, Si = Symbol("PathScurry setAsCwd"), Ei = class {
+    name;
+    root;
+    roots;
+    parent;
+    nocase;
+    isCWD = !1;
+    #t;
+    #e;
+    get dev() {
+        return this.#e;
+    }
+    #i;
+    get mode() {
+        return this.#i;
+    }
+    #s;
+    get nlink() {
+        return this.#s;
+    }
+    #r;
+    get uid() {
+        return this.#r;
+    }
+    #h;
+    get gid() {
+        return this.#h;
+    }
+    #n;
+    get rdev() {
+        return this.#n;
+    }
+    #o;
+    get blksize() {
+        return this.#o;
+    }
+    #a;
+    get ino() {
+        return this.#a;
+    }
+    #l;
+    get size() {
+        return this.#l;
+    }
+    #c;
+    get blocks() {
+        return this.#c;
+    }
+    #u;
+    get atimeMs() {
+        return this.#u;
+    }
+    #p;
+    get mtimeMs() {
+        return this.#p;
+    }
+    #d;
+    get ctimeMs() {
+        return this.#d;
+    }
+    #f;
+    get birthtimeMs() {
+        return this.#f;
+    }
+    #g;
+    get atime() {
+        return this.#g;
+    }
+    #m;
+    get mtime() {
+        return this.#m;
+    }
+    #w;
+    get ctime() {
+        return this.#w;
+    }
+    #y;
+    get birthtime() {
+        return this.#y;
+    }
+    #b;
+    #v;
+    #S;
+    #E;
+    #k;
+    #x;
+    #_;
+    #C;
+    #W;
+    #L;
+    get parentPath() {
+        return (this.parent || this).fullpath();
+    }
+    get path() {
+        return this.parentPath;
+    }
+    constructor(i, p = ze, f, g, y, b, v){
+        this.name = i, this.#b = y ? _t(i) : bt(i), this.#_ = p & mi, this.nocase = y, this.roots = g, this.root = f || this, this.#C = b, this.#S = v.fullpath, this.#k = v.relative, this.#x = v.relativePosix, this.parent = v.parent, this.parent ? this.#t = this.parent.#t : this.#t = Ue(v.fs);
+    }
+    depth() {
+        return void 0 !== this.#v ? this.#v : this.parent ? this.#v = this.parent.depth() + 1 : this.#v = 0;
+    }
+    childrenCache() {
+        return this.#C;
+    }
+    resolve(i) {
+        if (!i) return this;
+        let p = this.getRootString(i), f = i.substring(p.length).split(this.splitSep);
+        return p ? this.getRoot(p).#z(f) : this.#z(f);
+    }
+    #z(i) {
+        let p = this;
+        for (let f of i)p = p.child(f);
+        return p;
+    }
+    children() {
+        let i = this.#C.get(this);
+        if (i) return i;
+        let p = Object.assign([], {
+            provisional: 0
+        });
+        return this.#C.set(this, p), this.#_ &= ~Ve, p;
+    }
+    child(i, p) {
+        if ("" === i || "." === i) return this;
+        if (".." === i) return this.parent || this;
+        let f = this.children(), g = this.nocase ? _t(i) : bt(i);
+        for (let i of f)if (i.#b === g) return i;
+        let y = this.parent ? this.sep : "", b = this.#S ? this.#S + y + i : void 0, v = this.newChild(i, ze, {
+            ...p,
+            parent: this,
+            fullpath: b
+        });
+        return this.canReaddir() || (v.#_ |= si), f.push(v), v;
+    }
+    relative() {
+        if (this.isCWD) return "";
+        if (void 0 !== this.#k) return this.#k;
+        let i = this.name, p = this.parent;
+        if (!p) return this.#k = this.name;
+        let f = p.relative();
+        return f + (f && p.parent ? this.sep : "") + i;
+    }
+    relativePosix() {
+        if ("/" === this.sep) return this.relative();
+        if (this.isCWD) return "";
+        if (void 0 !== this.#x) return this.#x;
+        let i = this.name, p = this.parent;
+        if (!p) return this.#x = this.fullpathPosix();
+        let f = p.relativePosix();
+        return f + (f && p.parent ? "/" : "") + i;
+    }
+    fullpath() {
+        if (void 0 !== this.#S) return this.#S;
+        let i = this.name, p = this.parent;
+        if (!p) return this.#S = this.name;
+        let f = p.fullpath() + (p.parent ? this.sep : "") + i;
+        return this.#S = f;
+    }
+    fullpathPosix() {
+        if (void 0 !== this.#E) return this.#E;
+        if ("/" === this.sep) return this.#E = this.fullpath();
+        if (!this.parent) {
+            let i = this.fullpath().replace(/\\/g, "/");
+            return /^[a-z]:\//i.test(i) ? this.#E = `//?/${i}` : this.#E = i;
+        }
+        let i = this.parent, p = i.fullpathPosix(), f = p + (p && i.parent ? "/" : "") + this.name;
+        return this.#E = f;
+    }
+    isUnknown() {
+        return (this.#_ & Ze) === ze;
+    }
+    isType(i) {
+        return this[`is${i}`]();
+    }
+    getType() {
+        return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+    }
+    isFile() {
+        return (this.#_ & Ze) === Ge;
+    }
+    isDirectory() {
+        return (this.#_ & Ze) === $e;
+    }
+    isCharacterDevice() {
+        return (this.#_ & Ze) === Be;
+    }
+    isBlockDevice() {
+        return (this.#_ & Ze) === Ie;
+    }
+    isFIFO() {
+        return (this.#_ & Ze) === Ne;
+    }
+    isSocket() {
+        return (this.#_ & Ze) === He;
+    }
+    isSymbolicLink() {
+        return (this.#_ & qe) === qe;
+    }
+    lstatCached() {
+        return this.#_ & Ye ? this : void 0;
+    }
+    readlinkCached() {
+        return this.#W;
+    }
+    realpathCached() {
+        return this.#L;
+    }
+    readdirCached() {
+        let i = this.children();
+        return i.slice(0, i.provisional);
+    }
+    canReadlink() {
+        if (this.#W) return !0;
+        if (!this.parent) return !1;
+        let i = this.#_ & Ze;
+        return !(i !== ze && i !== qe || this.#_ & ri || this.#_ & si);
+    }
+    calledReaddir() {
+        return !!(this.#_ & Ve);
+    }
+    isENOENT() {
+        return !!(this.#_ & si);
+    }
+    isNamed(i) {
+        return this.nocase ? this.#b === _t(i) : this.#b === bt(i);
+    }
+    async readlink() {
+        let i = this.#W;
+        if (i) return i;
+        if (this.canReadlink() && this.parent) try {
+            let i = await this.#t.promises.readlink(this.fullpath()), p = (await this.parent.realpath())?.resolve(i);
+            if (p) return this.#W = p;
+        } catch (i) {
+            this.#F(i.code);
+            return;
+        }
+    }
+    readlinkSync() {
+        let i = this.#W;
+        if (i) return i;
+        if (this.canReadlink() && this.parent) try {
+            let i = this.#t.readlinkSync(this.fullpath()), p = this.parent.realpathSync()?.resolve(i);
+            if (p) return this.#W = p;
+        } catch (i) {
+            this.#F(i.code);
+            return;
+        }
+    }
+    #j(i) {
+        this.#_ |= Ve;
+        for(let p = i.provisional; p < i.length; p++){
+            let f = i[p];
+            f && f.#M();
+        }
+    }
+    #M() {
+        this.#_ & si || (this.#_ = (this.#_ | si) & Ke, this.#P());
+    }
+    #P() {
+        let i = this.children();
+        i.provisional = 0;
+        for (let p of i)p.#M();
+    }
+    #N() {
+        this.#_ |= ni, this.#$();
+    }
+    #$() {
+        if (this.#_ & Xe) return;
+        let i = this.#_;
+        (i & Ze) === $e && (i &= Ke), this.#_ = i | Xe, this.#P();
+    }
+    #B(i = "") {
+        "ENOTDIR" === i || "EPERM" === i ? this.#$() : "ENOENT" === i ? this.#M() : this.children().provisional = 0;
+    }
+    #R(i = "") {
+        "ENOTDIR" === i ? this.parent.#$() : "ENOENT" === i && this.#M();
+    }
+    #F(i = "") {
+        let p = this.#_;
+        p |= ri, "ENOENT" === i && (p |= si), ("EINVAL" === i || "UNKNOWN" === i) && (p &= Ke), this.#_ = p, "ENOTDIR" === i && this.parent && this.parent.#$();
+    }
+    #I(i, p) {
+        return this.#A(i, p) || this.#U(i, p);
+    }
+    #U(i, p) {
+        let f = ie(i), g = this.newChild(i.name, f, {
+            parent: this
+        }), y = g.#_ & Ze;
+        return y !== $e && y !== qe && y !== ze && (g.#_ |= Xe), p.unshift(g), p.provisional++, g;
+    }
+    #A(i, p) {
+        for(let f = p.provisional; f < p.length; f++){
+            let g = p[f];
+            if ((this.nocase ? _t(i.name) : bt(i.name)) === g.#b) return this.#O(i, g, f, p);
+        }
+    }
+    #O(i, p, f, g) {
+        let y = p.name;
+        return p.#_ = p.#_ & Ke | ie(i), y !== i.name && (p.name = i.name), f !== g.provisional && (f === g.length - 1 ? g.pop() : g.splice(f, 1), g.unshift(p)), g.provisional++, p;
+    }
+    async lstat() {
+        if ((this.#_ & si) === 0) try {
+            return this.#G(await this.#t.promises.lstat(this.fullpath())), this;
+        } catch (i) {
+            this.#R(i.code);
+        }
+    }
+    lstatSync() {
+        if ((this.#_ & si) === 0) try {
+            return this.#G(this.#t.lstatSync(this.fullpath())), this;
+        } catch (i) {
+            this.#R(i.code);
+        }
+    }
+    #G(i) {
+        let { atime: p, atimeMs: f, birthtime: g, birthtimeMs: y, blksize: b, blocks: v, ctime: S, ctimeMs: E, dev: k, gid: x, ino: _, mode: C, mtime: A, mtimeMs: T, nlink: R, rdev: F, size: M, uid: P } = i;
+        this.#g = p, this.#u = f, this.#y = g, this.#f = y, this.#o = b, this.#c = v, this.#w = S, this.#d = E, this.#e = k, this.#h = x, this.#a = _, this.#i = C, this.#m = A, this.#p = T, this.#s = R, this.#n = F, this.#l = M, this.#r = P;
+        let j = ie(i);
+        this.#_ = this.#_ & Ke | j | Ye, j !== ze && j !== $e && j !== qe && (this.#_ |= Xe);
+    }
+    #T = [];
+    #D = !1;
+    #q(i) {
+        this.#D = !1;
+        let p = this.#T.slice();
+        this.#T.length = 0, p.forEach((p)=>p(null, i));
+    }
+    readdirCB(i, p = !1) {
+        if (!this.canReaddir()) return void (p ? i(null, []) : queueMicrotask(()=>i(null, [])));
+        let f = this.children();
+        if (this.calledReaddir()) {
+            let g = f.slice(0, f.provisional);
+            p ? i(null, g) : queueMicrotask(()=>i(null, g));
+            return;
+        }
+        if (this.#T.push(i), this.#D) return;
+        this.#D = !0;
+        let g = this.fullpath();
+        this.#t.readdir(g, {
+            withFileTypes: !0
+        }, (i, p)=>{
+            if (i) this.#B(i.code), f.provisional = 0;
+            else {
+                for (let i of p)this.#I(i, f);
+                this.#j(f);
+            }
+            this.#q(f.slice(0, f.provisional));
+        });
+    }
+    #H;
+    async readdir() {
+        if (!this.canReaddir()) return [];
+        let i = this.children();
+        if (this.calledReaddir()) return i.slice(0, i.provisional);
+        let p = this.fullpath();
+        if (this.#H) await this.#H;
+        else {
+            let s = ()=>{};
+            this.#H = new Promise((i)=>s = i);
+            try {
+                for (let f of (await this.#t.promises.readdir(p, {
+                    withFileTypes: !0
+                })))this.#I(f, i);
+                this.#j(i);
+            } catch (p) {
+                this.#B(p.code), i.provisional = 0;
+            }
+            this.#H = void 0, s();
+        }
+        return i.slice(0, i.provisional);
+    }
+    readdirSync() {
+        if (!this.canReaddir()) return [];
+        let i = this.children();
+        if (this.calledReaddir()) return i.slice(0, i.provisional);
+        let p = this.fullpath();
+        try {
+            for (let f of this.#t.readdirSync(p, {
+                withFileTypes: !0
+            }))this.#I(f, i);
+            this.#j(i);
+        } catch (p) {
+            this.#B(p.code), i.provisional = 0;
+        }
+        return i.slice(0, i.provisional);
+    }
+    canReaddir() {
+        if (this.#_ & gi) return !1;
+        let i = Ze & this.#_;
+        return i === ze || i === $e || i === qe;
+    }
+    shouldWalk(i, p) {
+        return (this.#_ & $e) === $e && !(this.#_ & gi) && !i.has(this) && (!p || p(this));
+    }
+    async realpath() {
+        if (this.#L) return this.#L;
+        if (!((ni | ri | si) & this.#_)) try {
+            let i = await this.#t.promises.realpath(this.fullpath());
+            return this.#L = this.resolve(i);
+        } catch  {
+            this.#N();
+        }
+    }
+    realpathSync() {
+        if (this.#L) return this.#L;
+        if (!((ni | ri | si) & this.#_)) try {
+            let i = this.#t.realpathSync(this.fullpath());
+            return this.#L = this.resolve(i);
+        } catch  {
+            this.#N();
+        }
+    }
+    [Si](i) {
+        if (i === this) return;
+        i.isCWD = !1, this.isCWD = !0;
+        let p = new Set([]), f = [], g = this;
+        for(; g && g.parent;)p.add(g), g.#k = f.join(this.sep), g.#x = f.join("/"), g = g.parent, f.push("..");
+        for(g = i; g && g.parent && !p.has(g);)g.#k = void 0, g.#x = void 0, g = g.parent;
+    }
+}, ki = class n extends Ei {
+    sep = "\\";
+    splitSep = Le;
+    constructor(i, p = ze, f, g, y, b, v){
+        super(i, p, f, g, y, b, v);
+    }
+    newChild(i, p = ze, f = {}) {
+        return new n(i, p, this.root, this.roots, this.nocase, this.childrenCache(), f);
+    }
+    getRootString(i) {
+        return b.win32.parse(i).root;
+    }
+    getRoot(i) {
+        if (i = Ri(i.toUpperCase()), i === this.root.name) return this.root;
+        for (let [p, f] of Object.entries(this.roots))if (this.sameRoot(i, p)) return this.roots[i] = f;
+        return this.roots[i] = new Ci(i, this).root;
+    }
+    sameRoot(i, p = this.root.name) {
+        return i = i.toUpperCase().replace(/\//g, "\\").replace(je, "$1\\"), i === p;
+    }
+}, xi = class n extends Ei {
+    splitSep = "/";
+    sep = "/";
+    constructor(i, p = ze, f, g, y, b, v){
+        super(i, p, f, g, y, b, v);
+    }
+    getRootString(i) {
+        return i.startsWith("/") ? "/" : "";
+    }
+    getRoot(i) {
+        return this.root;
+    }
+    newChild(i, p = ze, f = {}) {
+        return new n(i, p, this.root, this.roots, this.nocase, this.childrenCache(), f);
+    }
+}, _i = class {
+    root;
+    rootPath;
+    roots;
+    cwd;
+    #t;
+    #e;
+    #i;
+    nocase;
+    #s;
+    constructor(i = process.cwd(), p, f, { nocase: g, childrenCacheSize: b = 16384, fs: v = We } = {}){
+        this.#s = Ue(v), (i instanceof URL || i.startsWith("file://")) && (i = (0, y.fileURLToPath)(i));
+        let S = p.resolve(i);
+        this.roots = Object.create(null), this.rootPath = this.parseRootPath(S), this.#t = new bi, this.#e = new bi, this.#i = new vi(b);
+        let E = S.substring(this.rootPath.length).split(f);
+        if (1 !== E.length || E[0] || E.pop(), void 0 === g) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+        this.nocase = g, this.root = this.newRoot(this.#s), this.roots[this.rootPath] = this.root;
+        let k = this.root, x = E.length - 1, _ = p.sep, C = this.rootPath, A = !1;
+        for (let i of E){
+            let p = x--;
+            k = k.child(i, {
+                relative: new Array(p).fill("..").join(_),
+                relativePosix: new Array(p).fill("..").join("/"),
+                fullpath: C += (A ? "" : _) + i
+            }), A = !0;
+        }
+        this.cwd = k;
+    }
+    depth(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.depth();
+    }
+    childrenCache() {
+        return this.#i;
+    }
+    resolve(...i) {
+        let p = "";
+        for(let f = i.length - 1; f >= 0; f--){
+            let g = i[f];
+            if (!(!g || "." === g) && (p = p ? `${g}/${p}` : g, this.isAbsolute(g))) break;
+        }
+        let f = this.#t.get(p);
+        if (void 0 !== f) return f;
+        let g = this.cwd.resolve(p).fullpath();
+        return this.#t.set(p, g), g;
+    }
+    resolvePosix(...i) {
+        let p = "";
+        for(let f = i.length - 1; f >= 0; f--){
+            let g = i[f];
+            if (!(!g || "." === g) && (p = p ? `${g}/${p}` : g, this.isAbsolute(g))) break;
+        }
+        let f = this.#e.get(p);
+        if (void 0 !== f) return f;
+        let g = this.cwd.resolve(p).fullpathPosix();
+        return this.#e.set(p, g), g;
+    }
+    relative(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.relative();
+    }
+    relativePosix(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.relativePosix();
+    }
+    basename(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.name;
+    }
+    dirname(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), (i.parent || i).fullpath();
+    }
+    async readdir(i = this.cwd, p = {
+        withFileTypes: !0
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f } = p;
+        if (!i.canReaddir()) return [];
+        else {
+            let p = await i.readdir();
+            return f ? p : p.map((i)=>i.name);
+        }
+    }
+    readdirSync(i = this.cwd, p = {
+        withFileTypes: !0
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0 } = p;
+        return i.canReaddir() ? f ? i.readdirSync() : i.readdirSync().map((i)=>i.name) : [];
+    }
+    async lstat(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.lstat();
+    }
+    lstatSync(i = this.cwd) {
+        return "string" == typeof i && (i = this.cwd.resolve(i)), i.lstatSync();
+    }
+    async readlink(i = this.cwd, { withFileTypes: p } = {
+        withFileTypes: !1
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i.withFileTypes, i = this.cwd);
+        let f = await i.readlink();
+        return p ? f : f?.fullpath();
+    }
+    readlinkSync(i = this.cwd, { withFileTypes: p } = {
+        withFileTypes: !1
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i.withFileTypes, i = this.cwd);
+        let f = i.readlinkSync();
+        return p ? f : f?.fullpath();
+    }
+    async realpath(i = this.cwd, { withFileTypes: p } = {
+        withFileTypes: !1
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i.withFileTypes, i = this.cwd);
+        let f = await i.realpath();
+        return p ? f : f?.fullpath();
+    }
+    realpathSync(i = this.cwd, { withFileTypes: p } = {
+        withFileTypes: !1
+    }) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i.withFileTypes, i = this.cwd);
+        let f = i.realpathSync();
+        return p ? f : f?.fullpath();
+    }
+    async walk(i = this.cwd, p = {}) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0, follow: g = !1, filter: y, walkFilter: b } = p, v = [];
+        (!y || y(i)) && v.push(f ? i : i.fullpath());
+        let S = new Set, l = (i, p)=>{
+            S.add(i), i.readdirCB((i, E)=>{
+                if (i) return p(i);
+                let k = E.length;
+                if (!k) return p();
+                let w = ()=>{
+                    0 === --k && p();
+                };
+                for (let i of E)(!y || y(i)) && v.push(f ? i : i.fullpath()), g && i.isSymbolicLink() ? i.realpath().then((i)=>i?.isUnknown() ? i.lstat() : i).then((i)=>i?.shouldWalk(S, b) ? l(i, w) : w()) : i.shouldWalk(S, b) ? l(i, w) : w();
+            }, !0);
+        }, E = i;
+        return new Promise((i, p)=>{
+            l(E, (f)=>{
+                if (f) return p(f);
+                i(v);
+            });
+        });
+    }
+    walkSync(i = this.cwd, p = {}) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0, follow: g = !1, filter: y, walkFilter: b } = p, v = [];
+        (!y || y(i)) && v.push(f ? i : i.fullpath());
+        let S = new Set([
+            i
+        ]);
+        for (let i of S){
+            let p = i.readdirSync();
+            for (let i of p){
+                (!y || y(i)) && v.push(f ? i : i.fullpath());
+                let p = i;
+                if (i.isSymbolicLink()) {
+                    if (!(g && (p = i.realpathSync()))) continue;
+                    p.isUnknown() && p.lstatSync();
+                }
+                p.shouldWalk(S, b) && S.add(p);
+            }
+        }
+        return v;
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+    iterate(i = this.cwd, p = {}) {
+        return "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd), this.stream(i, p)[Symbol.asyncIterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    *iterateSync(i = this.cwd, p = {}) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0, follow: g = !1, filter: y, walkFilter: b } = p;
+        (!y || y(i)) && (yield f ? i : i.fullpath());
+        let v = new Set([
+            i
+        ]);
+        for (let i of v){
+            let p = i.readdirSync();
+            for (let i of p){
+                (!y || y(i)) && (yield f ? i : i.fullpath());
+                let p = i;
+                if (i.isSymbolicLink()) {
+                    if (!(g && (p = i.realpathSync()))) continue;
+                    p.isUnknown() && p.lstatSync();
+                }
+                p.shouldWalk(v, b) && v.add(p);
+            }
+        }
+    }
+    stream(i = this.cwd, p = {}) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0, follow: g = !1, filter: y, walkFilter: b } = p, v = new Re({
+            objectMode: !0
+        });
+        (!y || y(i)) && v.write(f ? i : i.fullpath());
+        let S = new Set, E = [
+            i
+        ], k = 0, c = ()=>{
+            let i = !1;
+            for(; !i;){
+                let p = E.shift();
+                if (!p) {
+                    0 === k && v.end();
+                    return;
+                }
+                k++, S.add(p);
+                let m = (p, _, C = !1)=>{
+                    if (p) return v.emit("error", p);
+                    if (g && !C) {
+                        let i = [];
+                        for (let p of _)p.isSymbolicLink() && i.push(p.realpath().then((i)=>i?.isUnknown() ? i.lstat() : i));
+                        if (i.length) return void Promise.all(i).then(()=>m(null, _, !0));
+                    }
+                    for (let p of _)p && (!y || y(p)) && (v.write(f ? p : p.fullpath()) || (i = !0));
+                    k--;
+                    for (let i of _){
+                        let p = i.realpathCached() || i;
+                        p.shouldWalk(S, b) && E.push(p);
+                    }
+                    i && !v.flowing ? v.once("drain", c) : x || c();
+                }, x = !0;
+                p.readdirCB(m, !0), x = !1;
+            }
+        };
+        return c(), v;
+    }
+    streamSync(i = this.cwd, p = {}) {
+        "string" == typeof i ? i = this.cwd.resolve(i) : i instanceof Ei || (p = i, i = this.cwd);
+        let { withFileTypes: f = !0, follow: g = !1, filter: y, walkFilter: b } = p, v = new Re({
+            objectMode: !0
+        }), S = new Set;
+        (!y || y(i)) && v.write(f ? i : i.fullpath());
+        let E = [
+            i
+        ], k = 0, c = ()=>{
+            let i = !1;
+            for(; !i;){
+                let p = E.shift();
+                if (!p) {
+                    0 === k && v.end();
+                    return;
+                }
+                k++, S.add(p);
+                let x = p.readdirSync();
+                for (let p of x)(!y || y(p)) && (v.write(f ? p : p.fullpath()) || (i = !0));
+                k--;
+                for (let i of x){
+                    let p = i;
+                    if (i.isSymbolicLink()) {
+                        if (!(g && (p = i.realpathSync()))) continue;
+                        p.isUnknown() && p.lstatSync();
+                    }
+                    p.shouldWalk(S, b) && E.push(p);
+                }
+            }
+            i && !v.flowing && v.once("drain", c);
+        };
+        return c(), v;
+    }
+    chdir(i = this.cwd) {
+        let p = this.cwd;
+        this.cwd = "string" == typeof i ? this.cwd.resolve(i) : i, this.cwd[Si](p);
+    }
+}, Ci = class extends _i {
+    sep = "\\";
+    constructor(i = process.cwd(), p = {}){
+        let { nocase: f = !0 } = p;
+        super(i, b.win32, "\\", {
+            ...p,
+            nocase: f
+        }), this.nocase = f;
+        for(let i = this.cwd; i; i = i.parent)i.nocase = this.nocase;
+    }
+    parseRootPath(i) {
+        return b.win32.parse(i).root.toUpperCase();
+    }
+    newRoot(i) {
+        return new ki(this.rootPath, $e, void 0, this.roots, this.nocase, this.childrenCache(), {
+            fs: i
+        });
+    }
+    isAbsolute(i) {
+        return i.startsWith("/") || i.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(i);
+    }
+}, Oi = class extends _i {
+    sep = "/";
+    constructor(i = process.cwd(), p = {}){
+        let { nocase: f = !1 } = p;
+        super(i, b.posix, "/", {
+            ...p,
+            nocase: f
+        }), this.nocase = f;
+    }
+    parseRootPath(i) {
+        return "/";
+    }
+    newRoot(i) {
+        return new xi(this.rootPath, $e, void 0, this.roots, this.nocase, this.childrenCache(), {
+            fs: i
+        });
+    }
+    isAbsolute(i) {
+        return i.startsWith("/");
+    }
+}, Ai = class extends Oi {
+    constructor(i = process.cwd(), p = {}){
+        let { nocase: f = !0 } = p;
+        super(i, {
+            ...p,
+            nocase: f
+        });
+    }
+}, Fi = (process.platform, "win32" === process.platform ? Ci : "darwin" === process.platform ? Ai : Oi);
+var Di = (i)=>i.length >= 1, Mi = (i)=>i.length >= 1, Pi = Symbol.for("nodejs.util.inspect.custom"), Wi = class n {
+    #t;
+    #e;
+    #i;
+    length;
+    #s;
+    #r;
+    #h;
+    #n;
+    #o;
+    #a;
+    #l = !0;
+    constructor(i, p, f, g){
+        if (!Di(i)) throw new TypeError("empty pattern list");
+        if (!Mi(p)) throw new TypeError("empty glob list");
+        if (p.length !== i.length) throw new TypeError("mismatched pattern list and glob list lengths");
+        if (this.length = i.length, f < 0 || f >= this.length) throw new TypeError("index out of range");
+        if (this.#t = i, this.#e = p, this.#i = f, this.#s = g, 0 === this.#i) {
+            if (this.isUNC()) {
+                let [i, p, f, g, ...y] = this.#t, [b, v, S, E, ...k] = this.#e;
+                "" === y[0] && (y.shift(), k.shift());
+                let x = [
+                    i,
+                    p,
+                    f,
+                    g,
+                    ""
+                ].join("/"), _ = [
+                    b,
+                    v,
+                    S,
+                    E,
+                    ""
+                ].join("/");
+                this.#t = [
+                    x,
+                    ...y
+                ], this.#e = [
+                    _,
+                    ...k
+                ], this.length = this.#t.length;
+            } else if (this.isDrive() || this.isAbsolute()) {
+                let [i, ...p] = this.#t, [f, ...g] = this.#e;
+                "" === p[0] && (p.shift(), g.shift());
+                let y = i + "/", b = f + "/";
+                this.#t = [
+                    y,
+                    ...p
+                ], this.#e = [
+                    b,
+                    ...g
+                ], this.length = this.#t.length;
+            }
+        }
+    }
+    [Pi]() {
+        return "Pattern <" + this.#e.slice(this.#i).join("/") + ">";
+    }
+    pattern() {
+        return this.#t[this.#i];
+    }
+    isString() {
+        return "string" == typeof this.#t[this.#i];
+    }
+    isGlobstar() {
+        return this.#t[this.#i] === yt;
+    }
+    isRegExp() {
+        return this.#t[this.#i] instanceof RegExp;
+    }
+    globString() {
+        return this.#h = this.#h || (0 === this.#i ? this.isAbsolute() ? this.#e[0] + this.#e.slice(1).join("/") : this.#e.join("/") : this.#e.slice(this.#i).join("/"));
+    }
+    hasMore() {
+        return this.length > this.#i + 1;
+    }
+    rest() {
+        return void 0 !== this.#r ? this.#r : this.hasMore() ? (this.#r = new n(this.#t, this.#e, this.#i + 1, this.#s), this.#r.#a = this.#a, this.#r.#o = this.#o, this.#r.#n = this.#n, this.#r) : this.#r = null;
+    }
+    isUNC() {
+        let i = this.#t;
+        return void 0 !== this.#o ? this.#o : this.#o = "win32" === this.#s && 0 === this.#i && "" === i[0] && "" === i[1] && "string" == typeof i[2] && !!i[2] && "string" == typeof i[3] && !!i[3];
+    }
+    isDrive() {
+        let i = this.#t;
+        return void 0 !== this.#n ? this.#n : this.#n = "win32" === this.#s && 0 === this.#i && this.length > 1 && "string" == typeof i[0] && /^[a-z]:$/i.test(i[0]);
+    }
+    isAbsolute() {
+        let i = this.#t;
+        return void 0 !== this.#a ? this.#a : this.#a = "" === i[0] && i.length > 1 || this.isDrive() || this.isUNC();
+    }
+    root() {
+        let i = this.#t[0];
+        return "string" == typeof i && this.isAbsolute() && 0 === this.#i ? i : "";
+    }
+    checkFollowGlobstar() {
+        return !(0 === this.#i || !this.isGlobstar() || !this.#l);
+    }
+    markFollowGlobstar() {
+        return 0 !== this.#i && this.isGlobstar() && this.#l ? (this.#l = !1, !0) : !1;
+    }
+};
+var ji = "object" == typeof process && process && "string" == typeof process.platform ? process.platform : "linux", zi = class {
+    relative;
+    relativeChildren;
+    absolute;
+    absoluteChildren;
+    platform;
+    mmopts;
+    constructor(i, { nobrace: p, nocase: f, noext: g, noglobstar: y, platform: b = ji }){
+        this.relative = [], this.absolute = [], this.relativeChildren = [], this.absoluteChildren = [], this.platform = b, this.mmopts = {
+            dot: !0,
+            nobrace: p,
+            nocase: f,
+            noext: g,
+            noglobstar: y,
+            optimizationLevel: 2,
+            platform: b,
+            nocomment: !0,
+            nonegate: !0
+        };
+        for (let p of i)this.add(p);
+    }
+    add(i) {
+        let p = new Ct(i, this.mmopts);
+        for(let i = 0; i < p.set.length; i++){
+            let f = p.set[i], g = p.globParts[i];
+            if (!f || !g) throw new Error("invalid pattern object");
+            for(; "." === f[0] && "." === g[0];)f.shift(), g.shift();
+            let y = new Wi(f, g, 0, this.platform), b = new Ct(y.globString(), this.mmopts), v = "**" === g[g.length - 1], S = y.isAbsolute();
+            S ? this.absolute.push(b) : this.relative.push(b), v && (S ? this.absoluteChildren.push(b) : this.relativeChildren.push(b));
+        }
+    }
+    ignored(i) {
+        let p = i.fullpath(), f = `${p}/`, g = i.relative() || ".", y = `${g}/`;
+        for (let i of this.relative)if (i.match(g) || i.match(y)) return !0;
+        for (let i of this.absolute)if (i.match(p) || i.match(f)) return !0;
+        return !1;
+    }
+    childrenIgnored(i) {
+        let p = i.fullpath() + "/", f = (i.relative() || ".") + "/";
+        for (let i of this.relativeChildren)if (i.match(f)) return !0;
+        for (let i of this.absoluteChildren)if (i.match(p)) return !0;
+        return !1;
+    }
+};
+var Ni = class n {
+    store;
+    constructor(i = new Map){
+        this.store = i;
+    }
+    copy() {
+        return new n(new Map(this.store));
+    }
+    hasWalked(i, p) {
+        return this.store.get(i.fullpath())?.has(p.globString());
+    }
+    storeWalked(i, p) {
+        let f = i.fullpath(), g = this.store.get(f);
+        g ? g.add(p.globString()) : this.store.set(f, new Set([
+            p.globString()
+        ]));
+    }
+}, Bi = class {
+    store = new Map;
+    add(i, p, f) {
+        let g = (p ? 2 : 0) | (f ? 1 : 0), y = this.store.get(i);
+        this.store.set(i, void 0 === y ? g : g & y);
+    }
+    entries() {
+        return [
+            ...this.store.entries()
+        ].map(([i, p])=>[
+                i,
+                !!(2 & p),
+                !!(1 & p)
+            ]);
+    }
+}, $i = class {
+    store = new Map;
+    add(i, p) {
+        if (!i.canReaddir()) return;
+        let f = this.store.get(i);
+        f ? f.find((i)=>i.globString() === p.globString()) || f.push(p) : this.store.set(i, [
+            p
+        ]);
+    }
+    get(i) {
+        let p = this.store.get(i);
+        if (!p) throw new Error("attempting to walk unknown path");
+        return p;
+    }
+    entries() {
+        return this.keys().map((i)=>[
+                i,
+                this.store.get(i)
+            ]);
+    }
+    keys() {
+        return [
+            ...this.store.keys()
+        ].filter((i)=>i.canReaddir());
+    }
+}, Ui = class n {
+    hasWalkedCache;
+    matches = new Bi;
+    subwalks = new $i;
+    patterns;
+    follow;
+    dot;
+    opts;
+    constructor(i, p){
+        this.opts = i, this.follow = !!i.follow, this.dot = !!i.dot, this.hasWalkedCache = p ? p.copy() : new Ni;
+    }
+    processPatterns(i, p) {
+        this.patterns = p;
+        let f = p.map((p)=>[
+                i,
+                p
+            ]);
+        for (let [i, p] of f){
+            this.hasWalkedCache.storeWalked(i, p);
+            let f = p.root(), g = p.isAbsolute() && !1 !== this.opts.absolute;
+            if (f) {
+                i = i.resolve("/" === f && void 0 !== this.opts.root ? this.opts.root : f);
+                let g = p.rest();
+                if (g) p = g;
+                else {
+                    this.matches.add(i, !0, !1);
+                    continue;
+                }
+            }
+            if (i.isENOENT()) continue;
+            let y, b, v = !1;
+            for(; "string" == typeof (y = p.pattern()) && (b = p.rest());)i = i.resolve(y), p = b, v = !0;
+            if (y = p.pattern(), b = p.rest(), v) {
+                if (this.hasWalkedCache.hasWalked(i, p)) continue;
+                this.hasWalkedCache.storeWalked(i, p);
+            }
+            if ("string" == typeof y) {
+                let p = ".." === y || "" === y || "." === y;
+                this.matches.add(i.resolve(y), g, p);
+                continue;
+            } else if (y === yt) {
+                (!i.isSymbolicLink() || this.follow || p.checkFollowGlobstar()) && this.subwalks.add(i, p);
+                let f = b?.pattern(), y = b?.rest();
+                if (b && ("" !== f && "." !== f || y)) {
+                    if (".." === f) {
+                        let p = i.parent || i;
+                        y ? this.hasWalkedCache.hasWalked(p, y) || this.subwalks.add(p, y) : this.matches.add(p, g, !0);
+                    }
+                } else this.matches.add(i, g, "" === f || "." === f);
+            } else y instanceof RegExp && this.subwalks.add(i, p);
+        }
+        return this;
+    }
+    subwalkTargets() {
+        return this.subwalks.keys();
+    }
+    child() {
+        return new n(this.opts, this.hasWalkedCache);
+    }
+    filterEntries(i, p) {
+        let f = this.subwalks.get(i), g = this.child();
+        for (let i of p)for (let p of f){
+            let f = p.isAbsolute(), y = p.pattern(), b = p.rest();
+            y === yt ? g.testGlobstar(i, p, b, f) : y instanceof RegExp ? g.testRegExp(i, y, b, f) : g.testString(i, y, b, f);
+        }
+        return g;
+    }
+    testGlobstar(i, p, f, g) {
+        if ((this.dot || !i.name.startsWith(".")) && (p.hasMore() || this.matches.add(i, g, !1), i.canReaddir() && (this.follow || !i.isSymbolicLink() ? this.subwalks.add(i, p) : i.isSymbolicLink() && (f && p.checkFollowGlobstar() ? this.subwalks.add(i, f) : p.markFollowGlobstar() && this.subwalks.add(i, p)))), f) {
+            let p = f.pattern();
+            if ("string" == typeof p && ".." !== p && "" !== p && "." !== p) this.testString(i, p, f.rest(), g);
+            else if (".." === p) {
+                let p = i.parent || i;
+                this.subwalks.add(p, f);
+            } else p instanceof RegExp && this.testRegExp(i, p, f.rest(), g);
+        }
+    }
+    testRegExp(i, p, f, g) {
+        p.test(i.name) && (f ? this.subwalks.add(i, f) : this.matches.add(i, g, !1));
+    }
+    testString(i, p, f, g) {
+        i.isNamed(p) && (f ? this.subwalks.add(i, f) : this.matches.add(i, g, !1));
+    }
+};
+var Li = (i, p)=>"string" == typeof i ? new zi([
+        i
+    ], p) : Array.isArray(i) ? new zi(i, p) : i, Ii = class {
+    path;
+    patterns;
+    opts;
+    seen = new Set;
+    paused = !1;
+    aborted = !1;
+    #t = [];
+    #e;
+    #i;
+    signal;
+    maxDepth;
+    includeChildMatches;
+    constructor(i, p, f){
+        if (this.patterns = i, this.path = p, this.opts = f, this.#i = f.posix || "win32" !== f.platform ? "/" : "\\", this.includeChildMatches = !1 !== f.includeChildMatches, (f.ignore || !this.includeChildMatches) && (this.#e = Li(f.ignore ?? [], f), !this.includeChildMatches && "function" != typeof this.#e.add)) {
+            let i = "cannot ignore child matches, ignore lacks add() method.";
+            throw new Error(i);
+        }
+        this.maxDepth = f.maxDepth || 1 / 0, f.signal && (this.signal = f.signal, this.signal.addEventListener("abort", ()=>{
+            this.#t.length = 0;
+        }));
+    }
+    #s(i) {
+        return this.seen.has(i) || !!this.#e?.ignored?.(i);
+    }
+    #r(i) {
+        return !!this.#e?.childrenIgnored?.(i);
+    }
+    pause() {
+        this.paused = !0;
+    }
+    resume() {
+        if (this.signal?.aborted) return;
+        this.paused = !1;
+        let i;
+        for(; !this.paused && (i = this.#t.shift());)i();
+    }
+    onResume(i) {
+        this.signal?.aborted || (this.paused ? this.#t.push(i) : i());
+    }
+    async matchCheck(i, p) {
+        if (p && this.opts.nodir) return;
+        let f;
+        if (this.opts.realpath) {
+            if (f = i.realpathCached() || await i.realpath(), !f) return;
+            i = f;
+        }
+        let g = i.isUnknown() || this.opts.stat ? await i.lstat() : i;
+        if (this.opts.follow && this.opts.nodir && g?.isSymbolicLink()) {
+            let i = await g.realpath();
+            i && (i.isUnknown() || this.opts.stat) && await i.lstat();
+        }
+        return this.matchCheckTest(g, p);
+    }
+    matchCheckTest(i, p) {
+        return i && (1 / 0 === this.maxDepth || i.depth() <= this.maxDepth) && (!p || i.canReaddir()) && (!this.opts.nodir || !i.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !i.isSymbolicLink() || !i.realpathCached()?.isDirectory()) && !this.#s(i) ? i : void 0;
+    }
+    matchCheckSync(i, p) {
+        if (p && this.opts.nodir) return;
+        let f;
+        if (this.opts.realpath) {
+            if (f = i.realpathCached() || i.realpathSync(), !f) return;
+            i = f;
+        }
+        let g = i.isUnknown() || this.opts.stat ? i.lstatSync() : i;
+        if (this.opts.follow && this.opts.nodir && g?.isSymbolicLink()) {
+            let i = g.realpathSync();
+            i && (i?.isUnknown() || this.opts.stat) && i.lstatSync();
+        }
+        return this.matchCheckTest(g, p);
+    }
+    matchFinish(i, p) {
+        if (this.#s(i)) return;
+        if (!this.includeChildMatches && this.#e?.add) {
+            let p = `${i.relativePosix()}/**`;
+            this.#e.add(p);
+        }
+        let f = void 0 === this.opts.absolute ? p : this.opts.absolute;
+        this.seen.add(i);
+        let g = this.opts.mark && i.isDirectory() ? this.#i : "";
+        if (this.opts.withFileTypes) this.matchEmit(i);
+        else if (f) {
+            let p = this.opts.posix ? i.fullpathPosix() : i.fullpath();
+            this.matchEmit(p + g);
+        } else {
+            let p = this.opts.posix ? i.relativePosix() : i.relative(), f = this.opts.dotRelative && !p.startsWith(".." + this.#i) ? "." + this.#i : "";
+            this.matchEmit(p ? f + p + g : "." + g);
+        }
+    }
+    async match(i, p, f) {
+        let g = await this.matchCheck(i, f);
+        g && this.matchFinish(g, p);
+    }
+    matchSync(i, p, f) {
+        let g = this.matchCheckSync(i, f);
+        g && this.matchFinish(g, p);
+    }
+    walkCB(i, p, f) {
+        this.signal?.aborted && f(), this.walkCB2(i, p, new Ui(this.opts), f);
+    }
+    walkCB2(i, p, f, g) {
+        if (this.#r(i)) return g();
+        if (this.signal?.aborted && g(), this.paused) return void this.onResume(()=>this.walkCB2(i, p, f, g));
+        f.processPatterns(i, p);
+        let y = 1, o = ()=>{
+            0 === --y && g();
+        };
+        for (let [i, p, g] of f.matches.entries())this.#s(i) || (y++, this.match(i, p, g).then(()=>o()));
+        for (let i of f.subwalkTargets()){
+            if (1 / 0 !== this.maxDepth && i.depth() >= this.maxDepth) continue;
+            y++;
+            let p = i.readdirCached();
+            i.calledReaddir() ? this.walkCB3(i, p, f, o) : i.readdirCB((p, g)=>this.walkCB3(i, g, f, o), !0);
+        }
+        o();
+    }
+    walkCB3(i, p, f, g) {
+        f = f.filterEntries(i, p);
+        let y = 1, o = ()=>{
+            0 === --y && g();
+        };
+        for (let [i, p, g] of f.matches.entries())this.#s(i) || (y++, this.match(i, p, g).then(()=>o()));
+        for (let [i, p] of f.subwalks.entries())y++, this.walkCB2(i, p, f.child(), o);
+        o();
+    }
+    walkCBSync(i, p, f) {
+        this.signal?.aborted && f(), this.walkCB2Sync(i, p, new Ui(this.opts), f);
+    }
+    walkCB2Sync(i, p, f, g) {
+        if (this.#r(i)) return g();
+        if (this.signal?.aborted && g(), this.paused) return void this.onResume(()=>this.walkCB2Sync(i, p, f, g));
+        f.processPatterns(i, p);
+        let y = 1, o = ()=>{
+            0 === --y && g();
+        };
+        for (let [i, p, g] of f.matches.entries())this.#s(i) || this.matchSync(i, p, g);
+        for (let i of f.subwalkTargets()){
+            if (1 / 0 !== this.maxDepth && i.depth() >= this.maxDepth) continue;
+            y++;
+            let p = i.readdirSync();
+            this.walkCB3Sync(i, p, f, o);
+        }
+        o();
+    }
+    walkCB3Sync(i, p, f, g) {
+        f = f.filterEntries(i, p);
+        let y = 1, o = ()=>{
+            0 === --y && g();
+        };
+        for (let [i, p, g] of f.matches.entries())this.#s(i) || this.matchSync(i, p, g);
+        for (let [i, p] of f.subwalks.entries())y++, this.walkCB2Sync(i, p, f.child(), o);
+        o();
+    }
+}, Gi = class extends Ii {
+    matches = new Set;
+    constructor(i, p, f){
+        super(i, p, f);
+    }
+    matchEmit(i) {
+        this.matches.add(i);
+    }
+    async walk() {
+        if (this.signal?.aborted) throw this.signal.reason;
+        return this.path.isUnknown() && await this.path.lstat(), await new Promise((i, p)=>{
+            this.walkCB(this.path, this.patterns, ()=>{
+                this.signal?.aborted ? p(this.signal.reason) : i(this.matches);
+            });
+        }), this.matches;
+    }
+    walkSync() {
+        if (this.signal?.aborted) throw this.signal.reason;
+        return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, ()=>{
+            if (this.signal?.aborted) throw this.signal.reason;
+        }), this.matches;
+    }
+}, qi = class extends Ii {
+    results;
+    constructor(i, p, f){
+        super(i, p, f), this.results = new Re({
+            signal: this.signal,
+            objectMode: !0
+        }), this.results.on("drain", ()=>this.resume()), this.results.on("resume", ()=>this.resume());
+    }
+    matchEmit(i) {
+        this.results.write(i), this.results.flowing || this.pause();
+    }
+    stream() {
+        let i = this.path;
+        return i.isUnknown() ? i.lstat().then(()=>{
+            this.walkCB(i, this.patterns, ()=>this.results.end());
+        }) : this.walkCB(i, this.patterns, ()=>this.results.end()), this.results;
+    }
+    streamSync() {
+        return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, ()=>this.results.end()), this.results;
+    }
+};
+var Hi = "object" == typeof process && process && "string" == typeof process.platform ? process.platform : "linux", Zi = class {
+    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(i, p){
+        if (!p) throw new TypeError("glob options required");
+        if (this.withFileTypes = !!p.withFileTypes, this.signal = p.signal, this.follow = !!p.follow, this.dot = !!p.dot, this.dotRelative = !!p.dotRelative, this.nodir = !!p.nodir, this.mark = !!p.mark, p.cwd ? (p.cwd instanceof URL || p.cwd.startsWith("file://")) && (p.cwd = (0, y.fileURLToPath)(p.cwd)) : this.cwd = "", this.cwd = p.cwd || "", this.root = p.root, this.magicalBraces = !!p.magicalBraces, this.nobrace = !!p.nobrace, this.noext = !!p.noext, this.realpath = !!p.realpath, this.absolute = p.absolute, this.includeChildMatches = !1 !== p.includeChildMatches, this.noglobstar = !!p.noglobstar, this.matchBase = !!p.matchBase, this.maxDepth = "number" == typeof p.maxDepth ? p.maxDepth : 1 / 0, this.stat = !!p.stat, this.ignore = p.ignore, this.withFileTypes && void 0 !== this.absolute) throw new Error("cannot set absolute and withFileTypes:true");
+        if ("string" == typeof i && (i = [
+            i
+        ]), this.windowsPathsNoEscape = !!p.windowsPathsNoEscape || !1 === p.allowWindowsEscape, this.windowsPathsNoEscape && (i = i.map((i)=>i.replace(/\\/g, "/"))), this.matchBase) {
+            if (p.noglobstar) throw new TypeError("base matching requires globstar");
+            i = i.map((i)=>i.includes("/") ? i : `./**/${i}`);
+        }
+        if (this.pattern = i, this.platform = p.platform || Hi, this.opts = {
+            ...p,
+            platform: this.platform
+        }, p.scurry) {
+            if (this.scurry = p.scurry, void 0 !== p.nocase && p.nocase !== p.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+        } else {
+            let i = "win32" === p.platform ? Ci : "darwin" === p.platform ? Ai : p.platform ? Oi : Fi;
+            this.scurry = new i(this.cwd, {
+                nocase: p.nocase,
+                fs: p.fs
+            });
+        }
+        this.nocase = this.scurry.nocase;
+        let f = "darwin" === this.platform || "win32" === this.platform, g = {
+            braceExpandMax: 1e4,
+            ...p,
+            dot: this.dot,
+            matchBase: this.matchBase,
+            nobrace: this.nobrace,
+            nocase: this.nocase,
+            nocaseMagicOnly: f,
+            nocomment: !0,
+            noext: this.noext,
+            nonegate: !0,
+            optimizationLevel: 2,
+            platform: this.platform,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            debug: !!this.opts.debug
+        }, b = this.pattern.map((i)=>new Ct(i, g)), [v, S] = b.reduce((i, p)=>(i[0].push(...p.set), i[1].push(...p.globParts), i), [
+            [],
+            []
+        ]);
+        this.patterns = v.map((i, p)=>{
+            let f = S[p];
+            if (!f) throw new Error("invalid pattern object");
+            return new Wi(i, f, 0, this.platform);
+        });
+    }
+    async walk() {
+        return [
+            ...await new Gi(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: 1 / 0 !== this.maxDepth ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches
+            }).walk()
+        ];
+    }
+    walkSync() {
+        return [
+            ...new Gi(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: 1 / 0 !== this.maxDepth ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches
+            }).walkSync()
+        ];
+    }
+    stream() {
+        return new qi(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: 1 / 0 !== this.maxDepth ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches
+        }).stream();
+    }
+    streamSync() {
+        return new qi(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: 1 / 0 !== this.maxDepth ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0,
+            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();
+    }
+};
+var le = (i, p = {})=>{
+    Array.isArray(i) || (i = [
+        i
+    ]);
+    for (let f of i)if (new Ct(f, p).hasMagic()) return !0;
+    return !1;
+};
+function Bt(i, p = {}) {
+    return new Zi(i, p).streamSync();
+}
+function Qe(i, p = {}) {
+    return new Zi(i, p).stream();
+}
+function ts(i, p = {}) {
+    return new Zi(i, p).walkSync();
+}
+async function Je(i, p = {}) {
+    return new Zi(i, p).walk();
+}
+function Ut(i, p = {}) {
+    return new Zi(i, p).iterateSync();
+}
+function es(i, p = {}) {
+    return new Zi(i, p).iterate();
+}
+var Ji = Bt, Qi = Object.assign(Qe, {
+    sync: Bt
+}), Ki = Ut, Vi = Object.assign(es, {
+    sync: Ut
+}), Yi = Object.assign(ts, {
+    stream: Bt,
+    iterate: Ut
+}), Xi = Object.assign(Je, {
+    glob: Je,
+    globSync: ts,
+    sync: Yi,
+    globStream: Qe,
+    stream: Qi,
+    globStreamSync: Bt,
+    streamSync: Ji,
+    globIterate: es,
+    iterate: Vi,
+    globIterateSync: Ut,
+    iterateSync: Ki,
+    Glob: Zi,
+    hasMagic: le,
+    escape: tt,
+    unescape: W
+});
+Xi.glob = Xi;
+var is = g.fo;
+var rs = g.Nt;
+var hs = g.ih;
+var ns = g.TI;
+var os = g.nk;
+var as = g.ue;
+var ls = g.lj;
+var cs = g.CK;
+var us = g.AZ;
+var fs = g.qt;
+var ds = g.nl;
+var vs = g.qD;
+var Ss = g.Td;
+var xs = g.Qo;
+var Cs = g.OH;
+var As = g.x4;
+export { is as Glob, rs as Ignore, hs as escape, ns as glob, os as globIterate, as as globIterateSync, ls as globStream, cs as globStreamSync, us as globSync, fs as hasMagic, ds as iterate, vs as iterateSync, Ss as stream, xs as streamSync, Cs as sync, As as unescape };