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

package/dist/index.js

@@ -1,7 +1,24 @@
-import f from "./__vite-browser-external-BDMct_Gn.js";
-import { i as K, o as O, v as z } from "./plugin-lvjNLBe-.js";
-import { g as H } from "./generate-lastmod-changefreq-CYV0c6WF.js";
-const $ = `
+var Yt = Object.defineProperty;
+var Et = (n) => {
+  throw TypeError(n);
+};
+var Xt = (n, t, e) => t in n ? Yt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var k = (n, t, e) => Xt(n, typeof t != "symbol" ? t + "" : t, e), at = (n, t, e) => t.has(n) || Et("Cannot " + e);
+var c = (n, t, e) => (at(n, t, "read from private field"), e ? e.call(n) : t.get(n)), R = (n, t, e) => t.has(n) ? Et("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), b = (n, t, e, s) => (at(n, t, "write to private field"), s ? s.call(n, e) : t.set(n, e), e), v = (n, t, e) => (at(n, t, "access private method"), e);
+var ht = (n, t, e, s) => ({
+  set _(i) {
+    b(n, t, i, e);
+  },
+  get _() {
+    return c(n, t, s);
+  }
+});
+import { i as js, o as Ds, v as Ps } from "./plugin-lvjNLBe-.js";
+import Qt, { resolve as te } from "node:path";
+import { exec as ee } from "node:child_process";
+import { writeFileSync as se } from "node:fs";
+import { promisify as ne } from "node:util";
+const Z = {}, ie = `
 (function () { 
   function getCookie(key) {
     const name = encodeURIComponent(key) + '=';
@@ -27,93 +44,93 @@ const $ = `
   }
 })();
 `.trim();
-function I(e) {
+function ks(n) {
   const {
-    cookieKey: n,
-    lightValue: t = "light",
-    darkValue: r = "dark",
-    attribute: a = "data-o-theme",
-    attributeLightValue: s = t,
-    attributeDarkValue: c = r,
-    classLightValue: w = t,
-    classDarkValue: p = r,
-    filename: l = "check-theme.js"
-  } = e, g = $.replace(/\$COOKIE_KEY/g, n).replace(/\$LIGHT_VALUE/g, t).replace(/\$DARK_VALUE/g, r).replace(/\$CLASS_LIGHT_VALUE/g, w).replace(/\$CLASS_DARK_VALUE/g, p).replace(/\$ATTRIBUTE_NAME/g, a).replace(/\$ATTRIBUTE_LIGHT_VALUE/g, s).replace(/\$ATTRIBUTE_DARK_VALUE/g, c);
-  let d = "", h = !1, u = "", m = !1;
+    cookieKey: t,
+    lightValue: e = "light",
+    darkValue: s = "dark",
+    attribute: i = "data-o-theme",
+    attributeLightValue: r = e,
+    attributeDarkValue: o = s,
+    classLightValue: u = e,
+    classDarkValue: p = s,
+    filename: a = "check-theme.js"
+  } = n, h = ie.replace(/\$COOKIE_KEY/g, t).replace(/\$LIGHT_VALUE/g, e).replace(/\$DARK_VALUE/g, s).replace(/\$CLASS_LIGHT_VALUE/g, u).replace(/\$CLASS_DARK_VALUE/g, p).replace(/\$ATTRIBUTE_NAME/g, i).replace(/\$ATTRIBUTE_LIGHT_VALUE/g, r).replace(/\$ATTRIBUTE_DARK_VALUE/g, o);
+  let l = "", f = !1, d = "", g = !1;
   return {
     name: "vite-check-theme-plugin",
     enforce: "pre",
-    configResolved(o) {
-      if (d = o.base, h = o.command === "serve", u = o.build.outDir, m = !!o.vitepress, !m || !Array.isArray(o.vitepress.site.head))
+    configResolved(y) {
+      if (l = y.base, f = y.command === "serve", d = y.build.outDir, g = !!y.vitepress, !g || !Array.isArray(y.vitepress.site.head))
         return;
-      const k = o.vitepress.site.head.find((x) => {
-        var y, E;
-        return x[0] === "script" && ((E = (y = x[1]) == null ? void 0 : y.src) == null ? void 0 : E.startsWith(`${d}${l}`));
+      const x = y.vitepress.site.head.find((E) => {
+        var S, m;
+        return E[0] === "script" && ((m = (S = E[1]) == null ? void 0 : S.src) == null ? void 0 : m.startsWith(`${l}${a}`));
       });
-      k ? k[1].src = `${d}${l}?t=${(/* @__PURE__ */ new Date()).getTime()}` : o.vitepress.site.head.push([
+      x ? x[1].src = `${l}${a}?t=${(/* @__PURE__ */ new Date()).getTime()}` : y.vitepress.site.head.push([
         "script",
         {
-          src: `${d}${l}?t=${(/* @__PURE__ */ new Date()).getTime()}`
+          src: `${l}${a}?t=${(/* @__PURE__ */ new Date()).getTime()}`
         }
       ]);
     },
     generateBundle() {
-      h || f.existsSync(f.join(u, l)) || (f.existsSync(u) || f.mkdirSync(u, { recursive: !0 }), f.writeFileSync(f.join(u, l), g, "utf-8"));
+      f || Z.existsSync(Z.join(d, a)) || (Z.existsSync(d) || Z.mkdirSync(d, { recursive: !0 }), Z.writeFileSync(Z.join(d, a), h, "utf-8"));
     },
-    configureServer(o) {
-      o.middlewares.use(`${d}${l}`, (k, x) => {
-        x.setHeader("Content-Type", "application/javascript"), x.end(g);
+    configureServer(y) {
+      y.middlewares.use(`${l}${a}`, (x, E) => {
+        E.setHeader("Content-Type", "application/javascript"), E.end(h);
       });
     },
-    transformIndexHtml(o) {
-      return m ? o : o.replace("</head>", `<script src="${d}${l}?t=${(/* @__PURE__ */ new Date()).getTime()}"><\/script></head>`);
+    transformIndexHtml(y) {
+      return g ? y : y.replace("</head>", `<script src="${l}${a}?t=${(/* @__PURE__ */ new Date()).getTime()}"><\/script></head>`);
     }
   };
 }
-function b(e) {
+function Rt(n) {
   if (typeof window > "u")
     return !1;
-  let n;
+  let t;
   try {
-    n = new URL(e, window.location.href);
+    t = new URL(n, window.location.href);
   } catch {
     return !1;
   }
-  return /^https?:$/.test(n.protocol) ? n.hostname !== window.location.hostname : !1;
+  return /^https?:$/.test(t.protocol) ? t.hostname !== window.location.hostname : !1;
 }
-function A(e, n = []) {
-  return n.some((t) => {
-    if (t === "*") return !0;
-    if (t.startsWith("*.")) {
-      const r = t.slice(2);
-      return e === r || e.endsWith(`.${r}`);
-    }
-    return e === t || e.endsWith(`.${t}`);
+function Nt(n, t = []) {
+  return t.some((e) => {
+    if (e === "*") return !0;
+    if (e.startsWith("*.")) {
+      const s = e.slice(2);
+      return n === s || n.endsWith(`.${s}`);
+    }
+    return n === e || n.endsWith(`.${e}`);
   });
 }
-const T = {
+const re = {
   zh: {
     title: "即将跳转到外部网站",
-    message: (e) => `您将要访问的链接不属于${e}，请关注您的账号安全。`,
+    message: (n) => `您将要访问的链接不属于${n}，请关注您的账号安全。`,
     cancel: "取消",
     confirm: "继续前往"
   },
   en: {
     title: "You will be redirected to an external website",
-    message: (e) => `The link you are about to visit does not belong to ${e}. Please ensure the security of your account.`,
+    message: (n) => `The link you are about to visit does not belong to ${n}. Please ensure the security of your account.`,
     cancel: "Cancel",
     confirm: "Continue"
   }
 };
-let i = null, v = !1;
-function C(e, n, t) {
-  const r = T[e];
-  return new Promise((a) => {
-    if (v) {
-      a(!1);
+let L = null, ut = !1;
+function oe(n, t, e) {
+  const s = re[n];
+  return new Promise((i) => {
+    if (ut) {
+      i(!1);
       return;
     }
-    v = !0, _(), i || (i = document.createElement("div"), i.className = "elg-mask", i.innerHTML = `
+    ut = !0, ce(), L || (L = document.createElement("div"), L.className = "elg-mask", L.innerHTML = `
         <div class="elg-modal">
           <div class="elg-title"></div>
           <div class="elg-content">
@@ -122,26 +139,26 @@ function C(e, n, t) {
           </div>
           
           <div class="elg-actions">
-            <button class="elg-btn elg-confirm">${r.confirm}</button>
-            <button class="elg-btn elg-cancel">${r.cancel}</button>
+            <button class="elg-btn elg-confirm">${s.confirm}</button>
+            <button class="elg-btn elg-cancel">${s.cancel}</button>
           </div>
         </div>
-      `, document.body.appendChild(i));
-    const s = i.querySelector(".elg-title"), c = i.querySelector(".elg-message"), w = i.querySelector(".elg-url"), p = i.querySelector(".elg-cancel"), l = i.querySelector(".elg-confirm");
-    s.textContent = r.title, c.textContent = r.message(t), w.textContent = n, i.style.display = "flex";
-    const g = (m) => {
-      i && (i.style.display = "none", i.removeEventListener("click", u), p.removeEventListener("click", d), l.removeEventListener("click", h), v = !1, a(m));
-    }, d = () => g(!1), h = () => g(!0), u = (m) => {
-      m.target === i && g(!1);
+      `, document.body.appendChild(L));
+    const r = L.querySelector(".elg-title"), o = L.querySelector(".elg-message"), u = L.querySelector(".elg-url"), p = L.querySelector(".elg-cancel"), a = L.querySelector(".elg-confirm");
+    r.textContent = s.title, o.textContent = s.message(e), u.textContent = t, L.style.display = "flex";
+    const h = (g) => {
+      L && (L.style.display = "none", L.removeEventListener("click", d), p.removeEventListener("click", l), a.removeEventListener("click", f), ut = !1, i(g));
+    }, l = () => h(!1), f = () => h(!0), d = (g) => {
+      g.target === L && h(!1);
     };
-    i.addEventListener("click", u), p.addEventListener("click", d), l.addEventListener("click", h);
+    L.addEventListener("click", d), p.addEventListener("click", l), a.addEventListener("click", f);
   });
 }
-function _() {
+function ce() {
   if (document.getElementById("elg-confirm-style"))
     return;
-  const e = document.createElement("style");
-  e.id = "elg-confirm-style", e.textContent = `
+  const n = document.createElement("style");
+  n.id = "elg-confirm-style", n.textContent = `
       :root {
         --elg-primary: var(--o-color-primary1);
         --elg-text: var(--o-color-info1);
@@ -253,64 +270,1416 @@ function _() {
           background: rgba(81, 119, 202)
         }
       }
-    `, document.head.appendChild(e);
+    `, document.head.appendChild(n);
 }
-async function L(e, n) {
-  if (n.showCustomConfirm)
-    return C(n.lang || "zh", e, n.community || "");
-  const t = n.message ?? `即将离开本站，前往第三方网站：
+async function Ot(n, t) {
+  if (t.showCustomConfirm)
+    return oe(t.lang || "zh", n, t.community || "");
+  const e = t.message ?? `即将离开本站，前往第三方网站：
 
-${e}`;
-  return Promise.resolve(window.confirm(t));
+${n}`;
+  return Promise.resolve(window.confirm(e));
 }
-function U(e) {
-  const n = window.open;
+function le(n) {
+  const t = window.open;
   document.addEventListener(
     "click",
-    async (t) => {
-      const r = t.target;
-      if (!r)
+    async (e) => {
+      const s = e.target;
+      if (!s)
         return;
-      const a = r.closest("a[href]");
-      if (!a)
+      const i = s.closest("a[href]");
+      if (!i)
         return;
-      const s = a.getAttribute("href");
-      if (!s || s.startsWith("#") || !b(s))
+      const r = i.getAttribute("href");
+      if (!r || r.startsWith("#") || !Rt(r))
         return;
-      const c = new URL(s, window.location.href);
-      if (A(c.hostname, e.whitelist))
+      const o = new URL(r, window.location.href);
+      if (Nt(o.hostname, n.whitelist))
         return;
-      t.preventDefault(), await L(c.href, e) && ((a.getAttribute("target") || "_self") === "_blank" ? n.call(window, c.href, "_blank", "noopener,noreferrer") : window.location.href = c.href);
+      e.preventDefault(), await Ot(o.href, n) && ((i.getAttribute("target") || "_self") === "_blank" ? t.call(window, o.href, "_blank", "noopener,noreferrer") : window.location.href = o.href);
     },
     !0
   );
 }
-function S(e) {
-  const n = window.open;
-  window.open = async function(t, ...r) {
-    if (t) {
-      const a = t.toString();
-      if (b(a)) {
-        const s = new URL(a, window.location.href);
-        if (!A(s.hostname, e.whitelist) && !await L(s.href, e))
+function ae(n) {
+  const t = window.open;
+  window.open = async function(e, ...s) {
+    if (e) {
+      const i = e.toString();
+      if (Rt(i)) {
+        const r = new URL(i, window.location.href);
+        if (!Nt(r.hostname, n.whitelist) && !await Ot(r.href, n))
           return null;
       }
     }
-    return n.call(window, t, ...r);
+    return t.call(window, e, ...s);
   };
 }
-function V(e = {}) {
+function Cs(n = {}) {
   return {
     install() {
-      typeof window > "u" || (U(e), S(e));
+      typeof window > "u" || (le(n), ae(n));
+    }
+  };
+}
+const Lt = (n, t, e) => {
+  const s = n instanceof RegExp ? bt(n, e) : n, i = t instanceof RegExp ? bt(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)
+  };
+}, bt = (n, t) => {
+  const e = t.match(n);
+  return e ? e[0] : null;
+}, he = (n, t, e) => {
+  let s, i, r, o, u, p = e.indexOf(n), a = e.indexOf(t, p + 1), h = p;
+  if (p >= 0 && a > 0) {
+    if (n === t)
+      return [p, a];
+    for (s = [], r = e.length; h >= 0 && !u; ) {
+      if (h === p)
+        s.push(h), p = e.indexOf(n, h + 1);
+      else if (s.length === 1) {
+        const l = s.pop();
+        l !== void 0 && (u = [l, a]);
+      } else
+        i = s.pop(), i !== void 0 && i < r && (r = i, o = a), a = e.indexOf(t, h + 1);
+      h = p < a && p >= 0 ? p : a;
+    }
+    s.length && o !== void 0 && (u = [r, o]);
+  }
+  return u;
+}, _t = "\0SLASH" + Math.random() + "\0", jt = "\0OPEN" + Math.random() + "\0", wt = "\0CLOSE" + Math.random() + "\0", Dt = "\0COMMA" + Math.random() + "\0", Pt = "\0PERIOD" + Math.random() + "\0", ue = new RegExp(_t, "g"), fe = new RegExp(jt, "g"), pe = new RegExp(wt, "g"), de = new RegExp(Dt, "g"), ge = new RegExp(Pt, "g"), me = /\\\\/g, ye = /\\{/g, we = /\\}/g, xe = /\\,/g, Ee = /\\\./g, be = 1e5;
+function ft(n) {
+  return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+}
+function Se(n) {
+  return n.replace(me, _t).replace(ye, jt).replace(we, wt).replace(xe, Dt).replace(Ee, Pt);
+}
+function ve(n) {
+  return n.replace(ue, "\\").replace(fe, "{").replace(pe, "}").replace(de, ",").replace(ge, ".");
+}
+function Wt(n) {
+  if (!n)
+    return [""];
+  const t = [], e = Lt("{", "}", n);
+  if (!e)
+    return n.split(",");
+  const { pre: s, body: i, post: r } = e, o = s.split(",");
+  o[o.length - 1] += "{" + i + "}";
+  const u = Wt(r);
+  return r.length && (o[o.length - 1] += u.shift(), o.push.apply(o, u)), t.push.apply(t, o), t;
+}
+function Ae(n, t = {}) {
+  if (!n)
+    return [];
+  const { max: e = be } = t;
+  return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), tt(Se(n), e, !0).map(ve);
+}
+function $e(n) {
+  return "{" + n + "}";
+}
+function Te(n) {
+  return /^-?0\d/.test(n);
+}
+function Me(n, t) {
+  return n <= t;
+}
+function ke(n, t) {
+  return n >= t;
+}
+function tt(n, t, e) {
+  const s = [], i = Lt("{", "}", n);
+  if (!i)
+    return [n];
+  const r = i.pre, o = i.post.length ? tt(i.post, t, !1) : [""];
+  if (/\$$/.test(i.pre))
+    for (let u = 0; u < o.length && u < t; u++) {
+      const p = r + "{" + i.body + "}" + o[u];
+      s.push(p);
+    }
+  else {
+    const u = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), p = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), a = u || p, h = i.body.indexOf(",") >= 0;
+    if (!a && !h)
+      return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + wt + i.post, tt(n, t, !0)) : [n];
+    let l;
+    if (a)
+      l = i.body.split(/\.\./);
+    else if (l = Wt(i.body), l.length === 1 && l[0] !== void 0 && (l = tt(l[0], t, !1).map($e), l.length === 1))
+      return o.map((d) => i.pre + l[0] + d);
+    let f;
+    if (a && l[0] !== void 0 && l[1] !== void 0) {
+      const d = ft(l[0]), g = ft(l[1]), y = Math.max(l[0].length, l[1].length);
+      let x = l.length === 3 && l[2] !== void 0 ? Math.max(Math.abs(ft(l[2])), 1) : 1, E = Me;
+      g < d && (x *= -1, E = ke);
+      const m = l.some(Te);
+      f = [];
+      for (let T = d; E(T, g); T += x) {
+        let $;
+        if (p)
+          $ = String.fromCharCode(T), $ === "\\" && ($ = "");
+        else if ($ = String(T), m) {
+          const K = y - $.length;
+          if (K > 0) {
+            const X = new Array(K + 1).join("0");
+            T < 0 ? $ = "-" + X + $.slice(1) : $ = X + $;
+          }
+        }
+        f.push($);
+      }
+    } else {
+      f = [];
+      for (let d = 0; d < l.length; d++)
+        f.push.apply(f, tt(l[d], t, !1));
+    }
+    for (let d = 0; d < f.length; d++)
+      for (let g = 0; g < o.length && s.length < t; g++) {
+        const y = r + f[d] + o[g];
+        (!e || a || y) && s.push(y);
+      }
+  }
+  return s;
+}
+const Ce = 1024 * 64, ot = (n) => {
+  if (typeof n != "string")
+    throw new TypeError("invalid pattern");
+  if (n.length > Ce)
+    throw new TypeError("pattern is too long");
+}, Re = {
+  "[: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]
+}, Q = (n) => n.replace(/[[\]\\-]/g, "\\$&"), Ne = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), St = (n) => n.join(""), Oe = (n, t) => {
+  const e = t;
+  if (n.charAt(e) !== "[")
+    throw new Error("not in a brace expression");
+  const s = [], i = [];
+  let r = e + 1, o = !1, u = !1, p = !1, a = !1, h = e, l = "";
+  t: for (; r < n.length; ) {
+    const y = n.charAt(r);
+    if ((y === "!" || y === "^") && r === e + 1) {
+      a = !0, r++;
+      continue;
+    }
+    if (y === "]" && o && !p) {
+      h = r + 1;
+      break;
+    }
+    if (o = !0, y === "\\" && !p) {
+      p = !0, r++;
+      continue;
+    }
+    if (y === "[" && !p) {
+      for (const [x, [E, S, m]] of Object.entries(Re))
+        if (n.startsWith(x, r)) {
+          if (l)
+            return ["$.", !1, n.length - e, !0];
+          r += x.length, m ? i.push(E) : s.push(E), u = u || S;
+          continue t;
+        }
+    }
+    if (p = !1, l) {
+      y > l ? s.push(Q(l) + "-" + Q(y)) : y === l && s.push(Q(y)), l = "", r++;
+      continue;
+    }
+    if (n.startsWith("-]", r + 1)) {
+      s.push(Q(y + "-")), r += 2;
+      continue;
+    }
+    if (n.startsWith("-", r + 1)) {
+      l = y, r += 2;
+      continue;
+    }
+    s.push(Q(y)), r++;
+  }
+  if (h < 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]) && !a) {
+    const y = s[0].length === 2 ? s[0].slice(-1) : s[0];
+    return [Ne(y), !1, h - e, !1];
+  }
+  const f = "[" + (a ? "^" : "") + St(s) + "]", d = "[" + (a ? "" : "^") + St(i) + "]";
+  return [s.length && i.length ? "(" + f + "|" + d + ")" : s.length ? f : d, u, h - e, !0];
+}, et = (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 j;
+const Le = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), pt = (n) => Le.has(n), vt = (n) => pt(n.type), _e = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]), je = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]), De = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]), At = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]), Pe = "(?!(?:^|/)\\.\\.?(?:$|/))", st = "(?!\\.)", We = /* @__PURE__ */ new Set(["[", "."]), ze = /* @__PURE__ */ new Set(["..", "."]), Ue = new Set("().*{}+?[]^$\\!"), qe = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), xt = "[^/]", $t = xt + "*?", Tt = xt + "+?";
+let Ie = 0;
+var C, N, q, w, M, I, F, G, z, U, Y, A, zt, V, nt, Ut, dt, it, qt, gt, It, Gt, Bt, rt, mt, Vt;
+class ct {
+  constructor(t, e, s = {}) {
+    R(this, A);
+    k(this, "type");
+    R(this, C);
+    R(this, N);
+    R(this, q, !1);
+    R(this, w, []);
+    R(this, M);
+    R(this, I);
+    R(this, F);
+    R(this, G, !1);
+    R(this, z);
+    R(this, U);
+    // set to true if it's an extglob with no children
+    // (which really means one child of '')
+    R(this, Y, !1);
+    k(this, "id", ++Ie);
+    this.type = t, t && b(this, N, !0), b(this, M, e), b(this, C, c(this, M) ? c(c(this, M), C) : this), b(this, z, c(this, C) === this ? s : c(c(this, C), z)), b(this, F, c(this, C) === this ? [] : c(c(this, C), F)), t === "!" && !c(c(this, C), G) && c(this, F).push(this), b(this, I, c(this, M) ? c(c(this, M), w).length : 0);
+  }
+  get depth() {
+    var t;
+    return (((t = c(this, M)) == 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: c(this, C).id,
+      parent: (t = c(this, M)) == null ? void 0 : t.id,
+      depth: this.depth,
+      partsLength: c(this, w).length,
+      parts: c(this, w)
+    };
+  }
+  get hasMagic() {
+    if (c(this, N) !== void 0)
+      return c(this, N);
+    for (const t of c(this, w))
+      if (typeof t != "string" && (t.type || t.hasMagic))
+        return b(this, N, !0);
+    return c(this, N);
+  }
+  // reconstructs the pattern
+  toString() {
+    return c(this, U) !== void 0 ? c(this, U) : this.type ? b(this, U, this.type + "(" + c(this, w).map((t) => String(t)).join("|") + ")") : b(this, U, c(this, w).map((t) => String(t)).join(""));
+  }
+  push(...t) {
+    for (const e of t)
+      if (e !== "") {
+        if (typeof e != "string" && !(e instanceof j && c(e, M) === this))
+          throw new Error("invalid part: " + e);
+        c(this, w).push(e);
+      }
+  }
+  toJSON() {
+    var e;
+    const t = this.type === null ? c(this, w).slice().map((s) => typeof s == "string" ? s : s.toJSON()) : [this.type, ...c(this, w).map((s) => s.toJSON())];
+    return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === c(this, C) || c(c(this, C), G) && ((e = c(this, M)) == null ? void 0 : e.type) === "!") && t.push({}), t;
+  }
+  isStart() {
+    var e;
+    if (c(this, C) === this)
+      return !0;
+    if (!((e = c(this, M)) != null && e.isStart()))
+      return !1;
+    if (c(this, I) === 0)
+      return !0;
+    const t = c(this, M);
+    for (let s = 0; s < c(this, I); s++) {
+      const i = c(t, w)[s];
+      if (!(i instanceof j && i.type === "!"))
+        return !1;
+    }
+    return !0;
+  }
+  isEnd() {
+    var e, s, i;
+    if (c(this, C) === this || ((e = c(this, M)) == null ? void 0 : e.type) === "!")
+      return !0;
+    if (!((s = c(this, M)) != null && s.isEnd()))
+      return !1;
+    if (!this.type)
+      return (i = c(this, M)) == null ? void 0 : i.isEnd();
+    const t = c(this, M) ? c(c(this, M), w).length : 0;
+    return c(this, I) === t - 1;
+  }
+  copyIn(t) {
+    typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+  }
+  clone(t) {
+    const e = new j(this.type, t);
+    for (const s of c(this, w))
+      e.copyIn(s);
+    return e;
+  }
+  static fromGlob(t, e = {}) {
+    var i;
+    const s = new j(null, void 0, e);
+    return v(i = j, V, nt).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 !== c(this, C))
+      return c(this, C).toMMPattern();
+    const t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+    if (!(i || c(this, N) || c(this, z).nocase && !c(this, z).nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase()))
+      return s;
+    const u = (c(this, z).nocase ? "i" : "") + (r ? "u" : "");
+    return Object.assign(new RegExp(`^${e}$`, u), {
+      _src: e,
+      _glob: t
+    });
+  }
+  get options() {
+    return c(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 ?? !!c(this, z).dot;
+    if (c(this, C) === this && (v(this, A, rt).call(this), v(this, A, zt).call(this)), !vt(this)) {
+      const a = this.isStart() && this.isEnd() && !c(this, w).some((g) => typeof g != "string"), h = c(this, w).map((g) => {
+        var m;
+        const [y, x, E, S] = typeof g == "string" ? v(m = j, V, Vt).call(m, g, c(this, N), a) : g.toRegExpSource(t);
+        return b(this, N, c(this, N) || E), b(this, q, c(this, q) || S), y;
+      }).join("");
+      let l = "";
+      if (this.isStart() && typeof c(this, w)[0] == "string" && !(c(this, w).length === 1 && ze.has(c(this, w)[0]))) {
+        const y = We, x = (
+          // dots are allowed, and the pattern starts with [ or .
+          e && y.has(h.charAt(0)) || // the pattern starts with \., and then [ or .
+          h.startsWith("\\.") && y.has(h.charAt(2)) || // the pattern starts with \.\., and then [ or .
+          h.startsWith("\\.\\.") && y.has(h.charAt(4))
+        ), E = !e && !t && y.has(h.charAt(0));
+        l = x ? Pe : E ? st : "";
+      }
+      let f = "";
+      return this.isEnd() && c(c(this, C), G) && ((p = c(this, M)) == null ? void 0 : p.type) === "!" && (f = "(?:$|\\/)"), [
+        l + h + f,
+        et(h),
+        b(this, N, !!c(this, N)),
+        c(this, q)
+      ];
+    }
+    const s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let r = v(this, A, mt).call(this, e);
+    if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+      const a = this.toString(), h = this;
+      return b(h, w, [a]), h.type = null, b(h, N, void 0), [a, et(this.toString()), !1, !1];
+    }
+    let o = !s || t || e || !st ? "" : v(this, A, mt).call(this, !0);
+    o === r && (o = ""), o && (r = `(?:${r})(?:${o})*?`);
+    let u = "";
+    if (this.type === "!" && c(this, Y))
+      u = (this.isStart() && !e ? st : "") + Tt;
+    else {
+      const a = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !e && !t ? st : "") + $t + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : `)${this.type}`;
+      u = i + r + a;
+    }
+    return [
+      u,
+      et(r),
+      b(this, N, !!c(this, N)),
+      c(this, q)
+    ];
+  }
+}
+C = new WeakMap(), N = new WeakMap(), q = new WeakMap(), w = new WeakMap(), M = new WeakMap(), I = new WeakMap(), F = new WeakMap(), G = new WeakMap(), z = new WeakMap(), U = new WeakMap(), Y = new WeakMap(), A = new WeakSet(), zt = function() {
+  if (this !== c(this, C))
+    throw new Error("should only call on root");
+  if (c(this, G))
+    return this;
+  this.toString(), b(this, G, !0);
+  let t;
+  for (; t = c(this, F).pop(); ) {
+    if (t.type !== "!")
+      continue;
+    let e = t, s = c(e, M);
+    for (; s; ) {
+      for (let i = c(e, I) + 1; !s.type && i < c(s, w).length; i++)
+        for (const r of c(t, w)) {
+          if (typeof r == "string")
+            throw new Error("string part in extglob AST??");
+          r.copyIn(c(s, w)[i]);
+        }
+      e = s, s = c(e, M);
+    }
+  }
+  return this;
+}, V = new WeakSet(), nt = function(t, e, s, i, r) {
+  var y, x, E, S;
+  const o = i.maxExtglobRecursion ?? 2;
+  let u = !1, p = !1, a = -1, h = !1;
+  if (e.type === null) {
+    let m = s, T = "";
+    for (; m < t.length; ) {
+      const $ = t.charAt(m++);
+      if (u || $ === "\\") {
+        u = !u, T += $;
+        continue;
+      }
+      if (p) {
+        m === a + 1 ? ($ === "^" || $ === "!") && (h = !0) : $ === "]" && !(m === a + 2 && h) && (p = !1), T += $;
+        continue;
+      } else if ($ === "[") {
+        p = !0, a = m, h = !1, T += $;
+        continue;
+      }
+      if (!i.noext && pt($) && t.charAt(m) === "(" && r <= o) {
+        e.push(T), T = "";
+        const X = new j($, e);
+        m = v(y = j, V, nt).call(y, t, X, m, i, r + 1), e.push(X);
+        continue;
+      }
+      T += $;
+    }
+    return e.push(T), m;
+  }
+  let l = s + 1, f = new j(null, e);
+  const d = [];
+  let g = "";
+  for (; l < t.length; ) {
+    const m = t.charAt(l++);
+    if (u || m === "\\") {
+      u = !u, g += m;
+      continue;
+    }
+    if (p) {
+      l === a + 1 ? (m === "^" || m === "!") && (h = !0) : m === "]" && !(l === a + 2 && h) && (p = !1), g += m;
+      continue;
+    } else if (m === "[") {
+      p = !0, a = l, h = !1, g += m;
+      continue;
+    }
+    if (!i.noext && pt(m) && t.charAt(l) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+    (r <= o || e && v(x = e, A, it).call(x, m))) {
+      const $ = e && v(E = e, A, it).call(E, m) ? 0 : 1;
+      f.push(g), g = "";
+      const K = new j(m, f);
+      f.push(K), l = v(S = j, V, nt).call(S, t, K, l, i, r + $);
+      continue;
+    }
+    if (m === "|") {
+      f.push(g), g = "", d.push(f), f = new j(null, e);
+      continue;
+    }
+    if (m === ")")
+      return g === "" && c(e, w).length === 0 && b(e, Y, !0), f.push(g), g = "", e.push(...d, f), l;
+    g += m;
+  }
+  return e.type = null, b(e, N, void 0), b(e, w, [t.substring(s - 1)]), l;
+}, Ut = function(t) {
+  return v(this, A, dt).call(this, t, je);
+}, dt = function(t, e = _e) {
+  if (!t || typeof t != "object" || t.type !== null || c(t, w).length !== 1 || this.type === null)
+    return !1;
+  const s = c(t, w)[0];
+  return !s || typeof s != "object" || s.type === null ? !1 : v(this, A, it).call(this, s.type, e);
+}, it = function(t, e = De) {
+  var s;
+  return !!((s = e.get(this.type)) != null && s.includes(t));
+}, qt = function(t, e) {
+  const s = c(t, w)[0], i = new j(null, s, this.options);
+  c(i, w).push(""), s.push(i), v(this, A, gt).call(this, t, e);
+}, gt = function(t, e) {
+  const s = c(t, w)[0];
+  c(this, w).splice(e, 1, ...c(s, w));
+  for (const i of c(s, w))
+    typeof i == "object" && b(i, M, this);
+  b(this, U, void 0);
+}, It = function(t) {
+  const e = At.get(this.type);
+  return !!(e != null && e.has(t));
+}, Gt = function(t) {
+  if (!t || typeof t != "object" || t.type !== null || c(t, w).length !== 1 || this.type === null || c(this, w).length !== 1)
+    return !1;
+  const e = c(t, w)[0];
+  return !e || typeof e != "object" || e.type === null ? !1 : v(this, A, It).call(this, e.type);
+}, Bt = function(t) {
+  const e = At.get(this.type), s = c(t, w)[0], i = e == null ? void 0 : e.get(s.type);
+  if (!i)
+    return !1;
+  b(this, w, c(s, w));
+  for (const r of c(this, w))
+    typeof r == "object" && b(r, M, this);
+  this.type = i, b(this, U, void 0), b(this, Y, !1);
+}, rt = function() {
+  var t, e;
+  if (vt(this)) {
+    let s = 0, i = !1;
+    do {
+      i = !0;
+      for (let r = 0; r < c(this, w).length; r++) {
+        const o = c(this, w)[r];
+        typeof o == "object" && (v(e = o, A, rt).call(e), v(this, A, dt).call(this, o) ? (i = !1, v(this, A, gt).call(this, o, r)) : v(this, A, Ut).call(this, o) ? (i = !1, v(this, A, qt).call(this, o, r)) : v(this, A, Gt).call(this, o) && (i = !1, v(this, A, Bt).call(this, o)));
+      }
+    } while (!i && ++s < 10);
+  } else
+    for (const s of c(this, w))
+      typeof s == "object" && v(t = s, A, rt).call(t);
+  b(this, U, void 0);
+}, mt = function(t) {
+  return c(this, w).map((e) => {
+    if (typeof e == "string")
+      throw new Error("string type in extglob ast??");
+    const [s, i, r, o] = e.toRegExpSource(t);
+    return b(this, q, c(this, q) || o), s;
+  }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+}, Vt = function(t, e, s = !1) {
+  let i = !1, r = "", o = !1, u = !1;
+  for (let p = 0; p < t.length; p++) {
+    const a = t.charAt(p);
+    if (i) {
+      i = !1, r += (Ue.has(a) ? "\\" : "") + a;
+      continue;
+    }
+    if (a === "*") {
+      if (u)
+        continue;
+      u = !0, r += s && /^[*]+$/.test(t) ? Tt : $t, e = !0;
+      continue;
+    } else
+      u = !1;
+    if (a === "\\") {
+      p === t.length - 1 ? r += "\\\\" : i = !0;
+      continue;
+    }
+    if (a === "[") {
+      const [h, l, f, d] = Oe(t, p);
+      if (f) {
+        r += h, o = o || l, p += f - 1, e = e || d;
+        continue;
+      }
+    }
+    if (a === "?") {
+      r += xt, e = !0;
+      continue;
+    }
+    r += qe(a);
+  }
+  return [r, et(t), !!e, o];
+}, R(ct, V);
+j = ct;
+const Ge = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&"), O = (n, t, e = {}) => (ot(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new lt(t, e).match(n)), Be = /^\*+([^+@!?*[(]*)$/, Ve = (n) => (t) => !t.startsWith(".") && t.endsWith(n), Fe = (n) => (t) => t.endsWith(n), He = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n)), Ke = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n)), Ze = /^\*+\.\*+$/, Je = (n) => !n.startsWith(".") && n.includes("."), Ye = (n) => n !== "." && n !== ".." && n.includes("."), Xe = /^\.\*+$/, Qe = (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 = Ft([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;
+}, cs = ([n, t = ""]) => {
+  const e = Ft([n]);
+  return t ? (s) => e(s) && s.endsWith(t) : e;
+}, Ft = ([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 !== "..";
+}, Kt = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", Mt = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+}, ls = Kt === "win32" ? Mt.win32.sep : Mt.posix.sep;
+O.sep = ls;
+const _ = Symbol("globstar **");
+O.GLOBSTAR = _;
+const as = "[^/]", hs = as + "*?", us = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", fs = "(?:(?!(?:\\/|^)\\.).)*?", ps = (n, t = {}) => (e) => O(e, n, t);
+O.filter = ps;
+const W = (n, t = {}) => Object.assign({}, n, t), ds = (n) => {
+  if (!n || typeof n != "object" || !Object.keys(n).length)
+    return O;
+  const t = O;
+  return Object.assign((s, i, r = {}) => t(s, i, W(n, r)), {
+    Minimatch: class extends t.Minimatch {
+      constructor(i, r = {}) {
+        super(i, W(n, r));
+      }
+      static defaults(i) {
+        return t.defaults(W(n, i)).Minimatch;
+      }
+    },
+    AST: class extends t.AST {
+      /* c8 ignore start */
+      constructor(i, r, o = {}) {
+        super(i, r, W(n, o));
+      }
+      /* c8 ignore stop */
+      static fromGlob(i, r = {}) {
+        return t.AST.fromGlob(i, W(n, r));
+      }
+    },
+    unescape: (s, i = {}) => t.unescape(s, W(n, i)),
+    escape: (s, i = {}) => t.escape(s, W(n, i)),
+    filter: (s, i = {}) => t.filter(s, W(n, i)),
+    defaults: (s) => t.defaults(W(n, s)),
+    makeRe: (s, i = {}) => t.makeRe(s, W(n, i)),
+    braceExpand: (s, i = {}) => t.braceExpand(s, W(n, i)),
+    match: (s, i, r = {}) => t.match(s, i, W(n, r)),
+    sep: t.sep,
+    GLOBSTAR: _
+  });
+};
+O.defaults = ds;
+const Zt = (n, t = {}) => (ot(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : Ae(n, { max: t.braceExpandMax }));
+O.braceExpand = Zt;
+const gs = (n, t = {}) => new lt(n, t).makeRe();
+O.makeRe = gs;
+const ms = (n, t, e = {}) => {
+  const s = new lt(t, e);
+  return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+};
+O.match = ms;
+const kt = /[?*]|[+@!]\(.*?\)|\[|\]/, ys = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var P, Jt, yt, J;
+class lt {
+  constructor(t, e = {}) {
+    R(this, P);
+    k(this, "options");
+    k(this, "set");
+    k(this, "pattern");
+    k(this, "windowsPathsNoEscape");
+    k(this, "nonegate");
+    k(this, "negate");
+    k(this, "comment");
+    k(this, "empty");
+    k(this, "preserveMultipleSlashes");
+    k(this, "partial");
+    k(this, "globSet");
+    k(this, "globParts");
+    k(this, "nocase");
+    k(this, "isWindows");
+    k(this, "platform");
+    k(this, "windowsNoMagicRoot");
+    k(this, "maxGlobstarRecursion");
+    k(this, "regexp");
+    ot(t), e = e || {}, this.options = e, this.maxGlobstarRecursion = e.maxGlobstarRecursion ?? 200, this.pattern = t, this.platform = e.platform || Kt, 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, o, u) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const p = r[0] === "" && r[1] === "" && (r[2] === "?" || !kt.test(r[2])) && !kt.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, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows)
+      for (let r = 0; r < this.set.length; r++) {
+        const o = this.set[r];
+        o[0] === "" && o[1] === "" && this.globParts[r][2] === "?" && typeof o[3] == "string" && /^[a-z]:$/i.test(o[3]) && (o[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 o = i;
+          for (; s[o + 1] === "**"; )
+            o++;
+          o > i && s.splice(i + 1, o - i);
+          let u = s[i + 1];
+          const p = s[i + 2], a = s[i + 3];
+          if (u !== ".." || !p || p === "." || p === ".." || !a || a === "." || a === "..")
+            continue;
+          e = !0, s.splice(i, 1);
+          const h = s.slice(0);
+          h[i] = "**", t.push(h), i--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let o = 1; o < s.length - 1; o++) {
+            const u = s[o];
+            o === 1 && u === "" && s[0] === "" || (u === "." || u === "") && (e = !0, s.splice(o, 1), o--);
+          }
+          s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+        }
+        let r = 0;
+        for (; (r = s.indexOf("..", r + 1)) !== -1; ) {
+          const o = s[r - 1];
+          if (o && o !== "." && o !== ".." && o !== "**") {
+            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, o = [], u = "";
+    for (; i < t.length && r < e.length; )
+      if (t[i] === e[r])
+        o.push(u === "b" ? e[r] : t[i]), i++, r++;
+      else if (s && t[i] === "**" && e[r] === t[i + 1])
+        o.push(t[i]), i++;
+      else if (s && e[r] === "**" && t[i] === e[r + 1])
+        o.push(e[r]), r++;
+      else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+        if (u === "b")
+          return !1;
+        u = "a", o.push(t[i]), i++, r++;
+      } else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+        if (u === "a")
+          return !1;
+        u = "b", o.push(e[r]), i++, r++;
+      } else
+        return !1;
+    return t.length === e.length && o;
+  }
+  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 u = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), p = !u && 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 : u ? 0 : void 0, f = h ? 3 : a ? 0 : void 0;
+      if (typeof l == "number" && typeof f == "number") {
+        const [d, g] = [
+          t[l],
+          e[f]
+        ];
+        d.toLowerCase() === g.toLowerCase() && (e[f] = d, r = f, i = l);
+      }
+    }
+    const { optimizationLevel: o = 1 } = this.options;
+    return o >= 2 && (t = this.levelTwoFileOptimize(t)), e.includes(_) ? v(this, P, Jt).call(this, t, e, s, i, r) : v(this, P, J).call(this, t, e, s, i, r);
+  }
+  braceExpand() {
+    return Zt(this.pattern, this.options);
+  }
+  parse(t) {
+    ot(t);
+    const e = this.options;
+    if (t === "**")
+      return _;
+    if (t === "")
+      return "";
+    let s, i = null;
+    (s = t.match(ts)) ? i = e.dot ? ss : es : (s = t.match(Be)) ? i = (e.nocase ? e.dot ? Ke : He : e.dot ? Fe : Ve)(s[1]) : (s = t.match(ns)) ? i = (e.nocase ? e.dot ? rs : is : e.dot ? os : cs)(s) : (s = t.match(Ze)) ? i = e.dot ? Ye : Je : (s = t.match(Xe)) && (i = Qe);
+    const r = ct.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 ? us : fs, i = new Set(e.nocase ? ["i"] : []);
+    let r = t.map((p) => {
+      const a = p.map((l) => {
+        if (l instanceof RegExp)
+          for (const f of l.flags.split(""))
+            i.add(f);
+        return typeof l == "string" ? ys(l) : l === _ ? _ : l._src;
+      });
+      a.forEach((l, f) => {
+        const d = a[f + 1], g = a[f - 1];
+        l !== _ || g === _ || (g === void 0 ? d !== void 0 && d !== _ ? a[f + 1] = "(?:\\/|" + s + "\\/)?" + d : a[f] = s : d === void 0 ? a[f - 1] = g + "(?:\\/|\\/" + s + ")?" : d !== _ && (a[f - 1] = g + "(?:\\/|\\/" + s + "\\/)" + d, a[f + 1] = _));
+      });
+      const h = a.filter((l) => l !== _);
+      if (this.partial && h.length >= 1) {
+        const l = [];
+        for (let f = 1; f <= h.length; f++)
+          l.push(h.slice(0, f).join("/"));
+        return "(?:" + l.join("|") + ")";
+      }
+      return h.join("/");
+    }).join("|");
+    const [o, u] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+    r = "^" + o + r + u + "$", this.partial && (r = "^(?:\\/|" + o + r.slice(1, -1) + u + ")$"), 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 o = i[i.length - 1];
+    if (!o)
+      for (let u = i.length - 2; !o && u >= 0; u--)
+        o = i[u];
+    for (const u of r) {
+      let p = i;
+      if (s.matchBase && u.length === 1 && (p = [o]), this.matchOne(p, u, e))
+        return s.flipNegate ? !0 : !this.negate;
+    }
+    return s.flipNegate ? !1 : this.negate;
+  }
+  static defaults(t) {
+    return O.defaults(t).Minimatch;
+  }
+}
+P = new WeakSet(), Jt = function(t, e, s, i, r) {
+  const o = e.indexOf(_, r), u = e.lastIndexOf(_), [p, a, h] = s ? [
+    e.slice(r, o),
+    e.slice(o + 1),
+    []
+  ] : [
+    e.slice(r, o),
+    e.slice(o + 1, u),
+    e.slice(u + 1)
+  ];
+  if (p.length) {
+    const S = t.slice(i, i + p.length);
+    if (!v(this, P, J).call(this, S, p, s, 0, 0))
+      return !1;
+    i += p.length, r += p.length;
+  }
+  let l = 0;
+  if (h.length) {
+    if (h.length + i > t.length)
+      return !1;
+    let S = t.length - h.length;
+    if (v(this, P, J).call(this, t, h, s, S, 0))
+      l = h.length;
+    else {
+      if (t[t.length - 1] !== "" || i + h.length === t.length || (S--, !v(this, P, J).call(this, t, h, s, S, 0)))
+        return !1;
+      l = h.length + 1;
+    }
+  }
+  if (!a.length) {
+    let S = !!l;
+    for (let m = i; m < t.length - l; m++) {
+      const T = String(t[m]);
+      if (S = !0, T === "." || T === ".." || !this.options.dot && T.startsWith("."))
+        return !1;
+    }
+    return s || S;
+  }
+  const f = [[[], 0]];
+  let d = f[0], g = 0;
+  const y = [0];
+  for (const S of a)
+    S === _ ? (y.push(g), d = [[], 0], f.push(d)) : (d[0].push(S), g++);
+  let x = f.length - 1;
+  const E = t.length - l;
+  for (const S of f)
+    S[1] = E - (y[x--] + S[0].length);
+  return !!v(this, P, yt).call(this, t, f, 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, o, u) {
+  const p = e[i];
+  if (!p) {
+    for (let l = s; l < t.length; l++) {
+      u = !0;
+      const f = t[l];
+      if (f === "." || f === ".." || !this.options.dot && f.startsWith("."))
+        return !1;
+    }
+    return u;
+  }
+  const [a, h] = p;
+  for (; s <= h; ) {
+    if (v(this, P, J).call(this, t.slice(0, s + a.length), a, r, s, 0) && o < this.maxGlobstarRecursion) {
+      const d = v(this, P, yt).call(this, t, e, s + a.length, i + 1, r, o + 1, u);
+      if (d !== !1)
+        return d;
+    }
+    const f = t[s];
+    if (f === "." || f === ".." || !this.options.dot && f.startsWith("."))
+      return !1;
+    s++;
+  }
+  return r || null;
+}, J = function(t, e, s, i, r) {
+  let o, u, p, a;
+  for (o = i, u = r, a = t.length, p = e.length; o < a && u < p; o++, u++) {
+    this.debug("matchOne loop");
+    let h = e[u], l = t[o];
+    if (this.debug(e, h, l), h === !1 || h === _)
+      return !1;
+    let f;
+    if (typeof h == "string" ? (f = l === h, this.debug("string match", h, l, f)) : (f = h.test(l), this.debug("pattern match", h, l, f)), !f)
+      return !1;
+  }
+  if (o === a && u === p)
+    return !0;
+  if (o === a)
+    return s;
+  if (u === p)
+    return o === a - 1 && t[o] === "";
+  throw new Error("wtf?");
+};
+O.AST = ct;
+O.Minimatch = lt;
+O.escape = Ge;
+O.unescape = et;
+class ws {
+  constructor(t) {
+    k(this, "value");
+    k(this, "next");
+    this.value = t;
+  }
+}
+var D, B, H;
+class xs {
+  constructor() {
+    R(this, D);
+    R(this, B);
+    R(this, H);
+    this.clear();
+  }
+  enqueue(t) {
+    const e = new ws(t);
+    c(this, D) ? (c(this, B).next = e, b(this, B, e)) : (b(this, D, e), b(this, B, e)), ht(this, H)._++;
+  }
+  dequeue() {
+    const t = c(this, D);
+    if (t)
+      return b(this, D, c(this, D).next), ht(this, H)._--, c(this, D) || b(this, B, void 0), t.value;
+  }
+  peek() {
+    if (c(this, D))
+      return c(this, D).value;
+  }
+  clear() {
+    b(this, D, void 0), b(this, B, void 0), b(this, H, 0);
+  }
+  get size() {
+    return c(this, H);
+  }
+  *[Symbol.iterator]() {
+    let t = c(this, D);
+    for (; t; )
+      yield t.value, t = t.next;
+  }
+  *drain() {
+    for (; c(this, D); )
+      yield this.dequeue();
+  }
+}
+D = new WeakMap(), B = new WeakMap(), H = new WeakMap();
+function Es(n) {
+  let t = !1;
+  if (typeof n == "object" && ({ concurrency: n, rejectOnClear: t = !1 } = n), Ct(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();
+  }, o = async (a, h, l) => {
+    const f = (async () => a(...l))();
+    h(f);
+    try {
+      await f;
+    } catch {
+    }
+    r();
+  }, u = (a, h, l, f) => {
+    const d = { reject: l };
+    new Promise((g) => {
+      d.run = g, e.enqueue(d);
+    }).then(o.bind(void 0, a, h, f)), s < n && i();
+  }, p = (a, ...h) => new Promise((l, f) => {
+    u(a, l, f, 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: () => n,
+      set(a) {
+        Ct(a), n = a, queueMicrotask(() => {
+          for (; s < n && e.size > 0; )
+            i();
+        });
+      }
+    },
+    map: {
+      async value(a, h) {
+        const l = Array.from(a, (f, d) => this(h, f, d));
+        return Promise.all(l);
+      }
+    }
+  }), p;
+}
+function Ct(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 = ne(ee);
+function Ss(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 Os(n) {
+  const t = n.pageEntryPattern;
+  let e = n.rootDir ?? "", s = n.outputFile ?? "";
+  const i = n.concurrency ?? 20, r = n.commitCount ?? 10, o = n.ignoreDeps ? Array.isArray(n.ignoreDeps) ? n.ignoreDeps : [n.ignoreDeps] : [], u = {};
+  let p;
+  return {
+    name: "vite-last-modified",
+    async configResolved(a) {
+      p = a.build.ssr, e || (e = a.root), s || (s = te(e, "last-modified.json"));
+    },
+    async buildEnd() {
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const a = /* @__PURE__ */ new Map(), h = Es(i), l = (x) => {
+        if (a.has(x))
+          return a.get(x);
+        const E = h(async () => {
+          try {
+            const S = x.includes("?") ? x.slice(0, x.indexOf("?")) : x, m = Qt.relative(e, S).replace(/\\/g, "/"), { stdout: T } = await bs(`git log --follow -n ${r} --format=%at -- "${m}"`, { cwd: e });
+            return T.trim() ? T.trim().split(`
+`).map(($) => parseInt($, 10) * 1e3) : [];
+          } catch {
+            return [];
+          }
+        });
+        return a.set(x, E), E;
+      }, f = (x, E) => {
+        if (E.has(x)) return;
+        E.add(x);
+        const S = this.getModuleInfo(x);
+        if (S)
+          for (const m of S.importedIds) {
+            if (m.includes("node_modules") || !m.startsWith(e))
+              continue;
+            const T = m.slice(e.length).replace(/^\/?/, "").split("?")[0];
+            o.some(($) => O(T, $, { dot: !0 })) || f(m, E);
+          }
+      }, d = [...this.getModuleIds()].filter((x) => {
+        if (!x.startsWith(e))
+          return !1;
+        const E = x.slice(e.length).replace(/^\//, "");
+        return typeof t == "string" ? O(E, t, { dot: !0 }) : t.test(E);
+      });
+      if (d.length === 0) {
+        console.warn("[lastModifiedPlugin] No MD files found in module graph");
+        return;
+      }
+      console.log("[lastModifiedPlugin] start collect entry files deps");
+      let g = /* @__PURE__ */ new Map();
+      for (const x of d) {
+        const E = /* @__PURE__ */ new Set();
+        f(x, E), g.set(x, E);
+      }
+      if (console.log(`[lastModifiedPlugin] Analyzed ${d.length} entry files`), typeof n.modifyDepMap == "function") {
+        const x = await n.modifyDepMap(g);
+        x && x instanceof Map && (g = x);
+      }
+      const y = /* @__PURE__ */ new Set();
+      for (const x of g.values())
+        for (const E of x)
+          y.add(E);
+      await Promise.all([...y].map(l));
+      for (const [x, E] of g) {
+        const S = x.slice(e.length).replace(/^\//, ""), m = (await Promise.all([...E].map(l))).flat(), T = m.length > 0 ? Math.max(...m) : 0, $ = Ss(m);
+        u[S] = { lastmod: T, changefreq: $ };
+      }
+    },
+    closeBundle() {
+      if (p || process.env.NODE_ENV !== "production")
+        return;
+      const a = Object.fromEntries(Object.entries(u).sort(([h], [l]) => h.localeCompare(l)));
+      se(s, JSON.stringify(a, null, 2), "utf8"), console.log(`[lastModifiedPlugin] Written ${s}`);
     }
   };
 }
 export {
-  I as CheckThemePlugin,
-  V as createExternalLinkGuard,
-  H as generateLastmodAndChangefreq,
-  K as initOpenDesignAnalytics,
-  O as oaReport,
-  z as vAnalytics
+  ks as CheckThemePlugin,
+  Cs as createExternalLinkGuard,
+  Os as generateLastmodAndChangefreq,
+  js as initOpenDesignAnalytics,
+  Ds as oaReport,
+  Ps as vAnalytics
 };