@opendesign-plus-test/plugins 0.0.1-rc.1 → 0.0.1-rc.11

package/dist/generate-lastmod-changefreq-CYV0c6WF.js

@@ -0,0 +1,1372 @@
+var Ht = Object.defineProperty;
+var St = (i) => {
+  throw TypeError(i);
+};
+var Jt = (i, t, e) => t in i ? Ht(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var $ = (i, t, e) => Jt(i, typeof t != "symbol" ? t + "" : t, e), at = (i, t, e) => t.has(i) || St("Cannot " + e);
+var o = (i, t, e) => (at(i, t, "read from private field"), e ? e.call(i) : t.get(i)), v = (i, t, e) => t.has(i) ? St("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, e), E = (i, t, e, s) => (at(i, t, "write to private field"), s ? s.call(i, e) : t.set(i, e), e), x = (i, t, e) => (at(i, t, "access private method"), e);
+var ht = (i, t, e, s) => ({
+  set _(n) {
+    E(i, t, n, e);
+  },
+  get _() {
+    return o(i, t, s);
+  }
+});
+const vt = (i, t, e) => {
+  const s = i instanceof RegExp ? Et(i, e) : i, n = t instanceof RegExp ? Et(t, e) : t, r = s !== null && n != null && Vt(s, n, e);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: e.slice(0, r[0]),
+    body: e.slice(r[0] + s.length, r[1]),
+    post: e.slice(r[1] + n.length)
+  };
+}, Et = (i, t) => {
+  const e = t.match(i);
+  return e ? e[0] : null;
+}, Vt = (i, t, e) => {
+  let s, n, r, c, f, p = e.indexOf(i), a = e.indexOf(t, p + 1), h = p;
+  if (p >= 0 && a > 0) {
+    if (i === t)
+      return [p, a];
+    for (s = [], r = e.length; h >= 0 && !f; ) {
+      if (h === p)
+        s.push(h), p = e.indexOf(i, h + 1);
+      else if (s.length === 1) {
+        const l = s.pop();
+        l !== void 0 && (f = [l, a]);
+      } else
+        n = s.pop(), n !== void 0 && n < r && (r = n, c = a), a = e.indexOf(t, h + 1);
+      h = p < a && p >= 0 ? p : a;
+    }
+    s.length && c !== void 0 && (f = [r, c]);
+  }
+  return f;
+}, Rt = "\0SLASH" + Math.random() + "\0", jt = "\0OPEN" + Math.random() + "\0", yt = "\0CLOSE" + Math.random() + "\0", Pt = "\0COMMA" + Math.random() + "\0", Ct = "\0PERIOD" + Math.random() + "\0", Xt = new RegExp(Rt, "g"), Qt = new RegExp(jt, "g"), Kt = new RegExp(yt, "g"), Yt = new RegExp(Pt, "g"), te = new RegExp(Ct, "g"), ee = /\\\\/g, se = /\\{/g, ne = /\\}/g, ie = /\\,/g, re = /\\\./g, oe = 1e5;
+function ft(i) {
+  return isNaN(i) ? i.charCodeAt(0) : parseInt(i, 10);
+}
+function ce(i) {
+  return i.replace(ee, Rt).replace(se, jt).replace(ne, yt).replace(ie, Pt).replace(re, Ct);
+}
+function le(i) {
+  return i.replace(Xt, "\\").replace(Qt, "{").replace(Kt, "}").replace(Yt, ",").replace(te, ".");
+}
+function Wt(i) {
+  if (!i)
+    return [""];
+  const t = [], e = vt("{", "}", i);
+  if (!e)
+    return i.split(",");
+  const { pre: s, body: n, post: r } = e, c = s.split(",");
+  c[c.length - 1] += "{" + n + "}";
+  const f = Wt(r);
+  return r.length && (c[c.length - 1] += f.shift(), c.push.apply(c, f)), t.push.apply(t, c), t;
+}
+function ae(i, t = {}) {
+  if (!i)
+    return [];
+  const { max: e = oe } = t;
+  return i.slice(0, 2) === "{}" && (i = "\\{\\}" + i.slice(2)), tt(ce(i), e, !0).map(le);
+}
+function he(i) {
+  return "{" + i + "}";
+}
+function fe(i) {
+  return /^-?0\d/.test(i);
+}
+function ue(i, t) {
+  return i <= t;
+}
+function pe(i, t) {
+  return i >= t;
+}
+function tt(i, t, e) {
+  const s = [], n = vt("{", "}", i);
+  if (!n)
+    return [i];
+  const r = n.pre, c = n.post.length ? tt(n.post, t, !1) : [""];
+  if (/\$$/.test(n.pre))
+    for (let f = 0; f < c.length && f < t; f++) {
+      const p = r + "{" + n.body + "}" + c[f];
+      s.push(p);
+    }
+  else {
+    const f = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(n.body), p = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(n.body), a = f || p, h = n.body.indexOf(",") >= 0;
+    if (!a && !h)
+      return n.post.match(/,(?!,).*\}/) ? (i = n.pre + "{" + n.body + yt + n.post, tt(i, t, !0)) : [i];
+    let l;
+    if (a)
+      l = n.body.split(/\.\./);
+    else if (l = Wt(n.body), l.length === 1 && l[0] !== void 0 && (l = tt(l[0], t, !1).map(he), l.length === 1))
+      return c.map((g) => n.pre + l[0] + g);
+    let u;
+    if (a && l[0] !== void 0 && l[1] !== void 0) {
+      const g = ft(l[0]), w = ft(l[1]), b = Math.max(l[0].length, l[1].length);
+      let P = l.length === 3 && l[2] !== void 0 ? Math.max(Math.abs(ft(l[2])), 1) : 1, T = ue;
+      w < g && (P *= -1, T = pe);
+      const S = l.some(fe);
+      u = [];
+      for (let m = g; T(m, w); m += P) {
+        let y;
+        if (p)
+          y = String.fromCharCode(m), y === "\\" && (y = "");
+        else if (y = String(m), S) {
+          const k = b - y.length;
+          if (k > 0) {
+            const C = new Array(k + 1).join("0");
+            m < 0 ? y = "-" + C + y.slice(1) : y = C + y;
+          }
+        }
+        u.push(y);
+      }
+    } else {
+      u = [];
+      for (let g = 0; g < l.length; g++)
+        u.push.apply(u, tt(l[g], t, !1));
+    }
+    for (let g = 0; g < u.length; g++)
+      for (let w = 0; w < c.length && s.length < t; w++) {
+        const b = r + u[g] + c[w];
+        (!e || a || b) && s.push(b);
+      }
+  }
+  return s;
+}
+const ge = 1024 * 64, ot = (i) => {
+  if (typeof i != "string")
+    throw new TypeError("invalid pattern");
+  if (i.length > ge)
+    throw new TypeError("pattern is too long");
+}, de = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", !0],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", !0],
+  "[:ascii:]": ["\\x00-\\x7f", !1],
+  "[:blank:]": ["\\p{Zs}\\t", !0],
+  "[:cntrl:]": ["\\p{Cc}", !0],
+  "[:digit:]": ["\\p{Nd}", !0],
+  "[:graph:]": ["\\p{Z}\\p{C}", !0, !0],
+  "[:lower:]": ["\\p{Ll}", !0],
+  "[:print:]": ["\\p{C}", !0],
+  "[:punct:]": ["\\p{P}", !0],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", !0],
+  "[:upper:]": ["\\p{Lu}", !0],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", !0],
+  "[:xdigit:]": ["A-Fa-f0-9", !1]
+}, Y = (i) => i.replace(/[[\]\\-]/g, "\\$&"), me = (i) => i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), bt = (i) => i.join(""), ye = (i, t) => {
+  const e = t;
+  if (i.charAt(e) !== "[")
+    throw new Error("not in a brace expression");
+  const s = [], n = [];
+  let r = e + 1, c = !1, f = !1, p = !1, a = !1, h = e, l = "";
+  t: for (; r < i.length; ) {
+    const b = i.charAt(r);
+    if ((b === "!" || b === "^") && r === e + 1) {
+      a = !0, r++;
+      continue;
+    }
+    if (b === "]" && c && !p) {
+      h = r + 1;
+      break;
+    }
+    if (c = !0, b === "\\" && !p) {
+      p = !0, r++;
+      continue;
+    }
+    if (b === "[" && !p) {
+      for (const [P, [T, N, S]] of Object.entries(de))
+        if (i.startsWith(P, r)) {
+          if (l)
+            return ["$.", !1, i.length - e, !0];
+          r += P.length, S ? n.push(T) : s.push(T), f = f || N;
+          continue t;
+        }
+    }
+    if (p = !1, l) {
+      b > l ? s.push(Y(l) + "-" + Y(b)) : b === l && s.push(Y(b)), l = "", r++;
+      continue;
+    }
+    if (i.startsWith("-]", r + 1)) {
+      s.push(Y(b + "-")), r += 2;
+      continue;
+    }
+    if (i.startsWith("-", r + 1)) {
+      l = b, r += 2;
+      continue;
+    }
+    s.push(Y(b)), r++;
+  }
+  if (h < r)
+    return ["", !1, 0, !1];
+  if (!s.length && !n.length)
+    return ["$.", !1, i.length - e, !0];
+  if (n.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !a) {
+    const b = s[0].length === 2 ? s[0].slice(-1) : s[0];
+    return [me(b), !1, h - e, !1];
+  }
+  const u = "[" + (a ? "^" : "") + bt(s) + "]", g = "[" + (a ? "" : "^") + bt(n) + "]";
+  return [s.length && n.length ? "(" + u + "|" + g + ")" : s.length ? u : g, f, h - e, !0];
+}, et = (i, { windowsPathsNoEscape: t = !1, magicalBraces: e = !0 } = {}) => e ? t ? i.replace(/\[([^/\\])\]/g, "$1") : i.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1") : t ? i.replace(/\[([^/\\{}])\]/g, "$1") : i.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
+var D;
+const we = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), ut = (i) => we.has(i), xt = (i) => ut(i.type), Se = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]), Ee = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]), be = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]), Mt = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]), xe = "(?!(?:^|/)\\.\\.?(?:$|/))", st = "(?!\\.)", Me = /* @__PURE__ */ new Set(["[", "."]), Ne = /* @__PURE__ */ new Set(["..", "."]), Ae = new Set("().*{}+?[]^$\\!"), $e = (i) => i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), wt = "[^/]", Nt = wt + "*?", At = wt + "+?";
+let Oe = 0;
+var O, R, F, d, A, B, H, I, z, G, Q, M, Dt, Z, nt, Lt, pt, it, kt, gt, _t, qt, zt, rt, dt, Gt;
+class ct {
+  constructor(t, e, s = {}) {
+    v(this, M);
+    $(this, "type");
+    v(this, O);
+    v(this, R);
+    v(this, F, !1);
+    v(this, d, []);
+    v(this, A);
+    v(this, B);
+    v(this, H);
+    v(this, I, !1);
+    v(this, z);
+    v(this, G);
+    // set to true if it's an extglob with no children
+    // (which really means one child of '')
+    v(this, Q, !1);
+    $(this, "id", ++Oe);
+    this.type = t, t && E(this, R, !0), E(this, A, e), E(this, O, o(this, A) ? o(o(this, A), O) : this), E(this, z, o(this, O) === this ? s : o(o(this, O), z)), E(this, H, o(this, O) === this ? [] : o(o(this, O), H)), t === "!" && !o(o(this, O), I) && o(this, H).push(this), E(this, B, o(this, A) ? o(o(this, A), d).length : 0);
+  }
+  get depth() {
+    var t;
+    return (((t = o(this, A)) == null ? void 0 : t.depth) ?? -1) + 1;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    var t;
+    return {
+      "@@type": "AST",
+      id: this.id,
+      type: this.type,
+      root: o(this, O).id,
+      parent: (t = o(this, A)) == null ? void 0 : t.id,
+      depth: this.depth,
+      partsLength: o(this, d).length,
+      parts: o(this, d)
+    };
+  }
+  get hasMagic() {
+    if (o(this, R) !== void 0)
+      return o(this, R);
+    for (const t of o(this, d))
+      if (typeof t != "string" && (t.type || t.hasMagic))
+        return E(this, R, !0);
+    return o(this, R);
+  }
+  // reconstructs the pattern
+  toString() {
+    return o(this, G) !== void 0 ? o(this, G) : this.type ? E(this, G, this.type + "(" + o(this, d).map((t) => String(t)).join("|") + ")") : E(this, G, o(this, d).map((t) => String(t)).join(""));
+  }
+  push(...t) {
+    for (const e of t)
+      if (e !== "") {
+        if (typeof e != "string" && !(e instanceof D && o(e, A) === this))
+          throw new Error("invalid part: " + e);
+        o(this, d).push(e);
+      }
+  }
+  toJSON() {
+    var e;
+    const t = this.type === null ? o(this, d).slice().map((s) => typeof s == "string" ? s : s.toJSON()) : [this.type, ...o(this, d).map((s) => s.toJSON())];
+    return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === o(this, O) || o(o(this, O), I) && ((e = o(this, A)) == null ? void 0 : e.type) === "!") && t.push({}), t;
+  }
+  isStart() {
+    var e;
+    if (o(this, O) === this)
+      return !0;
+    if (!((e = o(this, A)) != null && e.isStart()))
+      return !1;
+    if (o(this, B) === 0)
+      return !0;
+    const t = o(this, A);
+    for (let s = 0; s < o(this, B); s++) {
+      const n = o(t, d)[s];
+      if (!(n instanceof D && n.type === "!"))
+        return !1;
+    }
+    return !0;
+  }
+  isEnd() {
+    var e, s, n;
+    if (o(this, O) === this || ((e = o(this, A)) == null ? void 0 : e.type) === "!")
+      return !0;
+    if (!((s = o(this, A)) != null && s.isEnd()))
+      return !1;
+    if (!this.type)
+      return (n = o(this, A)) == null ? void 0 : n.isEnd();
+    const t = o(this, A) ? o(o(this, A), d).length : 0;
+    return o(this, B) === t - 1;
+  }
+  copyIn(t) {
+    typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+  }
+  clone(t) {
+    const e = new D(this.type, t);
+    for (const s of o(this, d))
+      e.copyIn(s);
+    return e;
+  }
+  static fromGlob(t, e = {}) {
+    var n;
+    const s = new D(null, void 0, e);
+    return x(n = D, Z, nt).call(n, t, s, 0, e, 0), s;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== o(this, O))
+      return o(this, O).toMMPattern();
+    const t = this.toString(), [e, s, n, r] = this.toRegExpSource();
+    if (!(n || o(this, R) || o(this, z).nocase && !o(this, z).nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase()))
+      return s;
+    const f = (o(this, z).nocase ? "i" : "") + (r ? "u" : "");
+    return Object.assign(new RegExp(`^${e}$`, f), {
+      _src: e,
+      _glob: t
+    });
+  }
+  get options() {
+    return o(this, z);
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(t) {
+    var p;
+    const e = t ?? !!o(this, z).dot;
+    if (o(this, O) === this && (x(this, M, rt).call(this), x(this, M, Dt).call(this)), !xt(this)) {
+      const a = this.isStart() && this.isEnd() && !o(this, d).some((w) => typeof w != "string"), h = o(this, d).map((w) => {
+        var S;
+        const [b, P, T, N] = typeof w == "string" ? x(S = D, Z, Gt).call(S, w, o(this, R), a) : w.toRegExpSource(t);
+        return E(this, R, o(this, R) || T), E(this, F, o(this, F) || N), b;
+      }).join("");
+      let l = "";
+      if (this.isStart() && typeof o(this, d)[0] == "string" && !(o(this, d).length === 1 && Ne.has(o(this, d)[0]))) {
+        const b = Me, P = (
+          // dots are allowed, and the pattern starts with [ or .
+          e && b.has(h.charAt(0)) || // the pattern starts with \., and then [ or .
+          h.startsWith("\\.") && b.has(h.charAt(2)) || // the pattern starts with \.\., and then [ or .
+          h.startsWith("\\.\\.") && b.has(h.charAt(4))
+        ), T = !e && !t && b.has(h.charAt(0));
+        l = P ? xe : T ? st : "";
+      }
+      let u = "";
+      return this.isEnd() && o(o(this, O), I) && ((p = o(this, A)) == null ? void 0 : p.type) === "!" && (u = "(?:$|\\/)"), [
+        l + h + u,
+        et(h),
+        E(this, R, !!o(this, R)),
+        o(this, F)
+      ];
+    }
+    const s = this.type === "*" || this.type === "+", n = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let r = x(this, M, dt).call(this, e);
+    if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+      const a = this.toString(), h = this;
+      return E(h, d, [a]), h.type = null, E(h, R, void 0), [a, et(this.toString()), !1, !1];
+    }
+    let c = !s || t || e || !st ? "" : x(this, M, dt).call(this, !0);
+    c === r && (c = ""), c && (r = `(?:${r})(?:${c})*?`);
+    let f = "";
+    if (this.type === "!" && o(this, Q))
+      f = (this.isStart() && !e ? st : "") + At;
+    else {
+      const a = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !e && !t ? st : "") + Nt + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && c ? ")" : this.type === "*" && c ? ")?" : `)${this.type}`;
+      f = n + r + a;
+    }
+    return [
+      f,
+      et(r),
+      E(this, R, !!o(this, R)),
+      o(this, F)
+    ];
+  }
+}
+O = new WeakMap(), R = new WeakMap(), F = new WeakMap(), d = new WeakMap(), A = new WeakMap(), B = new WeakMap(), H = new WeakMap(), I = new WeakMap(), z = new WeakMap(), G = new WeakMap(), Q = new WeakMap(), M = new WeakSet(), Dt = function() {
+  if (this !== o(this, O))
+    throw new Error("should only call on root");
+  if (o(this, I))
+    return this;
+  this.toString(), E(this, I, !0);
+  let t;
+  for (; t = o(this, H).pop(); ) {
+    if (t.type !== "!")
+      continue;
+    let e = t, s = o(e, A);
+    for (; s; ) {
+      for (let n = o(e, B) + 1; !s.type && n < o(s, d).length; n++)
+        for (const r of o(t, d)) {
+          if (typeof r == "string")
+            throw new Error("string part in extglob AST??");
+          r.copyIn(o(s, d)[n]);
+        }
+      e = s, s = o(e, A);
+    }
+  }
+  return this;
+}, Z = new WeakSet(), nt = function(t, e, s, n, r) {
+  var b, P, T, N;
+  const c = n.maxExtglobRecursion ?? 2;
+  let f = !1, p = !1, a = -1, h = !1;
+  if (e.type === null) {
+    let S = s, m = "";
+    for (; S < t.length; ) {
+      const y = t.charAt(S++);
+      if (f || y === "\\") {
+        f = !f, m += y;
+        continue;
+      }
+      if (p) {
+        S === a + 1 ? (y === "^" || y === "!") && (h = !0) : y === "]" && !(S === a + 2 && h) && (p = !1), m += y;
+        continue;
+      } else if (y === "[") {
+        p = !0, a = S, h = !1, m += y;
+        continue;
+      }
+      if (!n.noext && ut(y) && t.charAt(S) === "(" && r <= c) {
+        e.push(m), m = "";
+        const C = new D(y, e);
+        S = x(b = D, Z, nt).call(b, t, C, S, n, r + 1), e.push(C);
+        continue;
+      }
+      m += y;
+    }
+    return e.push(m), S;
+  }
+  let l = s + 1, u = new D(null, e);
+  const g = [];
+  let w = "";
+  for (; l < t.length; ) {
+    const S = t.charAt(l++);
+    if (f || S === "\\") {
+      f = !f, w += S;
+      continue;
+    }
+    if (p) {
+      l === a + 1 ? (S === "^" || S === "!") && (h = !0) : S === "]" && !(l === a + 2 && h) && (p = !1), w += S;
+      continue;
+    } else if (S === "[") {
+      p = !0, a = l, h = !1, w += S;
+      continue;
+    }
+    if (!n.noext && ut(S) && t.charAt(l) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+    (r <= c || e && x(P = e, M, it).call(P, S))) {
+      const y = e && x(T = e, M, it).call(T, S) ? 0 : 1;
+      u.push(w), w = "";
+      const k = new D(S, u);
+      u.push(k), l = x(N = D, Z, nt).call(N, t, k, l, n, r + y);
+      continue;
+    }
+    if (S === "|") {
+      u.push(w), w = "", g.push(u), u = new D(null, e);
+      continue;
+    }
+    if (S === ")")
+      return w === "" && o(e, d).length === 0 && E(e, Q, !0), u.push(w), w = "", e.push(...g, u), l;
+    w += S;
+  }
+  return e.type = null, E(e, R, void 0), E(e, d, [t.substring(s - 1)]), l;
+}, Lt = function(t) {
+  return x(this, M, pt).call(this, t, Ee);
+}, pt = function(t, e = Se) {
+  if (!t || typeof t != "object" || t.type !== null || o(t, d).length !== 1 || this.type === null)
+    return !1;
+  const s = o(t, d)[0];
+  return !s || typeof s != "object" || s.type === null ? !1 : x(this, M, it).call(this, s.type, e);
+}, it = function(t, e = be) {
+  var s;
+  return !!((s = e.get(this.type)) != null && s.includes(t));
+}, kt = function(t, e) {
+  const s = o(t, d)[0], n = new D(null, s, this.options);
+  o(n, d).push(""), s.push(n), x(this, M, gt).call(this, t, e);
+}, gt = function(t, e) {
+  const s = o(t, d)[0];
+  o(this, d).splice(e, 1, ...o(s, d));
+  for (const n of o(s, d))
+    typeof n == "object" && E(n, A, this);
+  E(this, G, void 0);
+}, _t = function(t) {
+  const e = Mt.get(this.type);
+  return !!(e != null && e.has(t));
+}, qt = function(t) {
+  if (!t || typeof t != "object" || t.type !== null || o(t, d).length !== 1 || this.type === null || o(this, d).length !== 1)
+    return !1;
+  const e = o(t, d)[0];
+  return !e || typeof e != "object" || e.type === null ? !1 : x(this, M, _t).call(this, e.type);
+}, zt = function(t) {
+  const e = Mt.get(this.type), s = o(t, d)[0], n = e == null ? void 0 : e.get(s.type);
+  if (!n)
+    return !1;
+  E(this, d, o(s, d));
+  for (const r of o(this, d))
+    typeof r == "object" && E(r, A, this);
+  this.type = n, E(this, G, void 0), E(this, Q, !1);
+}, rt = function() {
+  var t, e;
+  if (xt(this)) {
+    let s = 0, n = !1;
+    do {
+      n = !0;
+      for (let r = 0; r < o(this, d).length; r++) {
+        const c = o(this, d)[r];
+        typeof c == "object" && (x(e = c, M, rt).call(e), x(this, M, pt).call(this, c) ? (n = !1, x(this, M, gt).call(this, c, r)) : x(this, M, Lt).call(this, c) ? (n = !1, x(this, M, kt).call(this, c, r)) : x(this, M, qt).call(this, c) && (n = !1, x(this, M, zt).call(this, c)));
+      }
+    } while (!n && ++s < 10);
+  } else
+    for (const s of o(this, d))
+      typeof s == "object" && x(t = s, M, rt).call(t);
+  E(this, G, void 0);
+}, dt = function(t) {
+  return o(this, d).map((e) => {
+    if (typeof e == "string")
+      throw new Error("string type in extglob ast??");
+    const [s, n, r, c] = e.toRegExpSource(t);
+    return E(this, F, o(this, F) || c), s;
+  }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+}, Gt = function(t, e, s = !1) {
+  let n = !1, r = "", c = !1, f = !1;
+  for (let p = 0; p < t.length; p++) {
+    const a = t.charAt(p);
+    if (n) {
+      n = !1, r += (Ae.has(a) ? "\\" : "") + a;
+      continue;
+    }
+    if (a === "*") {
+      if (f)
+        continue;
+      f = !0, r += s && /^[*]+$/.test(t) ? At : Nt, e = !0;
+      continue;
+    } else
+      f = !1;
+    if (a === "\\") {
+      p === t.length - 1 ? r += "\\\\" : n = !0;
+      continue;
+    }
+    if (a === "[") {
+      const [h, l, u, g] = ye(t, p);
+      if (u) {
+        r += h, c = c || l, p += u - 1, e = e || g;
+        continue;
+      }
+    }
+    if (a === "?") {
+      r += wt, e = !0;
+      continue;
+    }
+    r += $e(a);
+  }
+  return [r, et(t), !!e, c];
+}, v(ct, Z);
+D = ct;
+const Te = (i, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? i.replace(/[?*()[\]{}]/g, "[$&]") : i.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? i.replace(/[?*()[\]]/g, "[$&]") : i.replace(/[?*()[\]\\]/g, "\\$&"), j = (i, t, e = {}) => (ot(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new lt(t, e).match(i)), ve = /^\*+([^+@!?*[(]*)$/, Re = (i) => (t) => !t.startsWith(".") && t.endsWith(i), je = (i) => (t) => t.endsWith(i), Pe = (i) => (i = i.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(i)), Ce = (i) => (i = i.toLowerCase(), (t) => t.toLowerCase().endsWith(i)), We = /^\*+\.\*+$/, De = (i) => !i.startsWith(".") && i.includes("."), Le = (i) => i !== "." && i !== ".." && i.includes("."), ke = /^\.\*+$/, _e = (i) => i !== "." && i !== ".." && i.startsWith("."), qe = /^\*+$/, ze = (i) => i.length !== 0 && !i.startsWith("."), Ge = (i) => i.length !== 0 && i !== "." && i !== "..", Fe = /^\?+([^+@!?*[(]*)?$/, Be = ([i, t = ""]) => {
+  const e = Ft([i]);
+  return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+}, Ie = ([i, t = ""]) => {
+  const e = Bt([i]);
+  return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+}, Ue = ([i, t = ""]) => {
+  const e = Bt([i]);
+  return t ? (s) => e(s) && s.endsWith(t) : e;
+}, Ze = ([i, t = ""]) => {
+  const e = Ft([i]);
+  return t ? (s) => e(s) && s.endsWith(t) : e;
+}, Ft = ([i]) => {
+  const t = i.length;
+  return (e) => e.length === t && !e.startsWith(".");
+}, Bt = ([i]) => {
+  const t = i.length;
+  return (e) => e.length === t && e !== "." && e !== "..";
+}, It = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", $t = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+}, He = It === "win32" ? $t.win32.sep : $t.posix.sep;
+j.sep = He;
+const W = Symbol("globstar **");
+j.GLOBSTAR = W;
+const Je = "[^/]", Ve = Je + "*?", Xe = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", Qe = "(?:(?!(?:\\/|^)\\.).)*?", Ke = (i, t = {}) => (e) => j(e, i, t);
+j.filter = Ke;
+const q = (i, t = {}) => Object.assign({}, i, t), Ye = (i) => {
+  if (!i || typeof i != "object" || !Object.keys(i).length)
+    return j;
+  const t = j;
+  return Object.assign((s, n, r = {}) => t(s, n, q(i, r)), {
+    Minimatch: class extends t.Minimatch {
+      constructor(n, r = {}) {
+        super(n, q(i, r));
+      }
+      static defaults(n) {
+        return t.defaults(q(i, n)).Minimatch;
+      }
+    },
+    AST: class extends t.AST {
+      /* c8 ignore start */
+      constructor(n, r, c = {}) {
+        super(n, r, q(i, c));
+      }
+      /* c8 ignore stop */
+      static fromGlob(n, r = {}) {
+        return t.AST.fromGlob(n, q(i, r));
+      }
+    },
+    unescape: (s, n = {}) => t.unescape(s, q(i, n)),
+    escape: (s, n = {}) => t.escape(s, q(i, n)),
+    filter: (s, n = {}) => t.filter(s, q(i, n)),
+    defaults: (s) => t.defaults(q(i, s)),
+    makeRe: (s, n = {}) => t.makeRe(s, q(i, n)),
+    braceExpand: (s, n = {}) => t.braceExpand(s, q(i, n)),
+    match: (s, n, r = {}) => t.match(s, n, q(i, r)),
+    sep: t.sep,
+    GLOBSTAR: W
+  });
+};
+j.defaults = Ye;
+const Ut = (i, t = {}) => (ot(i), t.nobrace || !/\{(?:(?!\{).)*\}/.test(i) ? [i] : ae(i, { max: t.braceExpandMax }));
+j.braceExpand = Ut;
+const ts = (i, t = {}) => new lt(i, t).makeRe();
+j.makeRe = ts;
+const es = (i, t, e = {}) => {
+  const s = new lt(t, e);
+  return i = i.filter((n) => s.match(n)), s.options.nonull && !i.length && i.push(t), i;
+};
+j.match = es;
+const Ot = /[?*]|[+@!]\(.*?\)|\[|\]/, ss = (i) => i.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var _, Zt, mt, X;
+class lt {
+  constructor(t, e = {}) {
+    v(this, _);
+    $(this, "options");
+    $(this, "set");
+    $(this, "pattern");
+    $(this, "windowsPathsNoEscape");
+    $(this, "nonegate");
+    $(this, "negate");
+    $(this, "comment");
+    $(this, "empty");
+    $(this, "preserveMultipleSlashes");
+    $(this, "partial");
+    $(this, "globSet");
+    $(this, "globParts");
+    $(this, "nocase");
+    $(this, "isWindows");
+    $(this, "platform");
+    $(this, "windowsNoMagicRoot");
+    $(this, "maxGlobstarRecursion");
+    $(this, "regexp");
+    ot(t), e = e || {}, this.options = e, this.maxGlobstarRecursion = e.maxGlobstarRecursion ?? 200, this.pattern = t, this.platform = e.platform || It, this.isWindows = this.platform === "win32";
+    const s = "allowWindowsEscape";
+    this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e[s] === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1)
+      return !0;
+    for (const t of this.set)
+      for (const e of t)
+        if (typeof e != "string")
+          return !0;
+    return !1;
+  }
+  debug(...t) {
+  }
+  make() {
+    const t = this.pattern, e = this.options;
+    if (!e.nocomment && t.charAt(0) === "#") {
+      this.comment = !0;
+      return;
+    }
+    if (!t) {
+      this.empty = !0;
+      return;
+    }
+    this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+    const s = this.globSet.map((r) => this.slashSplit(r));
+    this.globParts = this.preprocess(s), this.debug(this.pattern, this.globParts);
+    let n = this.globParts.map((r, c, f) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const p = r[0] === "" && r[1] === "" && (r[2] === "?" || !Ot.test(r[2])) && !Ot.test(r[3]), a = /^[a-z]:/i.test(r[0]);
+        if (p)
+          return [
+            ...r.slice(0, 4),
+            ...r.slice(4).map((h) => this.parse(h))
+          ];
+        if (a)
+          return [r[0], ...r.slice(1).map((h) => this.parse(h))];
+      }
+      return r.map((p) => this.parse(p));
+    });
+    if (this.debug(this.pattern, n), this.set = n.filter((r) => r.indexOf(!1) === -1), this.isWindows)
+      for (let r = 0; r < this.set.length; r++) {
+        const c = this.set[r];
+        c[0] === "" && c[1] === "" && this.globParts[r][2] === "?" && typeof c[3] == "string" && /^[a-z]:$/i.test(c[3]) && (c[2] = "?");
+      }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(t) {
+    if (this.options.noglobstar)
+      for (const s of t)
+        for (let n = 0; n < s.length; n++)
+          s[n] === "**" && (s[n] = "*");
+    const { optimizationLevel: e = 1 } = this.options;
+    return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(t) {
+    return t.map((e) => {
+      let s = -1;
+      for (; (s = e.indexOf("**", s + 1)) !== -1; ) {
+        let n = s;
+        for (; e[n + 1] === "**"; )
+          n++;
+        n !== s && e.splice(s, n - s);
+      }
+      return e;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(t) {
+    return t.map((e) => (e = e.reduce((s, n) => {
+      const r = s[s.length - 1];
+      return n === "**" && r === "**" ? s : n === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(n), s);
+    }, []), e.length === 0 ? [""] : e));
+  }
+  levelTwoFileOptimize(t) {
+    Array.isArray(t) || (t = this.slashSplit(t));
+    let e = !1;
+    do {
+      if (e = !1, !this.preserveMultipleSlashes) {
+        for (let n = 1; n < t.length - 1; n++) {
+          const r = t[n];
+          n === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(n, 1), n--);
+        }
+        t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+      }
+      let s = 0;
+      for (; (s = t.indexOf("..", s + 1)) !== -1; ) {
+        const n = t[s - 1];
+        n && n !== "." && n !== ".." && n !== "**" && !(this.isWindows && /^[a-z]:$/i.test(n)) && (e = !0, t.splice(s - 1, 2), s -= 2);
+      }
+    } while (e);
+    return t.length === 0 ? [""] : t;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(t) {
+    let e = !1;
+    do {
+      e = !1;
+      for (let s of t) {
+        let n = -1;
+        for (; (n = s.indexOf("**", n + 1)) !== -1; ) {
+          let c = n;
+          for (; s[c + 1] === "**"; )
+            c++;
+          c > n && s.splice(n + 1, c - n);
+          let f = s[n + 1];
+          const p = s[n + 2], a = s[n + 3];
+          if (f !== ".." || !p || p === "." || p === ".." || !a || a === "." || a === "..")
+            continue;
+          e = !0, s.splice(n, 1);
+          const h = s.slice(0);
+          h[n] = "**", t.push(h), n--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let c = 1; c < s.length - 1; c++) {
+            const f = s[c];
+            c === 1 && f === "" && s[0] === "" || (f === "." || f === "") && (e = !0, s.splice(c, 1), c--);
+          }
+          s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+        }
+        let r = 0;
+        for (; (r = s.indexOf("..", r + 1)) !== -1; ) {
+          const c = s[r - 1];
+          if (c && c !== "." && c !== ".." && c !== "**") {
+            e = !0;
+            const p = r === 1 && s[r + 1] === "**" ? ["."] : [];
+            s.splice(r - 1, 2, ...p), s.length === 0 && s.push(""), r -= 2;
+          }
+        }
+      }
+    } while (e);
+    return t;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(t) {
+    for (let e = 0; e < t.length - 1; e++)
+      for (let s = e + 1; s < t.length; s++) {
+        const n = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+        if (n) {
+          t[e] = [], t[s] = n;
+          break;
+        }
+      }
+    return t.filter((e) => e.length);
+  }
+  partsMatch(t, e, s = !1) {
+    let n = 0, r = 0, c = [], f = "";
+    for (; n < t.length && r < e.length; )
+      if (t[n] === e[r])
+        c.push(f === "b" ? e[r] : t[n]), n++, r++;
+      else if (s && t[n] === "**" && e[r] === t[n + 1])
+        c.push(t[n]), n++;
+      else if (s && e[r] === "**" && t[n] === e[r + 1])
+        c.push(e[r]), r++;
+      else if (t[n] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+        if (f === "b")
+          return !1;
+        f = "a", c.push(t[n]), n++, r++;
+      } else if (e[r] === "*" && t[n] && (this.options.dot || !t[n].startsWith(".")) && t[n] !== "**") {
+        if (f === "a")
+          return !1;
+        f = "b", c.push(e[r]), n++, r++;
+      } else
+        return !1;
+    return t.length === e.length && c;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const t = this.pattern;
+    let e = !1, s = 0;
+    for (let n = 0; n < t.length && t.charAt(n) === "!"; n++)
+      e = !e, s++;
+    s && (this.pattern = t.slice(s)), this.negate = e;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(t, e, s = !1) {
+    let n = 0, r = 0;
+    if (this.isWindows) {
+      const f = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), p = !f && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), a = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), h = !a && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), l = p ? 3 : f ? 0 : void 0, u = h ? 3 : a ? 0 : void 0;
+      if (typeof l == "number" && typeof u == "number") {
+        const [g, w] = [
+          t[l],
+          e[u]
+        ];
+        g.toLowerCase() === w.toLowerCase() && (e[u] = g, r = u, n = l);
+      }
+    }
+    const { optimizationLevel: c = 1 } = this.options;
+    return c >= 2 && (t = this.levelTwoFileOptimize(t)), e.includes(W) ? x(this, _, Zt).call(this, t, e, s, n, r) : x(this, _, X).call(this, t, e, s, n, r);
+  }
+  braceExpand() {
+    return Ut(this.pattern, this.options);
+  }
+  parse(t) {
+    ot(t);
+    const e = this.options;
+    if (t === "**")
+      return W;
+    if (t === "")
+      return "";
+    let s, n = null;
+    (s = t.match(qe)) ? n = e.dot ? Ge : ze : (s = t.match(ve)) ? n = (e.nocase ? e.dot ? Ce : Pe : e.dot ? je : Re)(s[1]) : (s = t.match(Fe)) ? n = (e.nocase ? e.dot ? Ie : Be : e.dot ? Ue : Ze)(s) : (s = t.match(We)) ? n = e.dot ? Le : De : (s = t.match(ke)) && (n = _e);
+    const r = ct.fromGlob(t, this.options).toMMPattern();
+    return n && typeof r == "object" && Reflect.defineProperty(r, "test", { value: n }), r;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === !1)
+      return this.regexp;
+    const t = this.set;
+    if (!t.length)
+      return this.regexp = !1, this.regexp;
+    const e = this.options, s = e.noglobstar ? Ve : e.dot ? Xe : Qe, n = new Set(e.nocase ? ["i"] : []);
+    let r = t.map((p) => {
+      const a = p.map((l) => {
+        if (l instanceof RegExp)
+          for (const u of l.flags.split(""))
+            n.add(u);
+        return typeof l == "string" ? ss(l) : l === W ? W : l._src;
+      });
+      a.forEach((l, u) => {
+        const g = a[u + 1], w = a[u - 1];
+        l !== W || w === W || (w === void 0 ? g !== void 0 && g !== W ? a[u + 1] = "(?:\\/|" + s + "\\/)?" + g : a[u] = s : g === void 0 ? a[u - 1] = w + "(?:\\/|\\/" + s + ")?" : g !== W && (a[u - 1] = w + "(?:\\/|\\/" + s + "\\/)" + g, a[u + 1] = W));
+      });
+      const h = a.filter((l) => l !== W);
+      if (this.partial && h.length >= 1) {
+        const l = [];
+        for (let u = 1; u <= h.length; u++)
+          l.push(h.slice(0, u).join("/"));
+        return "(?:" + l.join("|") + ")";
+      }
+      return h.join("/");
+    }).join("|");
+    const [c, f] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+    r = "^" + c + r + f + "$", this.partial && (r = "^(?:\\/|" + c + r.slice(1, -1) + f + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+    try {
+      this.regexp = new RegExp(r, [...n].join(""));
+    } catch {
+      this.regexp = !1;
+    }
+    return this.regexp;
+  }
+  slashSplit(t) {
+    return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\/\/[^/]+/.test(t) ? ["", ...t.split(/\/+/)] : t.split(/\/+/);
+  }
+  match(t, e = this.partial) {
+    if (this.debug("match", t, this.pattern), this.comment)
+      return !1;
+    if (this.empty)
+      return t === "";
+    if (t === "/" && e)
+      return !0;
+    const s = this.options;
+    this.isWindows && (t = t.split("\\").join("/"));
+    const n = this.slashSplit(t);
+    this.debug(this.pattern, "split", n);
+    const r = this.set;
+    this.debug(this.pattern, "set", r);
+    let c = n[n.length - 1];
+    if (!c)
+      for (let f = n.length - 2; !c && f >= 0; f--)
+        c = n[f];
+    for (const f of r) {
+      let p = n;
+      if (s.matchBase && f.length === 1 && (p = [c]), this.matchOne(p, f, e))
+        return s.flipNegate ? !0 : !this.negate;
+    }
+    return s.flipNegate ? !1 : this.negate;
+  }
+  static defaults(t) {
+    return j.defaults(t).Minimatch;
+  }
+}
+_ = new WeakSet(), Zt = function(t, e, s, n, r) {
+  const c = e.indexOf(W, r), f = e.lastIndexOf(W), [p, a, h] = s ? [
+    e.slice(r, c),
+    e.slice(c + 1),
+    []
+  ] : [
+    e.slice(r, c),
+    e.slice(c + 1, f),
+    e.slice(f + 1)
+  ];
+  if (p.length) {
+    const N = t.slice(n, n + p.length);
+    if (!x(this, _, X).call(this, N, p, s, 0, 0))
+      return !1;
+    n += p.length, r += p.length;
+  }
+  let l = 0;
+  if (h.length) {
+    if (h.length + n > t.length)
+      return !1;
+    let N = t.length - h.length;
+    if (x(this, _, X).call(this, t, h, s, N, 0))
+      l = h.length;
+    else {
+      if (t[t.length - 1] !== "" || n + h.length === t.length || (N--, !x(this, _, X).call(this, t, h, s, N, 0)))
+        return !1;
+      l = h.length + 1;
+    }
+  }
+  if (!a.length) {
+    let N = !!l;
+    for (let S = n; S < t.length - l; S++) {
+      const m = String(t[S]);
+      if (N = !0, m === "." || m === ".." || !this.options.dot && m.startsWith("."))
+        return !1;
+    }
+    return s || N;
+  }
+  const u = [[[], 0]];
+  let g = u[0], w = 0;
+  const b = [0];
+  for (const N of a)
+    N === W ? (b.push(w), g = [[], 0], u.push(g)) : (g[0].push(N), w++);
+  let P = u.length - 1;
+  const T = t.length - l;
+  for (const N of u)
+    N[1] = T - (b[P--] + N[0].length);
+  return !!x(this, _, mt).call(this, t, u, n, 0, s, 0, !!l);
+}, // return false for "nope, not matching"
+// return null for "not matching, cannot keep trying"
+mt = function(t, e, s, n, r, c, f) {
+  const p = e[n];
+  if (!p) {
+    for (let l = s; l < t.length; l++) {
+      f = !0;
+      const u = t[l];
+      if (u === "." || u === ".." || !this.options.dot && u.startsWith("."))
+        return !1;
+    }
+    return f;
+  }
+  const [a, h] = p;
+  for (; s <= h; ) {
+    if (x(this, _, X).call(this, t.slice(0, s + a.length), a, r, s, 0) && c < this.maxGlobstarRecursion) {
+      const g = x(this, _, mt).call(this, t, e, s + a.length, n + 1, r, c + 1, f);
+      if (g !== !1)
+        return g;
+    }
+    const u = t[s];
+    if (u === "." || u === ".." || !this.options.dot && u.startsWith("."))
+      return !1;
+    s++;
+  }
+  return r || null;
+}, X = function(t, e, s, n, r) {
+  let c, f, p, a;
+  for (c = n, f = r, a = t.length, p = e.length; c < a && f < p; c++, f++) {
+    this.debug("matchOne loop");
+    let h = e[f], l = t[c];
+    if (this.debug(e, h, l), h === !1 || h === W)
+      return !1;
+    let u;
+    if (typeof h == "string" ? (u = l === h, this.debug("string match", h, l, u)) : (u = h.test(l), this.debug("pattern match", h, l, u)), !u)
+      return !1;
+  }
+  if (c === a && f === p)
+    return !0;
+  if (c === a)
+    return s;
+  if (f === p)
+    return c === a - 1 && t[c] === "";
+  throw new Error("wtf?");
+};
+j.AST = ct;
+j.Minimatch = lt;
+j.escape = Te;
+j.unescape = et;
+class ns {
+  constructor(t) {
+    $(this, "value");
+    $(this, "next");
+    this.value = t;
+  }
+}
+var L, U, J;
+class is {
+  constructor() {
+    v(this, L);
+    v(this, U);
+    v(this, J);
+    this.clear();
+  }
+  enqueue(t) {
+    const e = new ns(t);
+    o(this, L) ? (o(this, U).next = e, E(this, U, e)) : (E(this, L, e), E(this, U, e)), ht(this, J)._++;
+  }
+  dequeue() {
+    const t = o(this, L);
+    if (t)
+      return E(this, L, o(this, L).next), ht(this, J)._--, o(this, L) || E(this, U, void 0), t.value;
+  }
+  peek() {
+    if (o(this, L))
+      return o(this, L).value;
+  }
+  clear() {
+    E(this, L, void 0), E(this, U, void 0), E(this, J, 0);
+  }
+  get size() {
+    return o(this, J);
+  }
+  *[Symbol.iterator]() {
+    let t = o(this, L);
+    for (; t; )
+      yield t.value, t = t.next;
+  }
+  *drain() {
+    for (; o(this, L); )
+      yield this.dequeue();
+  }
+}
+L = new WeakMap(), U = new WeakMap(), J = new WeakMap();
+function rs(i) {
+  let t = !1;
+  if (typeof i == "object" && ({ concurrency: i, rejectOnClear: t = !1 } = i), Tt(i), typeof t != "boolean")
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  const e = new is();
+  let s = 0;
+  const n = () => {
+    s < i && e.size > 0 && (s++, e.dequeue().run());
+  }, r = () => {
+    s--, n();
+  }, c = async (a, h, l) => {
+    const u = (async () => a(...l))();
+    h(u);
+    try {
+      await u;
+    } catch {
+    }
+    r();
+  }, f = (a, h, l, u) => {
+    const g = { reject: l };
+    new Promise((w) => {
+      g.run = w, e.enqueue(g);
+    }).then(c.bind(void 0, a, h, u)), s < i && n();
+  }, p = (a, ...h) => new Promise((l, u) => {
+    f(a, l, u, h);
+  });
+  return Object.defineProperties(p, {
+    activeCount: {
+      get: () => s
+    },
+    pendingCount: {
+      get: () => e.size
+    },
+    clearQueue: {
+      value() {
+        if (!t) {
+          e.clear();
+          return;
+        }
+        const a = AbortSignal.abort().reason;
+        for (; e.size > 0; )
+          e.dequeue().reject(a);
+      }
+    },
+    concurrency: {
+      get: () => i,
+      set(a) {
+        Tt(a), i = a, queueMicrotask(() => {
+          for (; s < i && e.size > 0; )
+            n();
+        });
+      }
+    },
+    map: {
+      async value(a, h) {
+        const l = Array.from(a, (u, g) => this(h, u, g));
+        return Promise.all(l);
+      }
+    }
+  }), p;
+}
+function Tt(i) {
+  if (!((Number.isInteger(i) || i === Number.POSITIVE_INFINITY) && i > 0))
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+function os(i) {
+  if (i.length < 2) return "never";
+  const t = [...i].sort((n, r) => n - r);
+  let e = 0;
+  for (let n = 1; n < t.length; n++)
+    e += t[n] - t[n - 1];
+  const s = e / (t.length - 1) / 864e5;
+  return s <= 1 ? "daily" : s <= 7 ? "weekly" : s <= 30 ? "monthly" : s <= 365 ? "yearly" : "never";
+}
+function hs(i) {
+  const t = i.pageEntryPattern;
+  let e = i.rootDir ?? "", s = i.outputFile ?? "";
+  const n = i.concurrency ?? 20, r = i.commitCount ?? 10, c = i.ignoreDeps ? Array.isArray(i.ignoreDeps) ? i.ignoreDeps : [i.ignoreDeps] : [], f = {};
+  let p;
+  return {
+    name: "vite-last-modified",
+    async configResolved(a) {
+      const { resolve: h } = await import("./__vite-browser-external-BDMct_Gn.js");
+      p = a.build.ssr, e || (e = a.root), s || (s = h(e, "last-modified.json"));
+    },
+    async buildEnd() {
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const { exec: a } = await import("./__vite-browser-external-BDMct_Gn.js"), h = await import("./__vite-browser-external-BDMct_Gn.js"), { promisify: l } = await import("./__vite-browser-external-BDMct_Gn.js"), u = l(a), g = /* @__PURE__ */ new Map(), w = rs(n), b = (m) => {
+        if (g.has(m))
+          return g.get(m);
+        const y = w(async () => {
+          try {
+            const k = m.includes("?") ? m.slice(0, m.indexOf("?")) : m, C = h.relative(e, k).replace(/\\/g, "/"), { stdout: V } = await u(`git log --follow -n ${r} --format=%at -- "${C}"`, { cwd: e });
+            return V.trim() ? V.trim().split(`
+`).map((K) => parseInt(K, 10) * 1e3) : [];
+          } catch {
+            return [];
+          }
+        });
+        return g.set(m, y), y;
+      }, P = (m, y) => {
+        if (y.has(m)) return;
+        y.add(m);
+        const k = this.getModuleInfo(m);
+        if (k)
+          for (const C of k.importedIds) {
+            if (C.includes("node_modules") || !C.startsWith(e))
+              continue;
+            const V = C.slice(e.length).replace(/^\/?/, "").split("?")[0];
+            c.some((K) => j(V, K, { dot: !0 })) || P(C, y);
+          }
+      }, T = [...this.getModuleIds()].filter((m) => {
+        if (!m.startsWith(e))
+          return !1;
+        const y = m.slice(e.length).replace(/^\//, "");
+        return typeof t == "string" ? j(y, t, { dot: !0 }) : t.test(y);
+      });
+      if (T.length === 0) {
+        console.warn("[lastModifiedPlugin] No MD files found in module graph");
+        return;
+      }
+      console.log("[lastModifiedPlugin] start collect entry files deps");
+      let N = /* @__PURE__ */ new Map();
+      for (const m of T) {
+        const y = /* @__PURE__ */ new Set();
+        P(m, y), N.set(m, y);
+      }
+      if (console.log(`[lastModifiedPlugin] Analyzed ${T.length} entry files`), typeof i.modifyDepMap == "function") {
+        const m = await i.modifyDepMap(N);
+        m && m instanceof Map && (N = m);
+      }
+      const S = /* @__PURE__ */ new Set();
+      for (const m of N.values())
+        for (const y of m)
+          S.add(y);
+      await Promise.all([...S].map(b));
+      for (const [m, y] of N) {
+        const k = m.slice(e.length).replace(/^\//, ""), C = (await Promise.all([...y].map(b))).flat(), V = C.length > 0 ? Math.max(...C) : 0, K = os(C);
+        f[k] = { lastmod: V, changefreq: K };
+      }
+    },
+    async closeBundle() {
+      const { writeFileSync: a } = await import("./__vite-browser-external-BDMct_Gn.js");
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const h = Object.fromEntries(Object.entries(f).sort(([l], [u]) => l.localeCompare(u)));
+      a(s, JSON.stringify(h, null, 2), "utf8"), console.log(`[lastModifiedPlugin] Written ${s}`);
+    }
+  };
+}
+export {
+  hs as g,
+  j as m
+};