gennady 0.6.0 → 0.7.0

package/dist/chunks/index-zBnnuvLA.js

@@ -0,0 +1,3788 @@
+import yt from "node:fs";
+import St from "node:path";
+import { d as Hn, g as Dn, l as xe, p as In, V as Nn, e as qn } from "./services-CaLOhuLV.js";
+import Kt from "os";
+import Se from "path";
+import Pn from "util";
+import dt from "stream";
+import Fn from "events";
+import Qt from "fs";
+import { p as Bn, s as ne } from "./shared-Bjy30TeM.js";
+var se = {}, ie = {}, Oe = {}, nr;
+function jn() {
+  if (nr) return Oe;
+  nr = 1, Object.defineProperty(Oe, "__esModule", { value: !0 }), Oe.splitWhen = Oe.flatten = void 0;
+  function o(l) {
+    return l.reduce((u, r) => [].concat(u, r), []);
+  }
+  Oe.flatten = o;
+  function a(l, u) {
+    const r = [[]];
+    let t = 0;
+    for (const n of l)
+      u(n) ? (t++, r[t] = []) : r[t].push(n);
+    return r;
+  }
+  return Oe.splitWhen = a, Oe;
+}
+var ke = {}, sr;
+function Gn() {
+  if (sr) return ke;
+  sr = 1, Object.defineProperty(ke, "__esModule", { value: !0 }), ke.isEnoentCodeError = void 0;
+  function o(a) {
+    return a.code === "ENOENT";
+  }
+  return ke.isEnoentCodeError = o, ke;
+}
+var Me = {}, ir;
+function Un() {
+  if (ir) return Me;
+  ir = 1, Object.defineProperty(Me, "__esModule", { value: !0 }), Me.createDirentFromStats = void 0;
+  class o {
+    constructor(u, r) {
+      this.name = u, this.isBlockDevice = r.isBlockDevice.bind(r), this.isCharacterDevice = r.isCharacterDevice.bind(r), this.isDirectory = r.isDirectory.bind(r), this.isFIFO = r.isFIFO.bind(r), this.isFile = r.isFile.bind(r), this.isSocket = r.isSocket.bind(r), this.isSymbolicLink = r.isSymbolicLink.bind(r);
+    }
+  }
+  function a(l, u) {
+    return new o(l, u);
+  }
+  return Me.createDirentFromStats = a, Me;
+}
+var ee = {}, ar;
+function Wn() {
+  if (ar) return ee;
+  ar = 1, Object.defineProperty(ee, "__esModule", { value: !0 }), ee.convertPosixPathToPattern = ee.convertWindowsPathToPattern = ee.convertPathToPattern = ee.escapePosixPath = ee.escapeWindowsPath = ee.escape = ee.removeLeadingDotSegment = ee.makeAbsolute = ee.unixify = void 0;
+  const o = Kt, a = Se, l = o.platform() === "win32", u = 2, r = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g, t = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g, n = /^\\\\([.?])/, e = /\\(?![!()+@[\]{}])/g;
+  function i(C) {
+    return C.replace(/\\/g, "/");
+  }
+  ee.unixify = i;
+  function s(C, m) {
+    return a.resolve(C, m);
+  }
+  ee.makeAbsolute = s;
+  function p(C) {
+    if (C.charAt(0) === ".") {
+      const m = C.charAt(1);
+      if (m === "/" || m === "\\")
+        return C.slice(u);
+    }
+    return C;
+  }
+  ee.removeLeadingDotSegment = p, ee.escape = l ? h : d;
+  function h(C) {
+    return C.replace(t, "\\$2");
+  }
+  ee.escapeWindowsPath = h;
+  function d(C) {
+    return C.replace(r, "\\$2");
+  }
+  ee.escapePosixPath = d, ee.convertPathToPattern = l ? y : T;
+  function y(C) {
+    return h(C).replace(n, "//$1").replace(e, "/");
+  }
+  ee.convertWindowsPathToPattern = y;
+  function T(C) {
+    return d(C);
+  }
+  return ee.convertPosixPathToPattern = T, ee;
+}
+var I = {};
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+var mt, or;
+function Vn() {
+  return or || (or = 1, mt = function(a) {
+    if (typeof a != "string" || a === "")
+      return !1;
+    for (var l; l = /(\\).|([@?!+*]\(.*\))/g.exec(a); ) {
+      if (l[2]) return !0;
+      a = a.slice(l.index + l[0].length);
+    }
+    return !1;
+  }), mt;
+}
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+var vt, ur;
+function Kn() {
+  if (ur) return vt;
+  ur = 1;
+  var o = Vn(), a = { "{": "}", "(": ")", "[": "]" }, l = function(r) {
+    if (r[0] === "!")
+      return !0;
+    for (var t = 0, n = -2, e = -2, i = -2, s = -2, p = -2; t < r.length; ) {
+      if (r[t] === "*" || r[t + 1] === "?" && /[\].+)]/.test(r[t]) || e !== -1 && r[t] === "[" && r[t + 1] !== "]" && (e < t && (e = r.indexOf("]", t)), e > t && (p === -1 || p > e || (p = r.indexOf("\\", t), p === -1 || p > e))) || i !== -1 && r[t] === "{" && r[t + 1] !== "}" && (i = r.indexOf("}", t), i > t && (p = r.indexOf("\\", t), p === -1 || p > i)) || s !== -1 && r[t] === "(" && r[t + 1] === "?" && /[:!=]/.test(r[t + 2]) && r[t + 3] !== ")" && (s = r.indexOf(")", t), s > t && (p = r.indexOf("\\", t), p === -1 || p > s)) || n !== -1 && r[t] === "(" && r[t + 1] !== "|" && (n < t && (n = r.indexOf("|", t)), n !== -1 && r[n + 1] !== ")" && (s = r.indexOf(")", n), s > n && (p = r.indexOf("\\", n), p === -1 || p > s))))
+        return !0;
+      if (r[t] === "\\") {
+        var h = r[t + 1];
+        t += 2;
+        var d = a[h];
+        if (d) {
+          var y = r.indexOf(d, t);
+          y !== -1 && (t = y + 1);
+        }
+        if (r[t] === "!")
+          return !0;
+      } else
+        t++;
+    }
+    return !1;
+  }, u = function(r) {
+    if (r[0] === "!")
+      return !0;
+    for (var t = 0; t < r.length; ) {
+      if (/[*?{}()[\]]/.test(r[t]))
+        return !0;
+      if (r[t] === "\\") {
+        var n = r[t + 1];
+        t += 2;
+        var e = a[n];
+        if (e) {
+          var i = r.indexOf(e, t);
+          i !== -1 && (t = i + 1);
+        }
+        if (r[t] === "!")
+          return !0;
+      } else
+        t++;
+    }
+    return !1;
+  };
+  return vt = function(t, n) {
+    if (typeof t != "string" || t === "")
+      return !1;
+    if (o(t))
+      return !0;
+    var e = l;
+    return n && n.strict === !1 && (e = u), e(t);
+  }, vt;
+}
+var Rt, cr;
+function Qn() {
+  if (cr) return Rt;
+  cr = 1;
+  var o = Kn(), a = Se.posix.dirname, l = Kt.platform() === "win32", u = "/", r = /\\/g, t = /[\{\[].*[\}\]]$/, n = /(^|[^\\])([\{\[]|\([^\)]+$)/, e = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+  return Rt = function(s, p) {
+    var h = Object.assign({ flipBackslashes: !0 }, p);
+    h.flipBackslashes && l && s.indexOf(u) < 0 && (s = s.replace(r, u)), t.test(s) && (s += u), s += "a";
+    do
+      s = a(s);
+    while (o(s) || n.test(s));
+    return s.replace(e, "$1");
+  }, Rt;
+}
+var Et = {}, lr;
+function Xt() {
+  return lr || (lr = 1, (function(o) {
+    o.isInteger = (a) => typeof a == "number" ? Number.isInteger(a) : typeof a == "string" && a.trim() !== "" ? Number.isInteger(Number(a)) : !1, o.find = (a, l) => a.nodes.find((u) => u.type === l), o.exceedsLimit = (a, l, u = 1, r) => r === !1 || !o.isInteger(a) || !o.isInteger(l) ? !1 : (Number(l) - Number(a)) / Number(u) >= r, o.escapeNode = (a, l = 0, u) => {
+      const r = a.nodes[l];
+      r && (u && r.type === u || r.type === "open" || r.type === "close") && r.escaped !== !0 && (r.value = "\\" + r.value, r.escaped = !0);
+    }, o.encloseBrace = (a) => a.type !== "brace" ? !1 : a.commas >> 0 + a.ranges >> 0 === 0 ? (a.invalid = !0, !0) : !1, o.isInvalidBrace = (a) => a.type !== "brace" ? !1 : a.invalid === !0 || a.dollar ? !0 : a.commas >> 0 + a.ranges >> 0 === 0 || a.open !== !0 || a.close !== !0 ? (a.invalid = !0, !0) : !1, o.isOpenOrClose = (a) => a.type === "open" || a.type === "close" ? !0 : a.open === !0 || a.close === !0, o.reduce = (a) => a.reduce((l, u) => (u.type === "text" && l.push(u.value), u.type === "range" && (u.type = "text"), l), []), o.flatten = (...a) => {
+      const l = [], u = (r) => {
+        for (let t = 0; t < r.length; t++) {
+          const n = r[t];
+          if (Array.isArray(n)) {
+            u(n);
+            continue;
+          }
+          n !== void 0 && l.push(n);
+        }
+        return l;
+      };
+      return u(a), l;
+    };
+  })(Et)), Et;
+}
+var At, fr;
+function Yt() {
+  if (fr) return At;
+  fr = 1;
+  const o = Xt();
+  return At = (a, l = {}) => {
+    const u = (r, t = {}) => {
+      const n = l.escapeInvalid && o.isInvalidBrace(t), e = r.invalid === !0 && l.escapeInvalid === !0;
+      let i = "";
+      if (r.value)
+        return (n || e) && o.isOpenOrClose(r) ? "\\" + r.value : r.value;
+      if (r.value)
+        return r.value;
+      if (r.nodes)
+        for (const s of r.nodes)
+          i += u(s);
+      return i;
+    };
+    return u(a);
+  }, At;
+}
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+var bt, hr;
+function Xn() {
+  return hr || (hr = 1, bt = function(o) {
+    return typeof o == "number" ? o - o === 0 : typeof o == "string" && o.trim() !== "" ? Number.isFinite ? Number.isFinite(+o) : isFinite(+o) : !1;
+  }), bt;
+}
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+var Pt, pr;
+function Yn() {
+  if (pr) return Pt;
+  pr = 1;
+  const o = Xn(), a = (m, S, _) => {
+    if (o(m) === !1)
+      throw new TypeError("toRegexRange: expected the first argument to be a number");
+    if (S === void 0 || m === S)
+      return String(m);
+    if (o(S) === !1)
+      throw new TypeError("toRegexRange: expected the second argument to be a number.");
+    let c = { relaxZeros: !0, ..._ };
+    typeof c.strictZeros == "boolean" && (c.relaxZeros = c.strictZeros === !1);
+    let f = String(c.relaxZeros), g = String(c.shorthand), R = String(c.capture), v = String(c.wrap), P = m + ":" + S + "=" + f + g + R + v;
+    if (a.cache.hasOwnProperty(P))
+      return a.cache[P].result;
+    let O = Math.min(m, S), D = Math.max(m, S);
+    if (Math.abs(O - D) === 1) {
+      let N = m + "|" + S;
+      return c.capture ? `(${N})` : c.wrap === !1 ? N : `(?:${N})`;
+    }
+    let k = T(m) || T(S), M = { min: m, max: S, a: O, b: D }, x = [], U = [];
+    if (k && (M.isPadded = k, M.maxLen = String(M.max).length), O < 0) {
+      let N = D < 0 ? Math.abs(D) : 1;
+      U = t(N, Math.abs(O), M, c), O = M.a = 0;
+    }
+    return D >= 0 && (x = t(O, D, M, c)), M.negatives = U, M.positives = x, M.result = l(U, x), c.capture === !0 ? M.result = `(${M.result})` : c.wrap !== !1 && x.length + U.length > 1 && (M.result = `(?:${M.result})`), a.cache[P] = M, M.result;
+  };
+  function l(m, S, _) {
+    let c = n(m, S, "-", !1) || [], f = n(S, m, "", !1) || [], g = n(m, S, "-?", !0) || [];
+    return c.concat(g).concat(f).join("|");
+  }
+  function u(m, S) {
+    let _ = 1, c = 1, f = p(m, _), g = /* @__PURE__ */ new Set([S]);
+    for (; m <= f && f <= S; )
+      g.add(f), _ += 1, f = p(m, _);
+    for (f = h(S + 1, c) - 1; m < f && f <= S; )
+      g.add(f), c += 1, f = h(S + 1, c) - 1;
+    return g = [...g], g.sort(i), g;
+  }
+  function r(m, S, _) {
+    if (m === S)
+      return { pattern: m, count: [], digits: 0 };
+    let c = e(m, S), f = c.length, g = "", R = 0;
+    for (let v = 0; v < f; v++) {
+      let [P, O] = c[v];
+      P === O ? g += P : P !== "0" || O !== "9" ? g += y(P, O) : R++;
+    }
+    return R && (g += _.shorthand === !0 ? "\\d" : "[0-9]"), { pattern: g, count: [R], digits: f };
+  }
+  function t(m, S, _, c) {
+    let f = u(m, S), g = [], R = m, v;
+    for (let P = 0; P < f.length; P++) {
+      let O = f[P], D = r(String(R), String(O), c), k = "";
+      if (!_.isPadded && v && v.pattern === D.pattern) {
+        v.count.length > 1 && v.count.pop(), v.count.push(D.count[0]), v.string = v.pattern + d(v.count), R = O + 1;
+        continue;
+      }
+      _.isPadded && (k = C(O, _, c)), D.string = k + D.pattern + d(D.count), g.push(D), R = O + 1, v = D;
+    }
+    return g;
+  }
+  function n(m, S, _, c, f) {
+    let g = [];
+    for (let R of m) {
+      let { string: v } = R;
+      !c && !s(S, "string", v) && g.push(_ + v), c && s(S, "string", v) && g.push(_ + v);
+    }
+    return g;
+  }
+  function e(m, S) {
+    let _ = [];
+    for (let c = 0; c < m.length; c++) _.push([m[c], S[c]]);
+    return _;
+  }
+  function i(m, S) {
+    return m > S ? 1 : S > m ? -1 : 0;
+  }
+  function s(m, S, _) {
+    return m.some((c) => c[S] === _);
+  }
+  function p(m, S) {
+    return Number(String(m).slice(0, -S) + "9".repeat(S));
+  }
+  function h(m, S) {
+    return m - m % Math.pow(10, S);
+  }
+  function d(m) {
+    let [S = 0, _ = ""] = m;
+    return _ || S > 1 ? `{${S + (_ ? "," + _ : "")}}` : "";
+  }
+  function y(m, S, _) {
+    return `[${m}${S - m === 1 ? "" : "-"}${S}]`;
+  }
+  function T(m) {
+    return /^-?(0+)\d/.test(m);
+  }
+  function C(m, S, _) {
+    if (!S.isPadded)
+      return m;
+    let c = Math.abs(S.maxLen - String(m).length), f = _.relaxZeros !== !1;
+    switch (c) {
+      case 0:
+        return "";
+      case 1:
+        return f ? "0?" : "0";
+      case 2:
+        return f ? "0{0,2}" : "00";
+      default:
+        return f ? `0{0,${c}}` : `0{${c}}`;
+    }
+  }
+  return a.cache = {}, a.clearCache = () => a.cache = {}, Pt = a, Pt;
+}
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+var xt, dr;
+function xn() {
+  if (dr) return xt;
+  dr = 1;
+  const o = Pn, a = Yn(), l = (c) => c !== null && typeof c == "object" && !Array.isArray(c), u = (c) => (f) => c === !0 ? Number(f) : String(f), r = (c) => typeof c == "number" || typeof c == "string" && c !== "", t = (c) => Number.isInteger(+c), n = (c) => {
+    let f = `${c}`, g = -1;
+    if (f[0] === "-" && (f = f.slice(1)), f === "0") return !1;
+    for (; f[++g] === "0"; ) ;
+    return g > 0;
+  }, e = (c, f, g) => typeof c == "string" || typeof f == "string" ? !0 : g.stringify === !0, i = (c, f, g) => {
+    if (f > 0) {
+      let R = c[0] === "-" ? "-" : "";
+      R && (c = c.slice(1)), c = R + c.padStart(R ? f - 1 : f, "0");
+    }
+    return g === !1 ? String(c) : c;
+  }, s = (c, f) => {
+    let g = c[0] === "-" ? "-" : "";
+    for (g && (c = c.slice(1), f--); c.length < f; ) c = "0" + c;
+    return g ? "-" + c : c;
+  }, p = (c, f, g) => {
+    c.negatives.sort((D, k) => D < k ? -1 : D > k ? 1 : 0), c.positives.sort((D, k) => D < k ? -1 : D > k ? 1 : 0);
+    let R = f.capture ? "" : "?:", v = "", P = "", O;
+    return c.positives.length && (v = c.positives.map((D) => s(String(D), g)).join("|")), c.negatives.length && (P = `-(${R}${c.negatives.map((D) => s(String(D), g)).join("|")})`), v && P ? O = `${v}|${P}` : O = v || P, f.wrap ? `(${R}${O})` : O;
+  }, h = (c, f, g, R) => {
+    if (g)
+      return a(c, f, { wrap: !1, ...R });
+    let v = String.fromCharCode(c);
+    if (c === f) return v;
+    let P = String.fromCharCode(f);
+    return `[${v}-${P}]`;
+  }, d = (c, f, g) => {
+    if (Array.isArray(c)) {
+      let R = g.wrap === !0, v = g.capture ? "" : "?:";
+      return R ? `(${v}${c.join("|")})` : c.join("|");
+    }
+    return a(c, f, g);
+  }, y = (...c) => new RangeError("Invalid range arguments: " + o.inspect(...c)), T = (c, f, g) => {
+    if (g.strictRanges === !0) throw y([c, f]);
+    return [];
+  }, C = (c, f) => {
+    if (f.strictRanges === !0)
+      throw new TypeError(`Expected step "${c}" to be a number`);
+    return [];
+  }, m = (c, f, g = 1, R = {}) => {
+    let v = Number(c), P = Number(f);
+    if (!Number.isInteger(v) || !Number.isInteger(P)) {
+      if (R.strictRanges === !0) throw y([c, f]);
+      return [];
+    }
+    v === 0 && (v = 0), P === 0 && (P = 0);
+    let O = v > P, D = String(c), k = String(f), M = String(g);
+    g = Math.max(Math.abs(g), 1);
+    let x = n(D) || n(k) || n(M), U = x ? Math.max(D.length, k.length, M.length) : 0, N = x === !1 && e(c, f, R) === !1, q = R.transform || u(N);
+    if (R.toRegex && g === 1)
+      return h(s(c, U), s(f, U), !0, R);
+    let F = { negatives: [], positives: [] }, z = (H) => F[H < 0 ? "negatives" : "positives"].push(Math.abs(H)), ce = [], $ = 0;
+    for (; O ? v >= P : v <= P; )
+      R.toRegex === !0 && g > 1 ? z(v) : ce.push(i(q(v, $), U, N)), v = O ? v - g : v + g, $++;
+    return R.toRegex === !0 ? g > 1 ? p(F, R, U) : d(ce, null, { wrap: !1, ...R }) : ce;
+  }, S = (c, f, g = 1, R = {}) => {
+    if (!t(c) && c.length > 1 || !t(f) && f.length > 1)
+      return T(c, f, R);
+    let v = R.transform || ((N) => String.fromCharCode(N)), P = `${c}`.charCodeAt(0), O = `${f}`.charCodeAt(0), D = P > O, k = Math.min(P, O), M = Math.max(P, O);
+    if (R.toRegex && g === 1)
+      return h(k, M, !1, R);
+    let x = [], U = 0;
+    for (; D ? P >= O : P <= O; )
+      x.push(v(P, U)), P = D ? P - g : P + g, U++;
+    return R.toRegex === !0 ? d(x, null, { wrap: !1, options: R }) : x;
+  }, _ = (c, f, g, R = {}) => {
+    if (f == null && r(c))
+      return [c];
+    if (!r(c) || !r(f))
+      return T(c, f, R);
+    if (typeof g == "function")
+      return _(c, f, 1, { transform: g });
+    if (l(g))
+      return _(c, f, 0, g);
+    let v = { ...R };
+    return v.capture === !0 && (v.wrap = !0), g = g || v.step || 1, t(g) ? t(c) && t(f) ? m(c, f, g, v) : S(c, f, Math.max(Math.abs(g), 1), v) : g != null && !l(g) ? C(g, v) : _(c, f, 1, g);
+  };
+  return xt = _, xt;
+}
+var Ct, _r;
+function Zn() {
+  if (_r) return Ct;
+  _r = 1;
+  const o = xn(), a = Xt();
+  return Ct = (u, r = {}) => {
+    const t = (n, e = {}) => {
+      const i = a.isInvalidBrace(e), s = n.invalid === !0 && r.escapeInvalid === !0, p = i === !0 || s === !0, h = r.escapeInvalid === !0 ? "\\" : "";
+      let d = "";
+      if (n.isOpen === !0)
+        return h + n.value;
+      if (n.isClose === !0)
+        return console.log("node.isClose", h, n.value), h + n.value;
+      if (n.type === "open")
+        return p ? h + n.value : "(";
+      if (n.type === "close")
+        return p ? h + n.value : ")";
+      if (n.type === "comma")
+        return n.prev.type === "comma" ? "" : p ? n.value : "|";
+      if (n.value)
+        return n.value;
+      if (n.nodes && n.ranges > 0) {
+        const y = a.reduce(n.nodes), T = o(...y, { ...r, wrap: !1, toRegex: !0, strictZeros: !0 });
+        if (T.length !== 0)
+          return y.length > 1 && T.length > 1 ? `(${T})` : T;
+      }
+      if (n.nodes)
+        for (const y of n.nodes)
+          d += t(y, n);
+      return d;
+    };
+    return t(u);
+  }, Ct;
+}
+var Tt, gr;
+function zn() {
+  if (gr) return Tt;
+  gr = 1;
+  const o = xn(), a = Yt(), l = Xt(), u = (t = "", n = "", e = !1) => {
+    const i = [];
+    if (t = [].concat(t), n = [].concat(n), !n.length) return t;
+    if (!t.length)
+      return e ? l.flatten(n).map((s) => `{${s}}`) : n;
+    for (const s of t)
+      if (Array.isArray(s))
+        for (const p of s)
+          i.push(u(p, n, e));
+      else
+        for (let p of n)
+          e === !0 && typeof p == "string" && (p = `{${p}}`), i.push(Array.isArray(p) ? u(s, p, e) : s + p);
+    return l.flatten(i);
+  };
+  return Tt = (t, n = {}) => {
+    const e = n.rangeLimit === void 0 ? 1e3 : n.rangeLimit, i = (s, p = {}) => {
+      s.queue = [];
+      let h = p, d = p.queue;
+      for (; h.type !== "brace" && h.type !== "root" && h.parent; )
+        h = h.parent, d = h.queue;
+      if (s.invalid || s.dollar) {
+        d.push(u(d.pop(), a(s, n)));
+        return;
+      }
+      if (s.type === "brace" && s.invalid !== !0 && s.nodes.length === 2) {
+        d.push(u(d.pop(), ["{}"]));
+        return;
+      }
+      if (s.nodes && s.ranges > 0) {
+        const m = l.reduce(s.nodes);
+        if (l.exceedsLimit(...m, n.step, e))
+          throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
+        let S = o(...m, n);
+        S.length === 0 && (S = a(s, n)), d.push(u(d.pop(), S)), s.nodes = [];
+        return;
+      }
+      const y = l.encloseBrace(s);
+      let T = s.queue, C = s;
+      for (; C.type !== "brace" && C.type !== "root" && C.parent; )
+        C = C.parent, T = C.queue;
+      for (let m = 0; m < s.nodes.length; m++) {
+        const S = s.nodes[m];
+        if (S.type === "comma" && s.type === "brace") {
+          m === 1 && T.push(""), T.push("");
+          continue;
+        }
+        if (S.type === "close") {
+          d.push(u(d.pop(), T, y));
+          continue;
+        }
+        if (S.value && S.type !== "open") {
+          T.push(u(T.pop(), S.value));
+          continue;
+        }
+        S.nodes && i(S, s);
+      }
+      return T;
+    };
+    return l.flatten(i(t));
+  }, Tt;
+}
+var Ot, yr;
+function Jn() {
+  return yr || (yr = 1, Ot = {
+    MAX_LENGTH: 1e4,
+    // Digits
+    CHAR_0: "0",
+    /* 0 */
+    CHAR_9: "9",
+    /* 9 */
+    // Alphabet chars.
+    CHAR_UPPERCASE_A: "A",
+    /* A */
+    CHAR_LOWERCASE_A: "a",
+    /* a */
+    CHAR_UPPERCASE_Z: "Z",
+    /* Z */
+    CHAR_LOWERCASE_Z: "z",
+    /* z */
+    CHAR_LEFT_PARENTHESES: "(",
+    /* ( */
+    CHAR_RIGHT_PARENTHESES: ")",
+    /* ) */
+    CHAR_ASTERISK: "*",
+    /* * */
+    // Non-alphabetic chars.
+    CHAR_AMPERSAND: "&",
+    /* & */
+    CHAR_AT: "@",
+    /* @ */
+    CHAR_BACKSLASH: "\\",
+    /* \ */
+    CHAR_BACKTICK: "`",
+    /* ` */
+    CHAR_CARRIAGE_RETURN: "\r",
+    /* \r */
+    CHAR_CIRCUMFLEX_ACCENT: "^",
+    /* ^ */
+    CHAR_COLON: ":",
+    /* : */
+    CHAR_COMMA: ",",
+    /* , */
+    CHAR_DOLLAR: "$",
+    /* . */
+    CHAR_DOT: ".",
+    /* . */
+    CHAR_DOUBLE_QUOTE: '"',
+    /* " */
+    CHAR_EQUAL: "=",
+    /* = */
+    CHAR_EXCLAMATION_MARK: "!",
+    /* ! */
+    CHAR_FORM_FEED: "\f",
+    /* \f */
+    CHAR_FORWARD_SLASH: "/",
+    /* / */
+    CHAR_HASH: "#",
+    /* # */
+    CHAR_HYPHEN_MINUS: "-",
+    /* - */
+    CHAR_LEFT_ANGLE_BRACKET: "<",
+    /* < */
+    CHAR_LEFT_CURLY_BRACE: "{",
+    /* { */
+    CHAR_LEFT_SQUARE_BRACKET: "[",
+    /* [ */
+    CHAR_LINE_FEED: `
+`,
+    /* \n */
+    CHAR_NO_BREAK_SPACE: " ",
+    /* \u00A0 */
+    CHAR_PERCENT: "%",
+    /* % */
+    CHAR_PLUS: "+",
+    /* + */
+    CHAR_QUESTION_MARK: "?",
+    /* ? */
+    CHAR_RIGHT_ANGLE_BRACKET: ">",
+    /* > */
+    CHAR_RIGHT_CURLY_BRACE: "}",
+    /* } */
+    CHAR_RIGHT_SQUARE_BRACKET: "]",
+    /* ] */
+    CHAR_SEMICOLON: ";",
+    /* ; */
+    CHAR_SINGLE_QUOTE: "'",
+    /* ' */
+    CHAR_SPACE: " ",
+    /*   */
+    CHAR_TAB: "	",
+    /* \t */
+    CHAR_UNDERSCORE: "_",
+    /* _ */
+    CHAR_VERTICAL_LINE: "|",
+    /* | */
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
+    /* \uFEFF */
+  }), Ot;
+}
+var wt, Sr;
+function es() {
+  if (Sr) return wt;
+  Sr = 1;
+  const o = Yt(), {
+    MAX_LENGTH: a,
+    CHAR_BACKSLASH: l,
+    /* \ */
+    CHAR_BACKTICK: u,
+    /* ` */
+    CHAR_COMMA: r,
+    /* , */
+    CHAR_DOT: t,
+    /* . */
+    CHAR_LEFT_PARENTHESES: n,
+    /* ( */
+    CHAR_RIGHT_PARENTHESES: e,
+    /* ) */
+    CHAR_LEFT_CURLY_BRACE: i,
+    /* { */
+    CHAR_RIGHT_CURLY_BRACE: s,
+    /* } */
+    CHAR_LEFT_SQUARE_BRACKET: p,
+    /* [ */
+    CHAR_RIGHT_SQUARE_BRACKET: h,
+    /* ] */
+    CHAR_DOUBLE_QUOTE: d,
+    /* " */
+    CHAR_SINGLE_QUOTE: y,
+    /* ' */
+    CHAR_NO_BREAK_SPACE: T,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: C
+  } = Jn();
+  return wt = (S, _ = {}) => {
+    if (typeof S != "string")
+      throw new TypeError("Expected a string");
+    const c = _ || {}, f = typeof c.maxLength == "number" ? Math.min(a, c.maxLength) : a;
+    if (S.length > f)
+      throw new SyntaxError(`Input length (${S.length}), exceeds max characters (${f})`);
+    const g = { type: "root", input: S, nodes: [] }, R = [g];
+    let v = g, P = g, O = 0;
+    const D = S.length;
+    let k = 0, M = 0, x;
+    const U = () => S[k++], N = (q) => {
+      if (q.type === "text" && P.type === "dot" && (P.type = "text"), P && P.type === "text" && q.type === "text") {
+        P.value += q.value;
+        return;
+      }
+      return v.nodes.push(q), q.parent = v, q.prev = P, P = q, q;
+    };
+    for (N({ type: "bos" }); k < D; )
+      if (v = R[R.length - 1], x = U(), !(x === C || x === T)) {
+        if (x === l) {
+          N({ type: "text", value: (_.keepEscaping ? x : "") + U() });
+          continue;
+        }
+        if (x === h) {
+          N({ type: "text", value: "\\" + x });
+          continue;
+        }
+        if (x === p) {
+          O++;
+          let q;
+          for (; k < D && (q = U()); ) {
+            if (x += q, q === p) {
+              O++;
+              continue;
+            }
+            if (q === l) {
+              x += U();
+              continue;
+            }
+            if (q === h && (O--, O === 0))
+              break;
+          }
+          N({ type: "text", value: x });
+          continue;
+        }
+        if (x === n) {
+          v = N({ type: "paren", nodes: [] }), R.push(v), N({ type: "text", value: x });
+          continue;
+        }
+        if (x === e) {
+          if (v.type !== "paren") {
+            N({ type: "text", value: x });
+            continue;
+          }
+          v = R.pop(), N({ type: "text", value: x }), v = R[R.length - 1];
+          continue;
+        }
+        if (x === d || x === y || x === u) {
+          const q = x;
+          let F;
+          for (_.keepQuotes !== !0 && (x = ""); k < D && (F = U()); ) {
+            if (F === l) {
+              x += F + U();
+              continue;
+            }
+            if (F === q) {
+              _.keepQuotes === !0 && (x += F);
+              break;
+            }
+            x += F;
+          }
+          N({ type: "text", value: x });
+          continue;
+        }
+        if (x === i) {
+          M++;
+          const F = {
+            type: "brace",
+            open: !0,
+            close: !1,
+            dollar: P.value && P.value.slice(-1) === "$" || v.dollar === !0,
+            depth: M,
+            commas: 0,
+            ranges: 0,
+            nodes: []
+          };
+          v = N(F), R.push(v), N({ type: "open", value: x });
+          continue;
+        }
+        if (x === s) {
+          if (v.type !== "brace") {
+            N({ type: "text", value: x });
+            continue;
+          }
+          const q = "close";
+          v = R.pop(), v.close = !0, N({ type: q, value: x }), M--, v = R[R.length - 1];
+          continue;
+        }
+        if (x === r && M > 0) {
+          if (v.ranges > 0) {
+            v.ranges = 0;
+            const q = v.nodes.shift();
+            v.nodes = [q, { type: "text", value: o(v) }];
+          }
+          N({ type: "comma", value: x }), v.commas++;
+          continue;
+        }
+        if (x === t && M > 0 && v.commas === 0) {
+          const q = v.nodes;
+          if (M === 0 || q.length === 0) {
+            N({ type: "text", value: x });
+            continue;
+          }
+          if (P.type === "dot") {
+            if (v.range = [], P.value += x, P.type = "range", v.nodes.length !== 3 && v.nodes.length !== 5) {
+              v.invalid = !0, v.ranges = 0, P.type = "text";
+              continue;
+            }
+            v.ranges++, v.args = [];
+            continue;
+          }
+          if (P.type === "range") {
+            q.pop();
+            const F = q[q.length - 1];
+            F.value += P.value + x, P = F, v.ranges--;
+            continue;
+          }
+          N({ type: "dot", value: x });
+          continue;
+        }
+        N({ type: "text", value: x });
+      }
+    do
+      if (v = R.pop(), v.type !== "root") {
+        v.nodes.forEach((z) => {
+          z.nodes || (z.type === "open" && (z.isOpen = !0), z.type === "close" && (z.isClose = !0), z.nodes || (z.type = "text"), z.invalid = !0);
+        });
+        const q = R[R.length - 1], F = q.nodes.indexOf(v);
+        q.nodes.splice(F, 1, ...v.nodes);
+      }
+    while (R.length > 0);
+    return N({ type: "eos" }), g;
+  }, wt;
+}
+var $t, mr;
+function ts() {
+  if (mr) return $t;
+  mr = 1;
+  const o = Yt(), a = Zn(), l = zn(), u = es(), r = (t, n = {}) => {
+    let e = [];
+    if (Array.isArray(t))
+      for (const i of t) {
+        const s = r.create(i, n);
+        Array.isArray(s) ? e.push(...s) : e.push(s);
+      }
+    else
+      e = [].concat(r.create(t, n));
+    return n && n.expand === !0 && n.nodupes === !0 && (e = [...new Set(e)]), e;
+  };
+  return r.parse = (t, n = {}) => u(t, n), r.stringify = (t, n = {}) => o(typeof t == "string" ? r.parse(t, n) : t, n), r.compile = (t, n = {}) => (typeof t == "string" && (t = r.parse(t, n)), a(t, n)), r.expand = (t, n = {}) => {
+    typeof t == "string" && (t = r.parse(t, n));
+    let e = l(t, n);
+    return n.noempty === !0 && (e = e.filter(Boolean)), n.nodupes === !0 && (e = [...new Set(e)]), e;
+  }, r.create = (t, n = {}) => t === "" || t.length < 3 ? [t] : n.expand !== !0 ? r.compile(t, n) : r.expand(t, n), $t = r, $t;
+}
+var Lt = {}, kt, vr;
+function _t() {
+  if (vr) return kt;
+  vr = 1;
+  const o = Se, a = "\\\\/", l = `[^${a}]`, u = 0, r = "\\.", t = "\\+", n = "\\?", e = "\\/", i = "(?=.)", s = "[^/]", p = `(?:${e}|$)`, h = `(?:^|${e})`, d = `${r}{1,2}${p}`, y = `(?!${r})`, T = `(?!${h}${d})`, C = `(?!${r}{0,1}${p})`, m = `(?!${d})`, S = `[^.${e}]`, _ = `${s}*?`, c = {
+    DOT_LITERAL: r,
+    PLUS_LITERAL: t,
+    QMARK_LITERAL: n,
+    SLASH_LITERAL: e,
+    ONE_CHAR: i,
+    QMARK: s,
+    END_ANCHOR: p,
+    DOTS_SLASH: d,
+    NO_DOT: y,
+    NO_DOTS: T,
+    NO_DOT_SLASH: C,
+    NO_DOTS_SLASH: m,
+    QMARK_NO_DOT: S,
+    STAR: _,
+    START_ANCHOR: h
+  }, f = {
+    ...c,
+    SLASH_LITERAL: `[${a}]`,
+    QMARK: l,
+    STAR: `${l}*?`,
+    DOTS_SLASH: `${r}{1,2}(?:[${a}]|$)`,
+    NO_DOT: `(?!${r})`,
+    NO_DOTS: `(?!(?:^|[${a}])${r}{1,2}(?:[${a}]|$))`,
+    NO_DOT_SLASH: `(?!${r}{0,1}(?:[${a}]|$))`,
+    NO_DOTS_SLASH: `(?!${r}{1,2}(?:[${a}]|$))`,
+    QMARK_NO_DOT: `[^.${a}]`,
+    START_ANCHOR: `(?:^|[${a}])`,
+    END_ANCHOR: `(?:[${a}]|$)`
+  }, g = {
+    __proto__: null,
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
+  };
+  return kt = {
+    DEFAULT_MAX_EXTGLOB_RECURSION: u,
+    MAX_LENGTH: 1024 * 64,
+    POSIX_REGEX_SOURCE: g,
+    // regular expressions
+    REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+    REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+    REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+    REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+    REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+    REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+    // Replace globs with equivalent patterns to reduce parsing time.
+    REPLACEMENTS: {
+      __proto__: null,
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    // Digits
+    CHAR_0: 48,
+    /* 0 */
+    CHAR_9: 57,
+    /* 9 */
+    // Alphabet chars.
+    CHAR_UPPERCASE_A: 65,
+    /* A */
+    CHAR_LOWERCASE_A: 97,
+    /* a */
+    CHAR_UPPERCASE_Z: 90,
+    /* Z */
+    CHAR_LOWERCASE_Z: 122,
+    /* z */
+    CHAR_LEFT_PARENTHESES: 40,
+    /* ( */
+    CHAR_RIGHT_PARENTHESES: 41,
+    /* ) */
+    CHAR_ASTERISK: 42,
+    /* * */
+    // Non-alphabetic chars.
+    CHAR_AMPERSAND: 38,
+    /* & */
+    CHAR_AT: 64,
+    /* @ */
+    CHAR_BACKWARD_SLASH: 92,
+    /* \ */
+    CHAR_CARRIAGE_RETURN: 13,
+    /* \r */
+    CHAR_CIRCUMFLEX_ACCENT: 94,
+    /* ^ */
+    CHAR_COLON: 58,
+    /* : */
+    CHAR_COMMA: 44,
+    /* , */
+    CHAR_DOT: 46,
+    /* . */
+    CHAR_DOUBLE_QUOTE: 34,
+    /* " */
+    CHAR_EQUAL: 61,
+    /* = */
+    CHAR_EXCLAMATION_MARK: 33,
+    /* ! */
+    CHAR_FORM_FEED: 12,
+    /* \f */
+    CHAR_FORWARD_SLASH: 47,
+    /* / */
+    CHAR_GRAVE_ACCENT: 96,
+    /* ` */
+    CHAR_HASH: 35,
+    /* # */
+    CHAR_HYPHEN_MINUS: 45,
+    /* - */
+    CHAR_LEFT_ANGLE_BRACKET: 60,
+    /* < */
+    CHAR_LEFT_CURLY_BRACE: 123,
+    /* { */
+    CHAR_LEFT_SQUARE_BRACKET: 91,
+    /* [ */
+    CHAR_LINE_FEED: 10,
+    /* \n */
+    CHAR_NO_BREAK_SPACE: 160,
+    /* \u00A0 */
+    CHAR_PERCENT: 37,
+    /* % */
+    CHAR_PLUS: 43,
+    /* + */
+    CHAR_QUESTION_MARK: 63,
+    /* ? */
+    CHAR_RIGHT_ANGLE_BRACKET: 62,
+    /* > */
+    CHAR_RIGHT_CURLY_BRACE: 125,
+    /* } */
+    CHAR_RIGHT_SQUARE_BRACKET: 93,
+    /* ] */
+    CHAR_SEMICOLON: 59,
+    /* ; */
+    CHAR_SINGLE_QUOTE: 39,
+    /* ' */
+    CHAR_SPACE: 32,
+    /*   */
+    CHAR_TAB: 9,
+    /* \t */
+    CHAR_UNDERSCORE: 95,
+    /* _ */
+    CHAR_VERTICAL_LINE: 124,
+    /* | */
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+    /* \uFEFF */
+    SEP: o.sep,
+    /**
+     * Create EXTGLOB_CHARS
+     */
+    extglobChars(R) {
+      return {
+        "!": { type: "negate", open: "(?:(?!(?:", close: `))${R.STAR})` },
+        "?": { type: "qmark", open: "(?:", close: ")?" },
+        "+": { type: "plus", open: "(?:", close: ")+" },
+        "*": { type: "star", open: "(?:", close: ")*" },
+        "@": { type: "at", open: "(?:", close: ")" }
+      };
+    },
+    /**
+     * Create GLOB_CHARS
+     */
+    globChars(R) {
+      return R === !0 ? f : c;
+    }
+  }, kt;
+}
+var Rr;
+function gt() {
+  return Rr || (Rr = 1, (function(o) {
+    const a = Se, l = process.platform === "win32", {
+      REGEX_BACKSLASH: u,
+      REGEX_REMOVE_BACKSLASH: r,
+      REGEX_SPECIAL_CHARS: t,
+      REGEX_SPECIAL_CHARS_GLOBAL: n
+    } = _t();
+    o.isObject = (e) => e !== null && typeof e == "object" && !Array.isArray(e), o.hasRegexChars = (e) => t.test(e), o.isRegexChar = (e) => e.length === 1 && o.hasRegexChars(e), o.escapeRegex = (e) => e.replace(n, "\\$1"), o.toPosixSlashes = (e) => e.replace(u, "/"), o.removeBackslashes = (e) => e.replace(r, (i) => i === "\\" ? "" : i), o.supportsLookbehinds = () => {
+      const e = process.version.slice(1).split(".").map(Number);
+      return e.length === 3 && e[0] >= 9 || e[0] === 8 && e[1] >= 10;
+    }, o.isWindows = (e) => e && typeof e.windows == "boolean" ? e.windows : l === !0 || a.sep === "\\", o.escapeLast = (e, i, s) => {
+      const p = e.lastIndexOf(i, s);
+      return p === -1 ? e : e[p - 1] === "\\" ? o.escapeLast(e, i, p - 1) : `${e.slice(0, p)}\\${e.slice(p)}`;
+    }, o.removePrefix = (e, i = {}) => {
+      let s = e;
+      return s.startsWith("./") && (s = s.slice(2), i.prefix = "./"), s;
+    }, o.wrapOutput = (e, i = {}, s = {}) => {
+      const p = s.contains ? "" : "^", h = s.contains ? "" : "$";
+      let d = `${p}(?:${e})${h}`;
+      return i.negated === !0 && (d = `(?:^(?!${d}).*$)`), d;
+    };
+  })(Lt)), Lt;
+}
+var Mt, Er;
+function rs() {
+  if (Er) return Mt;
+  Er = 1;
+  const o = gt(), {
+    CHAR_ASTERISK: a,
+    /* * */
+    CHAR_AT: l,
+    /* @ */
+    CHAR_BACKWARD_SLASH: u,
+    /* \ */
+    CHAR_COMMA: r,
+    /* , */
+    CHAR_DOT: t,
+    /* . */
+    CHAR_EXCLAMATION_MARK: n,
+    /* ! */
+    CHAR_FORWARD_SLASH: e,
+    /* / */
+    CHAR_LEFT_CURLY_BRACE: i,
+    /* { */
+    CHAR_LEFT_PARENTHESES: s,
+    /* ( */
+    CHAR_LEFT_SQUARE_BRACKET: p,
+    /* [ */
+    CHAR_PLUS: h,
+    /* + */
+    CHAR_QUESTION_MARK: d,
+    /* ? */
+    CHAR_RIGHT_CURLY_BRACE: y,
+    /* } */
+    CHAR_RIGHT_PARENTHESES: T,
+    /* ) */
+    CHAR_RIGHT_SQUARE_BRACKET: C
+    /* ] */
+  } = _t(), m = (c) => c === e || c === u, S = (c) => {
+    c.isPrefix !== !0 && (c.depth = c.isGlobstar ? 1 / 0 : 1);
+  };
+  return Mt = (c, f) => {
+    const g = f || {}, R = c.length - 1, v = g.parts === !0 || g.scanToEnd === !0, P = [], O = [], D = [];
+    let k = c, M = -1, x = 0, U = 0, N = !1, q = !1, F = !1, z = !1, ce = !1, $ = !1, H = !1, V = !1, oe = !1, ue = !1, ae = 0, fe, B, W = { value: "", depth: 0, isGlob: !1 };
+    const A = () => M >= R, le = () => k.charCodeAt(M + 1), te = () => (fe = B, k.charCodeAt(++M));
+    for (; M < R; ) {
+      B = te();
+      let K;
+      if (B === u) {
+        H = W.backslashes = !0, B = te(), B === i && ($ = !0);
+        continue;
+      }
+      if ($ === !0 || B === i) {
+        for (ae++; A() !== !0 && (B = te()); ) {
+          if (B === u) {
+            H = W.backslashes = !0, te();
+            continue;
+          }
+          if (B === i) {
+            ae++;
+            continue;
+          }
+          if ($ !== !0 && B === t && (B = te()) === t) {
+            if (N = W.isBrace = !0, F = W.isGlob = !0, ue = !0, v === !0)
+              continue;
+            break;
+          }
+          if ($ !== !0 && B === r) {
+            if (N = W.isBrace = !0, F = W.isGlob = !0, ue = !0, v === !0)
+              continue;
+            break;
+          }
+          if (B === y && (ae--, ae === 0)) {
+            $ = !1, N = W.isBrace = !0, ue = !0;
+            break;
+          }
+        }
+        if (v === !0)
+          continue;
+        break;
+      }
+      if (B === e) {
+        if (P.push(M), O.push(W), W = { value: "", depth: 0, isGlob: !1 }, ue === !0) continue;
+        if (fe === t && M === x + 1) {
+          x += 2;
+          continue;
+        }
+        U = M + 1;
+        continue;
+      }
+      if (g.noext !== !0 && (B === h || B === l || B === a || B === d || B === n) === !0 && le() === s) {
+        if (F = W.isGlob = !0, z = W.isExtglob = !0, ue = !0, B === n && M === x && (oe = !0), v === !0) {
+          for (; A() !== !0 && (B = te()); ) {
+            if (B === u) {
+              H = W.backslashes = !0, B = te();
+              continue;
+            }
+            if (B === T) {
+              F = W.isGlob = !0, ue = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (B === a) {
+        if (fe === a && (ce = W.isGlobstar = !0), F = W.isGlob = !0, ue = !0, v === !0)
+          continue;
+        break;
+      }
+      if (B === d) {
+        if (F = W.isGlob = !0, ue = !0, v === !0)
+          continue;
+        break;
+      }
+      if (B === p) {
+        for (; A() !== !0 && (K = te()); ) {
+          if (K === u) {
+            H = W.backslashes = !0, te();
+            continue;
+          }
+          if (K === C) {
+            q = W.isBracket = !0, F = W.isGlob = !0, ue = !0;
+            break;
+          }
+        }
+        if (v === !0)
+          continue;
+        break;
+      }
+      if (g.nonegate !== !0 && B === n && M === x) {
+        V = W.negated = !0, x++;
+        continue;
+      }
+      if (g.noparen !== !0 && B === s) {
+        if (F = W.isGlob = !0, v === !0) {
+          for (; A() !== !0 && (B = te()); ) {
+            if (B === s) {
+              H = W.backslashes = !0, B = te();
+              continue;
+            }
+            if (B === T) {
+              ue = !0;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (F === !0) {
+        if (ue = !0, v === !0)
+          continue;
+        break;
+      }
+    }
+    g.noext === !0 && (z = !1, F = !1);
+    let J = k, b = "", E = "";
+    x > 0 && (b = k.slice(0, x), k = k.slice(x), U -= x), J && F === !0 && U > 0 ? (J = k.slice(0, U), E = k.slice(U)) : F === !0 ? (J = "", E = k) : J = k, J && J !== "" && J !== "/" && J !== k && m(J.charCodeAt(J.length - 1)) && (J = J.slice(0, -1)), g.unescape === !0 && (E && (E = o.removeBackslashes(E)), J && H === !0 && (J = o.removeBackslashes(J)));
+    const he = {
+      prefix: b,
+      input: c,
+      start: x,
+      base: J,
+      glob: E,
+      isBrace: N,
+      isBracket: q,
+      isGlob: F,
+      isExtglob: z,
+      isGlobstar: ce,
+      negated: V,
+      negatedExtglob: oe
+    };
+    if (g.tokens === !0 && (he.maxDepth = 0, m(B) || O.push(W), he.tokens = O), g.parts === !0 || g.tokens === !0) {
+      let K;
+      for (let Z = 0; Z < P.length; Z++) {
+        const me = K ? K + 1 : x, pe = P[Z], be = c.slice(me, pe);
+        g.tokens && (Z === 0 && x !== 0 ? (O[Z].isPrefix = !0, O[Z].value = b) : O[Z].value = be, S(O[Z]), he.maxDepth += O[Z].depth), (Z !== 0 || be !== "") && D.push(be), K = pe;
+      }
+      if (K && K + 1 < c.length) {
+        const Z = c.slice(K + 1);
+        D.push(Z), g.tokens && (O[O.length - 1].value = Z, S(O[O.length - 1]), he.maxDepth += O[O.length - 1].depth);
+      }
+      he.slashes = P, he.parts = D;
+    }
+    return he;
+  }, Mt;
+}
+var Ht, Ar;
+function ns() {
+  if (Ar) return Ht;
+  Ar = 1;
+  const o = _t(), a = gt(), {
+    MAX_LENGTH: l,
+    POSIX_REGEX_SOURCE: u,
+    REGEX_NON_SPECIAL_CHARS: r,
+    REGEX_SPECIAL_CHARS_BACKREF: t,
+    REPLACEMENTS: n
+  } = o, e = (_, c) => {
+    if (typeof c.expandRange == "function")
+      return c.expandRange(..._, c);
+    _.sort();
+    const f = `[${_.join("-")}]`;
+    try {
+      new RegExp(f);
+    } catch {
+      return _.map((R) => a.escapeRegex(R)).join("..");
+    }
+    return f;
+  }, i = (_, c) => `Missing ${_}: "${c}" - use "\\\\${c}" to match literal characters`, s = (_) => {
+    const c = [];
+    let f = 0, g = 0, R = 0, v = "", P = !1;
+    for (const O of _) {
+      if (P === !0) {
+        v += O, P = !1;
+        continue;
+      }
+      if (O === "\\") {
+        v += O, P = !0;
+        continue;
+      }
+      if (O === '"') {
+        R = R === 1 ? 0 : 1, v += O;
+        continue;
+      }
+      if (R === 0) {
+        if (O === "[")
+          f++;
+        else if (O === "]" && f > 0)
+          f--;
+        else if (f === 0) {
+          if (O === "(")
+            g++;
+          else if (O === ")" && g > 0)
+            g--;
+          else if (O === "|" && g === 0) {
+            c.push(v), v = "";
+            continue;
+          }
+        }
+      }
+      v += O;
+    }
+    return c.push(v), c;
+  }, p = (_) => {
+    let c = !1;
+    for (const f of _) {
+      if (c === !0) {
+        c = !1;
+        continue;
+      }
+      if (f === "\\") {
+        c = !0;
+        continue;
+      }
+      if (/[?*+@!()[\]{}]/.test(f))
+        return !1;
+    }
+    return !0;
+  }, h = (_) => {
+    let c = _.trim(), f = !0;
+    for (; f === !0; )
+      f = !1, /^@\([^\\()[\]{}|]+\)$/.test(c) && (c = c.slice(2, -1), f = !0);
+    if (p(c))
+      return c.replace(/\\(.)/g, "$1");
+  }, d = (_) => {
+    const c = _.map(h).filter(Boolean);
+    for (let f = 0; f < c.length; f++)
+      for (let g = f + 1; g < c.length; g++) {
+        const R = c[f], v = c[g], P = R[0];
+        if (!(!P || R !== P.repeat(R.length) || v !== P.repeat(v.length)) && (R === v || R.startsWith(v) || v.startsWith(R)))
+          return !0;
+      }
+    return !1;
+  }, y = (_, c = !0) => {
+    if (_[0] !== "+" && _[0] !== "*" || _[1] !== "(")
+      return;
+    let f = 0, g = 0, R = 0, v = !1;
+    for (let P = 1; P < _.length; P++) {
+      const O = _[P];
+      if (v === !0) {
+        v = !1;
+        continue;
+      }
+      if (O === "\\") {
+        v = !0;
+        continue;
+      }
+      if (O === '"') {
+        R = R === 1 ? 0 : 1;
+        continue;
+      }
+      if (R !== 1) {
+        if (O === "[") {
+          f++;
+          continue;
+        }
+        if (O === "]" && f > 0) {
+          f--;
+          continue;
+        }
+        if (!(f > 0)) {
+          if (O === "(") {
+            g++;
+            continue;
+          }
+          if (O === ")" && (g--, g === 0))
+            return c === !0 && P !== _.length - 1 ? void 0 : {
+              type: _[0],
+              body: _.slice(2, P),
+              end: P
+            };
+        }
+      }
+    }
+  }, T = (_) => {
+    let c = 0;
+    const f = [];
+    for (; c < _.length; ) {
+      const R = y(_.slice(c), !1);
+      if (!R || R.type !== "*")
+        return;
+      const v = s(R.body).map((O) => O.trim());
+      if (v.length !== 1)
+        return;
+      const P = h(v[0]);
+      if (!P || P.length !== 1)
+        return;
+      f.push(P), c += R.end + 1;
+    }
+    return f.length < 1 ? void 0 : `${f.length === 1 ? a.escapeRegex(f[0]) : `[${f.map((R) => a.escapeRegex(R)).join("")}]`}*`;
+  }, C = (_) => {
+    let c = 0, f = _.trim(), g = y(f);
+    for (; g; )
+      c++, f = g.body.trim(), g = y(f);
+    return c;
+  }, m = (_, c) => {
+    if (c.maxExtglobRecursion === !1)
+      return { risky: !1 };
+    const f = typeof c.maxExtglobRecursion == "number" ? c.maxExtglobRecursion : o.DEFAULT_MAX_EXTGLOB_RECURSION, g = s(_).map((R) => R.trim());
+    if (g.length > 1 && (g.some((R) => R === "") || g.some((R) => /^[*?]+$/.test(R)) || d(g)))
+      return { risky: !0 };
+    for (const R of g) {
+      const v = T(R);
+      if (v)
+        return { risky: !0, safeOutput: v };
+      if (C(R) > f)
+        return { risky: !0 };
+    }
+    return { risky: !1 };
+  }, S = (_, c) => {
+    if (typeof _ != "string")
+      throw new TypeError("Expected a string");
+    _ = n[_] || _;
+    const f = { ...c }, g = typeof f.maxLength == "number" ? Math.min(l, f.maxLength) : l;
+    let R = _.length;
+    if (R > g)
+      throw new SyntaxError(`Input length: ${R}, exceeds maximum allowed length: ${g}`);
+    const v = { type: "bos", value: "", output: f.prepend || "" }, P = [v], O = f.capture ? "" : "?:", D = a.isWindows(c), k = o.globChars(D), M = o.extglobChars(k), {
+      DOT_LITERAL: x,
+      PLUS_LITERAL: U,
+      SLASH_LITERAL: N,
+      ONE_CHAR: q,
+      DOTS_SLASH: F,
+      NO_DOT: z,
+      NO_DOT_SLASH: ce,
+      NO_DOTS_SLASH: $,
+      QMARK: H,
+      QMARK_NO_DOT: V,
+      STAR: oe,
+      START_ANCHOR: ue
+    } = k, ae = (L) => `(${O}(?:(?!${ue}${L.dot ? F : x}).)*?)`, fe = f.dot ? "" : z, B = f.dot ? H : V;
+    let W = f.bash === !0 ? ae(f) : oe;
+    f.capture && (W = `(${W})`), typeof f.noext == "boolean" && (f.noextglob = f.noext);
+    const A = {
+      input: _,
+      index: -1,
+      start: 0,
+      dot: f.dot === !0,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: !1,
+      negated: !1,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: !1,
+      tokens: P
+    };
+    _ = a.removePrefix(_, A), R = _.length;
+    const le = [], te = [], J = [];
+    let b = v, E;
+    const he = () => A.index === R - 1, K = A.peek = (L = 1) => _[A.index + L], Z = A.advance = () => _[++A.index] || "", me = () => _.slice(A.index + 1), pe = (L = "", Y = 0) => {
+      A.consumed += L, A.index += Y;
+    }, be = (L) => {
+      A.output += L.output != null ? L.output : L.value, pe(L.value);
+    }, kn = () => {
+      let L = 1;
+      for (; K() === "!" && (K(2) !== "(" || K(3) === "?"); )
+        Z(), A.start++, L++;
+      return L % 2 === 0 ? !1 : (A.negated = !0, A.start++, !0);
+    }, je = (L) => {
+      A[L]++, J.push(L);
+    }, Pe = (L) => {
+      A[L]--, J.pop();
+    }, G = (L) => {
+      if (b.type === "globstar") {
+        const Y = A.braces > 0 && (L.type === "comma" || L.type === "brace"), w = L.extglob === !0 || le.length && (L.type === "pipe" || L.type === "paren");
+        L.type !== "slash" && L.type !== "paren" && !Y && !w && (A.output = A.output.slice(0, -b.output.length), b.type = "star", b.value = "*", b.output = W, A.output += b.output);
+      }
+      if (le.length && L.type !== "paren" && (le[le.length - 1].inner += L.value), (L.value || L.output) && be(L), b && b.type === "text" && L.type === "text") {
+        b.value += L.value, b.output = (b.output || "") + L.value;
+        return;
+      }
+      L.prev = b, P.push(L), b = L;
+    }, Ge = (L, Y) => {
+      const w = { ...M[Y], conditions: 1, inner: "" };
+      w.prev = b, w.parens = A.parens, w.output = A.output, w.startIndex = A.index, w.tokensIndex = P.length;
+      const j = (f.capture ? "(" : "") + w.open;
+      je("parens"), G({ type: L, value: Y, output: A.output ? "" : q }), G({ type: "paren", extglob: !0, value: Z(), output: j }), le.push(w);
+    }, Mn = (L) => {
+      const Y = _.slice(L.startIndex, A.index + 1), w = _.slice(L.startIndex + 2, A.index), j = m(w, f);
+      if ((L.type === "plus" || L.type === "star") && j.risky) {
+        const Q = j.safeOutput ? (L.output ? "" : q) + (f.capture ? `(${j.safeOutput})` : j.safeOutput) : void 0, ge = P[L.tokensIndex];
+        ge.type = "text", ge.value = Y, ge.output = Q || a.escapeRegex(Y);
+        for (let ye = L.tokensIndex + 1; ye < P.length; ye++)
+          P[ye].value = "", P[ye].output = "", delete P[ye].suffix;
+        A.output = L.output + ge.output, A.backtrack = !0, G({ type: "paren", extglob: !0, value: E, output: "" }), Pe("parens");
+        return;
+      }
+      let X = L.close + (f.capture ? ")" : ""), re;
+      if (L.type === "negate") {
+        let Q = W;
+        if (L.inner && L.inner.length > 1 && L.inner.includes("/") && (Q = ae(f)), (Q !== W || he() || /^\)+$/.test(me())) && (X = L.close = `)$))${Q}`), L.inner.includes("*") && (re = me()) && /^\.[^\\/.]+$/.test(re)) {
+          const ge = S(re, { ...c, fastpaths: !1 }).output;
+          X = L.close = `)${ge})${Q})`;
+        }
+        L.prev.type === "bos" && (A.negatedExtglob = !0);
+      }
+      G({ type: "paren", extglob: !0, value: E, output: X }), Pe("parens");
+    };
+    if (f.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(_)) {
+      let L = !1, Y = _.replace(t, (w, j, X, re, Q, ge) => re === "\\" ? (L = !0, w) : re === "?" ? j ? j + re + (Q ? H.repeat(Q.length) : "") : ge === 0 ? B + (Q ? H.repeat(Q.length) : "") : H.repeat(X.length) : re === "." ? x.repeat(X.length) : re === "*" ? j ? j + re + (Q ? W : "") : W : j ? w : `\\${w}`);
+      return L === !0 && (f.unescape === !0 ? Y = Y.replace(/\\/g, "") : Y = Y.replace(/\\+/g, (w) => w.length % 2 === 0 ? "\\\\" : w ? "\\" : "")), Y === _ && f.contains === !0 ? (A.output = _, A) : (A.output = a.wrapOutput(Y, A, c), A);
+    }
+    for (; !he(); ) {
+      if (E = Z(), E === "\0")
+        continue;
+      if (E === "\\") {
+        const w = K();
+        if (w === "/" && f.bash !== !0 || w === "." || w === ";")
+          continue;
+        if (!w) {
+          E += "\\", G({ type: "text", value: E });
+          continue;
+        }
+        const j = /^\\+/.exec(me());
+        let X = 0;
+        if (j && j[0].length > 2 && (X = j[0].length, A.index += X, X % 2 !== 0 && (E += "\\")), f.unescape === !0 ? E = Z() : E += Z(), A.brackets === 0) {
+          G({ type: "text", value: E });
+          continue;
+        }
+      }
+      if (A.brackets > 0 && (E !== "]" || b.value === "[" || b.value === "[^")) {
+        if (f.posix !== !1 && E === ":") {
+          const w = b.value.slice(1);
+          if (w.includes("[") && (b.posix = !0, w.includes(":"))) {
+            const j = b.value.lastIndexOf("["), X = b.value.slice(0, j), re = b.value.slice(j + 2), Q = u[re];
+            if (Q) {
+              b.value = X + Q, A.backtrack = !0, Z(), !v.output && P.indexOf(b) === 1 && (v.output = q);
+              continue;
+            }
+          }
+        }
+        (E === "[" && K() !== ":" || E === "-" && K() === "]") && (E = `\\${E}`), E === "]" && (b.value === "[" || b.value === "[^") && (E = `\\${E}`), f.posix === !0 && E === "!" && b.value === "[" && (E = "^"), b.value += E, be({ value: E });
+        continue;
+      }
+      if (A.quotes === 1 && E !== '"') {
+        E = a.escapeRegex(E), b.value += E, be({ value: E });
+        continue;
+      }
+      if (E === '"') {
+        A.quotes = A.quotes === 1 ? 0 : 1, f.keepQuotes === !0 && G({ type: "text", value: E });
+        continue;
+      }
+      if (E === "(") {
+        je("parens"), G({ type: "paren", value: E });
+        continue;
+      }
+      if (E === ")") {
+        if (A.parens === 0 && f.strictBrackets === !0)
+          throw new SyntaxError(i("opening", "("));
+        const w = le[le.length - 1];
+        if (w && A.parens === w.parens + 1) {
+          Mn(le.pop());
+          continue;
+        }
+        G({ type: "paren", value: E, output: A.parens ? ")" : "\\)" }), Pe("parens");
+        continue;
+      }
+      if (E === "[") {
+        if (f.nobracket === !0 || !me().includes("]")) {
+          if (f.nobracket !== !0 && f.strictBrackets === !0)
+            throw new SyntaxError(i("closing", "]"));
+          E = `\\${E}`;
+        } else
+          je("brackets");
+        G({ type: "bracket", value: E });
+        continue;
+      }
+      if (E === "]") {
+        if (f.nobracket === !0 || b && b.type === "bracket" && b.value.length === 1) {
+          G({ type: "text", value: E, output: `\\${E}` });
+          continue;
+        }
+        if (A.brackets === 0) {
+          if (f.strictBrackets === !0)
+            throw new SyntaxError(i("opening", "["));
+          G({ type: "text", value: E, output: `\\${E}` });
+          continue;
+        }
+        Pe("brackets");
+        const w = b.value.slice(1);
+        if (b.posix !== !0 && w[0] === "^" && !w.includes("/") && (E = `/${E}`), b.value += E, be({ value: E }), f.literalBrackets === !1 || a.hasRegexChars(w))
+          continue;
+        const j = a.escapeRegex(b.value);
+        if (A.output = A.output.slice(0, -b.value.length), f.literalBrackets === !0) {
+          A.output += j, b.value = j;
+          continue;
+        }
+        b.value = `(${O}${j}|${b.value})`, A.output += b.value;
+        continue;
+      }
+      if (E === "{" && f.nobrace !== !0) {
+        je("braces");
+        const w = {
+          type: "brace",
+          value: E,
+          output: "(",
+          outputIndex: A.output.length,
+          tokensIndex: A.tokens.length
+        };
+        te.push(w), G(w);
+        continue;
+      }
+      if (E === "}") {
+        const w = te[te.length - 1];
+        if (f.nobrace === !0 || !w) {
+          G({ type: "text", value: E, output: E });
+          continue;
+        }
+        let j = ")";
+        if (w.dots === !0) {
+          const X = P.slice(), re = [];
+          for (let Q = X.length - 1; Q >= 0 && (P.pop(), X[Q].type !== "brace"); Q--)
+            X[Q].type !== "dots" && re.unshift(X[Q].value);
+          j = e(re, f), A.backtrack = !0;
+        }
+        if (w.comma !== !0 && w.dots !== !0) {
+          const X = A.output.slice(0, w.outputIndex), re = A.tokens.slice(w.tokensIndex);
+          w.value = w.output = "\\{", E = j = "\\}", A.output = X;
+          for (const Q of re)
+            A.output += Q.output || Q.value;
+        }
+        G({ type: "brace", value: E, output: j }), Pe("braces"), te.pop();
+        continue;
+      }
+      if (E === "|") {
+        le.length > 0 && le[le.length - 1].conditions++, G({ type: "text", value: E });
+        continue;
+      }
+      if (E === ",") {
+        let w = E;
+        const j = te[te.length - 1];
+        j && J[J.length - 1] === "braces" && (j.comma = !0, w = "|"), G({ type: "comma", value: E, output: w });
+        continue;
+      }
+      if (E === "/") {
+        if (b.type === "dot" && A.index === A.start + 1) {
+          A.start = A.index + 1, A.consumed = "", A.output = "", P.pop(), b = v;
+          continue;
+        }
+        G({ type: "slash", value: E, output: N });
+        continue;
+      }
+      if (E === ".") {
+        if (A.braces > 0 && b.type === "dot") {
+          b.value === "." && (b.output = x);
+          const w = te[te.length - 1];
+          b.type = "dots", b.output += E, b.value += E, w.dots = !0;
+          continue;
+        }
+        if (A.braces + A.parens === 0 && b.type !== "bos" && b.type !== "slash") {
+          G({ type: "text", value: E, output: x });
+          continue;
+        }
+        G({ type: "dot", value: E, output: x });
+        continue;
+      }
+      if (E === "?") {
+        if (!(b && b.value === "(") && f.noextglob !== !0 && K() === "(" && K(2) !== "?") {
+          Ge("qmark", E);
+          continue;
+        }
+        if (b && b.type === "paren") {
+          const j = K();
+          let X = E;
+          if (j === "<" && !a.supportsLookbehinds())
+            throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+          (b.value === "(" && !/[!=<:]/.test(j) || j === "<" && !/<([!=]|\w+>)/.test(me())) && (X = `\\${E}`), G({ type: "text", value: E, output: X });
+          continue;
+        }
+        if (f.dot !== !0 && (b.type === "slash" || b.type === "bos")) {
+          G({ type: "qmark", value: E, output: V });
+          continue;
+        }
+        G({ type: "qmark", value: E, output: H });
+        continue;
+      }
+      if (E === "!") {
+        if (f.noextglob !== !0 && K() === "(" && (K(2) !== "?" || !/[!=<:]/.test(K(3)))) {
+          Ge("negate", E);
+          continue;
+        }
+        if (f.nonegate !== !0 && A.index === 0) {
+          kn();
+          continue;
+        }
+      }
+      if (E === "+") {
+        if (f.noextglob !== !0 && K() === "(" && K(2) !== "?") {
+          Ge("plus", E);
+          continue;
+        }
+        if (b && b.value === "(" || f.regex === !1) {
+          G({ type: "plus", value: E, output: U });
+          continue;
+        }
+        if (b && (b.type === "bracket" || b.type === "paren" || b.type === "brace") || A.parens > 0) {
+          G({ type: "plus", value: E });
+          continue;
+        }
+        G({ type: "plus", value: U });
+        continue;
+      }
+      if (E === "@") {
+        if (f.noextglob !== !0 && K() === "(" && K(2) !== "?") {
+          G({ type: "at", extglob: !0, value: E, output: "" });
+          continue;
+        }
+        G({ type: "text", value: E });
+        continue;
+      }
+      if (E !== "*") {
+        (E === "$" || E === "^") && (E = `\\${E}`);
+        const w = r.exec(me());
+        w && (E += w[0], A.index += w[0].length), G({ type: "text", value: E });
+        continue;
+      }
+      if (b && (b.type === "globstar" || b.star === !0)) {
+        b.type = "star", b.star = !0, b.value += E, b.output = W, A.backtrack = !0, A.globstar = !0, pe(E);
+        continue;
+      }
+      let L = me();
+      if (f.noextglob !== !0 && /^\([^?]/.test(L)) {
+        Ge("star", E);
+        continue;
+      }
+      if (b.type === "star") {
+        if (f.noglobstar === !0) {
+          pe(E);
+          continue;
+        }
+        const w = b.prev, j = w.prev, X = w.type === "slash" || w.type === "bos", re = j && (j.type === "star" || j.type === "globstar");
+        if (f.bash === !0 && (!X || L[0] && L[0] !== "/")) {
+          G({ type: "star", value: E, output: "" });
+          continue;
+        }
+        const Q = A.braces > 0 && (w.type === "comma" || w.type === "brace"), ge = le.length && (w.type === "pipe" || w.type === "paren");
+        if (!X && w.type !== "paren" && !Q && !ge) {
+          G({ type: "star", value: E, output: "" });
+          continue;
+        }
+        for (; L.slice(0, 3) === "/**"; ) {
+          const ye = _[A.index + 4];
+          if (ye && ye !== "/")
+            break;
+          L = L.slice(3), pe("/**", 3);
+        }
+        if (w.type === "bos" && he()) {
+          b.type = "globstar", b.value += E, b.output = ae(f), A.output = b.output, A.globstar = !0, pe(E);
+          continue;
+        }
+        if (w.type === "slash" && w.prev.type !== "bos" && !re && he()) {
+          A.output = A.output.slice(0, -(w.output + b.output).length), w.output = `(?:${w.output}`, b.type = "globstar", b.output = ae(f) + (f.strictSlashes ? ")" : "|$)"), b.value += E, A.globstar = !0, A.output += w.output + b.output, pe(E);
+          continue;
+        }
+        if (w.type === "slash" && w.prev.type !== "bos" && L[0] === "/") {
+          const ye = L[1] !== void 0 ? "|$" : "";
+          A.output = A.output.slice(0, -(w.output + b.output).length), w.output = `(?:${w.output}`, b.type = "globstar", b.output = `${ae(f)}${N}|${N}${ye})`, b.value += E, A.output += w.output + b.output, A.globstar = !0, pe(E + Z()), G({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (w.type === "bos" && L[0] === "/") {
+          b.type = "globstar", b.value += E, b.output = `(?:^|${N}|${ae(f)}${N})`, A.output = b.output, A.globstar = !0, pe(E + Z()), G({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        A.output = A.output.slice(0, -b.output.length), b.type = "globstar", b.output = ae(f), b.value += E, A.output += b.output, A.globstar = !0, pe(E);
+        continue;
+      }
+      const Y = { type: "star", value: E, output: W };
+      if (f.bash === !0) {
+        Y.output = ".*?", (b.type === "bos" || b.type === "slash") && (Y.output = fe + Y.output), G(Y);
+        continue;
+      }
+      if (b && (b.type === "bracket" || b.type === "paren") && f.regex === !0) {
+        Y.output = E, G(Y);
+        continue;
+      }
+      (A.index === A.start || b.type === "slash" || b.type === "dot") && (b.type === "dot" ? (A.output += ce, b.output += ce) : f.dot === !0 ? (A.output += $, b.output += $) : (A.output += fe, b.output += fe), K() !== "*" && (A.output += q, b.output += q)), G(Y);
+    }
+    for (; A.brackets > 0; ) {
+      if (f.strictBrackets === !0) throw new SyntaxError(i("closing", "]"));
+      A.output = a.escapeLast(A.output, "["), Pe("brackets");
+    }
+    for (; A.parens > 0; ) {
+      if (f.strictBrackets === !0) throw new SyntaxError(i("closing", ")"));
+      A.output = a.escapeLast(A.output, "("), Pe("parens");
+    }
+    for (; A.braces > 0; ) {
+      if (f.strictBrackets === !0) throw new SyntaxError(i("closing", "}"));
+      A.output = a.escapeLast(A.output, "{"), Pe("braces");
+    }
+    if (f.strictSlashes !== !0 && (b.type === "star" || b.type === "bracket") && G({ type: "maybe_slash", value: "", output: `${N}?` }), A.backtrack === !0) {
+      A.output = "";
+      for (const L of A.tokens)
+        A.output += L.output != null ? L.output : L.value, L.suffix && (A.output += L.suffix);
+    }
+    return A;
+  };
+  return S.fastpaths = (_, c) => {
+    const f = { ...c }, g = typeof f.maxLength == "number" ? Math.min(l, f.maxLength) : l, R = _.length;
+    if (R > g)
+      throw new SyntaxError(`Input length: ${R}, exceeds maximum allowed length: ${g}`);
+    _ = n[_] || _;
+    const v = a.isWindows(c), {
+      DOT_LITERAL: P,
+      SLASH_LITERAL: O,
+      ONE_CHAR: D,
+      DOTS_SLASH: k,
+      NO_DOT: M,
+      NO_DOTS: x,
+      NO_DOTS_SLASH: U,
+      STAR: N,
+      START_ANCHOR: q
+    } = o.globChars(v), F = f.dot ? x : M, z = f.dot ? U : M, ce = f.capture ? "" : "?:", $ = { negated: !1, prefix: "" };
+    let H = f.bash === !0 ? ".*?" : N;
+    f.capture && (H = `(${H})`);
+    const V = (fe) => fe.noglobstar === !0 ? H : `(${ce}(?:(?!${q}${fe.dot ? k : P}).)*?)`, oe = (fe) => {
+      switch (fe) {
+        case "*":
+          return `${F}${D}${H}`;
+        case ".*":
+          return `${P}${D}${H}`;
+        case "*.*":
+          return `${F}${H}${P}${D}${H}`;
+        case "*/*":
+          return `${F}${H}${O}${D}${z}${H}`;
+        case "**":
+          return F + V(f);
+        case "**/*":
+          return `(?:${F}${V(f)}${O})?${z}${D}${H}`;
+        case "**/*.*":
+          return `(?:${F}${V(f)}${O})?${z}${H}${P}${D}${H}`;
+        case "**/.*":
+          return `(?:${F}${V(f)}${O})?${P}${D}${H}`;
+        default: {
+          const B = /^(.*?)\.(\w+)$/.exec(fe);
+          if (!B) return;
+          const W = oe(B[1]);
+          return W ? W + P + B[2] : void 0;
+        }
+      }
+    }, ue = a.removePrefix(_, $);
+    let ae = oe(ue);
+    return ae && f.strictSlashes !== !0 && (ae += `${O}?`), ae;
+  }, Ht = S, Ht;
+}
+var Dt, br;
+function ss() {
+  if (br) return Dt;
+  br = 1;
+  const o = Se, a = rs(), l = ns(), u = gt(), r = _t(), t = (e) => e && typeof e == "object" && !Array.isArray(e), n = (e, i, s = !1) => {
+    if (Array.isArray(e)) {
+      const S = e.map((c) => n(c, i, s));
+      return (c) => {
+        for (const f of S) {
+          const g = f(c);
+          if (g) return g;
+        }
+        return !1;
+      };
+    }
+    const p = t(e) && e.tokens && e.input;
+    if (e === "" || typeof e != "string" && !p)
+      throw new TypeError("Expected pattern to be a non-empty string");
+    const h = i || {}, d = u.isWindows(i), y = p ? n.compileRe(e, i) : n.makeRe(e, i, !1, !0), T = y.state;
+    delete y.state;
+    let C = () => !1;
+    if (h.ignore) {
+      const S = { ...i, ignore: null, onMatch: null, onResult: null };
+      C = n(h.ignore, S, s);
+    }
+    const m = (S, _ = !1) => {
+      const { isMatch: c, match: f, output: g } = n.test(S, y, i, { glob: e, posix: d }), R = { glob: e, state: T, regex: y, posix: d, input: S, output: g, match: f, isMatch: c };
+      return typeof h.onResult == "function" && h.onResult(R), c === !1 ? (R.isMatch = !1, _ ? R : !1) : C(S) ? (typeof h.onIgnore == "function" && h.onIgnore(R), R.isMatch = !1, _ ? R : !1) : (typeof h.onMatch == "function" && h.onMatch(R), _ ? R : !0);
+    };
+    return s && (m.state = T), m;
+  };
+  return n.test = (e, i, s, { glob: p, posix: h } = {}) => {
+    if (typeof e != "string")
+      throw new TypeError("Expected input to be a string");
+    if (e === "")
+      return { isMatch: !1, output: "" };
+    const d = s || {}, y = d.format || (h ? u.toPosixSlashes : null);
+    let T = e === p, C = T && y ? y(e) : e;
+    return T === !1 && (C = y ? y(e) : e, T = C === p), (T === !1 || d.capture === !0) && (d.matchBase === !0 || d.basename === !0 ? T = n.matchBase(e, i, s, h) : T = i.exec(C)), { isMatch: !!T, match: T, output: C };
+  }, n.matchBase = (e, i, s, p = u.isWindows(s)) => (i instanceof RegExp ? i : n.makeRe(i, s)).test(o.basename(e)), n.isMatch = (e, i, s) => n(i, s)(e), n.parse = (e, i) => Array.isArray(e) ? e.map((s) => n.parse(s, i)) : l(e, { ...i, fastpaths: !1 }), n.scan = (e, i) => a(e, i), n.compileRe = (e, i, s = !1, p = !1) => {
+    if (s === !0)
+      return e.output;
+    const h = i || {}, d = h.contains ? "" : "^", y = h.contains ? "" : "$";
+    let T = `${d}(?:${e.output})${y}`;
+    e && e.negated === !0 && (T = `^(?!${T}).*$`);
+    const C = n.toRegex(T, i);
+    return p === !0 && (C.state = e), C;
+  }, n.makeRe = (e, i = {}, s = !1, p = !1) => {
+    if (!e || typeof e != "string")
+      throw new TypeError("Expected a non-empty string");
+    let h = { negated: !1, fastpaths: !0 };
+    return i.fastpaths !== !1 && (e[0] === "." || e[0] === "*") && (h.output = l.fastpaths(e, i)), h.output || (h = l(e, i)), n.compileRe(h, i, s, p);
+  }, n.toRegex = (e, i) => {
+    try {
+      const s = i || {};
+      return new RegExp(e, s.flags || (s.nocase ? "i" : ""));
+    } catch (s) {
+      if (i && i.debug === !0) throw s;
+      return /$^/;
+    }
+  }, n.constants = r, Dt = n, Dt;
+}
+var It, Pr;
+function is() {
+  return Pr || (Pr = 1, It = ss()), It;
+}
+var Nt, xr;
+function as() {
+  if (xr) return Nt;
+  xr = 1;
+  const o = Pn, a = ts(), l = is(), u = gt(), r = (e) => e === "" || e === "./", t = (e) => {
+    const i = e.indexOf("{");
+    return i > -1 && e.indexOf("}", i) > -1;
+  }, n = (e, i, s) => {
+    i = [].concat(i), e = [].concat(e);
+    let p = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), y = 0, T = (S) => {
+      d.add(S.output), s && s.onResult && s.onResult(S);
+    };
+    for (let S = 0; S < i.length; S++) {
+      let _ = l(String(i[S]), { ...s, onResult: T }, !0), c = _.state.negated || _.state.negatedExtglob;
+      c && y++;
+      for (let f of e) {
+        let g = _(f, !0);
+        (c ? !g.isMatch : g.isMatch) && (c ? p.add(g.output) : (p.delete(g.output), h.add(g.output)));
+      }
+    }
+    let m = (y === i.length ? [...d] : [...h]).filter((S) => !p.has(S));
+    if (s && m.length === 0) {
+      if (s.failglob === !0)
+        throw new Error(`No matches found for "${i.join(", ")}"`);
+      if (s.nonull === !0 || s.nullglob === !0)
+        return s.unescape ? i.map((S) => S.replace(/\\/g, "")) : i;
+    }
+    return m;
+  };
+  return n.match = n, n.matcher = (e, i) => l(e, i), n.isMatch = (e, i, s) => l(i, s)(e), n.any = n.isMatch, n.not = (e, i, s = {}) => {
+    i = [].concat(i).map(String);
+    let p = /* @__PURE__ */ new Set(), h = [], d = (T) => {
+      s.onResult && s.onResult(T), h.push(T.output);
+    }, y = new Set(n(e, i, { ...s, onResult: d }));
+    for (let T of h)
+      y.has(T) || p.add(T);
+    return [...p];
+  }, n.contains = (e, i, s) => {
+    if (typeof e != "string")
+      throw new TypeError(`Expected a string: "${o.inspect(e)}"`);
+    if (Array.isArray(i))
+      return i.some((p) => n.contains(e, p, s));
+    if (typeof i == "string") {
+      if (r(e) || r(i))
+        return !1;
+      if (e.includes(i) || e.startsWith("./") && e.slice(2).includes(i))
+        return !0;
+    }
+    return n.isMatch(e, i, { ...s, contains: !0 });
+  }, n.matchKeys = (e, i, s) => {
+    if (!u.isObject(e))
+      throw new TypeError("Expected the first argument to be an object");
+    let p = n(Object.keys(e), i, s), h = {};
+    for (let d of p) h[d] = e[d];
+    return h;
+  }, n.some = (e, i, s) => {
+    let p = [].concat(e);
+    for (let h of [].concat(i)) {
+      let d = l(String(h), s);
+      if (p.some((y) => d(y)))
+        return !0;
+    }
+    return !1;
+  }, n.every = (e, i, s) => {
+    let p = [].concat(e);
+    for (let h of [].concat(i)) {
+      let d = l(String(h), s);
+      if (!p.every((y) => d(y)))
+        return !1;
+    }
+    return !0;
+  }, n.all = (e, i, s) => {
+    if (typeof e != "string")
+      throw new TypeError(`Expected a string: "${o.inspect(e)}"`);
+    return [].concat(i).every((p) => l(p, s)(e));
+  }, n.capture = (e, i, s) => {
+    let p = u.isWindows(s), d = l.makeRe(String(e), { ...s, capture: !0 }).exec(p ? u.toPosixSlashes(i) : i);
+    if (d)
+      return d.slice(1).map((y) => y === void 0 ? "" : y);
+  }, n.makeRe = (...e) => l.makeRe(...e), n.scan = (...e) => l.scan(...e), n.parse = (e, i) => {
+    let s = [];
+    for (let p of [].concat(e || []))
+      for (let h of a(String(p), i))
+        s.push(l.parse(h, i));
+    return s;
+  }, n.braces = (e, i) => {
+    if (typeof e != "string") throw new TypeError("Expected a string");
+    return i && i.nobrace === !0 || !t(e) ? [e] : a(e, i);
+  }, n.braceExpand = (e, i) => {
+    if (typeof e != "string") throw new TypeError("Expected a string");
+    return n.braces(e, { ...i, expand: !0 });
+  }, n.hasBraces = t, Nt = n, Nt;
+}
+var Cr;
+function os() {
+  if (Cr) return I;
+  Cr = 1, Object.defineProperty(I, "__esModule", { value: !0 }), I.isAbsolute = I.partitionAbsoluteAndRelative = I.removeDuplicateSlashes = I.matchAny = I.convertPatternsToRe = I.makeRe = I.getPatternParts = I.expandBraceExpansion = I.expandPatternsWithBraceExpansion = I.isAffectDepthOfReadingPattern = I.endsWithSlashGlobStar = I.hasGlobStar = I.getBaseDirectory = I.isPatternRelatedToParentDirectory = I.getPatternsOutsideCurrentDirectory = I.getPatternsInsideCurrentDirectory = I.getPositivePatterns = I.getNegativePatterns = I.isPositivePattern = I.isNegativePattern = I.convertToNegativePattern = I.convertToPositivePattern = I.isDynamicPattern = I.isStaticPattern = void 0;
+  const o = Se, a = Qn(), l = as(), u = "**", r = "\\", t = /[*?]|^!/, n = /\[[^[]*]/, e = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/, i = /[!*+?@]\([^(]*\)/, s = /,|\.\./, p = /(?!^)\/{2,}/g;
+  function h($, H = {}) {
+    return !d($, H);
+  }
+  I.isStaticPattern = h;
+  function d($, H = {}) {
+    return $ === "" ? !1 : !!(H.caseSensitiveMatch === !1 || $.includes(r) || t.test($) || n.test($) || e.test($) || H.extglob !== !1 && i.test($) || H.braceExpansion !== !1 && y($));
+  }
+  I.isDynamicPattern = d;
+  function y($) {
+    const H = $.indexOf("{");
+    if (H === -1)
+      return !1;
+    const V = $.indexOf("}", H + 1);
+    if (V === -1)
+      return !1;
+    const oe = $.slice(H, V);
+    return s.test(oe);
+  }
+  function T($) {
+    return m($) ? $.slice(1) : $;
+  }
+  I.convertToPositivePattern = T;
+  function C($) {
+    return "!" + $;
+  }
+  I.convertToNegativePattern = C;
+  function m($) {
+    return $.startsWith("!") && $[1] !== "(";
+  }
+  I.isNegativePattern = m;
+  function S($) {
+    return !m($);
+  }
+  I.isPositivePattern = S;
+  function _($) {
+    return $.filter(m);
+  }
+  I.getNegativePatterns = _;
+  function c($) {
+    return $.filter(S);
+  }
+  I.getPositivePatterns = c;
+  function f($) {
+    return $.filter((H) => !R(H));
+  }
+  I.getPatternsInsideCurrentDirectory = f;
+  function g($) {
+    return $.filter(R);
+  }
+  I.getPatternsOutsideCurrentDirectory = g;
+  function R($) {
+    return $.startsWith("..") || $.startsWith("./..");
+  }
+  I.isPatternRelatedToParentDirectory = R;
+  function v($) {
+    return a($, { flipBackslashes: !1 });
+  }
+  I.getBaseDirectory = v;
+  function P($) {
+    return $.includes(u);
+  }
+  I.hasGlobStar = P;
+  function O($) {
+    return $.endsWith("/" + u);
+  }
+  I.endsWithSlashGlobStar = O;
+  function D($) {
+    const H = o.basename($);
+    return O($) || h(H);
+  }
+  I.isAffectDepthOfReadingPattern = D;
+  function k($) {
+    return $.reduce((H, V) => H.concat(M(V)), []);
+  }
+  I.expandPatternsWithBraceExpansion = k;
+  function M($) {
+    const H = l.braces($, { expand: !0, nodupes: !0, keepEscaping: !0 });
+    return H.sort((V, oe) => V.length - oe.length), H.filter((V) => V !== "");
+  }
+  I.expandBraceExpansion = M;
+  function x($, H) {
+    let { parts: V } = l.scan($, Object.assign(Object.assign({}, H), { parts: !0 }));
+    return V.length === 0 && (V = [$]), V[0].startsWith("/") && (V[0] = V[0].slice(1), V.unshift("")), V;
+  }
+  I.getPatternParts = x;
+  function U($, H) {
+    return l.makeRe($, H);
+  }
+  I.makeRe = U;
+  function N($, H) {
+    return $.map((V) => U(V, H));
+  }
+  I.convertPatternsToRe = N;
+  function q($, H) {
+    return H.some((V) => V.test($));
+  }
+  I.matchAny = q;
+  function F($) {
+    return $.replace(p, "/");
+  }
+  I.removeDuplicateSlashes = F;
+  function z($) {
+    const H = [], V = [];
+    for (const oe of $)
+      ce(oe) ? H.push(oe) : V.push(oe);
+    return [H, V];
+  }
+  I.partitionAbsoluteAndRelative = z;
+  function ce($) {
+    return o.isAbsolute($);
+  }
+  return I.isAbsolute = ce, I;
+}
+var He = {}, qt, Tr;
+function us() {
+  if (Tr) return qt;
+  Tr = 1;
+  const a = dt.PassThrough, l = Array.prototype.slice;
+  qt = u;
+  function u() {
+    const t = [], n = l.call(arguments);
+    let e = !1, i = n[n.length - 1];
+    i && !Array.isArray(i) && i.pipe == null ? n.pop() : i = {};
+    const s = i.end !== !1, p = i.pipeError === !0;
+    i.objectMode == null && (i.objectMode = !0), i.highWaterMark == null && (i.highWaterMark = 64 * 1024);
+    const h = a(i);
+    function d() {
+      for (let C = 0, m = arguments.length; C < m; C++)
+        t.push(r(arguments[C], i));
+      return y(), this;
+    }
+    function y() {
+      if (e)
+        return;
+      e = !0;
+      let C = t.shift();
+      if (!C) {
+        process.nextTick(T);
+        return;
+      }
+      Array.isArray(C) || (C = [C]);
+      let m = C.length + 1;
+      function S() {
+        --m > 0 || (e = !1, y());
+      }
+      function _(c) {
+        function f() {
+          c.removeListener("merge2UnpipeEnd", f), c.removeListener("end", f), p && c.removeListener("error", g), S();
+        }
+        function g(R) {
+          h.emit("error", R);
+        }
+        if (c._readableState.endEmitted)
+          return S();
+        c.on("merge2UnpipeEnd", f), c.on("end", f), p && c.on("error", g), c.pipe(h, { end: !1 }), c.resume();
+      }
+      for (let c = 0; c < C.length; c++)
+        _(C[c]);
+      S();
+    }
+    function T() {
+      e = !1, h.emit("queueDrain"), s && h.end();
+    }
+    return h.setMaxListeners(0), h.add = d, h.on("unpipe", function(C) {
+      C.emit("merge2UnpipeEnd");
+    }), n.length && d.apply(null, n), h;
+  }
+  function r(t, n) {
+    if (Array.isArray(t))
+      for (let e = 0, i = t.length; e < i; e++)
+        t[e] = r(t[e], n);
+    else {
+      if (!t._readableState && t.pipe && (t = t.pipe(a(n))), !t._readableState || !t.pause || !t.pipe)
+        throw new Error("Only readable stream can be merged.");
+      t.pause();
+    }
+    return t;
+  }
+  return qt;
+}
+var Or;
+function cs() {
+  if (Or) return He;
+  Or = 1, Object.defineProperty(He, "__esModule", { value: !0 }), He.merge = void 0;
+  const o = us();
+  function a(u) {
+    const r = o(u);
+    return u.forEach((t) => {
+      t.once("error", (n) => r.emit("error", n));
+    }), r.once("close", () => l(u)), r.once("end", () => l(u)), r;
+  }
+  He.merge = a;
+  function l(u) {
+    u.forEach((r) => r.emit("close"));
+  }
+  return He;
+}
+var we = {}, wr;
+function ls() {
+  if (wr) return we;
+  wr = 1, Object.defineProperty(we, "__esModule", { value: !0 }), we.isEmpty = we.isString = void 0;
+  function o(l) {
+    return typeof l == "string";
+  }
+  we.isString = o;
+  function a(l) {
+    return l === "";
+  }
+  return we.isEmpty = a, we;
+}
+var $r;
+function Te() {
+  if ($r) return ie;
+  $r = 1, Object.defineProperty(ie, "__esModule", { value: !0 }), ie.string = ie.stream = ie.pattern = ie.path = ie.fs = ie.errno = ie.array = void 0;
+  const o = jn();
+  ie.array = o;
+  const a = Gn();
+  ie.errno = a;
+  const l = Un();
+  ie.fs = l;
+  const u = Wn();
+  ie.path = u;
+  const r = os();
+  ie.pattern = r;
+  const t = cs();
+  ie.stream = t;
+  const n = ls();
+  return ie.string = n, ie;
+}
+var Lr;
+function fs() {
+  if (Lr) return se;
+  Lr = 1, Object.defineProperty(se, "__esModule", { value: !0 }), se.convertPatternGroupToTask = se.convertPatternGroupsToTasks = se.groupPatternsByBaseDirectory = se.getNegativePatternsAsPositive = se.getPositivePatterns = se.convertPatternsToTasks = se.generate = void 0;
+  const o = Te();
+  function a(s, p) {
+    const h = l(s, p), d = l(p.ignore, p), y = r(h), T = t(h, d), C = y.filter((c) => o.pattern.isStaticPattern(c, p)), m = y.filter((c) => o.pattern.isDynamicPattern(c, p)), S = u(
+      C,
+      T,
+      /* dynamic */
+      !1
+    ), _ = u(
+      m,
+      T,
+      /* dynamic */
+      !0
+    );
+    return S.concat(_);
+  }
+  se.generate = a;
+  function l(s, p) {
+    let h = s;
+    return p.braceExpansion && (h = o.pattern.expandPatternsWithBraceExpansion(h)), p.baseNameMatch && (h = h.map((d) => d.includes("/") ? d : `**/${d}`)), h.map((d) => o.pattern.removeDuplicateSlashes(d));
+  }
+  function u(s, p, h) {
+    const d = [], y = o.pattern.getPatternsOutsideCurrentDirectory(s), T = o.pattern.getPatternsInsideCurrentDirectory(s), C = n(y), m = n(T);
+    return d.push(...e(C, p, h)), "." in m ? d.push(i(".", T, p, h)) : d.push(...e(m, p, h)), d;
+  }
+  se.convertPatternsToTasks = u;
+  function r(s) {
+    return o.pattern.getPositivePatterns(s);
+  }
+  se.getPositivePatterns = r;
+  function t(s, p) {
+    return o.pattern.getNegativePatterns(s).concat(p).map(o.pattern.convertToPositivePattern);
+  }
+  se.getNegativePatternsAsPositive = t;
+  function n(s) {
+    const p = {};
+    return s.reduce((h, d) => {
+      const y = o.pattern.getBaseDirectory(d);
+      return y in h ? h[y].push(d) : h[y] = [d], h;
+    }, p);
+  }
+  se.groupPatternsByBaseDirectory = n;
+  function e(s, p, h) {
+    return Object.keys(s).map((d) => i(d, s[d], p, h));
+  }
+  se.convertPatternGroupsToTasks = e;
+  function i(s, p, h, d) {
+    return {
+      dynamic: d,
+      positive: p,
+      negative: h,
+      base: s,
+      patterns: [].concat(p, h.map(o.pattern.convertToNegativePattern))
+    };
+  }
+  return se.convertPatternGroupToTask = i, se;
+}
+var Ue = {}, We = {}, de = {}, Ve = {}, Ke = {}, ve = {}, Re = {}, Ee = {}, De = {}, kr;
+function hs() {
+  if (kr) return De;
+  kr = 1, Object.defineProperty(De, "__esModule", { value: !0 }), De.read = void 0;
+  function o(u, r, t) {
+    r.fs.lstat(u, (n, e) => {
+      if (n !== null) {
+        a(t, n);
+        return;
+      }
+      if (!e.isSymbolicLink() || !r.followSymbolicLink) {
+        l(t, e);
+        return;
+      }
+      r.fs.stat(u, (i, s) => {
+        if (i !== null) {
+          if (r.throwErrorOnBrokenSymbolicLink) {
+            a(t, i);
+            return;
+          }
+          l(t, e);
+          return;
+        }
+        r.markSymbolicLink && (s.isSymbolicLink = () => !0), l(t, s);
+      });
+    });
+  }
+  De.read = o;
+  function a(u, r) {
+    u(r);
+  }
+  function l(u, r) {
+    u(null, r);
+  }
+  return De;
+}
+var Ie = {}, Mr;
+function ps() {
+  if (Mr) return Ie;
+  Mr = 1, Object.defineProperty(Ie, "__esModule", { value: !0 }), Ie.read = void 0;
+  function o(a, l) {
+    const u = l.fs.lstatSync(a);
+    if (!u.isSymbolicLink() || !l.followSymbolicLink)
+      return u;
+    try {
+      const r = l.fs.statSync(a);
+      return l.markSymbolicLink && (r.isSymbolicLink = () => !0), r;
+    } catch (r) {
+      if (!l.throwErrorOnBrokenSymbolicLink)
+        return u;
+      throw r;
+    }
+  }
+  return Ie.read = o, Ie;
+}
+var Qe = {}, Ft = {}, Hr;
+function ds() {
+  return Hr || (Hr = 1, (function(o) {
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.createFileSystemAdapter = o.FILE_SYSTEM_ADAPTER = void 0;
+    const a = Qt;
+    o.FILE_SYSTEM_ADAPTER = {
+      lstat: a.lstat,
+      stat: a.stat,
+      lstatSync: a.lstatSync,
+      statSync: a.statSync
+    };
+    function l(u) {
+      return u === void 0 ? o.FILE_SYSTEM_ADAPTER : Object.assign(Object.assign({}, o.FILE_SYSTEM_ADAPTER), u);
+    }
+    o.createFileSystemAdapter = l;
+  })(Ft)), Ft;
+}
+var Dr;
+function _s() {
+  if (Dr) return Qe;
+  Dr = 1, Object.defineProperty(Qe, "__esModule", { value: !0 });
+  const o = ds();
+  class a {
+    constructor(u = {}) {
+      this._options = u, this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, !0), this.fs = o.createFileSystemAdapter(this._options.fs), this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !0);
+    }
+    _getValue(u, r) {
+      return u ?? r;
+    }
+  }
+  return Qe.default = a, Qe;
+}
+var Ir;
+function Le() {
+  if (Ir) return Ee;
+  Ir = 1, Object.defineProperty(Ee, "__esModule", { value: !0 }), Ee.statSync = Ee.stat = Ee.Settings = void 0;
+  const o = hs(), a = ps(), l = _s();
+  Ee.Settings = l.default;
+  function u(n, e, i) {
+    if (typeof e == "function") {
+      o.read(n, t(), e);
+      return;
+    }
+    o.read(n, t(e), i);
+  }
+  Ee.stat = u;
+  function r(n, e) {
+    const i = t(e);
+    return a.read(n, i);
+  }
+  Ee.statSync = r;
+  function t(n = {}) {
+    return n instanceof l.default ? n : new l.default(n);
+  }
+  return Ee;
+}
+/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+var Bt, Nr;
+function gs() {
+  if (Nr) return Bt;
+  Nr = 1;
+  let o;
+  return Bt = typeof queueMicrotask == "function" ? queueMicrotask.bind(typeof window < "u" ? window : Hn) : (a) => (o || (o = Promise.resolve())).then(a).catch((l) => setTimeout(() => {
+    throw l;
+  }, 0)), Bt;
+}
+/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+var jt, qr;
+function ys() {
+  if (qr) return jt;
+  qr = 1, jt = a;
+  const o = gs();
+  function a(l, u) {
+    let r, t, n, e = !0;
+    Array.isArray(l) ? (r = [], t = l.length) : (n = Object.keys(l), r = {}, t = n.length);
+    function i(p) {
+      function h() {
+        u && u(p, r), u = null;
+      }
+      e ? o(h) : h();
+    }
+    function s(p, h, d) {
+      r[p] = d, (--t === 0 || h) && i(h);
+    }
+    t ? n ? n.forEach(function(p) {
+      l[p](function(h, d) {
+        s(p, h, d);
+      });
+    }) : l.forEach(function(p, h) {
+      p(function(d, y) {
+        s(h, d, y);
+      });
+    }) : i(null), e = !1;
+  }
+  return jt;
+}
+var Ne = {}, Fr;
+function Cn() {
+  if (Fr) return Ne;
+  Fr = 1, Object.defineProperty(Ne, "__esModule", { value: !0 }), Ne.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+  const o = process.versions.node.split(".");
+  if (o[0] === void 0 || o[1] === void 0)
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+  const a = Number.parseInt(o[0], 10), l = Number.parseInt(o[1], 10), u = 10, r = 10, t = a > u, n = a === u && l >= r;
+  return Ne.IS_SUPPORT_READDIR_WITH_FILE_TYPES = t || n, Ne;
+}
+var qe = {}, Fe = {}, Br;
+function Ss() {
+  if (Br) return Fe;
+  Br = 1, Object.defineProperty(Fe, "__esModule", { value: !0 }), Fe.createDirentFromStats = void 0;
+  class o {
+    constructor(u, r) {
+      this.name = u, this.isBlockDevice = r.isBlockDevice.bind(r), this.isCharacterDevice = r.isCharacterDevice.bind(r), this.isDirectory = r.isDirectory.bind(r), this.isFIFO = r.isFIFO.bind(r), this.isFile = r.isFile.bind(r), this.isSocket = r.isSocket.bind(r), this.isSymbolicLink = r.isSymbolicLink.bind(r);
+    }
+  }
+  function a(l, u) {
+    return new o(l, u);
+  }
+  return Fe.createDirentFromStats = a, Fe;
+}
+var jr;
+function Tn() {
+  if (jr) return qe;
+  jr = 1, Object.defineProperty(qe, "__esModule", { value: !0 }), qe.fs = void 0;
+  const o = Ss();
+  return qe.fs = o, qe;
+}
+var Be = {}, Gr;
+function On() {
+  if (Gr) return Be;
+  Gr = 1, Object.defineProperty(Be, "__esModule", { value: !0 }), Be.joinPathSegments = void 0;
+  function o(a, l, u) {
+    return a.endsWith(u) ? a + l : a + u + l;
+  }
+  return Be.joinPathSegments = o, Be;
+}
+var Ur;
+function ms() {
+  if (Ur) return Re;
+  Ur = 1, Object.defineProperty(Re, "__esModule", { value: !0 }), Re.readdir = Re.readdirWithFileTypes = Re.read = void 0;
+  const o = Le(), a = ys(), l = Cn(), u = Tn(), r = On();
+  function t(h, d, y) {
+    if (!d.stats && l.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+      n(h, d, y);
+      return;
+    }
+    i(h, d, y);
+  }
+  Re.read = t;
+  function n(h, d, y) {
+    d.fs.readdir(h, { withFileTypes: !0 }, (T, C) => {
+      if (T !== null) {
+        s(y, T);
+        return;
+      }
+      const m = C.map((_) => ({
+        dirent: _,
+        name: _.name,
+        path: r.joinPathSegments(h, _.name, d.pathSegmentSeparator)
+      }));
+      if (!d.followSymbolicLinks) {
+        p(y, m);
+        return;
+      }
+      const S = m.map((_) => e(_, d));
+      a(S, (_, c) => {
+        if (_ !== null) {
+          s(y, _);
+          return;
+        }
+        p(y, c);
+      });
+    });
+  }
+  Re.readdirWithFileTypes = n;
+  function e(h, d) {
+    return (y) => {
+      if (!h.dirent.isSymbolicLink()) {
+        y(null, h);
+        return;
+      }
+      d.fs.stat(h.path, (T, C) => {
+        if (T !== null) {
+          if (d.throwErrorOnBrokenSymbolicLink) {
+            y(T);
+            return;
+          }
+          y(null, h);
+          return;
+        }
+        h.dirent = u.fs.createDirentFromStats(h.name, C), y(null, h);
+      });
+    };
+  }
+  function i(h, d, y) {
+    d.fs.readdir(h, (T, C) => {
+      if (T !== null) {
+        s(y, T);
+        return;
+      }
+      const m = C.map((S) => {
+        const _ = r.joinPathSegments(h, S, d.pathSegmentSeparator);
+        return (c) => {
+          o.stat(_, d.fsStatSettings, (f, g) => {
+            if (f !== null) {
+              c(f);
+              return;
+            }
+            const R = {
+              name: S,
+              path: _,
+              dirent: u.fs.createDirentFromStats(S, g)
+            };
+            d.stats && (R.stats = g), c(null, R);
+          });
+        };
+      });
+      a(m, (S, _) => {
+        if (S !== null) {
+          s(y, S);
+          return;
+        }
+        p(y, _);
+      });
+    });
+  }
+  Re.readdir = i;
+  function s(h, d) {
+    h(d);
+  }
+  function p(h, d) {
+    h(null, d);
+  }
+  return Re;
+}
+var Ae = {}, Wr;
+function vs() {
+  if (Wr) return Ae;
+  Wr = 1, Object.defineProperty(Ae, "__esModule", { value: !0 }), Ae.readdir = Ae.readdirWithFileTypes = Ae.read = void 0;
+  const o = Le(), a = Cn(), l = Tn(), u = On();
+  function r(e, i) {
+    return !i.stats && a.IS_SUPPORT_READDIR_WITH_FILE_TYPES ? t(e, i) : n(e, i);
+  }
+  Ae.read = r;
+  function t(e, i) {
+    return i.fs.readdirSync(e, { withFileTypes: !0 }).map((p) => {
+      const h = {
+        dirent: p,
+        name: p.name,
+        path: u.joinPathSegments(e, p.name, i.pathSegmentSeparator)
+      };
+      if (h.dirent.isSymbolicLink() && i.followSymbolicLinks)
+        try {
+          const d = i.fs.statSync(h.path);
+          h.dirent = l.fs.createDirentFromStats(h.name, d);
+        } catch (d) {
+          if (i.throwErrorOnBrokenSymbolicLink)
+            throw d;
+        }
+      return h;
+    });
+  }
+  Ae.readdirWithFileTypes = t;
+  function n(e, i) {
+    return i.fs.readdirSync(e).map((p) => {
+      const h = u.joinPathSegments(e, p, i.pathSegmentSeparator), d = o.statSync(h, i.fsStatSettings), y = {
+        name: p,
+        path: h,
+        dirent: l.fs.createDirentFromStats(p, d)
+      };
+      return i.stats && (y.stats = d), y;
+    });
+  }
+  return Ae.readdir = n, Ae;
+}
+var Xe = {}, Gt = {}, Vr;
+function Rs() {
+  return Vr || (Vr = 1, (function(o) {
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.createFileSystemAdapter = o.FILE_SYSTEM_ADAPTER = void 0;
+    const a = Qt;
+    o.FILE_SYSTEM_ADAPTER = {
+      lstat: a.lstat,
+      stat: a.stat,
+      lstatSync: a.lstatSync,
+      statSync: a.statSync,
+      readdir: a.readdir,
+      readdirSync: a.readdirSync
+    };
+    function l(u) {
+      return u === void 0 ? o.FILE_SYSTEM_ADAPTER : Object.assign(Object.assign({}, o.FILE_SYSTEM_ADAPTER), u);
+    }
+    o.createFileSystemAdapter = l;
+  })(Gt)), Gt;
+}
+var Kr;
+function Es() {
+  if (Kr) return Xe;
+  Kr = 1, Object.defineProperty(Xe, "__esModule", { value: !0 });
+  const o = Se, a = Le(), l = Rs();
+  class u {
+    constructor(t = {}) {
+      this._options = t, this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, !1), this.fs = l.createFileSystemAdapter(this._options.fs), this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, o.sep), this.stats = this._getValue(this._options.stats, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !0), this.fsStatSettings = new a.Settings({
+        followSymbolicLink: this.followSymbolicLinks,
+        fs: this.fs,
+        throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+      });
+    }
+    _getValue(t, n) {
+      return t ?? n;
+    }
+  }
+  return Xe.default = u, Xe;
+}
+var Qr;
+function Zt() {
+  if (Qr) return ve;
+  Qr = 1, Object.defineProperty(ve, "__esModule", { value: !0 }), ve.Settings = ve.scandirSync = ve.scandir = void 0;
+  const o = ms(), a = vs(), l = Es();
+  ve.Settings = l.default;
+  function u(n, e, i) {
+    if (typeof e == "function") {
+      o.read(n, t(), e);
+      return;
+    }
+    o.read(n, t(e), i);
+  }
+  ve.scandir = u;
+  function r(n, e) {
+    const i = t(e);
+    return a.read(n, i);
+  }
+  ve.scandirSync = r;
+  function t(n = {}) {
+    return n instanceof l.default ? n : new l.default(n);
+  }
+  return ve;
+}
+var Ye = { exports: {} }, Ut, Xr;
+function As() {
+  if (Xr) return Ut;
+  Xr = 1;
+  function o(a) {
+    var l = new a(), u = l;
+    function r() {
+      var n = l;
+      return n.next ? l = n.next : (l = new a(), u = l), n.next = null, n;
+    }
+    function t(n) {
+      u.next = n, u = n;
+    }
+    return {
+      get: r,
+      release: t
+    };
+  }
+  return Ut = o, Ut;
+}
+var Yr;
+function bs() {
+  if (Yr) return Ye.exports;
+  Yr = 1;
+  var o = As();
+  function a(t, n, e) {
+    if (typeof t == "function" && (e = n, n = t, t = null), !(e >= 1))
+      throw new Error("fastqueue concurrency must be equal to or greater than 1");
+    var i = o(u), s = null, p = null, h = 0, d = null, y = {
+      push: f,
+      drain: l,
+      saturated: l,
+      pause: C,
+      paused: !1,
+      get concurrency() {
+        return e;
+      },
+      set concurrency(k) {
+        if (!(k >= 1))
+          throw new Error("fastqueue concurrency must be equal to or greater than 1");
+        if (e = k, !y.paused)
+          for (; s && h < e; )
+            h++, R();
+      },
+      running: T,
+      resume: _,
+      idle: c,
+      length: m,
+      getQueue: S,
+      unshift: g,
+      empty: l,
+      kill: v,
+      killAndDrain: P,
+      error: D,
+      abort: O
+    };
+    return y;
+    function T() {
+      return h;
+    }
+    function C() {
+      y.paused = !0;
+    }
+    function m() {
+      for (var k = s, M = 0; k; )
+        k = k.next, M++;
+      return M;
+    }
+    function S() {
+      for (var k = s, M = []; k; )
+        M.push(k.value), k = k.next;
+      return M;
+    }
+    function _() {
+      if (y.paused) {
+        if (y.paused = !1, s === null) {
+          h++, R();
+          return;
+        }
+        for (; s && h < e; )
+          h++, R();
+      }
+    }
+    function c() {
+      return h === 0 && y.length() === 0;
+    }
+    function f(k, M) {
+      var x = i.get();
+      x.context = t, x.release = R, x.value = k, x.callback = M || l, x.errorHandler = d, h >= e || y.paused ? p ? (p.next = x, p = x) : (s = x, p = x, y.saturated()) : (h++, n.call(t, x.value, x.worked));
+    }
+    function g(k, M) {
+      var x = i.get();
+      x.context = t, x.release = R, x.value = k, x.callback = M || l, x.errorHandler = d, h >= e || y.paused ? s ? (x.next = s, s = x) : (s = x, p = x, y.saturated()) : (h++, n.call(t, x.value, x.worked));
+    }
+    function R(k) {
+      k && i.release(k);
+      var M = s;
+      M && h <= e ? y.paused ? h-- : (p === s && (p = null), s = M.next, M.next = null, n.call(t, M.value, M.worked), p === null && y.empty()) : --h === 0 && y.drain();
+    }
+    function v() {
+      s = null, p = null, y.drain = l;
+    }
+    function P() {
+      s = null, p = null, y.drain(), y.drain = l;
+    }
+    function O() {
+      var k = s;
+      for (s = null, p = null; k; ) {
+        var M = k.next, x = k.callback, U = k.errorHandler, N = k.value, q = k.context;
+        k.value = null, k.callback = l, k.errorHandler = null, U && U(new Error("abort"), N), x.call(q, new Error("abort")), k.release(k), k = M;
+      }
+      y.drain = l;
+    }
+    function D(k) {
+      d = k;
+    }
+  }
+  function l() {
+  }
+  function u() {
+    this.value = null, this.callback = l, this.next = null, this.release = l, this.context = null, this.errorHandler = null;
+    var t = this;
+    this.worked = function(e, i) {
+      var s = t.callback, p = t.errorHandler, h = t.value;
+      t.value = null, t.callback = l, t.errorHandler && p(e, h), s.call(t.context, e, i), t.release(t);
+    };
+  }
+  function r(t, n, e) {
+    typeof t == "function" && (e = n, n = t, t = null);
+    function i(C, m) {
+      n.call(this, C).then(function(S) {
+        m(null, S);
+      }, m);
+    }
+    var s = a(t, i, e), p = s.push, h = s.unshift;
+    return s.push = d, s.unshift = y, s.drained = T, s;
+    function d(C) {
+      var m = new Promise(function(S, _) {
+        p(C, function(c, f) {
+          if (c) {
+            _(c);
+            return;
+          }
+          S(f);
+        });
+      });
+      return m.catch(l), m;
+    }
+    function y(C) {
+      var m = new Promise(function(S, _) {
+        h(C, function(c, f) {
+          if (c) {
+            _(c);
+            return;
+          }
+          S(f);
+        });
+      });
+      return m.catch(l), m;
+    }
+    function T() {
+      var C = new Promise(function(m) {
+        process.nextTick(function() {
+          if (s.idle())
+            m();
+          else {
+            var S = s.drain;
+            s.drain = function() {
+              typeof S == "function" && S(), m(), s.drain = S;
+            };
+          }
+        });
+      });
+      return C;
+    }
+  }
+  return Ye.exports = a, Ye.exports.promise = r, Ye.exports;
+}
+var _e = {}, Zr;
+function zt() {
+  if (Zr) return _e;
+  Zr = 1, Object.defineProperty(_e, "__esModule", { value: !0 }), _e.joinPathSegments = _e.replacePathSegmentSeparator = _e.isAppliedFilter = _e.isFatalError = void 0;
+  function o(r, t) {
+    return r.errorFilter === null ? !0 : !r.errorFilter(t);
+  }
+  _e.isFatalError = o;
+  function a(r, t) {
+    return r === null || r(t);
+  }
+  _e.isAppliedFilter = a;
+  function l(r, t) {
+    return r.split(/[/\\]/).join(t);
+  }
+  _e.replacePathSegmentSeparator = l;
+  function u(r, t, n) {
+    return r === "" ? t : r.endsWith(n) ? r + t : r + n + t;
+  }
+  return _e.joinPathSegments = u, _e;
+}
+var Ze = {}, zr;
+function wn() {
+  if (zr) return Ze;
+  zr = 1, Object.defineProperty(Ze, "__esModule", { value: !0 });
+  const o = zt();
+  class a {
+    constructor(u, r) {
+      this._root = u, this._settings = r, this._root = o.replacePathSegmentSeparator(u, r.pathSegmentSeparator);
+    }
+  }
+  return Ze.default = a, Ze;
+}
+var Jr;
+function $n() {
+  if (Jr) return Ke;
+  Jr = 1, Object.defineProperty(Ke, "__esModule", { value: !0 });
+  const o = Fn, a = Zt(), l = bs(), u = zt(), r = wn();
+  class t extends r.default {
+    constructor(e, i) {
+      super(e, i), this._settings = i, this._scandir = a.scandir, this._emitter = new o.EventEmitter(), this._queue = l(this._worker.bind(this), this._settings.concurrency), this._isFatalError = !1, this._isDestroyed = !1, this._queue.drain = () => {
+        this._isFatalError || this._emitter.emit("end");
+      };
+    }
+    read() {
+      return this._isFatalError = !1, this._isDestroyed = !1, setImmediate(() => {
+        this._pushToQueue(this._root, this._settings.basePath);
+      }), this._emitter;
+    }
+    get isDestroyed() {
+      return this._isDestroyed;
+    }
+    destroy() {
+      if (this._isDestroyed)
+        throw new Error("The reader is already destroyed");
+      this._isDestroyed = !0, this._queue.killAndDrain();
+    }
+    onEntry(e) {
+      this._emitter.on("entry", e);
+    }
+    onError(e) {
+      this._emitter.once("error", e);
+    }
+    onEnd(e) {
+      this._emitter.once("end", e);
+    }
+    _pushToQueue(e, i) {
+      const s = { directory: e, base: i };
+      this._queue.push(s, (p) => {
+        p !== null && this._handleError(p);
+      });
+    }
+    _worker(e, i) {
+      this._scandir(e.directory, this._settings.fsScandirSettings, (s, p) => {
+        if (s !== null) {
+          i(s, void 0);
+          return;
+        }
+        for (const h of p)
+          this._handleEntry(h, e.base);
+        i(null, void 0);
+      });
+    }
+    _handleError(e) {
+      this._isDestroyed || !u.isFatalError(this._settings, e) || (this._isFatalError = !0, this._isDestroyed = !0, this._emitter.emit("error", e));
+    }
+    _handleEntry(e, i) {
+      if (this._isDestroyed || this._isFatalError)
+        return;
+      const s = e.path;
+      i !== void 0 && (e.path = u.joinPathSegments(i, e.name, this._settings.pathSegmentSeparator)), u.isAppliedFilter(this._settings.entryFilter, e) && this._emitEntry(e), e.dirent.isDirectory() && u.isAppliedFilter(this._settings.deepFilter, e) && this._pushToQueue(s, i === void 0 ? void 0 : e.path);
+    }
+    _emitEntry(e) {
+      this._emitter.emit("entry", e);
+    }
+  }
+  return Ke.default = t, Ke;
+}
+var en;
+function Ps() {
+  if (en) return Ve;
+  en = 1, Object.defineProperty(Ve, "__esModule", { value: !0 });
+  const o = $n();
+  class a {
+    constructor(t, n) {
+      this._root = t, this._settings = n, this._reader = new o.default(this._root, this._settings), this._storage = [];
+    }
+    read(t) {
+      this._reader.onError((n) => {
+        l(t, n);
+      }), this._reader.onEntry((n) => {
+        this._storage.push(n);
+      }), this._reader.onEnd(() => {
+        u(t, this._storage);
+      }), this._reader.read();
+    }
+  }
+  Ve.default = a;
+  function l(r, t) {
+    r(t);
+  }
+  function u(r, t) {
+    r(null, t);
+  }
+  return Ve;
+}
+var ze = {}, tn;
+function xs() {
+  if (tn) return ze;
+  tn = 1, Object.defineProperty(ze, "__esModule", { value: !0 });
+  const o = dt, a = $n();
+  class l {
+    constructor(r, t) {
+      this._root = r, this._settings = t, this._reader = new a.default(this._root, this._settings), this._stream = new o.Readable({
+        objectMode: !0,
+        read: () => {
+        },
+        destroy: () => {
+          this._reader.isDestroyed || this._reader.destroy();
+        }
+      });
+    }
+    read() {
+      return this._reader.onError((r) => {
+        this._stream.emit("error", r);
+      }), this._reader.onEntry((r) => {
+        this._stream.push(r);
+      }), this._reader.onEnd(() => {
+        this._stream.push(null);
+      }), this._reader.read(), this._stream;
+    }
+  }
+  return ze.default = l, ze;
+}
+var Je = {}, et = {}, rn;
+function Cs() {
+  if (rn) return et;
+  rn = 1, Object.defineProperty(et, "__esModule", { value: !0 });
+  const o = Zt(), a = zt(), l = wn();
+  class u extends l.default {
+    constructor() {
+      super(...arguments), this._scandir = o.scandirSync, this._storage = [], this._queue = /* @__PURE__ */ new Set();
+    }
+    read() {
+      return this._pushToQueue(this._root, this._settings.basePath), this._handleQueue(), this._storage;
+    }
+    _pushToQueue(t, n) {
+      this._queue.add({ directory: t, base: n });
+    }
+    _handleQueue() {
+      for (const t of this._queue.values())
+        this._handleDirectory(t.directory, t.base);
+    }
+    _handleDirectory(t, n) {
+      try {
+        const e = this._scandir(t, this._settings.fsScandirSettings);
+        for (const i of e)
+          this._handleEntry(i, n);
+      } catch (e) {
+        this._handleError(e);
+      }
+    }
+    _handleError(t) {
+      if (a.isFatalError(this._settings, t))
+        throw t;
+    }
+    _handleEntry(t, n) {
+      const e = t.path;
+      n !== void 0 && (t.path = a.joinPathSegments(n, t.name, this._settings.pathSegmentSeparator)), a.isAppliedFilter(this._settings.entryFilter, t) && this._pushToStorage(t), t.dirent.isDirectory() && a.isAppliedFilter(this._settings.deepFilter, t) && this._pushToQueue(e, n === void 0 ? void 0 : t.path);
+    }
+    _pushToStorage(t) {
+      this._storage.push(t);
+    }
+  }
+  return et.default = u, et;
+}
+var nn;
+function Ts() {
+  if (nn) return Je;
+  nn = 1, Object.defineProperty(Je, "__esModule", { value: !0 });
+  const o = Cs();
+  class a {
+    constructor(u, r) {
+      this._root = u, this._settings = r, this._reader = new o.default(this._root, this._settings);
+    }
+    read() {
+      return this._reader.read();
+    }
+  }
+  return Je.default = a, Je;
+}
+var tt = {}, sn;
+function Os() {
+  if (sn) return tt;
+  sn = 1, Object.defineProperty(tt, "__esModule", { value: !0 });
+  const o = Se, a = Zt();
+  class l {
+    constructor(r = {}) {
+      this._options = r, this.basePath = this._getValue(this._options.basePath, void 0), this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY), this.deepFilter = this._getValue(this._options.deepFilter, null), this.entryFilter = this._getValue(this._options.entryFilter, null), this.errorFilter = this._getValue(this._options.errorFilter, null), this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, o.sep), this.fsScandirSettings = new a.Settings({
+        followSymbolicLinks: this._options.followSymbolicLinks,
+        fs: this._options.fs,
+        pathSegmentSeparator: this._options.pathSegmentSeparator,
+        stats: this._options.stats,
+        throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+      });
+    }
+    _getValue(r, t) {
+      return r ?? t;
+    }
+  }
+  return tt.default = l, tt;
+}
+var an;
+function Jt() {
+  if (an) return de;
+  an = 1, Object.defineProperty(de, "__esModule", { value: !0 }), de.Settings = de.walkStream = de.walkSync = de.walk = void 0;
+  const o = Ps(), a = xs(), l = Ts(), u = Os();
+  de.Settings = u.default;
+  function r(i, s, p) {
+    if (typeof s == "function") {
+      new o.default(i, e()).read(s);
+      return;
+    }
+    new o.default(i, e(s)).read(p);
+  }
+  de.walk = r;
+  function t(i, s) {
+    const p = e(s);
+    return new l.default(i, p).read();
+  }
+  de.walkSync = t;
+  function n(i, s) {
+    const p = e(s);
+    return new a.default(i, p).read();
+  }
+  de.walkStream = n;
+  function e(i = {}) {
+    return i instanceof u.default ? i : new u.default(i);
+  }
+  return de;
+}
+var rt = {}, on;
+function er() {
+  if (on) return rt;
+  on = 1, Object.defineProperty(rt, "__esModule", { value: !0 });
+  const o = Se, a = Le(), l = Te();
+  class u {
+    constructor(t) {
+      this._settings = t, this._fsStatSettings = new a.Settings({
+        followSymbolicLink: this._settings.followSymbolicLinks,
+        fs: this._settings.fs,
+        throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+      });
+    }
+    _getFullEntryPath(t) {
+      return o.resolve(this._settings.cwd, t);
+    }
+    _makeEntry(t, n) {
+      const e = {
+        name: n,
+        path: n,
+        dirent: l.fs.createDirentFromStats(n, t)
+      };
+      return this._settings.stats && (e.stats = t), e;
+    }
+    _isFatalError(t) {
+      return !l.errno.isEnoentCodeError(t) && !this._settings.suppressErrors;
+    }
+  }
+  return rt.default = u, rt;
+}
+var nt = {}, un;
+function Ln() {
+  if (un) return nt;
+  un = 1, Object.defineProperty(nt, "__esModule", { value: !0 });
+  const o = dt, a = Le(), l = Jt(), u = er();
+  class r extends u.default {
+    constructor() {
+      super(...arguments), this._walkStream = l.walkStream, this._stat = a.stat;
+    }
+    dynamic(n, e) {
+      return this._walkStream(n, e);
+    }
+    static(n, e) {
+      const i = n.map(this._getFullEntryPath, this), s = new o.PassThrough({ objectMode: !0 });
+      s._write = (p, h, d) => this._getEntry(i[p], n[p], e).then((y) => {
+        y !== null && e.entryFilter(y) && s.push(y), p === i.length - 1 && s.end(), d();
+      }).catch(d);
+      for (let p = 0; p < i.length; p++)
+        s.write(p);
+      return s;
+    }
+    _getEntry(n, e, i) {
+      return this._getStat(n).then((s) => this._makeEntry(s, e)).catch((s) => {
+        if (i.errorFilter(s))
+          return null;
+        throw s;
+      });
+    }
+    _getStat(n) {
+      return new Promise((e, i) => {
+        this._stat(n, this._fsStatSettings, (s, p) => s === null ? e(p) : i(s));
+      });
+    }
+  }
+  return nt.default = r, nt;
+}
+var cn;
+function ws() {
+  if (cn) return We;
+  cn = 1, Object.defineProperty(We, "__esModule", { value: !0 });
+  const o = Jt(), a = er(), l = Ln();
+  class u extends a.default {
+    constructor() {
+      super(...arguments), this._walkAsync = o.walk, this._readerStream = new l.default(this._settings);
+    }
+    dynamic(t, n) {
+      return new Promise((e, i) => {
+        this._walkAsync(t, n, (s, p) => {
+          s === null ? e(p) : i(s);
+        });
+      });
+    }
+    async static(t, n) {
+      const e = [], i = this._readerStream.static(t, n);
+      return new Promise((s, p) => {
+        i.once("error", p), i.on("data", (h) => e.push(h)), i.once("end", () => s(e));
+      });
+    }
+  }
+  return We.default = u, We;
+}
+var st = {}, it = {}, at = {}, ot = {}, ln;
+function $s() {
+  if (ln) return ot;
+  ln = 1, Object.defineProperty(ot, "__esModule", { value: !0 });
+  const o = Te();
+  class a {
+    constructor(u, r, t) {
+      this._patterns = u, this._settings = r, this._micromatchOptions = t, this._storage = [], this._fillStorage();
+    }
+    _fillStorage() {
+      for (const u of this._patterns) {
+        const r = this._getPatternSegments(u), t = this._splitSegmentsIntoSections(r);
+        this._storage.push({
+          complete: t.length <= 1,
+          pattern: u,
+          segments: r,
+          sections: t
+        });
+      }
+    }
+    _getPatternSegments(u) {
+      return o.pattern.getPatternParts(u, this._micromatchOptions).map((t) => o.pattern.isDynamicPattern(t, this._settings) ? {
+        dynamic: !0,
+        pattern: t,
+        patternRe: o.pattern.makeRe(t, this._micromatchOptions)
+      } : {
+        dynamic: !1,
+        pattern: t
+      });
+    }
+    _splitSegmentsIntoSections(u) {
+      return o.array.splitWhen(u, (r) => r.dynamic && o.pattern.hasGlobStar(r.pattern));
+    }
+  }
+  return ot.default = a, ot;
+}
+var fn;
+function Ls() {
+  if (fn) return at;
+  fn = 1, Object.defineProperty(at, "__esModule", { value: !0 });
+  const o = $s();
+  class a extends o.default {
+    match(u) {
+      const r = u.split("/"), t = r.length, n = this._storage.filter((e) => !e.complete || e.segments.length > t);
+      for (const e of n) {
+        const i = e.sections[0];
+        if (!e.complete && t > i.length || r.every((p, h) => {
+          const d = e.segments[h];
+          return !!(d.dynamic && d.patternRe.test(p) || !d.dynamic && d.pattern === p);
+        }))
+          return !0;
+      }
+      return !1;
+    }
+  }
+  return at.default = a, at;
+}
+var hn;
+function ks() {
+  if (hn) return it;
+  hn = 1, Object.defineProperty(it, "__esModule", { value: !0 });
+  const o = Te(), a = Ls();
+  class l {
+    constructor(r, t) {
+      this._settings = r, this._micromatchOptions = t;
+    }
+    getFilter(r, t, n) {
+      const e = this._getMatcher(t), i = this._getNegativePatternsRe(n);
+      return (s) => this._filter(r, s, e, i);
+    }
+    _getMatcher(r) {
+      return new a.default(r, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(r) {
+      const t = r.filter(o.pattern.isAffectDepthOfReadingPattern);
+      return o.pattern.convertPatternsToRe(t, this._micromatchOptions);
+    }
+    _filter(r, t, n, e) {
+      if (this._isSkippedByDeep(r, t.path) || this._isSkippedSymbolicLink(t))
+        return !1;
+      const i = o.path.removeLeadingDotSegment(t.path);
+      return this._isSkippedByPositivePatterns(i, n) ? !1 : this._isSkippedByNegativePatterns(i, e);
+    }
+    _isSkippedByDeep(r, t) {
+      return this._settings.deep === 1 / 0 ? !1 : this._getEntryLevel(r, t) >= this._settings.deep;
+    }
+    _getEntryLevel(r, t) {
+      const n = t.split("/").length;
+      if (r === "")
+        return n;
+      const e = r.split("/").length;
+      return n - e;
+    }
+    _isSkippedSymbolicLink(r) {
+      return !this._settings.followSymbolicLinks && r.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(r, t) {
+      return !this._settings.baseNameMatch && !t.match(r);
+    }
+    _isSkippedByNegativePatterns(r, t) {
+      return !o.pattern.matchAny(r, t);
+    }
+  }
+  return it.default = l, it;
+}
+var ut = {}, pn;
+function Ms() {
+  if (pn) return ut;
+  pn = 1, Object.defineProperty(ut, "__esModule", { value: !0 });
+  const o = Te();
+  class a {
+    constructor(u, r) {
+      this._settings = u, this._micromatchOptions = r, this.index = /* @__PURE__ */ new Map();
+    }
+    getFilter(u, r) {
+      const [t, n] = o.pattern.partitionAbsoluteAndRelative(r), e = {
+        positive: {
+          all: o.pattern.convertPatternsToRe(u, this._micromatchOptions)
+        },
+        negative: {
+          absolute: o.pattern.convertPatternsToRe(t, Object.assign(Object.assign({}, this._micromatchOptions), { dot: !0 })),
+          relative: o.pattern.convertPatternsToRe(n, Object.assign(Object.assign({}, this._micromatchOptions), { dot: !0 }))
+        }
+      };
+      return (i) => this._filter(i, e);
+    }
+    _filter(u, r) {
+      const t = o.path.removeLeadingDotSegment(u.path);
+      if (this._settings.unique && this._isDuplicateEntry(t) || this._onlyFileFilter(u) || this._onlyDirectoryFilter(u))
+        return !1;
+      const n = this._isMatchToPatternsSet(t, r, u.dirent.isDirectory());
+      return this._settings.unique && n && this._createIndexRecord(t), n;
+    }
+    _isDuplicateEntry(u) {
+      return this.index.has(u);
+    }
+    _createIndexRecord(u) {
+      this.index.set(u, void 0);
+    }
+    _onlyFileFilter(u) {
+      return this._settings.onlyFiles && !u.dirent.isFile();
+    }
+    _onlyDirectoryFilter(u) {
+      return this._settings.onlyDirectories && !u.dirent.isDirectory();
+    }
+    _isMatchToPatternsSet(u, r, t) {
+      return !(!this._isMatchToPatterns(u, r.positive.all, t) || this._isMatchToPatterns(u, r.negative.relative, t) || this._isMatchToAbsoluteNegative(u, r.negative.absolute, t));
+    }
+    _isMatchToAbsoluteNegative(u, r, t) {
+      if (r.length === 0)
+        return !1;
+      const n = o.path.makeAbsolute(this._settings.cwd, u);
+      return this._isMatchToPatterns(n, r, t);
+    }
+    _isMatchToPatterns(u, r, t) {
+      if (r.length === 0)
+        return !1;
+      const n = o.pattern.matchAny(u, r);
+      return !n && t ? o.pattern.matchAny(u + "/", r) : n;
+    }
+  }
+  return ut.default = a, ut;
+}
+var ct = {}, dn;
+function Hs() {
+  if (dn) return ct;
+  dn = 1, Object.defineProperty(ct, "__esModule", { value: !0 });
+  const o = Te();
+  class a {
+    constructor(u) {
+      this._settings = u;
+    }
+    getFilter() {
+      return (u) => this._isNonFatalError(u);
+    }
+    _isNonFatalError(u) {
+      return o.errno.isEnoentCodeError(u) || this._settings.suppressErrors;
+    }
+  }
+  return ct.default = a, ct;
+}
+var lt = {}, _n;
+function Ds() {
+  if (_n) return lt;
+  _n = 1, Object.defineProperty(lt, "__esModule", { value: !0 });
+  const o = Te();
+  class a {
+    constructor(u) {
+      this._settings = u;
+    }
+    getTransformer() {
+      return (u) => this._transform(u);
+    }
+    _transform(u) {
+      let r = u.path;
+      return this._settings.absolute && (r = o.path.makeAbsolute(this._settings.cwd, r), r = o.path.unixify(r)), this._settings.markDirectories && u.dirent.isDirectory() && (r += "/"), this._settings.objectMode ? Object.assign(Object.assign({}, u), { path: r }) : r;
+    }
+  }
+  return lt.default = a, lt;
+}
+var gn;
+function tr() {
+  if (gn) return st;
+  gn = 1, Object.defineProperty(st, "__esModule", { value: !0 });
+  const o = Se, a = ks(), l = Ms(), u = Hs(), r = Ds();
+  class t {
+    constructor(e) {
+      this._settings = e, this.errorFilter = new u.default(this._settings), this.entryFilter = new l.default(this._settings, this._getMicromatchOptions()), this.deepFilter = new a.default(this._settings, this._getMicromatchOptions()), this.entryTransformer = new r.default(this._settings);
+    }
+    _getRootDirectory(e) {
+      return o.resolve(this._settings.cwd, e.base);
+    }
+    _getReaderOptions(e) {
+      const i = e.base === "." ? "" : e.base;
+      return {
+        basePath: i,
+        pathSegmentSeparator: "/",
+        concurrency: this._settings.concurrency,
+        deepFilter: this.deepFilter.getFilter(i, e.positive, e.negative),
+        entryFilter: this.entryFilter.getFilter(e.positive, e.negative),
+        errorFilter: this.errorFilter.getFilter(),
+        followSymbolicLinks: this._settings.followSymbolicLinks,
+        fs: this._settings.fs,
+        stats: this._settings.stats,
+        throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+        transform: this.entryTransformer.getTransformer()
+      };
+    }
+    _getMicromatchOptions() {
+      return {
+        dot: this._settings.dot,
+        matchBase: this._settings.baseNameMatch,
+        nobrace: !this._settings.braceExpansion,
+        nocase: !this._settings.caseSensitiveMatch,
+        noext: !this._settings.extglob,
+        noglobstar: !this._settings.globstar,
+        posix: !0,
+        strictSlashes: !1
+      };
+    }
+  }
+  return st.default = t, st;
+}
+var yn;
+function Is() {
+  if (yn) return Ue;
+  yn = 1, Object.defineProperty(Ue, "__esModule", { value: !0 });
+  const o = ws(), a = tr();
+  class l extends a.default {
+    constructor() {
+      super(...arguments), this._reader = new o.default(this._settings);
+    }
+    async read(r) {
+      const t = this._getRootDirectory(r), n = this._getReaderOptions(r);
+      return (await this.api(t, r, n)).map((i) => n.transform(i));
+    }
+    api(r, t, n) {
+      return t.dynamic ? this._reader.dynamic(r, n) : this._reader.static(t.patterns, n);
+    }
+  }
+  return Ue.default = l, Ue;
+}
+var ft = {}, Sn;
+function Ns() {
+  if (Sn) return ft;
+  Sn = 1, Object.defineProperty(ft, "__esModule", { value: !0 });
+  const o = dt, a = Ln(), l = tr();
+  class u extends l.default {
+    constructor() {
+      super(...arguments), this._reader = new a.default(this._settings);
+    }
+    read(t) {
+      const n = this._getRootDirectory(t), e = this._getReaderOptions(t), i = this.api(n, t, e), s = new o.Readable({ objectMode: !0, read: () => {
+      } });
+      return i.once("error", (p) => s.emit("error", p)).on("data", (p) => s.emit("data", e.transform(p))).once("end", () => s.emit("end")), s.once("close", () => i.destroy()), s;
+    }
+    api(t, n, e) {
+      return n.dynamic ? this._reader.dynamic(t, e) : this._reader.static(n.patterns, e);
+    }
+  }
+  return ft.default = u, ft;
+}
+var ht = {}, pt = {}, mn;
+function qs() {
+  if (mn) return pt;
+  mn = 1, Object.defineProperty(pt, "__esModule", { value: !0 });
+  const o = Le(), a = Jt(), l = er();
+  class u extends l.default {
+    constructor() {
+      super(...arguments), this._walkSync = a.walkSync, this._statSync = o.statSync;
+    }
+    dynamic(t, n) {
+      return this._walkSync(t, n);
+    }
+    static(t, n) {
+      const e = [];
+      for (const i of t) {
+        const s = this._getFullEntryPath(i), p = this._getEntry(s, i, n);
+        p === null || !n.entryFilter(p) || e.push(p);
+      }
+      return e;
+    }
+    _getEntry(t, n, e) {
+      try {
+        const i = this._getStat(t);
+        return this._makeEntry(i, n);
+      } catch (i) {
+        if (e.errorFilter(i))
+          return null;
+        throw i;
+      }
+    }
+    _getStat(t) {
+      return this._statSync(t, this._fsStatSettings);
+    }
+  }
+  return pt.default = u, pt;
+}
+var vn;
+function Fs() {
+  if (vn) return ht;
+  vn = 1, Object.defineProperty(ht, "__esModule", { value: !0 });
+  const o = qs(), a = tr();
+  class l extends a.default {
+    constructor() {
+      super(...arguments), this._reader = new o.default(this._settings);
+    }
+    read(r) {
+      const t = this._getRootDirectory(r), n = this._getReaderOptions(r);
+      return this.api(t, r, n).map(n.transform);
+    }
+    api(r, t, n) {
+      return t.dynamic ? this._reader.dynamic(r, n) : this._reader.static(t.patterns, n);
+    }
+  }
+  return ht.default = l, ht;
+}
+var Wt = {}, Rn;
+function Bs() {
+  return Rn || (Rn = 1, (function(o) {
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+    const a = Qt, u = Math.max(Kt.cpus().length, 1);
+    o.DEFAULT_FILE_SYSTEM_ADAPTER = {
+      lstat: a.lstat,
+      lstatSync: a.lstatSync,
+      stat: a.stat,
+      statSync: a.statSync,
+      readdir: a.readdir,
+      readdirSync: a.readdirSync
+    };
+    class r {
+      constructor(n = {}) {
+        this._options = n, this.absolute = this._getValue(this._options.absolute, !1), this.baseNameMatch = this._getValue(this._options.baseNameMatch, !1), this.braceExpansion = this._getValue(this._options.braceExpansion, !0), this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, !0), this.concurrency = this._getValue(this._options.concurrency, u), this.cwd = this._getValue(this._options.cwd, process.cwd()), this.deep = this._getValue(this._options.deep, 1 / 0), this.dot = this._getValue(this._options.dot, !1), this.extglob = this._getValue(this._options.extglob, !0), this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, !0), this.fs = this._getFileSystemMethods(this._options.fs), this.globstar = this._getValue(this._options.globstar, !0), this.ignore = this._getValue(this._options.ignore, []), this.markDirectories = this._getValue(this._options.markDirectories, !1), this.objectMode = this._getValue(this._options.objectMode, !1), this.onlyDirectories = this._getValue(this._options.onlyDirectories, !1), this.onlyFiles = this._getValue(this._options.onlyFiles, !0), this.stats = this._getValue(this._options.stats, !1), this.suppressErrors = this._getValue(this._options.suppressErrors, !1), this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, !1), this.unique = this._getValue(this._options.unique, !0), this.onlyDirectories && (this.onlyFiles = !1), this.stats && (this.objectMode = !0), this.ignore = [].concat(this.ignore);
+      }
+      _getValue(n, e) {
+        return n === void 0 ? e : n;
+      }
+      _getFileSystemMethods(n = {}) {
+        return Object.assign(Object.assign({}, o.DEFAULT_FILE_SYSTEM_ADAPTER), n);
+      }
+    }
+    o.default = r;
+  })(Wt)), Wt;
+}
+var Vt, En;
+function js() {
+  if (En) return Vt;
+  En = 1;
+  const o = fs(), a = Is(), l = Ns(), u = Fs(), r = Bs(), t = Te();
+  async function n(s, p) {
+    i(s);
+    const h = e(s, a.default, p), d = await Promise.all(h);
+    return t.array.flatten(d);
+  }
+  (function(s) {
+    s.glob = s, s.globSync = p, s.globStream = h, s.async = s;
+    function p(m, S) {
+      i(m);
+      const _ = e(m, u.default, S);
+      return t.array.flatten(_);
+    }
+    s.sync = p;
+    function h(m, S) {
+      i(m);
+      const _ = e(m, l.default, S);
+      return t.stream.merge(_);
+    }
+    s.stream = h;
+    function d(m, S) {
+      i(m);
+      const _ = [].concat(m), c = new r.default(S);
+      return o.generate(_, c);
+    }
+    s.generateTasks = d;
+    function y(m, S) {
+      i(m);
+      const _ = new r.default(S);
+      return t.pattern.isDynamicPattern(m, _);
+    }
+    s.isDynamicPattern = y;
+    function T(m) {
+      return i(m), t.path.escape(m);
+    }
+    s.escapePath = T;
+    function C(m) {
+      return i(m), t.path.convertPathToPattern(m);
+    }
+    s.convertPathToPattern = C, (function(m) {
+      function S(c) {
+        return i(c), t.path.escapePosixPath(c);
+      }
+      m.escapePath = S;
+      function _(c) {
+        return i(c), t.path.convertPosixPathToPattern(c);
+      }
+      m.convertPathToPattern = _;
+    })(s.posix || (s.posix = {})), (function(m) {
+      function S(c) {
+        return i(c), t.path.escapeWindowsPath(c);
+      }
+      m.escapePath = S;
+      function _(c) {
+        return i(c), t.path.convertWindowsPathToPattern(c);
+      }
+      m.convertPathToPattern = _;
+    })(s.win32 || (s.win32 = {}));
+  })(n || (n = {}));
+  function e(s, p, h) {
+    const d = [].concat(s), y = new r.default(h), T = o.generate(d, y), C = new p(y);
+    return T.map(C.read, C);
+  }
+  function i(s) {
+    if (![].concat(s).every((d) => t.string.isString(d) && !t.string.isEmpty(d)))
+      throw new TypeError("Patterns must be a string (non empty) or an array of strings");
+  }
+  return Vt = n, Vt;
+}
+var Gs = js();
+const Us = /* @__PURE__ */ Dn(Gs), Ws = [".md", ".mdc", ".js", ".ts", ".tsx", ".go", ".sh", ".puml", "."], Vs = (o, a = {}) => {
+  const { extensions: l = Ws, exclude: u = [], ignoreDefaultExcludes: r = !1 } = a, n = (Array.isArray(u) ? u : [u]).map((y) => /[*{}!]/.test(y) ? y : `**/*${y}`);
+  r || n.push("**/node_modules/**");
+  const i = (Array.isArray(o) ? o : [o]).map((y) => {
+    try {
+      if (yt.existsSync(y) && yt.statSync(y).isDirectory())
+        return St.join(y, "**/*");
+    } catch (T) {
+      xe.debug(`[catGen] [paths → glob] Treating as glob: ${y}`, { cause: T });
+    }
+    return y;
+  }), s = {
+    ignore: n,
+    onlyFiles: !0,
+    absolute: !0,
+    dot: r,
+    suppressErrors: !0
+  };
+  let p = Us.sync(i, s);
+  const h = new Set(Array.isArray(l) ? l : [l]);
+  return h.has("*") || (p = p.filter((y) => h.has(St.extname(y).toLowerCase()))), p.map((y) => {
+    try {
+      const T = yt.readFileSync(y, "utf8"), C = St.relative(process.cwd(), y);
+      return { absPath: y, relativePath: C, contents: T };
+    } catch (T) {
+      return xe.warn(`[catGen] [reading → skip] ${y}`, { cause: T }), null;
+    }
+  }).filter((y) => y !== null);
+};
+async function Ks(o, a = {}) {
+  const l = In(o);
+  if (!l)
+    return {
+      ok: !1,
+      error: `Не удалось распознать URL: ${o}. Ожидается GitLab MR или GitHub PR.`
+    };
+  let u, r;
+  if (l.provider === "gitlab") {
+    if (u = process.env.GITLAB_PERSONAL_TOKEN ?? "", !u) return { ok: !1, error: "GITLAB_PERSONAL_TOKEN не установлен." };
+    r = `https://${l.host}${process.env.GITLAB_API_PATH ?? "/api/v4"}`;
+  } else {
+    if (u = process.env.GITHUB_PERSONAL_TOKEN ?? "", !u) return { ok: !1, error: "GITHUB_PERSONAL_TOKEN не установлен." };
+    r = l.host === "github.com" ? "https://api.github.com" : `https://${l.host}/api/v3`;
+  }
+  xe.info(
+    `[cat --url] provider=${l.provider} repo=${l.repository} iid=${l.iid}`
+  );
+  const t = l.provider === "gitlab" ? new Nn({ baseUrl: r, token: u }) : new qn({ baseUrl: r, token: u });
+  let n;
+  try {
+    n = await t.MergeRequests.getChanges({
+      repository: l.repository,
+      iid: l.iid
+    });
+  } catch (h) {
+    return {
+      ok: !1,
+      error: `Ошибка получения изменений: ${h instanceof Error ? h.message : String(h)}`
+    };
+  }
+  if (n.length === 0)
+    return { ok: !1, error: "MR/PR не содержит изменённых файлов." };
+  let e = n.filter((h) => h.status !== "deleted");
+  if (a.exclude) {
+    const h = Array.isArray(a.exclude) ? a.exclude : [a.exclude];
+    e = e.filter((d) => !h.some((y) => d.path.includes(y.replace(/\*/g, ""))));
+  }
+  if (a.extensions && a.extensions.length > 0) {
+    const h = new Set(a.extensions.map((d) => d.toLowerCase()));
+    e = e.filter((d) => {
+      const y = d.path.includes(".") ? "." + (d.path.split(".").pop() ?? "").toLowerCase() : ".";
+      return h.has(y);
+    });
+  }
+  if (e.length === 0)
+    return { ok: !1, error: "После фильтрации не осталось файлов для вывода." };
+  const i = e.length > 0 ? e[0].ref : "N/A";
+  xe.info(`[cat --url] total=${n.length} filtered=${e.length} ref=${i}`);
+  const s = [];
+  let p = 0;
+  for (const h of e) {
+    let d;
+    try {
+      if (d = await t.RepositoryFiles?.getFileContent({
+        repository: l.repository,
+        path: h.path,
+        ref: h.ref
+      }), !d) {
+        p++, xe.warn(`[cat --url] skip ${h.path}: 404 (ref=${h.ref}, repo=${l.repository})`);
+        continue;
+      }
+      if (d.encoding === "base64") {
+        p++, xe.warn(`[cat --url] skip ${h.path}: binary`);
+        continue;
+      }
+    } catch (y) {
+      p++, xe.warn(`[cat --url] skip ${h.path}: error: ${y.message}`);
+      continue;
+    }
+    s.push({
+      absPath: `vcs://${l.host}/${l.repository}/${h.path}?ref=${h.ref}`,
+      relativePath: h.path,
+      contents: d.content
+    });
+  }
+  return p > 0 && xe.info(`[cat --url] skipped ${p} files`), { ok: !0, files: s };
+}
+const Ce = Bn(process.argv, {
+  plain: ["plain"],
+  exclude: ["exclude", "e"],
+  extensions: ["ext"],
+  output: ["o"],
+  url: ["url"]
+}), An = (o) => {
+  console.log(ne.blue("## CODEBASE:")), o.forEach(({ relativePath: a, contents: l }) => {
+    console.log(ne.blue(`### SOURCE: ${a}`)), console.log(ne.gray("```" + (a.split(".").pop() ?? ""))), console.log(l), console.log(ne.gray("```")), console.log("");
+  });
+}, bn = (o) => {
+  console.log(ne.blue("<Codebase>")), o.forEach(({ relativePath: a, contents: l }) => {
+    const u = [
+      `${ne.yellow("type")}=${ne.green('"file"')}`,
+      `${ne.yellow("path")}=${ne.green(`"${a}"`)}`
+    ].join(" ");
+    console.log(`  ${ne.blue("<Source")} ${u}${ne.blue(">")}`), console.log(l), console.log(`  ${ne.blue("</Source>")}`);
+  }), console.log(ne.blue("</Codebase>")), console.log("");
+}, $e = Ce.url, rr = Ce._.filter((o) => !(o === "cat" || o.endsWith(".ts") || o.endsWith(".js") || o.endsWith(".mjs") || o.startsWith("/") || o.startsWith("./") || o.startsWith("../")));
+rr.length === 0 && !$e && (console.error(ne.yellow("Usage: npx gennady cat <path/to/glob> [--url=<MR/PR URL>]")), process.exit(1));
+$e && rr.length > 0 && (console.error(ne.red("Error: --url and positional arguments are mutually exclusive.")), process.exit(1));
+if ($e) {
+  const o = Ce.extensions, a = o ? Array.isArray(o) ? o : o.split(",").map((u) => u.trim()) : void 0, l = await Ks($e, {
+    exclude: Ce.exclude,
+    extensions: a
+  });
+  l.ok || (console.error(ne.red(l.error)), process.exit(1)), Ce.output === "md" ? An(l.files) : bn(l.files);
+} else {
+  const o = Vs(rr, Ce);
+  Ce.output === "md" ? An(o) : bn(o);
+}
+if (!Ce.plain) {
+  console.log(ne.green("^".repeat(40)));
+  const o = $e ? `npx gennady cat --url="${$e}" --plain | pbcopy` : `npx gennady cat ${process.argv.slice(3).join(" ")} --plain | pbcopy`;
+  console.log(ne.italic.gray(`Hint: ${o}`));
+}
+console.log("");