@opendesign-plus-test/plugins 0.0.1-rc.24 → 0.0.1-rc.26

package/dist/nuxt/sitemap/index.js

@@ -1,93 +1,1474 @@
-import { defineNuxtModule as S, addVitePlugin as A } from "nuxt/kit";
-import { g as O, m as v } from "../../generate-lastmod-changefreq-Wk3kOITw.js";
-import { existsSync as b, readFileSync as D, createWriteStream as q, writeFileSync as C, readdirSync as T } from "node:fs";
-import m, { join as z } from "node:path";
-import { pipeline as J } from "node:stream/promises";
-const H = S({
+var Kt = Object.defineProperty;
+var bt = (n) => {
+  throw TypeError(n);
+};
+var Qt = (n, t, e) => t in n ? Kt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var O = (n, t, e) => Qt(n, typeof t != "symbol" ? t + "" : t, e), ht = (n, t, e) => t.has(n) || bt("Cannot " + e);
+var o = (n, t, e) => (ht(n, t, "read from private field"), e ? e.call(n) : t.get(n)), T = (n, t, e) => t.has(n) ? bt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), E = (n, t, e, s) => (ht(n, t, "write to private field"), s ? s.call(n, e) : t.set(n, e), e), P = (n, t, e) => (ht(n, t, "access private method"), e);
+var ft = (n, t, e, s) => ({
+  set _(i) {
+    E(n, t, i, e);
+  },
+  get _() {
+    return o(n, t, s);
+  }
+});
+import { defineNuxtModule as Yt, addVitePlugin as te } from "nuxt/kit";
+import { writeFileSync as Wt, existsSync as Et, readFileSync as ee, createWriteStream as se, readdirSync as ne } from "node:fs";
+import ie, { resolve as re, join as Y, relative as oe } from "node:path";
+import { pipeline as ae } from "node:stream/promises";
+import { exec as le } from "node:child_process";
+import { promisify as ce } from "node:util";
+const Rt = (n, t, e) => {
+  const s = n instanceof RegExp ? Mt(n, e) : n, i = t instanceof RegExp ? Mt(t, e) : t, r = s !== null && i != null && he(s, i, 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] + i.length)
+  };
+}, Mt = (n, t) => {
+  const e = t.match(n);
+  return e ? e[0] : null;
+}, he = (n, t, e) => {
+  let s, i, r, a, h, p = e.indexOf(n), c = e.indexOf(t, p + 1), f = p;
+  if (p >= 0 && c > 0) {
+    if (n === t)
+      return [p, c];
+    for (s = [], r = e.length; f >= 0 && !h; ) {
+      if (f === p)
+        s.push(f), p = e.indexOf(n, f + 1);
+      else if (s.length === 1) {
+        const l = s.pop();
+        l !== void 0 && (h = [l, c]);
+      } else
+        i = s.pop(), i !== void 0 && i < r && (r = i, a = c), c = e.indexOf(t, f + 1);
+      f = p < c && p >= 0 ? p : c;
+    }
+    s.length && a !== void 0 && (h = [r, a]);
+  }
+  return h;
+}, Ct = "\0SLASH" + Math.random() + "\0", Dt = "\0OPEN" + Math.random() + "\0", wt = "\0CLOSE" + Math.random() + "\0", kt = "\0COMMA" + Math.random() + "\0", Lt = "\0PERIOD" + Math.random() + "\0", fe = new RegExp(Ct, "g"), ue = new RegExp(Dt, "g"), pe = new RegExp(wt, "g"), ge = new RegExp(kt, "g"), de = new RegExp(Lt, "g"), me = /\\\\/g, ye = /\\{/g, we = /\\}/g, xe = /\\,/g, Se = /\\\./g, be = 1e5;
+function ut(n) {
+  return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+}
+function Ee(n) {
+  return n.replace(me, Ct).replace(ye, Dt).replace(we, wt).replace(xe, kt).replace(Se, Lt);
+}
+function Me(n) {
+  return n.replace(fe, "\\").replace(ue, "{").replace(pe, "}").replace(ge, ",").replace(de, ".");
+}
+function qt(n) {
+  if (!n)
+    return [""];
+  const t = [], e = Rt("{", "}", n);
+  if (!e)
+    return n.split(",");
+  const { pre: s, body: i, post: r } = e, a = s.split(",");
+  a[a.length - 1] += "{" + i + "}";
+  const h = qt(r);
+  return r.length && (a[a.length - 1] += h.shift(), a.push.apply(a, h)), t.push.apply(t, a), t;
+}
+function $e(n, t = {}) {
+  if (!n)
+    return [];
+  const { max: e = be } = t;
+  return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), et(Ee(n), e, !0).map(Me);
+}
+function Pe(n) {
+  return "{" + n + "}";
+}
+function Ae(n) {
+  return /^-?0\d/.test(n);
+}
+function Ne(n, t) {
+  return n <= t;
+}
+function Oe(n, t) {
+  return n >= t;
+}
+function et(n, t, e) {
+  const s = [], i = Rt("{", "}", n);
+  if (!i)
+    return [n];
+  const r = i.pre, a = i.post.length ? et(i.post, t, !1) : [""];
+  if (/\$$/.test(i.pre))
+    for (let h = 0; h < a.length && h < t; h++) {
+      const p = r + "{" + i.body + "}" + a[h];
+      s.push(p);
+    }
+  else {
+    const h = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), p = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), c = h || p, f = i.body.indexOf(",") >= 0;
+    if (!c && !f)
+      return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + wt + i.post, et(n, t, !0)) : [n];
+    let l;
+    if (c)
+      l = i.body.split(/\.\./);
+    else if (l = qt(i.body), l.length === 1 && l[0] !== void 0 && (l = et(l[0], t, !1).map(Pe), l.length === 1))
+      return a.map((m) => i.pre + l[0] + m);
+    let u;
+    if (c && l[0] !== void 0 && l[1] !== void 0) {
+      const m = ut(l[0]), y = ut(l[1]), S = Math.max(l[0].length, l[1].length);
+      let g = l.length === 3 && l[2] !== void 0 ? Math.max(Math.abs(ut(l[2])), 1) : 1, x = Ne;
+      y < m && (g *= -1, x = Oe);
+      const d = l.some(Ae);
+      u = [];
+      for (let $ = m; x($, y); $ += g) {
+        let b;
+        if (p)
+          b = String.fromCharCode($), b === "\\" && (b = "");
+        else if (b = String($), d) {
+          const k = S - b.length;
+          if (k > 0) {
+            const H = new Array(k + 1).join("0");
+            $ < 0 ? b = "-" + H + b.slice(1) : b = H + b;
+          }
+        }
+        u.push(b);
+      }
+    } else {
+      u = [];
+      for (let m = 0; m < l.length; m++)
+        u.push.apply(u, et(l[m], t, !1));
+    }
+    for (let m = 0; m < u.length; m++)
+      for (let y = 0; y < a.length && s.length < t; y++) {
+        const S = r + u[m] + a[y];
+        (!e || c || S) && s.push(S);
+      }
+  }
+  return s;
+}
+const ve = 1024 * 64, at = (n) => {
+  if (typeof n != "string")
+    throw new TypeError("invalid pattern");
+  if (n.length > ve)
+    throw new TypeError("pattern is too long");
+}, Te = {
+  "[: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]
+}, tt = (n) => n.replace(/[[\]\\-]/g, "\\$&"), je = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), $t = (n) => n.join(""), We = (n, t) => {
+  const e = t;
+  if (n.charAt(e) !== "[")
+    throw new Error("not in a brace expression");
+  const s = [], i = [];
+  let r = e + 1, a = !1, h = !1, p = !1, c = !1, f = e, l = "";
+  t: for (; r < n.length; ) {
+    const S = n.charAt(r);
+    if ((S === "!" || S === "^") && r === e + 1) {
+      c = !0, r++;
+      continue;
+    }
+    if (S === "]" && a && !p) {
+      f = r + 1;
+      break;
+    }
+    if (a = !0, S === "\\" && !p) {
+      p = !0, r++;
+      continue;
+    }
+    if (S === "[" && !p) {
+      for (const [g, [x, M, d]] of Object.entries(Te))
+        if (n.startsWith(g, r)) {
+          if (l)
+            return ["$.", !1, n.length - e, !0];
+          r += g.length, d ? i.push(x) : s.push(x), h = h || M;
+          continue t;
+        }
+    }
+    if (p = !1, l) {
+      S > l ? s.push(tt(l) + "-" + tt(S)) : S === l && s.push(tt(S)), l = "", r++;
+      continue;
+    }
+    if (n.startsWith("-]", r + 1)) {
+      s.push(tt(S + "-")), r += 2;
+      continue;
+    }
+    if (n.startsWith("-", r + 1)) {
+      l = S, r += 2;
+      continue;
+    }
+    s.push(tt(S)), r++;
+  }
+  if (f < r)
+    return ["", !1, 0, !1];
+  if (!s.length && !i.length)
+    return ["$.", !1, n.length - e, !0];
+  if (i.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !c) {
+    const S = s[0].length === 2 ? s[0].slice(-1) : s[0];
+    return [je(S), !1, f - e, !1];
+  }
+  const u = "[" + (c ? "^" : "") + $t(s) + "]", m = "[" + (c ? "" : "^") + $t(i) + "]";
+  return [s.length && i.length ? "(" + u + "|" + m + ")" : s.length ? u : m, h, f - e, !0];
+}, st = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !0 } = {}) => e ? t ? n.replace(/\[([^/\\])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1") : t ? n.replace(/\[([^/\\{}])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
+var C;
+const Re = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), pt = (n) => Re.has(n), Pt = (n) => pt(n.type), Ce = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]), De = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]), ke = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]), At = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]), Le = "(?!(?:^|/)\\.\\.?(?:$|/))", nt = "(?!\\.)", qe = /* @__PURE__ */ new Set(["[", "."]), ze = /* @__PURE__ */ new Set(["..", "."]), _e = new Set("().*{}+?[]^$\\!"), Ge = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), xt = "[^/]", Nt = xt + "*?", Ot = xt + "+?";
+let Fe = 0;
+var v, j, F, w, N, B, Z, I, z, _, Q, A, zt, J, it, _t, gt, rt, Gt, dt, Ft, Bt, It, ot, mt, Ut;
+class lt {
+  constructor(t, e, s = {}) {
+    T(this, A);
+    O(this, "type");
+    T(this, v);
+    T(this, j);
+    T(this, F, !1);
+    T(this, w, []);
+    T(this, N);
+    T(this, B);
+    T(this, Z);
+    T(this, I, !1);
+    T(this, z);
+    T(this, _);
+    // set to true if it's an extglob with no children
+    // (which really means one child of '')
+    T(this, Q, !1);
+    O(this, "id", ++Fe);
+    this.type = t, t && E(this, j, !0), E(this, N, e), E(this, v, o(this, N) ? o(o(this, N), v) : this), E(this, z, o(this, v) === this ? s : o(o(this, v), z)), E(this, Z, o(this, v) === this ? [] : o(o(this, v), Z)), t === "!" && !o(o(this, v), I) && o(this, Z).push(this), E(this, B, o(this, N) ? o(o(this, N), w).length : 0);
+  }
+  get depth() {
+    var t;
+    return (((t = o(this, N)) == 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, v).id,
+      parent: (t = o(this, N)) == null ? void 0 : t.id,
+      depth: this.depth,
+      partsLength: o(this, w).length,
+      parts: o(this, w)
+    };
+  }
+  get hasMagic() {
+    if (o(this, j) !== void 0)
+      return o(this, j);
+    for (const t of o(this, w))
+      if (typeof t != "string" && (t.type || t.hasMagic))
+        return E(this, j, !0);
+    return o(this, j);
+  }
+  // reconstructs the pattern
+  toString() {
+    return o(this, _) !== void 0 ? o(this, _) : this.type ? E(this, _, this.type + "(" + o(this, w).map((t) => String(t)).join("|") + ")") : E(this, _, o(this, w).map((t) => String(t)).join(""));
+  }
+  push(...t) {
+    for (const e of t)
+      if (e !== "") {
+        if (typeof e != "string" && !(e instanceof C && o(e, N) === this))
+          throw new Error("invalid part: " + e);
+        o(this, w).push(e);
+      }
+  }
+  toJSON() {
+    var e;
+    const t = this.type === null ? o(this, w).slice().map((s) => typeof s == "string" ? s : s.toJSON()) : [this.type, ...o(this, w).map((s) => s.toJSON())];
+    return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === o(this, v) || o(o(this, v), I) && ((e = o(this, N)) == null ? void 0 : e.type) === "!") && t.push({}), t;
+  }
+  isStart() {
+    var e;
+    if (o(this, v) === this)
+      return !0;
+    if (!((e = o(this, N)) != null && e.isStart()))
+      return !1;
+    if (o(this, B) === 0)
+      return !0;
+    const t = o(this, N);
+    for (let s = 0; s < o(this, B); s++) {
+      const i = o(t, w)[s];
+      if (!(i instanceof C && i.type === "!"))
+        return !1;
+    }
+    return !0;
+  }
+  isEnd() {
+    var e, s, i;
+    if (o(this, v) === this || ((e = o(this, N)) == null ? void 0 : e.type) === "!")
+      return !0;
+    if (!((s = o(this, N)) != null && s.isEnd()))
+      return !1;
+    if (!this.type)
+      return (i = o(this, N)) == null ? void 0 : i.isEnd();
+    const t = o(this, N) ? o(o(this, N), w).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 C(this.type, t);
+    for (const s of o(this, w))
+      e.copyIn(s);
+    return e;
+  }
+  static fromGlob(t, e = {}) {
+    var i;
+    const s = new C(null, void 0, e);
+    return P(i = C, J, it).call(i, 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, v))
+      return o(this, v).toMMPattern();
+    const t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+    if (!(i || o(this, j) || o(this, z).nocase && !o(this, z).nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase()))
+      return s;
+    const h = (o(this, z).nocase ? "i" : "") + (r ? "u" : "");
+    return Object.assign(new RegExp(`^${e}$`, h), {
+      _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, v) === this && (P(this, A, ot).call(this), P(this, A, zt).call(this)), !Pt(this)) {
+      const c = this.isStart() && this.isEnd() && !o(this, w).some((y) => typeof y != "string"), f = o(this, w).map((y) => {
+        var d;
+        const [S, g, x, M] = typeof y == "string" ? P(d = C, J, Ut).call(d, y, o(this, j), c) : y.toRegExpSource(t);
+        return E(this, j, o(this, j) || x), E(this, F, o(this, F) || M), S;
+      }).join("");
+      let l = "";
+      if (this.isStart() && typeof o(this, w)[0] == "string" && !(o(this, w).length === 1 && ze.has(o(this, w)[0]))) {
+        const S = qe, g = (
+          // dots are allowed, and the pattern starts with [ or .
+          e && S.has(f.charAt(0)) || // the pattern starts with \., and then [ or .
+          f.startsWith("\\.") && S.has(f.charAt(2)) || // the pattern starts with \.\., and then [ or .
+          f.startsWith("\\.\\.") && S.has(f.charAt(4))
+        ), x = !e && !t && S.has(f.charAt(0));
+        l = g ? Le : x ? nt : "";
+      }
+      let u = "";
+      return this.isEnd() && o(o(this, v), I) && ((p = o(this, N)) == null ? void 0 : p.type) === "!" && (u = "(?:$|\\/)"), [
+        l + f + u,
+        st(f),
+        E(this, j, !!o(this, j)),
+        o(this, F)
+      ];
+    }
+    const s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let r = P(this, A, mt).call(this, e);
+    if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+      const c = this.toString(), f = this;
+      return E(f, w, [c]), f.type = null, E(f, j, void 0), [c, st(this.toString()), !1, !1];
+    }
+    let a = !s || t || e || !nt ? "" : P(this, A, mt).call(this, !0);
+    a === r && (a = ""), a && (r = `(?:${r})(?:${a})*?`);
+    let h = "";
+    if (this.type === "!" && o(this, Q))
+      h = (this.isStart() && !e ? nt : "") + Ot;
+    else {
+      const c = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !e && !t ? nt : "") + Nt + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && a ? ")" : this.type === "*" && a ? ")?" : `)${this.type}`;
+      h = i + r + c;
+    }
+    return [
+      h,
+      st(r),
+      E(this, j, !!o(this, j)),
+      o(this, F)
+    ];
+  }
+}
+v = new WeakMap(), j = new WeakMap(), F = new WeakMap(), w = new WeakMap(), N = new WeakMap(), B = new WeakMap(), Z = new WeakMap(), I = new WeakMap(), z = new WeakMap(), _ = new WeakMap(), Q = new WeakMap(), A = new WeakSet(), zt = function() {
+  if (this !== o(this, v))
+    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, Z).pop(); ) {
+    if (t.type !== "!")
+      continue;
+    let e = t, s = o(e, N);
+    for (; s; ) {
+      for (let i = o(e, B) + 1; !s.type && i < o(s, w).length; i++)
+        for (const r of o(t, w)) {
+          if (typeof r == "string")
+            throw new Error("string part in extglob AST??");
+          r.copyIn(o(s, w)[i]);
+        }
+      e = s, s = o(e, N);
+    }
+  }
+  return this;
+}, J = new WeakSet(), it = function(t, e, s, i, r) {
+  var S, g, x, M;
+  const a = i.maxExtglobRecursion ?? 2;
+  let h = !1, p = !1, c = -1, f = !1;
+  if (e.type === null) {
+    let d = s, $ = "";
+    for (; d < t.length; ) {
+      const b = t.charAt(d++);
+      if (h || b === "\\") {
+        h = !h, $ += b;
+        continue;
+      }
+      if (p) {
+        d === c + 1 ? (b === "^" || b === "!") && (f = !0) : b === "]" && !(d === c + 2 && f) && (p = !1), $ += b;
+        continue;
+      } else if (b === "[") {
+        p = !0, c = d, f = !1, $ += b;
+        continue;
+      }
+      if (!i.noext && pt(b) && t.charAt(d) === "(" && r <= a) {
+        e.push($), $ = "";
+        const H = new C(b, e);
+        d = P(S = C, J, it).call(S, t, H, d, i, r + 1), e.push(H);
+        continue;
+      }
+      $ += b;
+    }
+    return e.push($), d;
+  }
+  let l = s + 1, u = new C(null, e);
+  const m = [];
+  let y = "";
+  for (; l < t.length; ) {
+    const d = t.charAt(l++);
+    if (h || d === "\\") {
+      h = !h, y += d;
+      continue;
+    }
+    if (p) {
+      l === c + 1 ? (d === "^" || d === "!") && (f = !0) : d === "]" && !(l === c + 2 && f) && (p = !1), y += d;
+      continue;
+    } else if (d === "[") {
+      p = !0, c = l, f = !1, y += d;
+      continue;
+    }
+    if (!i.noext && pt(d) && t.charAt(l) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+    (r <= a || e && P(g = e, A, rt).call(g, d))) {
+      const b = e && P(x = e, A, rt).call(x, d) ? 0 : 1;
+      u.push(y), y = "";
+      const k = new C(d, u);
+      u.push(k), l = P(M = C, J, it).call(M, t, k, l, i, r + b);
+      continue;
+    }
+    if (d === "|") {
+      u.push(y), y = "", m.push(u), u = new C(null, e);
+      continue;
+    }
+    if (d === ")")
+      return y === "" && o(e, w).length === 0 && E(e, Q, !0), u.push(y), y = "", e.push(...m, u), l;
+    y += d;
+  }
+  return e.type = null, E(e, j, void 0), E(e, w, [t.substring(s - 1)]), l;
+}, _t = function(t) {
+  return P(this, A, gt).call(this, t, De);
+}, gt = function(t, e = Ce) {
+  if (!t || typeof t != "object" || t.type !== null || o(t, w).length !== 1 || this.type === null)
+    return !1;
+  const s = o(t, w)[0];
+  return !s || typeof s != "object" || s.type === null ? !1 : P(this, A, rt).call(this, s.type, e);
+}, rt = function(t, e = ke) {
+  var s;
+  return !!((s = e.get(this.type)) != null && s.includes(t));
+}, Gt = function(t, e) {
+  const s = o(t, w)[0], i = new C(null, s, this.options);
+  o(i, w).push(""), s.push(i), P(this, A, dt).call(this, t, e);
+}, dt = function(t, e) {
+  const s = o(t, w)[0];
+  o(this, w).splice(e, 1, ...o(s, w));
+  for (const i of o(s, w))
+    typeof i == "object" && E(i, N, this);
+  E(this, _, void 0);
+}, Ft = function(t) {
+  const e = At.get(this.type);
+  return !!(e != null && e.has(t));
+}, Bt = function(t) {
+  if (!t || typeof t != "object" || t.type !== null || o(t, w).length !== 1 || this.type === null || o(this, w).length !== 1)
+    return !1;
+  const e = o(t, w)[0];
+  return !e || typeof e != "object" || e.type === null ? !1 : P(this, A, Ft).call(this, e.type);
+}, It = function(t) {
+  const e = At.get(this.type), s = o(t, w)[0], i = e == null ? void 0 : e.get(s.type);
+  if (!i)
+    return !1;
+  E(this, w, o(s, w));
+  for (const r of o(this, w))
+    typeof r == "object" && E(r, N, this);
+  this.type = i, E(this, _, void 0), E(this, Q, !1);
+}, ot = function() {
+  var t, e;
+  if (Pt(this)) {
+    let s = 0, i = !1;
+    do {
+      i = !0;
+      for (let r = 0; r < o(this, w).length; r++) {
+        const a = o(this, w)[r];
+        typeof a == "object" && (P(e = a, A, ot).call(e), P(this, A, gt).call(this, a) ? (i = !1, P(this, A, dt).call(this, a, r)) : P(this, A, _t).call(this, a) ? (i = !1, P(this, A, Gt).call(this, a, r)) : P(this, A, Bt).call(this, a) && (i = !1, P(this, A, It).call(this, a)));
+      }
+    } while (!i && ++s < 10);
+  } else
+    for (const s of o(this, w))
+      typeof s == "object" && P(t = s, A, ot).call(t);
+  E(this, _, void 0);
+}, mt = function(t) {
+  return o(this, w).map((e) => {
+    if (typeof e == "string")
+      throw new Error("string type in extglob ast??");
+    const [s, i, r, a] = e.toRegExpSource(t);
+    return E(this, F, o(this, F) || a), s;
+  }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+}, Ut = function(t, e, s = !1) {
+  let i = !1, r = "", a = !1, h = !1;
+  for (let p = 0; p < t.length; p++) {
+    const c = t.charAt(p);
+    if (i) {
+      i = !1, r += (_e.has(c) ? "\\" : "") + c;
+      continue;
+    }
+    if (c === "*") {
+      if (h)
+        continue;
+      h = !0, r += s && /^[*]+$/.test(t) ? Ot : Nt, e = !0;
+      continue;
+    } else
+      h = !1;
+    if (c === "\\") {
+      p === t.length - 1 ? r += "\\\\" : i = !0;
+      continue;
+    }
+    if (c === "[") {
+      const [f, l, u, m] = We(t, p);
+      if (u) {
+        r += f, a = a || l, p += u - 1, e = e || m;
+        continue;
+      }
+    }
+    if (c === "?") {
+      r += xt, e = !0;
+      continue;
+    }
+    r += Ge(c);
+  }
+  return [r, st(t), !!e, a];
+}, T(lt, J);
+C = lt;
+const Be = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&"), W = (n, t, e = {}) => (at(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new ct(t, e).match(n)), Ie = /^\*+([^+@!?*[(]*)$/, Ue = (n) => (t) => !t.startsWith(".") && t.endsWith(n), Je = (n) => (t) => t.endsWith(n), He = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n)), Ve = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n)), Ze = /^\*+\.\*+$/, Xe = (n) => !n.startsWith(".") && n.includes("."), Ke = (n) => n !== "." && n !== ".." && n.includes("."), Qe = /^\.\*+$/, Ye = (n) => n !== "." && n !== ".." && n.startsWith("."), ts = /^\*+$/, es = (n) => n.length !== 0 && !n.startsWith("."), ss = (n) => n.length !== 0 && n !== "." && n !== "..", ns = /^\?+([^+@!?*[(]*)?$/, is = ([n, t = ""]) => {
+  const e = Jt([n]);
+  return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+}, rs = ([n, t = ""]) => {
+  const e = Ht([n]);
+  return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+}, os = ([n, t = ""]) => {
+  const e = Ht([n]);
+  return t ? (s) => e(s) && s.endsWith(t) : e;
+}, as = ([n, t = ""]) => {
+  const e = Jt([n]);
+  return t ? (s) => e(s) && s.endsWith(t) : e;
+}, Jt = ([n]) => {
+  const t = n.length;
+  return (e) => e.length === t && !e.startsWith(".");
+}, Ht = ([n]) => {
+  const t = n.length;
+  return (e) => e.length === t && e !== "." && e !== "..";
+}, Vt = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", vt = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+}, ls = Vt === "win32" ? vt.win32.sep : vt.posix.sep;
+W.sep = ls;
+const R = Symbol("globstar **");
+W.GLOBSTAR = R;
+const cs = "[^/]", hs = cs + "*?", fs = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", us = "(?:(?!(?:\\/|^)\\.).)*?", ps = (n, t = {}) => (e) => W(e, n, t);
+W.filter = ps;
+const q = (n, t = {}) => Object.assign({}, n, t), gs = (n) => {
+  if (!n || typeof n != "object" || !Object.keys(n).length)
+    return W;
+  const t = W;
+  return Object.assign((s, i, r = {}) => t(s, i, q(n, r)), {
+    Minimatch: class extends t.Minimatch {
+      constructor(i, r = {}) {
+        super(i, q(n, r));
+      }
+      static defaults(i) {
+        return t.defaults(q(n, i)).Minimatch;
+      }
+    },
+    AST: class extends t.AST {
+      /* c8 ignore start */
+      constructor(i, r, a = {}) {
+        super(i, r, q(n, a));
+      }
+      /* c8 ignore stop */
+      static fromGlob(i, r = {}) {
+        return t.AST.fromGlob(i, q(n, r));
+      }
+    },
+    unescape: (s, i = {}) => t.unescape(s, q(n, i)),
+    escape: (s, i = {}) => t.escape(s, q(n, i)),
+    filter: (s, i = {}) => t.filter(s, q(n, i)),
+    defaults: (s) => t.defaults(q(n, s)),
+    makeRe: (s, i = {}) => t.makeRe(s, q(n, i)),
+    braceExpand: (s, i = {}) => t.braceExpand(s, q(n, i)),
+    match: (s, i, r = {}) => t.match(s, i, q(n, r)),
+    sep: t.sep,
+    GLOBSTAR: R
+  });
+};
+W.defaults = gs;
+const Zt = (n, t = {}) => (at(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : $e(n, { max: t.braceExpandMax }));
+W.braceExpand = Zt;
+const ds = (n, t = {}) => new ct(n, t).makeRe();
+W.makeRe = ds;
+const ms = (n, t, e = {}) => {
+  const s = new ct(t, e);
+  return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+};
+W.match = ms;
+const Tt = /[?*]|[+@!]\(.*?\)|\[|\]/, ys = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var L, Xt, yt, K;
+class ct {
+  constructor(t, e = {}) {
+    T(this, L);
+    O(this, "options");
+    O(this, "set");
+    O(this, "pattern");
+    O(this, "windowsPathsNoEscape");
+    O(this, "nonegate");
+    O(this, "negate");
+    O(this, "comment");
+    O(this, "empty");
+    O(this, "preserveMultipleSlashes");
+    O(this, "partial");
+    O(this, "globSet");
+    O(this, "globParts");
+    O(this, "nocase");
+    O(this, "isWindows");
+    O(this, "platform");
+    O(this, "windowsNoMagicRoot");
+    O(this, "maxGlobstarRecursion");
+    O(this, "regexp");
+    at(t), e = e || {}, this.options = e, this.maxGlobstarRecursion = e.maxGlobstarRecursion ?? 200, this.pattern = t, this.platform = e.platform || Vt, 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 i = this.globParts.map((r, a, h) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const p = r[0] === "" && r[1] === "" && (r[2] === "?" || !Tt.test(r[2])) && !Tt.test(r[3]), c = /^[a-z]:/i.test(r[0]);
+        if (p)
+          return [
+            ...r.slice(0, 4),
+            ...r.slice(4).map((f) => this.parse(f))
+          ];
+        if (c)
+          return [r[0], ...r.slice(1).map((f) => this.parse(f))];
+      }
+      return r.map((p) => this.parse(p));
+    });
+    if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows)
+      for (let r = 0; r < this.set.length; r++) {
+        const a = this.set[r];
+        a[0] === "" && a[1] === "" && this.globParts[r][2] === "?" && typeof a[3] == "string" && /^[a-z]:$/i.test(a[3]) && (a[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 i = 0; i < s.length; i++)
+          s[i] === "**" && (s[i] = "*");
+    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 i = s;
+        for (; e[i + 1] === "**"; )
+          i++;
+        i !== s && e.splice(s, i - s);
+      }
+      return e;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(t) {
+    return t.map((e) => (e = e.reduce((s, i) => {
+      const r = s[s.length - 1];
+      return i === "**" && r === "**" ? s : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(i), 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 i = 1; i < t.length - 1; i++) {
+          const r = t[i];
+          i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(i, 1), i--);
+        }
+        t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+      }
+      let s = 0;
+      for (; (s = t.indexOf("..", s + 1)) !== -1; ) {
+        const i = t[s - 1];
+        i && i !== "." && i !== ".." && i !== "**" && !(this.isWindows && /^[a-z]:$/i.test(i)) && (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 i = -1;
+        for (; (i = s.indexOf("**", i + 1)) !== -1; ) {
+          let a = i;
+          for (; s[a + 1] === "**"; )
+            a++;
+          a > i && s.splice(i + 1, a - i);
+          let h = s[i + 1];
+          const p = s[i + 2], c = s[i + 3];
+          if (h !== ".." || !p || p === "." || p === ".." || !c || c === "." || c === "..")
+            continue;
+          e = !0, s.splice(i, 1);
+          const f = s.slice(0);
+          f[i] = "**", t.push(f), i--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let a = 1; a < s.length - 1; a++) {
+            const h = s[a];
+            a === 1 && h === "" && s[0] === "" || (h === "." || h === "") && (e = !0, s.splice(a, 1), a--);
+          }
+          s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+        }
+        let r = 0;
+        for (; (r = s.indexOf("..", r + 1)) !== -1; ) {
+          const a = s[r - 1];
+          if (a && a !== "." && a !== ".." && a !== "**") {
+            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 i = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+        if (i) {
+          t[e] = [], t[s] = i;
+          break;
+        }
+      }
+    return t.filter((e) => e.length);
+  }
+  partsMatch(t, e, s = !1) {
+    let i = 0, r = 0, a = [], h = "";
+    for (; i < t.length && r < e.length; )
+      if (t[i] === e[r])
+        a.push(h === "b" ? e[r] : t[i]), i++, r++;
+      else if (s && t[i] === "**" && e[r] === t[i + 1])
+        a.push(t[i]), i++;
+      else if (s && e[r] === "**" && t[i] === e[r + 1])
+        a.push(e[r]), r++;
+      else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+        if (h === "b")
+          return !1;
+        h = "a", a.push(t[i]), i++, r++;
+      } else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+        if (h === "a")
+          return !1;
+        h = "b", a.push(e[r]), i++, r++;
+      } else
+        return !1;
+    return t.length === e.length && a;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const t = this.pattern;
+    let e = !1, s = 0;
+    for (let i = 0; i < t.length && t.charAt(i) === "!"; i++)
+      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 i = 0, r = 0;
+    if (this.isWindows) {
+      const h = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), p = !h && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), c = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), f = !c && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), l = p ? 3 : h ? 0 : void 0, u = f ? 3 : c ? 0 : void 0;
+      if (typeof l == "number" && typeof u == "number") {
+        const [m, y] = [
+          t[l],
+          e[u]
+        ];
+        m.toLowerCase() === y.toLowerCase() && (e[u] = m, r = u, i = l);
+      }
+    }
+    const { optimizationLevel: a = 1 } = this.options;
+    return a >= 2 && (t = this.levelTwoFileOptimize(t)), e.includes(R) ? P(this, L, Xt).call(this, t, e, s, i, r) : P(this, L, K).call(this, t, e, s, i, r);
+  }
+  braceExpand() {
+    return Zt(this.pattern, this.options);
+  }
+  parse(t) {
+    at(t);
+    const e = this.options;
+    if (t === "**")
+      return R;
+    if (t === "")
+      return "";
+    let s, i = null;
+    (s = t.match(ts)) ? i = e.dot ? ss : es : (s = t.match(Ie)) ? i = (e.nocase ? e.dot ? Ve : He : e.dot ? Je : Ue)(s[1]) : (s = t.match(ns)) ? i = (e.nocase ? e.dot ? rs : is : e.dot ? os : as)(s) : (s = t.match(Ze)) ? i = e.dot ? Ke : Xe : (s = t.match(Qe)) && (i = Ye);
+    const r = lt.fromGlob(t, this.options).toMMPattern();
+    return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), 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 ? hs : e.dot ? fs : us, i = new Set(e.nocase ? ["i"] : []);
+    let r = t.map((p) => {
+      const c = p.map((l) => {
+        if (l instanceof RegExp)
+          for (const u of l.flags.split(""))
+            i.add(u);
+        return typeof l == "string" ? ys(l) : l === R ? R : l._src;
+      });
+      c.forEach((l, u) => {
+        const m = c[u + 1], y = c[u - 1];
+        l !== R || y === R || (y === void 0 ? m !== void 0 && m !== R ? c[u + 1] = "(?:\\/|" + s + "\\/)?" + m : c[u] = s : m === void 0 ? c[u - 1] = y + "(?:\\/|\\/" + s + ")?" : m !== R && (c[u - 1] = y + "(?:\\/|\\/" + s + "\\/)" + m, c[u + 1] = R));
+      });
+      const f = c.filter((l) => l !== R);
+      if (this.partial && f.length >= 1) {
+        const l = [];
+        for (let u = 1; u <= f.length; u++)
+          l.push(f.slice(0, u).join("/"));
+        return "(?:" + l.join("|") + ")";
+      }
+      return f.join("/");
+    }).join("|");
+    const [a, h] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+    r = "^" + a + r + h + "$", this.partial && (r = "^(?:\\/|" + a + r.slice(1, -1) + h + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+    try {
+      this.regexp = new RegExp(r, [...i].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 i = this.slashSplit(t);
+    this.debug(this.pattern, "split", i);
+    const r = this.set;
+    this.debug(this.pattern, "set", r);
+    let a = i[i.length - 1];
+    if (!a)
+      for (let h = i.length - 2; !a && h >= 0; h--)
+        a = i[h];
+    for (const h of r) {
+      let p = i;
+      if (s.matchBase && h.length === 1 && (p = [a]), this.matchOne(p, h, e))
+        return s.flipNegate ? !0 : !this.negate;
+    }
+    return s.flipNegate ? !1 : this.negate;
+  }
+  static defaults(t) {
+    return W.defaults(t).Minimatch;
+  }
+}
+L = new WeakSet(), Xt = function(t, e, s, i, r) {
+  const a = e.indexOf(R, r), h = e.lastIndexOf(R), [p, c, f] = s ? [
+    e.slice(r, a),
+    e.slice(a + 1),
+    []
+  ] : [
+    e.slice(r, a),
+    e.slice(a + 1, h),
+    e.slice(h + 1)
+  ];
+  if (p.length) {
+    const M = t.slice(i, i + p.length);
+    if (!P(this, L, K).call(this, M, p, s, 0, 0))
+      return !1;
+    i += p.length, r += p.length;
+  }
+  let l = 0;
+  if (f.length) {
+    if (f.length + i > t.length)
+      return !1;
+    let M = t.length - f.length;
+    if (P(this, L, K).call(this, t, f, s, M, 0))
+      l = f.length;
+    else {
+      if (t[t.length - 1] !== "" || i + f.length === t.length || (M--, !P(this, L, K).call(this, t, f, s, M, 0)))
+        return !1;
+      l = f.length + 1;
+    }
+  }
+  if (!c.length) {
+    let M = !!l;
+    for (let d = i; d < t.length - l; d++) {
+      const $ = String(t[d]);
+      if (M = !0, $ === "." || $ === ".." || !this.options.dot && $.startsWith("."))
+        return !1;
+    }
+    return s || M;
+  }
+  const u = [[[], 0]];
+  let m = u[0], y = 0;
+  const S = [0];
+  for (const M of c)
+    M === R ? (S.push(y), m = [[], 0], u.push(m)) : (m[0].push(M), y++);
+  let g = u.length - 1;
+  const x = t.length - l;
+  for (const M of u)
+    M[1] = x - (S[g--] + M[0].length);
+  return !!P(this, L, yt).call(this, t, u, i, 0, s, 0, !!l);
+}, // return false for "nope, not matching"
+// return null for "not matching, cannot keep trying"
+yt = function(t, e, s, i, r, a, h) {
+  const p = e[i];
+  if (!p) {
+    for (let l = s; l < t.length; l++) {
+      h = !0;
+      const u = t[l];
+      if (u === "." || u === ".." || !this.options.dot && u.startsWith("."))
+        return !1;
+    }
+    return h;
+  }
+  const [c, f] = p;
+  for (; s <= f; ) {
+    if (P(this, L, K).call(this, t.slice(0, s + c.length), c, r, s, 0) && a < this.maxGlobstarRecursion) {
+      const m = P(this, L, yt).call(this, t, e, s + c.length, i + 1, r, a + 1, h);
+      if (m !== !1)
+        return m;
+    }
+    const u = t[s];
+    if (u === "." || u === ".." || !this.options.dot && u.startsWith("."))
+      return !1;
+    s++;
+  }
+  return r || null;
+}, K = function(t, e, s, i, r) {
+  let a, h, p, c;
+  for (a = i, h = r, c = t.length, p = e.length; a < c && h < p; a++, h++) {
+    this.debug("matchOne loop");
+    let f = e[h], l = t[a];
+    if (this.debug(e, f, l), f === !1 || f === R)
+      return !1;
+    let u;
+    if (typeof f == "string" ? (u = l === f, this.debug("string match", f, l, u)) : (u = f.test(l), this.debug("pattern match", f, l, u)), !u)
+      return !1;
+  }
+  if (a === c && h === p)
+    return !0;
+  if (a === c)
+    return s;
+  if (h === p)
+    return a === c - 1 && t[a] === "";
+  throw new Error("wtf?");
+};
+W.AST = lt;
+W.Minimatch = ct;
+W.escape = Be;
+W.unescape = st;
+class ws {
+  constructor(t) {
+    O(this, "value");
+    O(this, "next");
+    this.value = t;
+  }
+}
+var D, U, X;
+class xs {
+  constructor() {
+    T(this, D);
+    T(this, U);
+    T(this, X);
+    this.clear();
+  }
+  enqueue(t) {
+    const e = new ws(t);
+    o(this, D) ? (o(this, U).next = e, E(this, U, e)) : (E(this, D, e), E(this, U, e)), ft(this, X)._++;
+  }
+  dequeue() {
+    const t = o(this, D);
+    if (t)
+      return E(this, D, o(this, D).next), ft(this, X)._--, o(this, D) || E(this, U, void 0), t.value;
+  }
+  peek() {
+    if (o(this, D))
+      return o(this, D).value;
+  }
+  clear() {
+    E(this, D, void 0), E(this, U, void 0), E(this, X, 0);
+  }
+  get size() {
+    return o(this, X);
+  }
+  *[Symbol.iterator]() {
+    let t = o(this, D);
+    for (; t; )
+      yield t.value, t = t.next;
+  }
+  *drain() {
+    for (; o(this, D); )
+      yield this.dequeue();
+  }
+}
+D = new WeakMap(), U = new WeakMap(), X = new WeakMap();
+function Ss(n) {
+  let t = !1;
+  if (typeof n == "object" && ({ concurrency: n, rejectOnClear: t = !1 } = n), jt(n), typeof t != "boolean")
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  const e = new xs();
+  let s = 0;
+  const i = () => {
+    s < n && e.size > 0 && (s++, e.dequeue().run());
+  }, r = () => {
+    s--, i();
+  }, a = async (c, f, l) => {
+    const u = (async () => c(...l))();
+    f(u);
+    try {
+      await u;
+    } catch {
+    }
+    r();
+  }, h = (c, f, l, u) => {
+    const m = { reject: l };
+    new Promise((y) => {
+      m.run = y, e.enqueue(m);
+    }).then(a.bind(void 0, c, f, u)), s < n && i();
+  }, p = (c, ...f) => new Promise((l, u) => {
+    h(c, l, u, f);
+  });
+  return Object.defineProperties(p, {
+    activeCount: {
+      get: () => s
+    },
+    pendingCount: {
+      get: () => e.size
+    },
+    clearQueue: {
+      value() {
+        if (!t) {
+          e.clear();
+          return;
+        }
+        const c = AbortSignal.abort().reason;
+        for (; e.size > 0; )
+          e.dequeue().reject(c);
+      }
+    },
+    concurrency: {
+      get: () => n,
+      set(c) {
+        jt(c), n = c, queueMicrotask(() => {
+          for (; s < n && e.size > 0; )
+            i();
+        });
+      }
+    },
+    map: {
+      async value(c, f) {
+        const l = Array.from(c, (u, m) => this(f, u, m));
+        return Promise.all(l);
+      }
+    }
+  }), p;
+}
+function jt(n) {
+  if (!((Number.isInteger(n) || n === Number.POSITIVE_INFINITY) && n > 0))
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+const bs = ce(le);
+function Es(n) {
+  if (n.length < 2) return "never";
+  const t = [...n].sort((i, r) => i - r);
+  let e = 0;
+  for (let i = 1; i < t.length; i++)
+    e += t[i] - t[i - 1];
+  const s = e / (t.length - 1) / 864e5;
+  return s <= 1 ? "daily" : s <= 7 ? "weekly" : s <= 30 ? "monthly" : s <= 365 ? "yearly" : "never";
+}
+function Ms(n) {
+  const t = n.pageEntryPattern;
+  let e = n.rootDir ?? "", s = n.outputFile ?? "";
+  const i = n.concurrency ?? 20, r = n.commitCount ?? 10, a = n.ignoreDeps ? Array.isArray(n.ignoreDeps) ? n.ignoreDeps : [n.ignoreDeps] : [], h = {};
+  let p;
+  return {
+    name: "vite-last-modified",
+    async configResolved(c) {
+      p = c.build.ssr, e || (e = c.root), s || (s = re(e, "last-modified.json"));
+    },
+    async buildEnd() {
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const c = /* @__PURE__ */ new Map(), f = Ss(i), l = (g) => {
+        if (c.has(g))
+          return c.get(g);
+        const x = f(async () => {
+          try {
+            const M = g.includes("?") ? g.slice(0, g.indexOf("?")) : g, d = ie.relative(e, M).replace(/\\/g, "/"), { stdout: $ } = await bs(`git log --follow -n ${r} --format=%at -- "${d}"`, { cwd: e });
+            return $.trim() ? $.trim().split(`
+`).map((b) => parseInt(b, 10) * 1e3) : [];
+          } catch {
+            return [];
+          }
+        });
+        return c.set(g, x), x;
+      }, u = (g, x) => {
+        if (x.has(g)) return;
+        x.add(g);
+        const M = this.getModuleInfo(g);
+        if (M)
+          for (const d of M.importedIds) {
+            if (d.includes("node_modules") || !d.startsWith(e))
+              continue;
+            const $ = d.slice(e.length).replace(/^\/?/, "").split("?")[0];
+            a.some((b) => W($, b, { dot: !0 })) || u(d, x);
+          }
+      }, m = [...this.getModuleIds()].filter((g) => {
+        if (!g.startsWith(e))
+          return !1;
+        const x = g.slice(e.length).replace(/^\//, "");
+        return typeof t == "string" ? W(x, t, { dot: !0 }) : t.test(x);
+      });
+      if (m.length === 0) {
+        console.warn("[lastModifiedPlugin] No MD files found in module graph");
+        return;
+      }
+      console.log("[lastModifiedPlugin] start collect entry files deps");
+      let y = /* @__PURE__ */ new Map();
+      for (const g of m) {
+        const x = /* @__PURE__ */ new Set();
+        u(g, x), y.set(g, x);
+      }
+      if (console.log(`[lastModifiedPlugin] Analyzed ${m.length} entry files`), typeof n.modifyDepMap == "function") {
+        const g = await n.modifyDepMap(y);
+        g && g instanceof Map && (y = g);
+      }
+      const S = /* @__PURE__ */ new Set();
+      for (const g of y.values())
+        for (const x of g)
+          S.add(x);
+      await Promise.all([...S].map(l));
+      for (const [g, x] of y) {
+        const M = g.slice(e.length).replace(/^\//, ""), d = (await Promise.all([...x].map(l))).flat(), $ = d.length > 0 ? Math.max(...d) : 0, b = Es(d);
+        h[M] = { lastmod: $, changefreq: b };
+      }
+    },
+    closeBundle() {
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const c = Object.fromEntries(Object.entries(h).sort(([f], [l]) => f.localeCompare(l)));
+      Wt(s, JSON.stringify(c, null, 2), "utf8"), console.log(`[lastModifiedPlugin] Written ${s}`);
+    }
+  };
+}
+const Rs = Yt({
   meta: {
     name: "sitemap",
     configKey: "sitemap"
   },
-  setup(t, f) {
-    A(
-      O({
-        rootDir: t.nuxtAppRoot || f.options.dir.app,
+  setup(n, t) {
+    var i;
+    te(
+      Ms({
+        rootDir: ((i = n.nuxtAppRoot) == null ? void 0 : i.replace(/\\/g, "/")) || t.options.dir.app,
         // @ts-ignore
         pageEntryPattern: "**/pages/**/*.vue",
-        ...t.lastmodAndChangefreqOptions
+        ...n.lastmodAndChangefreqOptions
       })
     );
-    const w = Array.isArray(t.ignore) ? t.ignore : typeof t.ignore == "string" ? [t.ignore] : [], c = t.hostname.endsWith("/") ? t.hostname.slice(0, -1) : t.hostname;
-    f.hook("close", async () => {
-      var h, u, x, g, P, y;
-      const r = m.join(f.options.rootDir, ".output", "public");
-      if (!b(r))
+    const e = Array.isArray(n.ignore) ? n.ignore : typeof n.ignore == "string" ? [n.ignore] : [], s = n.hostname.endsWith("/") ? n.hostname.slice(0, -1) : n.hostname;
+    t.hook("close", async () => {
+      var f, l, u, m, y, S;
+      const r = Y(t.options.rootDir, ".output", "public");
+      if (!Et(r))
         return;
-      const s = {};
-      if ((h = t.index) != null && h.items)
-        for (const e of t.index.items)
-          e.pathPrefix && (s[e.pathPrefix.startsWith("/") ? e.pathPrefix : `/${e.pathPrefix}`] = []);
+      const a = ((f = n.lastmodAndChangefreqOptions) == null ? void 0 : f.outputFile) || Y(n.nuxtAppRoot || t.options.dir.app, "last-modified.json");
+      if (!Et(a))
+        return;
+      const h = {};
+      if ((l = n.index) != null && l.items)
+        for (const g of n.index.items)
+          g.pathPrefix && (h[g.pathPrefix.startsWith("/") ? g.pathPrefix : `/${g.pathPrefix}`] = /* @__PURE__ */ new Set());
       else
-        s["/"] = [];
-      const d = (e) => {
-        const n = T(e, {
+        h["/"] = /* @__PURE__ */ new Set();
+      const p = (g) => {
+        const x = ne(g, {
           withFileTypes: !0,
           encoding: "utf-8"
         });
-        for (const o of n) {
-          if (o.isDirectory()) {
-            d(m.join(e, o.name));
+        for (const M of x) {
+          if (M.isDirectory()) {
+            p(Y(g, M.name));
             continue;
           }
-          if (o.name === "index.html") {
-            const l = `/${m.relative(r, e).replace(/\\/g, "/")}`;
-            for (const i of w)
-              v(l, i);
-            for (const i in s)
-              l.startsWith(i) && s[i].push(l);
+          if (M.name === "index.html") {
+            const d = `/${oe(r, g).replace(/\\/g, "/")}`;
+            for (const $ of e)
+              W(d, $);
+            for (const $ in h)
+              d.startsWith($) && h[$].add(d);
           }
         }
       };
-      d(r), console.log("[module:generate-sitemap] collect html done");
-      const j = ((u = t.lastmodAndChangefreqOptions) == null ? void 0 : u.outputFile) || m.join(t.nuxtAppRoot || f.options.dir.app, "last-modified.json"), p = JSON.parse(D(j, "utf-8"));
+      p(r), console.log("[module:generate-sitemap] collect html done");
+      const c = JSON.parse(ee(a, "utf-8"));
       await Promise.all(
-        (((x = t.index) == null ? void 0 : x.items) ?? [{ pathPrefix: "/", filename: "sitemap.xml" }]).filter((e) => e.pathPrefix && e.filename).map(async (e) => {
-          const n = e.pathPrefix.startsWith("/") ? e.pathPrefix : `/${e.pathPrefix}`, o = e.filename.endsWith(".xml") ? e.filename : `${e.filename}.xml`, l = q(m.join(r, n, o), "utf-8");
+        (((u = n.index) == null ? void 0 : u.items) ?? [{ pathPrefix: "/", filename: "sitemap.xml" }]).filter((g) => g.pathPrefix && g.filename).map(async (g) => {
+          const x = g.pathPrefix.startsWith("/") ? g.pathPrefix : `/${g.pathPrefix}`, M = g.filename.endsWith(".xml") ? g.filename : `${g.filename}.xml`, d = se(Y(r, x, M), "utf-8");
           try {
-            await J(function* () {
+            await ae(function* () {
               yield `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
 `;
-              for (const i of s[n]) {
-                if (!i.startsWith("/"))
+              const $ = h[x];
+              for (const b of $) {
+                if (!b.startsWith("/"))
                   continue;
-                const a = p[`pages${i.endsWith("/") ? i.slice(0, -1) : i}/index.vue`] || p[`pages${i}.md`];
-                a != null && a.lastmod && (a.lastmod = new Date(a.lastmod).toISOString());
-                const W = {
-                  loc: c + i,
-                  ...a
+                const k = c[`pages${b.endsWith("/") ? b.slice(0, -1) : b}/index.vue`] || c[`pages${b}.vue`];
+                k != null && k.lastmod && (k.lastmod = new Date(k.lastmod).toISOString());
+                const H = {
+                  loc: s + b,
+                  ...k
                 };
+                let St = [];
+                if (n.getAlternate && n.languages)
+                  for (const V of n.languages) {
+                    let G = n.getAlternate(b, V);
+                    G && (G = G.startsWith("/") ? G : "/" + G, $.has(G) && St.push(`<xhtml:link rel="alternate" hreflang="${V}" href="${s + G}" />`));
+                  }
                 yield `  <url>
-${Object.entries(W).map(([$, F]) => `    <${$}>${F}</${$}>`).join(`
+${Object.entries(H).map(([V, G]) => `    <${V}>${G}</${V}>`).join(`
+`)}
+${St.map((V) => `    ${V}`).join(`
 `)}
   </url>
 `;
               }
               yield "</urlset>";
-            }, l);
-          } catch (i) {
-            console.log("[module:generate-sitemap] error", i);
+            }, d);
+          } catch ($) {
+            console.log("[module:generate-sitemap] error", $);
             return;
           }
         })
-      ), (g = t.index) != null && g.indexFilename && ((y = (P = t.index) == null ? void 0 : P.items) != null && y.length) && C(
-        z(r, t.index.indexFilename),
+      ), (m = n.index) != null && m.indexFilename && ((S = (y = n.index) == null ? void 0 : y.items) != null && S.length) && Wt(
+        Y(r, n.index.indexFilename),
         `<?xml version="1.0" encoding="UTF-8"?>
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  ${t.index.items.filter((e) => e.loc || e.filename).map((e) => {
-          let n = e.pathPrefix ? e.pathPrefix.startsWith("/") ? e.pathPrefix : `/${e.pathPrefix}` : "";
-          return n.endsWith("/") && (n = n.slice(0, -1)), `<sitemap>
-    <loc>${e.filename ? `${c}${n}/${e.filename}` : e.loc}</loc>
+  ${n.index.items.filter((g) => g.loc || g.filename).map((g) => {
+          let x = g.pathPrefix ? g.pathPrefix.startsWith("/") ? g.pathPrefix : `/${g.pathPrefix}` : "";
+          return x.endsWith("/") && (x = x.slice(0, -1)), `<sitemap>
+    <loc>${g.filename ? `${s}${x}/${g.filename}` : g.loc}</loc>
   </sitemap>`;
         }).join("")}
 </sitemapindex>
@@ -98,5 +1479,5 @@ ${Object.entries(W).map(([$, F]) => `    <${$}>${F}</${$}>`).join(`
   }
 });
 export {
-  H as default
+  Rs as default
 };