@admin-core/design 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,2 +1,2352 @@
-
+const tt = "light", Me = "default", ne = {
+  MODE: "theme-mode",
+  VARIANT: "theme-variant"
+}, ae = {
+  DARK: "dark",
+  LIGHT: "light"
+}, xe = {
+  THEME: "data-theme",
+  MODE: "data-mode"
+}, Ye = 300, le = [
+  {
+    id: "default",
+    name: "经典蓝",
+    icon: "🔵",
+    description: "经典的蓝色主题，适合大多数场景",
+    primaryColor: "hsl(212, 100%, 48%)",
+    category: "colorful",
+    isDefault: !0
+  },
+  {
+    id: "slate",
+    name: "石板灰",
+    icon: "🔘",
+    description: "石板色主题，沉稳内敛",
+    primaryColor: "hsl(215, 20%, 40%)",
+    category: "neutral"
+  },
+  {
+    id: "burnished-lilac",
+    name: "烟熏薰衣草",
+    icon: "🪻",
+    description: "2026流行色 - 优雅的薰衣草紫，展现高贵气质",
+    primaryColor: "hsl(280, 35%, 65%)",
+    category: "colorful"
+  },
+  {
+    id: "teaberry",
+    name: "茶莓红",
+    icon: "🌹",
+    description: "2026流行色 - 浪漫的茶莓色，充满活力",
+    primaryColor: "hsl(345, 75%, 55%)",
+    category: "colorful"
+  },
+  {
+    id: "amaranth",
+    name: "苋菜紫",
+    icon: "💜",
+    description: "2026流行色 - 神秘的苋菜紫，时尚前卫",
+    primaryColor: "hsl(310, 60%, 45%)",
+    category: "colorful"
+  },
+  {
+    id: "pulse-blue",
+    name: "脉冲蓝",
+    icon: "💙",
+    description: "2026流行色 - 充满活力的脉冲蓝，现代时尚",
+    primaryColor: "hsl(200, 85%, 50%)",
+    category: "colorful"
+  },
+  {
+    id: "deep-teal",
+    name: "深邃青",
+    icon: "🩵",
+    description: "2026流行色 - 深邃的青色，沉稳大气",
+    primaryColor: "hsl(180, 65%, 35%)",
+    category: "colorful"
+  },
+  {
+    id: "mermaid-aqua",
+    name: "美人鱼蓝",
+    icon: "🧜‍♀️",
+    description: "2026流行色 - 梦幻的美人鱼蓝，清新可爱",
+    primaryColor: "hsl(185, 70%, 55%)",
+    category: "colorful"
+  },
+  {
+    id: "pearl-purple",
+    name: "珍珠紫",
+    icon: "🔮",
+    description: "2026流行色 - 柔和的珍珠紫，优雅迷人",
+    primaryColor: "hsl(270, 45%, 70%)",
+    category: "colorful"
+  },
+  {
+    id: "burgundy",
+    name: "勃艮第",
+    icon: "🍷",
+    description: "2026流行色 - 高端奢华的勃艮第红，尊贵典雅",
+    primaryColor: "hsl(345, 65%, 40%)",
+    category: "colorful"
+  },
+  {
+    id: "burnt-sienna",
+    name: "焦赭石",
+    icon: "🍂",
+    description: "2026流行色 - 温暖的焦赭石色，自然大地",
+    primaryColor: "hsl(15, 60%, 50%)",
+    category: "colorful"
+  },
+  {
+    id: "olive-sage",
+    name: "橄榄绿",
+    icon: "🫒",
+    description: "2026流行色 - 沉稳的橄榄绿，自然和谐",
+    primaryColor: "hsl(80, 30%, 45%)",
+    category: "colorful"
+  },
+  {
+    id: "champagne-gold",
+    name: "香槟金",
+    icon: "🥂",
+    description: "2026流行色 - 奢华的香槟金，高贵优雅",
+    primaryColor: "hsl(45, 55%, 60%)",
+    category: "colorful"
+  },
+  {
+    id: "dusty-rose",
+    name: "灰玫瑰",
+    icon: "🌸",
+    description: "2026流行色 - 柔和的灰玫瑰色，温柔可爱",
+    primaryColor: "hsl(350, 40%, 65%)",
+    category: "colorful"
+  },
+  {
+    id: "citrus-green",
+    name: "柑橘绿",
+    icon: "🍋",
+    description: "2026流行色 - 清新的柑橘绿，充满生机",
+    primaryColor: "hsl(75, 70%, 50%)",
+    category: "colorful"
+  }
+], Xr = {
+  colorful: le.filter((e) => e.category === "colorful"),
+  neutral: le.filter((e) => e.category === "neutral"),
+  monochrome: le.filter((e) => e.category === "monochrome")
+}, nt = new Map(
+  le.map((e) => [e.id, e])
+);
+function V() {
+  return document.documentElement;
+}
+function un() {
+  if (typeof window > "u") return null;
+  const e = localStorage.getItem(ne.MODE);
+  return e === "dark" || e === "light" ? e : null;
+}
+function fn() {
+  if (typeof window > "u") return null;
+  const e = localStorage.getItem(ne.VARIANT);
+  return nt.has(e) ? e : null;
+}
+function dn(e) {
+  typeof window > "u" || localStorage.setItem(ne.MODE, e);
+}
+function pn(e) {
+  typeof window > "u" || localStorage.setItem(ne.VARIANT, e);
+}
+function eo() {
+  typeof window > "u" || (localStorage.removeItem(ne.MODE), localStorage.removeItem(ne.VARIANT));
+}
+function hn(e) {
+  const t = V();
+  e === "dark" ? (t.classList.add(ae.DARK), t.classList.remove(ae.LIGHT)) : (t.classList.remove(ae.DARK), t.classList.add(ae.LIGHT)), t.setAttribute(xe.MODE, e);
+  const n = localStorage.getItem("custom-theme-primary"), r = localStorage.getItem("custom-theme-active") === "true";
+  n && r && setTimeout(() => {
+    const o = Tt(n, e);
+    rt(o, !1);
+  }, 0);
+}
+function mn(e) {
+  const t = V();
+  e === "default" || e === Me ? t.removeAttribute(xe.THEME) : t.setAttribute(xe.THEME, e), localStorage.getItem("custom-theme-primary") && (localStorage.setItem("custom-theme-active", "false"), [
+    "primary",
+    "primary-foreground",
+    "secondary",
+    "secondary-foreground",
+    "accent",
+    "accent-foreground",
+    "muted",
+    "muted-foreground",
+    "background",
+    "background-deep",
+    "foreground",
+    "card",
+    "card-foreground",
+    "border",
+    "input",
+    "ring",
+    "sidebar",
+    "sidebar-deep",
+    "header",
+    "menu"
+  ].forEach((o) => {
+    t.style.removeProperty(`--${o}`);
+  }));
+}
+function Nt() {
+  return typeof window > "u" ? tt : V().classList.contains(ae.DARK) ? "dark" : "light";
+}
+function to() {
+  return typeof window > "u" ? Me : V().getAttribute(xe.THEME) || Me;
+}
+function ue(e, t = {}) {
+  const { mode: n, variant: r, persist: o = !0 } = e, { transition: s = !0 } = t;
+  s && gn(), n && (hn(n), o && dn(n)), r && (mn(r), o && pn(r)), s && setTimeout(() => {
+    _n();
+  }, Ye);
+}
+function gn() {
+  V().style.setProperty("transition", `background-color ${Ye}ms ease, color ${Ye}ms ease`);
+}
+function _n() {
+  V().style.removeProperty("transition");
+}
+function vn(e = {}) {
+  const n = Nt() === "dark" ? "light" : "dark";
+  return ue({ mode: n }, e), n;
+}
+function yn() {
+  const e = un(), t = fn(), n = {
+    mode: e || tt,
+    variant: t || Me,
+    persist: !0,
+    enableTransition: !1
+    // 初始化时不启用过渡
+  };
+  return ue(n, { transition: !1 }), n;
+}
+function no() {
+  return typeof window > "u" ? tt : window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function En(e) {
+  if (typeof window > "u") return () => {
+  };
+  const t = window.matchMedia("(prefers-color-scheme: dark)"), n = (r) => {
+    e(r.matches ? "dark" : "light");
+  };
+  return t.addEventListener("change", n), () => {
+    t.removeEventListener("change", n);
+  };
+}
+function wn() {
+  return le;
+}
+function bn(e) {
+  return nt.get(e);
+}
+function _t(e) {
+  const n = e.replace(/hsl\(|\)|%/g, "").trim().split(/[\s,]+/).map(Number);
+  if (n.length < 3 || n[0] === void 0 || n[1] === void 0 || n[2] === void 0)
+    return null;
+  const r = {
+    h: n[0],
+    s: n[1],
+    l: n[2]
+  };
+  return n[3] !== void 0 && (r.a = n[3]), r;
+}
+function ro(e) {
+  const { h: t, s: n, l: r, a: o } = e;
+  return o !== void 0 && o !== 1 ? `hsla(${t}, ${n}%, ${r}%, ${o})` : `hsl(${t}, ${n}%, ${r}%)`;
+}
+function Sn(e) {
+  if (typeof window > "u") return "";
+  const t = V();
+  return getComputedStyle(t).getPropertyValue(`--${e}`).trim();
+}
+function oo(e, t) {
+  if (typeof window > "u") return;
+  V().style.setProperty(`--${e}`, t);
+}
+function so(e) {
+  const t = Sn(e);
+  return t && !t.startsWith("hsl") ? `hsl(${t})` : t;
+}
+function io(e) {
+  return nt.has(e);
+}
+function co(e) {
+  return e === "light" || e === "dark";
+}
+function rt(e, t = !1) {
+  if (typeof window > "u") return;
+  const n = V(), r = (o) => o.replace(/hsl\(|\)|%/g, "").trim();
+  Object.entries(e).forEach(([o, s]) => {
+    if (s) {
+      const i = o.replace(/([A-Z])/g, "-$1").toLowerCase(), c = r(s);
+      n.style.setProperty(`--${i}`, c);
+    }
+  }), t && localStorage.setItem("custom-theme-colors", JSON.stringify(e));
+}
+function Nn() {
+  if (typeof window > "u") return null;
+  const e = localStorage.getItem("custom-theme-colors");
+  if (!e) return null;
+  try {
+    return JSON.parse(e);
+  } catch {
+    return null;
+  }
+}
+function ao() {
+  if (typeof window > "u") return;
+  const e = V();
+  [
+    "primary",
+    "primaryForeground",
+    "secondary",
+    "secondaryForeground",
+    "accent",
+    "accentForeground",
+    "muted",
+    "mutedForeground",
+    "background",
+    "backgroundDeep",
+    "foreground",
+    "card",
+    "cardForeground",
+    "border",
+    "input",
+    "ring",
+    "sidebar",
+    "sidebarDeep",
+    "header",
+    "menu"
+  ].forEach((n) => {
+    const r = n.replace(/([A-Z])/g, "-$1").toLowerCase();
+    e.style.removeProperty(`--${r}`);
+  }), localStorage.removeItem("custom-theme-colors"), localStorage.removeItem("custom-theme-primary"), localStorage.removeItem("custom-theme-active");
+}
+function lo() {
+  const e = Nn();
+  return e ? (rt(e, !1), !0) : !1;
+}
+function Tn(e) {
+  e = e.replace("#", "");
+  const t = Number.parseInt(e.substring(0, 2), 16) / 255, n = Number.parseInt(e.substring(2, 4), 16) / 255, r = Number.parseInt(e.substring(4, 6), 16) / 255, o = Math.max(t, n, r), s = Math.min(t, n, r);
+  let i = 0, c = 0;
+  const l = (o + s) / 2;
+  if (o !== s) {
+    const d = o - s;
+    switch (c = l > 0.5 ? d / (2 - o - s) : d / (o + s), o) {
+      case t:
+        i = ((n - r) / d + (n < r ? 6 : 0)) / 6;
+        break;
+      case n:
+        i = ((r - t) / d + 2) / 6;
+        break;
+      case r:
+        i = ((t - n) / d + 4) / 6;
+        break;
+    }
+  }
+  i = Math.round(i * 360), c = Math.round(c * 100);
+  const u = Math.round(l * 100);
+  return `${i} ${c}% ${u}%`;
+}
+function uo(e, t, n) {
+  e /= 255, t /= 255, n /= 255;
+  const r = Math.max(e, t, n), o = Math.min(e, t, n);
+  let s = 0, i = 0;
+  const c = (r + o) / 2;
+  if (r !== o) {
+    const u = r - o;
+    switch (i = c > 0.5 ? u / (2 - r - o) : u / (r + o), r) {
+      case e:
+        s = ((t - n) / u + (t < n ? 6 : 0)) / 6;
+        break;
+      case t:
+        s = ((n - e) / u + 2) / 6;
+        break;
+      case n:
+        s = ((e - t) / u + 4) / 6;
+        break;
+    }
+  }
+  s = Math.round(s * 360), i = Math.round(i * 100);
+  const l = Math.round(c * 100);
+  return `${s} ${i}% ${l}%`;
+}
+function Tt(e, t = "light") {
+  let n;
+  if (e.startsWith("#"))
+    n = Tn(e);
+  else if (e.startsWith("hsl")) {
+    const o = _t(e);
+    n = o ? `${o.h} ${o.s}% ${o.l}%` : e;
+  } else
+    n = e;
+  const r = _t(n);
+  if (!r)
+    throw new Error("Invalid color format");
+  return t === "light" ? {
+    // 主色
+    primary: n,
+    primaryForeground: r.l > 50 ? "0 0% 10%" : "0 0% 98%",
+    // 次要色（降低饱和度，提高亮度）
+    secondary: `${r.h} ${Math.max(5, r.s - 30)}% ${Math.min(96, r.l + 40)}%`,
+    secondaryForeground: `${r.h} ${Math.min(100, r.s + 20)}% ${Math.max(10, r.l - 40)}%`,
+    // 强调色（稍微调整色相，保持饱和度）
+    accent: `${r.h} ${Math.max(5, r.s - 25)}% ${Math.min(96, r.l + 35)}%`,
+    accentForeground: `${r.h} ${Math.min(100, r.s + 15)}% ${Math.max(10, r.l - 35)}%`,
+    // 柔和色（大幅降低饱和度）
+    muted: `${r.h} ${Math.max(5, r.s - 40)}% 96%`,
+    mutedForeground: `${r.h} ${Math.max(5, r.s - 35)}% 46%`,
+    // 背景和前景
+    background: "0 0% 100%",
+    backgroundDeep: `${r.h} ${Math.max(5, r.s - 45)}% 95%`,
+    foreground: `${r.h} ${Math.max(5, r.s - 40)}% 15%`,
+    // 卡片
+    card: "0 0% 100%",
+    cardForeground: `${r.h} ${Math.max(5, r.s - 40)}% 15%`,
+    // 边框和输入
+    border: `${r.h} ${Math.max(5, r.s - 40)}% 90%`,
+    input: `${r.h} ${Math.max(5, r.s - 40)}% 90%`,
+    ring: n,
+    // 侧边栏和头部
+    sidebar: "0 0% 100%",
+    sidebarDeep: "0 0% 100%",
+    header: "0 0% 100%",
+    menu: "0 0% 100%"
+  } : {
+    // 主色（暗色模式下稍微提高亮度）
+    primary: `${r.h} ${r.s}% ${Math.min(65, r.l + 10)}%`,
+    primaryForeground: "0 0% 98%",
+    // 次要色
+    secondary: `${r.h} ${Math.max(5, r.s - 30)}% 17%`,
+    secondaryForeground: "0 0% 98%",
+    // 强调色
+    accent: `${r.h} ${Math.max(5, r.s - 25)}% 19%`,
+    accentForeground: "0 0% 98%",
+    // 柔和色
+    muted: `${r.h} ${Math.max(5, r.s - 35)}% 16%`,
+    mutedForeground: `${r.h} ${Math.max(5, r.s - 30)}% 65%`,
+    // 背景和前景
+    background: `${r.h} ${Math.max(5, r.s - 30)}% 12%`,
+    backgroundDeep: `${r.h} ${Math.max(5, r.s - 35)}% 9%`,
+    foreground: "0 0% 95%",
+    // 卡片
+    card: `${r.h} ${Math.max(5, r.s - 30)}% 12%`,
+    cardForeground: "0 0% 95%",
+    // 边框和输入
+    border: `${r.h} ${Math.max(5, r.s - 35)}% 22%`,
+    input: `${r.h} ${Math.max(5, r.s - 35)}% 22%`,
+    ring: `${r.h} ${r.s}% ${Math.min(65, r.l + 10)}%`,
+    // 侧边栏和头部
+    sidebar: `${r.h} ${Math.max(5, r.s - 30)}% 12%`,
+    sidebarDeep: `${r.h} ${Math.max(5, r.s - 35)}% 9%`,
+    header: `${r.h} ${Math.max(5, r.s - 30)}% 12%`,
+    menu: `${r.h} ${Math.max(5, r.s - 30)}% 12%`
+  };
+}
+function fo(e, t, n = !1) {
+  const r = t || Nt(), o = Tt(e, r);
+  rt(o, n), localStorage.setItem("custom-theme-primary", e), localStorage.setItem("custom-theme-active", "true");
+}
+// @__NO_SIDE_EFFECTS__
+function On(e) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const n of e.split(",")) t[n] = 1;
+  return (n) => n in t;
+}
+const pe = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {};
+process.env.NODE_ENV !== "production" && Object.freeze([]);
+const Z = () => {
+}, Dn = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
+(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), W = Object.assign, $n = Object.prototype.hasOwnProperty, Be = (e, t) => $n.call(e, t), v = Array.isArray, X = (e) => He(e) === "[object Map]", Mn = (e) => He(e) === "[object Set]", w = (e) => typeof e == "function", A = (e) => typeof e == "string", Ee = (e) => typeof e == "symbol", S = (e) => e !== null && typeof e == "object", xn = (e) => (S(e) || w(e)) && w(e.then) && w(e.catch), Cn = Object.prototype.toString, He = (e) => Cn.call(e), Ot = (e) => He(e).slice(8, -1), Vn = (e) => He(e) === "[object Object]", ot = (e) => A(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, Dt = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return ((n) => t[n] || (t[n] = e(n)));
+}, $t = Dt((e) => e.charAt(0).toUpperCase() + e.slice(1)), In = Dt(
+  (e) => e ? `on${$t(e)}` : ""
+), K = (e, t) => !Object.is(e, t);
+let vt;
+const Pe = () => vt || (vt = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function st(e) {
+  if (v(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++) {
+      const r = e[n], o = A(r) ? Hn(r) : st(r);
+      if (o)
+        for (const s in o)
+          t[s] = o[s];
+    }
+    return t;
+  } else if (A(e) || S(e))
+    return e;
+}
+const Rn = /;(?![^(]*\))/g, An = /:([^]+)/, kn = /\/\*[^]*?\*\//g;
+function Hn(e) {
+  const t = {};
+  return e.replace(kn, "").split(Rn).forEach((n) => {
+    if (n) {
+      const r = n.split(An);
+      r.length > 1 && (t[r[0].trim()] = r[1].trim());
+    }
+  }), t;
+}
+function it(e) {
+  let t = "";
+  if (A(e))
+    t = e;
+  else if (v(e))
+    for (let n = 0; n < e.length; n++) {
+      const r = it(e[n]);
+      r && (t += r + " ");
+    }
+  else if (S(e))
+    for (const n in e)
+      e[n] && (t += n + " ");
+  return t.trim();
+}
+function x(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let g;
+const Ke = /* @__PURE__ */ new WeakSet();
+class Pn {
+  constructor(t) {
+    this.fn = t, this.deps = void 0, this.depsTail = void 0, this.flags = 5, this.next = void 0, this.cleanup = void 0, this.scheduler = void 0;
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    this.flags & 64 && (this.flags &= -65, Ke.has(this) && (Ke.delete(this), this.trigger()));
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    this.flags & 2 && !(this.flags & 32) || this.flags & 8 || xt(this);
+  }
+  run() {
+    if (!(this.flags & 1))
+      return this.fn();
+    this.flags |= 2, yt(this), Ct(this);
+    const t = g, n = $;
+    g = this, $ = !0;
+    try {
+      return this.fn();
+    } finally {
+      process.env.NODE_ENV !== "production" && g !== this && x(
+        "Active effect was not restored correctly - this is likely a Vue internal bug."
+      ), Vt(this), g = t, $ = n, this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let t = this.deps; t; t = t.nextDep)
+        lt(t);
+      this.deps = this.depsTail = void 0, yt(this), this.onStop && this.onStop(), this.flags &= -2;
+    }
+  }
+  trigger() {
+    this.flags & 64 ? Ke.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty();
+  }
+  /**
+   * @internal
+   */
+  runIfDirty() {
+    qe(this) && this.run();
+  }
+  get dirty() {
+    return qe(this);
+  }
+}
+let Mt = 0, fe, de;
+function xt(e, t = !1) {
+  if (e.flags |= 8, t) {
+    e.next = de, de = e;
+    return;
+  }
+  e.next = fe, fe = e;
+}
+function ct() {
+  Mt++;
+}
+function at() {
+  if (--Mt > 0)
+    return;
+  if (de) {
+    let t = de;
+    for (de = void 0; t; ) {
+      const n = t.next;
+      t.next = void 0, t.flags &= -9, t = n;
+    }
+  }
+  let e;
+  for (; fe; ) {
+    let t = fe;
+    for (fe = void 0; t; ) {
+      const n = t.next;
+      if (t.next = void 0, t.flags &= -9, t.flags & 1)
+        try {
+          t.trigger();
+        } catch (r) {
+          e || (e = r);
+        }
+      t = n;
+    }
+  }
+  if (e) throw e;
+}
+function Ct(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t;
+}
+function Vt(e) {
+  let t, n = e.depsTail, r = n;
+  for (; r; ) {
+    const o = r.prevDep;
+    r.version === -1 ? (r === n && (n = o), lt(r), Fn(r)) : t = r, r.dep.activeLink = r.prevActiveLink, r.prevActiveLink = void 0, r = o;
+  }
+  e.deps = t, e.depsTail = n;
+}
+function qe(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    if (t.dep.version !== t.version || t.dep.computed && (It(t.dep.computed) || t.dep.version !== t.version))
+      return !0;
+  return !!e._dirty;
+}
+function It(e) {
+  if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === he) || (e.globalVersion = he, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !qe(e))))
+    return;
+  e.flags |= 2;
+  const t = e.dep, n = g, r = $;
+  g = e, $ = !0;
+  try {
+    Ct(e);
+    const o = e.fn(e._value);
+    (t.version === 0 || K(o, e._value)) && (e.flags |= 128, e._value = o, t.version++);
+  } catch (o) {
+    throw t.version++, o;
+  } finally {
+    g = n, $ = r, Vt(e), e.flags &= -3;
+  }
+}
+function lt(e, t = !1) {
+  const { dep: n, prevSub: r, nextSub: o } = e;
+  if (r && (r.nextSub = o, e.prevSub = void 0), o && (o.prevSub = r, e.nextSub = void 0), process.env.NODE_ENV !== "production" && n.subsHead === e && (n.subsHead = o), n.subs === e && (n.subs = r, !r && n.computed)) {
+    n.computed.flags &= -5;
+    for (let s = n.computed.deps; s; s = s.nextDep)
+      lt(s, !0);
+  }
+  !t && !--n.sc && n.map && n.map.delete(n.key);
+}
+function Fn(e) {
+  const { prevDep: t, nextDep: n } = e;
+  t && (t.nextDep = n, e.prevDep = void 0), n && (n.prevDep = t, e.nextDep = void 0);
+}
+let $ = !0;
+const Rt = [];
+function re() {
+  Rt.push($), $ = !1;
+}
+function oe() {
+  const e = Rt.pop();
+  $ = e === void 0 ? !0 : e;
+}
+function yt(e) {
+  const { cleanup: t } = e;
+  if (e.cleanup = void 0, t) {
+    const n = g;
+    g = void 0;
+    try {
+      t();
+    } finally {
+      g = n;
+    }
+  }
+}
+let he = 0;
+class Ln {
+  constructor(t, n) {
+    this.sub = t, this.dep = n, this.version = n.version, this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+  }
+}
+class ut {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(t) {
+    this.computed = t, this.version = 0, this.activeLink = void 0, this.subs = void 0, this.map = void 0, this.key = void 0, this.sc = 0, this.__v_skip = !0, process.env.NODE_ENV !== "production" && (this.subsHead = void 0);
+  }
+  track(t) {
+    if (!g || !$ || g === this.computed)
+      return;
+    let n = this.activeLink;
+    if (n === void 0 || n.sub !== g)
+      n = this.activeLink = new Ln(g, this), g.deps ? (n.prevDep = g.depsTail, g.depsTail.nextDep = n, g.depsTail = n) : g.deps = g.depsTail = n, At(n);
+    else if (n.version === -1 && (n.version = this.version, n.nextDep)) {
+      const r = n.nextDep;
+      r.prevDep = n.prevDep, n.prevDep && (n.prevDep.nextDep = r), n.prevDep = g.depsTail, n.nextDep = void 0, g.depsTail.nextDep = n, g.depsTail = n, g.deps === n && (g.deps = r);
+    }
+    return process.env.NODE_ENV !== "production" && g.onTrack && g.onTrack(
+      W(
+        {
+          effect: g
+        },
+        t
+      )
+    ), n;
+  }
+  trigger(t) {
+    this.version++, he++, this.notify(t);
+  }
+  notify(t) {
+    ct();
+    try {
+      if (process.env.NODE_ENV !== "production")
+        for (let n = this.subsHead; n; n = n.nextSub)
+          n.sub.onTrigger && !(n.sub.flags & 8) && n.sub.onTrigger(
+            W(
+              {
+                effect: n.sub
+              },
+              t
+            )
+          );
+      for (let n = this.subs; n; n = n.prevSub)
+        n.sub.notify() && n.sub.dep.notify();
+    } finally {
+      at();
+    }
+  }
+}
+function At(e) {
+  if (e.dep.sc++, e.sub.flags & 4) {
+    const t = e.dep.computed;
+    if (t && !e.dep.subs) {
+      t.flags |= 20;
+      for (let r = t.deps; r; r = r.nextDep)
+        At(r);
+    }
+    const n = e.dep.subs;
+    n !== e && (e.prevSub = n, n && (n.nextSub = e)), process.env.NODE_ENV !== "production" && e.dep.subsHead === void 0 && (e.dep.subsHead = e), e.dep.subs = e;
+  }
+}
+const Ge = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Object iterate" : ""
+), Qe = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Map keys iterate" : ""
+), me = /* @__PURE__ */ Symbol(
+  process.env.NODE_ENV !== "production" ? "Array iterate" : ""
+);
+function b(e, t, n) {
+  if ($ && g) {
+    let r = Ge.get(e);
+    r || Ge.set(e, r = /* @__PURE__ */ new Map());
+    let o = r.get(n);
+    o || (r.set(n, o = new ut()), o.map = r, o.key = n), process.env.NODE_ENV !== "production" ? o.track({
+      target: e,
+      type: t,
+      key: n
+    }) : o.track();
+  }
+}
+function F(e, t, n, r, o, s) {
+  const i = Ge.get(e);
+  if (!i) {
+    he++;
+    return;
+  }
+  const c = (l) => {
+    l && (process.env.NODE_ENV !== "production" ? l.trigger({
+      target: e,
+      type: t,
+      key: n,
+      newValue: r,
+      oldValue: o,
+      oldTarget: s
+    }) : l.trigger());
+  };
+  if (ct(), t === "clear")
+    i.forEach(c);
+  else {
+    const l = v(e), u = l && ot(n);
+    if (l && n === "length") {
+      const d = Number(r);
+      i.forEach((a, f) => {
+        (f === "length" || f === me || !Ee(f) && f >= d) && c(a);
+      });
+    } else
+      switch ((n !== void 0 || i.has(void 0)) && c(i.get(n)), u && c(i.get(me)), t) {
+        case "add":
+          l ? u && c(i.get("length")) : (c(i.get(z)), X(e) && c(i.get(Qe)));
+          break;
+        case "delete":
+          l || (c(i.get(z)), X(e) && c(i.get(Qe)));
+          break;
+        case "set":
+          X(e) && c(i.get(z));
+          break;
+      }
+  }
+  at();
+}
+function B(e) {
+  const t = h(e);
+  return t === e ? t : (b(t, "iterate", me), N(e) ? t : t.map(k));
+}
+function ft(e) {
+  return b(e = h(e), "iterate", me), e;
+}
+function H(e, t) {
+  return C(e) ? ee(e) ? ge(k(t)) : ge(t) : k(t);
+}
+const Kn = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return We(this, Symbol.iterator, (e) => H(this, e));
+  },
+  concat(...e) {
+    return B(this).concat(
+      ...e.map((t) => v(t) ? B(t) : t)
+    );
+  },
+  entries() {
+    return We(this, "entries", (e) => (e[1] = H(this, e[1]), e));
+  },
+  every(e, t) {
+    return I(this, "every", e, t, void 0, arguments);
+  },
+  filter(e, t) {
+    return I(
+      this,
+      "filter",
+      e,
+      t,
+      (n) => n.map((r) => H(this, r)),
+      arguments
+    );
+  },
+  find(e, t) {
+    return I(
+      this,
+      "find",
+      e,
+      t,
+      (n) => H(this, n),
+      arguments
+    );
+  },
+  findIndex(e, t) {
+    return I(this, "findIndex", e, t, void 0, arguments);
+  },
+  findLast(e, t) {
+    return I(
+      this,
+      "findLast",
+      e,
+      t,
+      (n) => H(this, n),
+      arguments
+    );
+  },
+  findLastIndex(e, t) {
+    return I(this, "findLastIndex", e, t, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(e, t) {
+    return I(this, "forEach", e, t, void 0, arguments);
+  },
+  includes(...e) {
+    return je(this, "includes", e);
+  },
+  indexOf(...e) {
+    return je(this, "indexOf", e);
+  },
+  join(e) {
+    return B(this).join(e);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...e) {
+    return je(this, "lastIndexOf", e);
+  },
+  map(e, t) {
+    return I(this, "map", e, t, void 0, arguments);
+  },
+  pop() {
+    return ce(this, "pop");
+  },
+  push(...e) {
+    return ce(this, "push", e);
+  },
+  reduce(e, ...t) {
+    return Et(this, "reduce", e, t);
+  },
+  reduceRight(e, ...t) {
+    return Et(this, "reduceRight", e, t);
+  },
+  shift() {
+    return ce(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(e, t) {
+    return I(this, "some", e, t, void 0, arguments);
+  },
+  splice(...e) {
+    return ce(this, "splice", e);
+  },
+  toReversed() {
+    return B(this).toReversed();
+  },
+  toSorted(e) {
+    return B(this).toSorted(e);
+  },
+  toSpliced(...e) {
+    return B(this).toSpliced(...e);
+  },
+  unshift(...e) {
+    return ce(this, "unshift", e);
+  },
+  values() {
+    return We(this, "values", (e) => H(this, e));
+  }
+};
+function We(e, t, n) {
+  const r = ft(e), o = r[t]();
+  return r !== e && !N(e) && (o._next = o.next, o.next = () => {
+    const s = o._next();
+    return s.done || (s.value = n(s.value)), s;
+  }), o;
+}
+const Wn = Array.prototype;
+function I(e, t, n, r, o, s) {
+  const i = ft(e), c = i !== e && !N(e), l = i[t];
+  if (l !== Wn[t]) {
+    const a = l.apply(e, s);
+    return c ? k(a) : a;
+  }
+  let u = n;
+  i !== e && (c ? u = function(a, f) {
+    return n.call(this, H(e, a), f, e);
+  } : n.length > 2 && (u = function(a, f) {
+    return n.call(this, a, f, e);
+  }));
+  const d = l.call(i, u, r);
+  return c && o ? o(d) : d;
+}
+function Et(e, t, n, r) {
+  const o = ft(e);
+  let s = n;
+  return o !== e && (N(e) ? n.length > 3 && (s = function(i, c, l) {
+    return n.call(this, i, c, l, e);
+  }) : s = function(i, c, l) {
+    return n.call(this, i, H(e, c), l, e);
+  }), o[t](s, ...r);
+}
+function je(e, t, n) {
+  const r = h(e);
+  b(r, "iterate", me);
+  const o = r[t](...n);
+  return (o === -1 || o === !1) && Ve(n[0]) ? (n[0] = h(n[0]), r[t](...n)) : o;
+}
+function ce(e, t, n = []) {
+  re(), ct();
+  const r = h(e)[t].apply(e, n);
+  return at(), oe(), r;
+}
+const jn = /* @__PURE__ */ On("__proto__,__v_isRef,__isVue"), kt = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(Ee)
+);
+function Un(e) {
+  Ee(e) || (e = String(e));
+  const t = h(this);
+  return b(t, "has", e), t.hasOwnProperty(e);
+}
+class Ht {
+  constructor(t = !1, n = !1) {
+    this._isReadonly = t, this._isShallow = n;
+  }
+  get(t, n, r) {
+    if (n === "__v_skip") return t.__v_skip;
+    const o = this._isReadonly, s = this._isShallow;
+    if (n === "__v_isReactive")
+      return !o;
+    if (n === "__v_isReadonly")
+      return o;
+    if (n === "__v_isShallow")
+      return s;
+    if (n === "__v_raw")
+      return r === (o ? s ? er : Lt : s ? Xn : Ft).get(t) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(t) === Object.getPrototypeOf(r) ? t : void 0;
+    const i = v(t);
+    if (!o) {
+      let l;
+      if (i && (l = Kn[n]))
+        return l;
+      if (n === "hasOwnProperty")
+        return Un;
+    }
+    const c = Reflect.get(
+      t,
+      n,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      D(t) ? t : r
+    );
+    if ((Ee(n) ? kt.has(n) : jn(n)) || (o || b(t, "get", n), s))
+      return c;
+    if (D(c)) {
+      const l = i && ot(n) ? c : c.value;
+      return o && S(l) ? Ce(l) : l;
+    }
+    return S(c) ? o ? Ce(c) : Kt(c) : c;
+  }
+}
+class zn extends Ht {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, n, r, o) {
+    let s = t[n];
+    const i = v(t) && ot(n);
+    if (!this._isShallow) {
+      const u = C(s);
+      if (!N(r) && !C(r) && (s = h(s), r = h(r)), !i && D(s) && !D(r))
+        return u ? (process.env.NODE_ENV !== "production" && x(
+          `Set operation on key "${String(n)}" failed: target is readonly.`,
+          t[n]
+        ), !0) : (s.value = r, !0);
+    }
+    const c = i ? Number(n) < t.length : Be(t, n), l = Reflect.set(
+      t,
+      n,
+      r,
+      D(t) ? t : o
+    );
+    return t === h(o) && (c ? K(r, s) && F(t, "set", n, r, s) : F(t, "add", n, r)), l;
+  }
+  deleteProperty(t, n) {
+    const r = Be(t, n), o = t[n], s = Reflect.deleteProperty(t, n);
+    return s && r && F(t, "delete", n, void 0, o), s;
+  }
+  has(t, n) {
+    const r = Reflect.has(t, n);
+    return (!Ee(n) || !kt.has(n)) && b(t, "has", n), r;
+  }
+  ownKeys(t) {
+    return b(
+      t,
+      "iterate",
+      v(t) ? "length" : z
+    ), Reflect.ownKeys(t);
+  }
+}
+class Jn extends Ht {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, n) {
+    return process.env.NODE_ENV !== "production" && x(
+      `Set operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+  deleteProperty(t, n) {
+    return process.env.NODE_ENV !== "production" && x(
+      `Delete operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+}
+const Yn = /* @__PURE__ */ new zn(), Bn = /* @__PURE__ */ new Jn(), Ze = (e) => e, Se = (e) => Reflect.getPrototypeOf(e);
+function qn(e, t, n) {
+  return function(...r) {
+    const o = this.__v_raw, s = h(o), i = X(s), c = e === "entries" || e === Symbol.iterator && i, l = e === "keys" && i, u = o[e](...r), d = n ? Ze : t ? ge : k;
+    return !t && b(
+      s,
+      "iterate",
+      l ? Qe : z
+    ), {
+      // iterator protocol
+      next() {
+        const { value: a, done: f } = u.next();
+        return f ? { value: a, done: f } : {
+          value: c ? [d(a[0]), d(a[1])] : d(a),
+          done: f
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function Ne(e) {
+  return function(...t) {
+    if (process.env.NODE_ENV !== "production") {
+      const n = t[0] ? `on key "${t[0]}" ` : "";
+      x(
+        `${$t(e)} operation ${n}failed: target is readonly.`,
+        h(this)
+      );
+    }
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function Gn(e, t) {
+  const n = {
+    get(o) {
+      const s = this.__v_raw, i = h(s), c = h(o);
+      e || (K(o, c) && b(i, "get", o), b(i, "get", c));
+      const { has: l } = Se(i), u = t ? Ze : e ? ge : k;
+      if (l.call(i, o))
+        return u(s.get(o));
+      if (l.call(i, c))
+        return u(s.get(c));
+      s !== i && s.get(o);
+    },
+    get size() {
+      const o = this.__v_raw;
+      return !e && b(h(o), "iterate", z), o.size;
+    },
+    has(o) {
+      const s = this.__v_raw, i = h(s), c = h(o);
+      return e || (K(o, c) && b(i, "has", o), b(i, "has", c)), o === c ? s.has(o) : s.has(o) || s.has(c);
+    },
+    forEach(o, s) {
+      const i = this, c = i.__v_raw, l = h(c), u = t ? Ze : e ? ge : k;
+      return !e && b(l, "iterate", z), c.forEach((d, a) => o.call(s, u(d), u(a), i));
+    }
+  };
+  return W(
+    n,
+    e ? {
+      add: Ne("add"),
+      set: Ne("set"),
+      delete: Ne("delete"),
+      clear: Ne("clear")
+    } : {
+      add(o) {
+        !t && !N(o) && !C(o) && (o = h(o));
+        const s = h(this);
+        return Se(s).has.call(s, o) || (s.add(o), F(s, "add", o, o)), this;
+      },
+      set(o, s) {
+        !t && !N(s) && !C(s) && (s = h(s));
+        const i = h(this), { has: c, get: l } = Se(i);
+        let u = c.call(i, o);
+        u ? process.env.NODE_ENV !== "production" && wt(i, c, o) : (o = h(o), u = c.call(i, o));
+        const d = l.call(i, o);
+        return i.set(o, s), u ? K(s, d) && F(i, "set", o, s, d) : F(i, "add", o, s), this;
+      },
+      delete(o) {
+        const s = h(this), { has: i, get: c } = Se(s);
+        let l = i.call(s, o);
+        l ? process.env.NODE_ENV !== "production" && wt(s, i, o) : (o = h(o), l = i.call(s, o));
+        const u = c ? c.call(s, o) : void 0, d = s.delete(o);
+        return l && F(s, "delete", o, void 0, u), d;
+      },
+      clear() {
+        const o = h(this), s = o.size !== 0, i = process.env.NODE_ENV !== "production" ? X(o) ? new Map(o) : new Set(o) : void 0, c = o.clear();
+        return s && F(
+          o,
+          "clear",
+          void 0,
+          void 0,
+          i
+        ), c;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((o) => {
+    n[o] = qn(o, e, t);
+  }), n;
+}
+function Pt(e, t) {
+  const n = Gn(e, t);
+  return (r, o, s) => o === "__v_isReactive" ? !e : o === "__v_isReadonly" ? e : o === "__v_raw" ? r : Reflect.get(
+    Be(n, o) && o in r ? n : r,
+    o,
+    s
+  );
+}
+const Qn = {
+  get: /* @__PURE__ */ Pt(!1, !1)
+}, Zn = {
+  get: /* @__PURE__ */ Pt(!0, !1)
+};
+function wt(e, t, n) {
+  const r = h(n);
+  if (r !== n && t.call(e, r)) {
+    const o = Ot(e);
+    x(
+      `Reactive ${o} contains both the raw and reactive versions of the same object${o === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+const Ft = /* @__PURE__ */ new WeakMap(), Xn = /* @__PURE__ */ new WeakMap(), Lt = /* @__PURE__ */ new WeakMap(), er = /* @__PURE__ */ new WeakMap();
+function tr(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function nr(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : tr(Ot(e));
+}
+function Kt(e) {
+  return C(e) ? e : Wt(
+    e,
+    !1,
+    Yn,
+    Qn,
+    Ft
+  );
+}
+function Ce(e) {
+  return Wt(
+    e,
+    !0,
+    Bn,
+    Zn,
+    Lt
+  );
+}
+function Wt(e, t, n, r, o) {
+  if (!S(e))
+    return process.env.NODE_ENV !== "production" && x(
+      `value cannot be made ${t ? "readonly" : "reactive"}: ${String(
+        e
+      )}`
+    ), e;
+  if (e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const s = nr(e);
+  if (s === 0)
+    return e;
+  const i = o.get(e);
+  if (i)
+    return i;
+  const c = new Proxy(
+    e,
+    s === 2 ? r : n
+  );
+  return o.set(e, c), c;
+}
+function ee(e) {
+  return C(e) ? ee(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function C(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function N(e) {
+  return !!(e && e.__v_isShallow);
+}
+function Ve(e) {
+  return e ? !!e.__v_raw : !1;
+}
+function h(e) {
+  const t = e && e.__v_raw;
+  return t ? h(t) : e;
+}
+const k = (e) => S(e) ? Kt(e) : e, ge = (e) => S(e) ? Ce(e) : e;
+function D(e) {
+  return e ? e.__v_isRef === !0 : !1;
+}
+function dt(e) {
+  return rr(e, !1);
+}
+function rr(e, t) {
+  return D(e) ? e : new or(e, t);
+}
+class or {
+  constructor(t, n) {
+    this.dep = new ut(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = n ? t : h(t), this._value = n ? t : k(t), this.__v_isShallow = n;
+  }
+  get value() {
+    return process.env.NODE_ENV !== "production" ? this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    }) : this.dep.track(), this._value;
+  }
+  set value(t) {
+    const n = this._rawValue, r = this.__v_isShallow || N(t) || C(t);
+    t = r ? t : h(t), K(t, n) && (this._rawValue = t, this._value = r ? t : k(t), process.env.NODE_ENV !== "production" ? this.dep.trigger({
+      target: this,
+      type: "set",
+      key: "value",
+      newValue: t,
+      oldValue: n
+    }) : this.dep.trigger());
+  }
+}
+class sr {
+  constructor(t, n, r) {
+    this.fn = t, this.setter = n, this._value = void 0, this.dep = new ut(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = he - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !n, this.isSSR = r;
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion
+    g !== this)
+      return xt(this, !0), !0;
+    process.env.NODE_ENV;
+  }
+  get value() {
+    const t = process.env.NODE_ENV !== "production" ? this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    }) : this.dep.track();
+    return It(this), t && (t.version = this.dep.version), this._value;
+  }
+  set value(t) {
+    this.setter ? this.setter(t) : process.env.NODE_ENV !== "production" && x("Write operation failed: computed value is readonly");
+  }
+}
+function ir(e, t, n = !1) {
+  let r, o;
+  w(e) ? r = e : (r = e.get, o = e.set);
+  const s = new sr(r, o, n);
+  return process.env.NODE_ENV, s;
+}
+const Te = {}, Ie = /* @__PURE__ */ new WeakMap();
+let U;
+function cr(e, t = !1, n = U) {
+  if (n) {
+    let r = Ie.get(n);
+    r || Ie.set(n, r = []), r.push(e);
+  } else process.env.NODE_ENV !== "production" && !t && x(
+    "onWatcherCleanup() was called when there was no active watcher to associate with."
+  );
+}
+function ar(e, t, n = pe) {
+  const { immediate: r, deep: o, once: s, scheduler: i, augmentJob: c, call: l } = n, u = (m) => {
+    (n.onWarn || x)(
+      "Invalid watch source: ",
+      m,
+      "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."
+    );
+  }, d = (m) => o ? m : N(m) || o === !1 || o === 0 ? L(m, 1) : L(m);
+  let a, f, p, _, T = !1, we = !1;
+  if (D(e) ? (f = () => e.value, T = N(e)) : ee(e) ? (f = () => d(e), T = !0) : v(e) ? (we = !0, T = e.some((m) => ee(m) || N(m)), f = () => e.map((m) => {
+    if (D(m))
+      return m.value;
+    if (ee(m))
+      return d(m);
+    if (w(m))
+      return l ? l(m, 2) : m();
+    process.env.NODE_ENV !== "production" && u(m);
+  })) : w(e) ? t ? f = l ? () => l(e, 2) : e : f = () => {
+    if (p) {
+      re();
+      try {
+        p();
+      } finally {
+        oe();
+      }
+    }
+    const m = U;
+    U = a;
+    try {
+      return l ? l(e, 3, [_]) : e(_);
+    } finally {
+      U = m;
+    }
+  } : (f = Z, process.env.NODE_ENV !== "production" && u(e)), t && o) {
+    const m = f, M = o === !0 ? 1 / 0 : o;
+    f = () => L(m(), M);
+  }
+  const Y = () => {
+    a.stop();
+  };
+  if (s && t) {
+    const m = t;
+    t = (...M) => {
+      m(...M), Y();
+    };
+  }
+  let j = we ? new Array(e.length).fill(Te) : Te;
+  const ie = (m) => {
+    if (!(!(a.flags & 1) || !a.dirty && !m))
+      if (t) {
+        const M = a.run();
+        if (o || T || (we ? M.some((Le, be) => K(Le, j[be])) : K(M, j))) {
+          p && p();
+          const Le = U;
+          U = a;
+          try {
+            const be = [
+              M,
+              // pass undefined as the old value when it's changed for the first time
+              j === Te ? void 0 : we && j[0] === Te ? [] : j,
+              _
+            ];
+            j = M, l ? l(t, 3, be) : (
+              // @ts-expect-error
+              t(...be)
+            );
+          } finally {
+            U = Le;
+          }
+        }
+      } else
+        a.run();
+  };
+  return c && c(ie), a = new Pn(f), a.scheduler = i ? () => i(ie, !1) : ie, _ = (m) => cr(m, !1, a), p = a.onStop = () => {
+    const m = Ie.get(a);
+    if (m) {
+      if (l)
+        l(m, 4);
+      else
+        for (const M of m) M();
+      Ie.delete(a);
+    }
+  }, process.env.NODE_ENV !== "production" && (a.onTrack = n.onTrack, a.onTrigger = n.onTrigger), t ? r ? ie(!0) : j = a.run() : i ? i(ie.bind(null, !0), !0) : a.run(), Y.pause = a.pause.bind(a), Y.resume = a.resume.bind(a), Y.stop = Y, Y;
+}
+function L(e, t = 1 / 0, n) {
+  if (t <= 0 || !S(e) || e.__v_skip || (n = n || /* @__PURE__ */ new Map(), (n.get(e) || 0) >= t))
+    return e;
+  if (n.set(e, t), t--, D(e))
+    L(e.value, t, n);
+  else if (v(e))
+    for (let r = 0; r < e.length; r++)
+      L(e[r], t, n);
+  else if (Mn(e) || X(e))
+    e.forEach((r) => {
+      L(r, t, n);
+    });
+  else if (Vn(e)) {
+    for (const r in e)
+      L(e[r], t, n);
+    for (const r of Object.getOwnPropertySymbols(e))
+      Object.prototype.propertyIsEnumerable.call(e, r) && L(e[r], t, n);
+  }
+  return e;
+}
+const J = [];
+function lr(e) {
+  J.push(e);
+}
+function ur() {
+  J.pop();
+}
+let Ue = !1;
+function E(e, ...t) {
+  if (Ue) return;
+  Ue = !0, re();
+  const n = J.length ? J[J.length - 1].component : null, r = n && n.appContext.config.warnHandler, o = fr();
+  if (r)
+    Fe(
+      r,
+      n,
+      11,
+      [
+        // eslint-disable-next-line no-restricted-syntax
+        e + t.map((s) => {
+          var i, c;
+          return (c = (i = s.toString) == null ? void 0 : i.call(s)) != null ? c : JSON.stringify(s);
+        }).join(""),
+        n && n.proxy,
+        o.map(
+          ({ vnode: s }) => `at <${cn(n, s.type)}>`
+        ).join(`
+`),
+        o
+      ]
+    );
+  else {
+    const s = [`[Vue warn]: ${e}`, ...t];
+    o.length && s.push(`
+`, ...dr(o)), console.warn(...s);
+  }
+  oe(), Ue = !1;
+}
+function fr() {
+  let e = J[J.length - 1];
+  if (!e)
+    return [];
+  const t = [];
+  for (; e; ) {
+    const n = t[0];
+    n && n.vnode === e ? n.recurseCount++ : t.push({
+      vnode: e,
+      recurseCount: 0
+    });
+    const r = e.component && e.component.parent;
+    e = r && r.vnode;
+  }
+  return t;
+}
+function dr(e) {
+  const t = [];
+  return e.forEach((n, r) => {
+    t.push(...r === 0 ? [] : [`
+`], ...pr(n));
+  }), t;
+}
+function pr({ vnode: e, recurseCount: t }) {
+  const n = t > 0 ? `... (${t} recursive calls)` : "", r = e.component ? e.component.parent == null : !1, o = ` at <${cn(
+    e.component,
+    e.type,
+    r
+  )}`, s = ">" + n;
+  return e.props ? [o, ...hr(e.props), s] : [o + s];
+}
+function hr(e) {
+  const t = [], n = Object.keys(e);
+  return n.slice(0, 3).forEach((r) => {
+    t.push(...jt(r, e[r]));
+  }), n.length > 3 && t.push(" ..."), t;
+}
+function jt(e, t, n) {
+  return A(t) ? (t = JSON.stringify(t), n ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? n ? t : [`${e}=${t}`] : D(t) ? (t = jt(e, h(t.value), !0), n ? t : [`${e}=Ref<`, t, ">"]) : w(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = h(t), n ? t : [`${e}=`, t]);
+}
+const pt = {
+  sp: "serverPrefetch hook",
+  bc: "beforeCreate hook",
+  c: "created hook",
+  bm: "beforeMount hook",
+  m: "mounted hook",
+  bu: "beforeUpdate hook",
+  u: "updated",
+  bum: "beforeUnmount hook",
+  um: "unmounted hook",
+  a: "activated hook",
+  da: "deactivated hook",
+  ec: "errorCaptured hook",
+  rtc: "renderTracked hook",
+  rtg: "renderTriggered hook",
+  0: "setup function",
+  1: "render function",
+  2: "watcher getter",
+  3: "watcher callback",
+  4: "watcher cleanup function",
+  5: "native event handler",
+  6: "component event handler",
+  7: "vnode hook",
+  8: "directive hook",
+  9: "transition hook",
+  10: "app errorHandler",
+  11: "app warnHandler",
+  12: "ref function",
+  13: "async component loader",
+  14: "scheduler flush",
+  15: "component update",
+  16: "app unmount cleanup function"
+};
+function Fe(e, t, n, r) {
+  try {
+    return r ? e(...r) : e();
+  } catch (o) {
+    mt(o, t, n);
+  }
+}
+function ht(e, t, n, r) {
+  if (w(e)) {
+    const o = Fe(e, t, n, r);
+    return o && xn(o) && o.catch((s) => {
+      mt(s, t, n);
+    }), o;
+  }
+  if (v(e)) {
+    const o = [];
+    for (let s = 0; s < e.length; s++)
+      o.push(ht(e[s], t, n, r));
+    return o;
+  } else process.env.NODE_ENV !== "production" && E(
+    `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof e}`
+  );
+}
+function mt(e, t, n, r = !0) {
+  const o = t ? t.vnode : null, { errorHandler: s, throwUnhandledErrorInProduction: i } = t && t.appContext.config || pe;
+  if (t) {
+    let c = t.parent;
+    const l = t.proxy, u = process.env.NODE_ENV !== "production" ? pt[n] : `https://vuejs.org/error-reference/#runtime-${n}`;
+    for (; c; ) {
+      const d = c.ec;
+      if (d) {
+        for (let a = 0; a < d.length; a++)
+          if (d[a](e, l, u) === !1)
+            return;
+      }
+      c = c.parent;
+    }
+    if (s) {
+      re(), Fe(s, null, 10, [
+        e,
+        l,
+        u
+      ]), oe();
+      return;
+    }
+  }
+  mr(e, n, o, r, i);
+}
+function mr(e, t, n, r = !0, o = !1) {
+  if (process.env.NODE_ENV !== "production") {
+    const s = pt[t];
+    if (n && lr(n), E(`Unhandled error${s ? ` during execution of ${s}` : ""}`), n && ur(), r)
+      throw e;
+    console.error(e);
+  } else {
+    if (o)
+      throw e;
+    console.error(e);
+  }
+}
+const O = [];
+let R = -1;
+const te = [];
+let P = null, G = 0;
+const gr = /* @__PURE__ */ Promise.resolve();
+let Xe = null;
+const _r = 100;
+function vr(e) {
+  let t = R + 1, n = O.length;
+  for (; t < n; ) {
+    const r = t + n >>> 1, o = O[r], s = _e(o);
+    s < e || s === e && o.flags & 2 ? t = r + 1 : n = r;
+  }
+  return t;
+}
+function Ut(e) {
+  if (!(e.flags & 1)) {
+    const t = _e(e), n = O[O.length - 1];
+    !n || // fast path when the job id is larger than the tail
+    !(e.flags & 2) && t >= _e(n) ? O.push(e) : O.splice(vr(t), 0, e), e.flags |= 1, zt();
+  }
+}
+function zt() {
+  Xe || (Xe = gr.then(Yt));
+}
+function Jt(e) {
+  v(e) ? te.push(...e) : P && e.id === -1 ? P.splice(G + 1, 0, e) : e.flags & 1 || (te.push(e), e.flags |= 1), zt();
+}
+function yr(e) {
+  if (te.length) {
+    const t = [...new Set(te)].sort(
+      (n, r) => _e(n) - _e(r)
+    );
+    if (te.length = 0, P) {
+      P.push(...t);
+      return;
+    }
+    for (P = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), G = 0; G < P.length; G++) {
+      const n = P[G];
+      process.env.NODE_ENV !== "production" && Bt(e, n) || (n.flags & 4 && (n.flags &= -2), n.flags & 8 || n(), n.flags &= -2);
+    }
+    P = null, G = 0;
+  }
+}
+const _e = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id;
+function Yt(e) {
+  process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map());
+  const t = process.env.NODE_ENV !== "production" ? (n) => Bt(e, n) : Z;
+  try {
+    for (R = 0; R < O.length; R++) {
+      const n = O[R];
+      if (n && !(n.flags & 8)) {
+        if (process.env.NODE_ENV !== "production" && t(n))
+          continue;
+        n.flags & 4 && (n.flags &= -2), Fe(
+          n,
+          n.i,
+          n.i ? 15 : 14
+        ), n.flags & 4 || (n.flags &= -2);
+      }
+    }
+  } finally {
+    for (; R < O.length; R++) {
+      const n = O[R];
+      n && (n.flags &= -2);
+    }
+    R = -1, O.length = 0, yr(e), Xe = null, (O.length || te.length) && Yt(e);
+  }
+}
+function Bt(e, t) {
+  const n = e.get(t) || 0;
+  if (n > _r) {
+    const r = t.i, o = r && sn(r.type);
+    return mt(
+      `Maximum recursive updates exceeded${o ? ` in component <${o}>` : ""}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+      null,
+      10
+    ), !0;
+  }
+  return e.set(t, n + 1), !1;
+}
+const ze = /* @__PURE__ */ new Map();
+process.env.NODE_ENV !== "production" && (Pe().__VUE_HMR_RUNTIME__ = {
+  createRecord: Je(Er),
+  rerender: Je(wr),
+  reload: Je(br)
+});
+const Re = /* @__PURE__ */ new Map();
+function Er(e, t) {
+  return Re.has(e) ? !1 : (Re.set(e, {
+    initialDef: Ae(t),
+    instances: /* @__PURE__ */ new Set()
+  }), !0);
+}
+function Ae(e) {
+  return an(e) ? e.__vccOpts : e;
+}
+function wr(e, t) {
+  const n = Re.get(e);
+  n && (n.initialDef.render = t, [...n.instances].forEach((r) => {
+    t && (r.render = t, Ae(r.type).render = t), r.renderCache = [], r.job.flags & 8 || r.update();
+  }));
+}
+function br(e, t) {
+  const n = Re.get(e);
+  if (!n) return;
+  t = Ae(t), bt(n.initialDef, t);
+  const r = [...n.instances];
+  for (let o = 0; o < r.length; o++) {
+    const s = r[o], i = Ae(s.type);
+    let c = ze.get(i);
+    c || (i !== n.initialDef && bt(i, t), ze.set(i, c = /* @__PURE__ */ new Set())), c.add(s), s.appContext.propsCache.delete(s.type), s.appContext.emitsCache.delete(s.type), s.appContext.optionsCache.delete(s.type), s.ceReload ? (c.add(s), s.ceReload(t.styles), c.delete(s)) : s.parent ? Ut(() => {
+      s.job.flags & 8 || (s.parent.update(), c.delete(s));
+    }) : s.appContext.reload ? s.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn(
+      "[HMR] Root or manually mounted instance modified. Full reload required."
+    ), s.root.ce && s !== s.root && s.root.ce._removeChildStyle(i);
+  }
+  Jt(() => {
+    ze.clear();
+  });
+}
+function bt(e, t) {
+  W(e, t);
+  for (const n in e)
+    n !== "__file" && !(n in t) && delete e[n];
+}
+function Je(e) {
+  return (t, n) => {
+    try {
+      return e(t, n);
+    } catch (r) {
+      console.error(r), console.warn(
+        "[HMR] Something went wrong during Vue component hot-reload. Full reload required."
+      );
+    }
+  };
+}
+let Q, Oe = [];
+function qt(e, t) {
+  var n, r;
+  Q = e, Q ? (Q.enabled = !0, Oe.forEach(({ event: o, args: s }) => Q.emit(o, ...s)), Oe = []) : /* handle late devtools injection - only do this if we are in an actual */ /* browser environment to avoid the timer handle stalling test runner exit */ /* (#4815) */ typeof window < "u" && // some envs mock window but not fully
+  window.HTMLElement && // also exclude jsdom
+  // eslint-disable-next-line no-restricted-syntax
+  !((r = (n = window.navigator) == null ? void 0 : n.userAgent) != null && r.includes("jsdom")) ? ((t.__VUE_DEVTOOLS_HOOK_REPLAY__ = t.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((s) => {
+    qt(s, t);
+  }), setTimeout(() => {
+    Q || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, Oe = []);
+  }, 3e3)) : Oe = [];
+}
+let ve = null, Sr = null;
+function Nr(e, t, n = !1) {
+  const r = on();
+  if (r || Rr) {
+    let o = r ? r.parent == null || r.ce ? r.vnode.appContext && r.vnode.appContext.provides : r.parent.provides : void 0;
+    if (o && e in o)
+      return o[e];
+    if (arguments.length > 1)
+      return n && w(t) ? t.call(r && r.proxy) : t;
+    process.env.NODE_ENV !== "production" && E(`injection "${String(e)}" not found.`);
+  } else process.env.NODE_ENV !== "production" && E("inject() can only be used inside setup() or functional components.");
+}
+const Tr = /* @__PURE__ */ Symbol.for("v-scx"), Or = () => {
+  {
+    const e = Nr(Tr);
+    return e || process.env.NODE_ENV !== "production" && E(
+      "Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."
+    ), e;
+  }
+};
+function Dr(e, t, n) {
+  return process.env.NODE_ENV !== "production" && !w(t) && E(
+    "`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature."
+  ), $r(e, t, n);
+}
+function $r(e, t, n = pe) {
+  const { immediate: r, deep: o, flush: s, once: i } = n;
+  process.env.NODE_ENV !== "production" && !t && (r !== void 0 && E(
+    'watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'
+  ), o !== void 0 && E(
+    'watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'
+  ), i !== void 0 && E(
+    'watch() "once" option is only respected when using the watch(source, callback, options?) signature.'
+  ));
+  const c = W({}, n);
+  process.env.NODE_ENV !== "production" && (c.onWarn = E);
+  const l = t && r || !t && s !== "post";
+  let u;
+  if (ye) {
+    if (s === "sync") {
+      const p = Or();
+      u = p.__watcherHandles || (p.__watcherHandles = []);
+    } else if (!l) {
+      const p = () => {
+      };
+      return p.stop = Z, p.resume = Z, p.pause = Z, p;
+    }
+  }
+  const d = se;
+  c.call = (p, _, T) => ht(p, d, _, T);
+  let a = !1;
+  s === "post" ? c.scheduler = (p) => {
+    kr(p, d && d.suspense);
+  } : s !== "sync" && (a = !0, c.scheduler = (p, _) => {
+    _ ? p() : Ut(p);
+  }), c.augmentJob = (p) => {
+    t && (p.flags |= 4), a && (p.flags |= 2, d && (p.id = d.uid, p.i = d));
+  };
+  const f = ar(e, t, c);
+  return ye && (u ? u.push(f) : l && f()), f;
+}
+const Mr = (e) => e.__isTeleport;
+function Gt(e, t) {
+  e.shapeFlag & 6 && e.component ? (e.transition = t, Gt(e.component.subTree, t)) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t;
+}
+Pe().requestIdleCallback;
+Pe().cancelIdleCallback;
+function xr(e, t, n = se, r = !1) {
+  if (n) {
+    const o = n[e] || (n[e] = []), s = t.__weh || (t.__weh = (...i) => {
+      re();
+      const c = Br(n), l = ht(t, n, e, i);
+      return c(), oe(), l;
+    });
+    return r ? o.unshift(s) : o.push(s), s;
+  } else if (process.env.NODE_ENV !== "production") {
+    const o = In(pt[e].replace(/ hook$/, ""));
+    E(
+      `${o} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`
+    );
+  }
+}
+const Qt = (e) => (t, n = se) => {
+  (!ye || e === "sp") && xr(e, (...r) => t(...r), n);
+}, Cr = Qt("m"), Zt = Qt("um"), Vr = /* @__PURE__ */ Symbol.for("v-ndc"), Ir = {};
+process.env.NODE_ENV !== "production" && (Ir.ownKeys = (e) => (E(
+  "Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."
+), Reflect.ownKeys(e)));
+let Rr = null;
+const Ar = {}, Xt = (e) => Object.getPrototypeOf(e) === Ar, kr = Pr, Hr = (e) => e.__isSuspense;
+function Pr(e, t) {
+  t && t.pendingBranch ? v(e) ? t.effects.push(...e) : t.effects.push(e) : Jt(e);
+}
+const en = /* @__PURE__ */ Symbol.for("v-fgt"), Fr = /* @__PURE__ */ Symbol.for("v-txt"), Lr = /* @__PURE__ */ Symbol.for("v-cmt");
+function Kr(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+const Wr = (...e) => nn(
+  ...e
+), tn = ({ key: e }) => e ?? null, $e = ({
+  ref: e,
+  ref_key: t,
+  ref_for: n
+}) => (typeof e == "number" && (e = "" + e), e != null ? A(e) || D(e) || w(e) ? { i: ve, r: e, k: t, f: !!n } : e : null);
+function jr(e, t = null, n = null, r = 0, o = null, s = e === en ? 0 : 1, i = !1, c = !1) {
+  const l = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && tn(t),
+    ref: t && $e(t),
+    scopeId: Sr,
+    slotScopeIds: null,
+    children: n,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetStart: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag: s,
+    patchFlag: r,
+    dynamicProps: o,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: ve
+  };
+  return c ? (gt(l, n), s & 128 && e.normalize(l)) : n && (l.shapeFlag |= A(n) ? 8 : 16), process.env.NODE_ENV !== "production" && l.key !== l.key && E("VNode created with invalid key (NaN). VNode type:", l.type), l;
+}
+const Ur = process.env.NODE_ENV !== "production" ? Wr : nn;
+function nn(e, t = null, n = null, r = 0, o = null, s = !1) {
+  if ((!e || e === Vr) && (process.env.NODE_ENV !== "production" && !e && E(`Invalid vnode type when creating vnode: ${e}.`), e = Lr), Kr(e)) {
+    const c = ke(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return n && gt(c, n), c.patchFlag = -2, c;
+  }
+  if (an(e) && (e = e.__vccOpts), t) {
+    t = zr(t);
+    let { class: c, style: l } = t;
+    c && !A(c) && (t.class = it(c)), S(l) && (Ve(l) && !v(l) && (l = W({}, l)), t.style = st(l));
+  }
+  const i = A(e) ? 1 : Hr(e) ? 128 : Mr(e) ? 64 : S(e) ? 4 : w(e) ? 2 : 0;
+  return process.env.NODE_ENV !== "production" && i & 4 && Ve(e) && (e = h(e), E(
+    "Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.",
+    `
+Component that was made reactive: `,
+    e
+  )), jr(
+    e,
+    t,
+    n,
+    r,
+    o,
+    i,
+    s,
+    !0
+  );
+}
+function zr(e) {
+  return e ? Ve(e) || Xt(e) ? W({}, e) : e : null;
+}
+function ke(e, t, n = !1, r = !1) {
+  const { props: o, ref: s, patchFlag: i, children: c, transition: l } = e, u = t ? Yr(o || {}, t) : o, d = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: u,
+    key: u && tn(u),
+    ref: t && t.ref ? (
+      // #2078 in the case of <component :is="vnode" ref="extra"/>
+      // if the vnode itself already has a ref, cloneVNode will need to merge
+      // the refs so the single vnode can be set on multiple refs
+      n && s ? v(s) ? s.concat($e(t)) : [s, $e(t)] : $e(t)
+    ) : s,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: process.env.NODE_ENV !== "production" && i === -1 && v(c) ? c.map(rn) : c,
+    target: e.target,
+    targetStart: e.targetStart,
+    targetAnchor: e.targetAnchor,
+    staticCount: e.staticCount,
+    shapeFlag: e.shapeFlag,
+    // if the vnode is cloned with extra props, we can no longer assume its
+    // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+    // note: preserve flag for fragments since they use the flag for children
+    // fast paths only.
+    patchFlag: t && e.type !== en ? i === -1 ? 16 : i | 16 : i,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: l,
+    // These should technically only be non-null on mounted VNodes. However,
+    // they *should* be copied for kept-alive vnodes. So we just always copy
+    // them since them being non-null during a mount doesn't affect the logic as
+    // they will simply be overwritten.
+    component: e.component,
+    suspense: e.suspense,
+    ssContent: e.ssContent && ke(e.ssContent),
+    ssFallback: e.ssFallback && ke(e.ssFallback),
+    placeholder: e.placeholder,
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+  return l && r && Gt(
+    d,
+    l.clone(d)
+  ), d;
+}
+function rn(e) {
+  const t = ke(e);
+  return v(e.children) && (t.children = e.children.map(rn)), t;
+}
+function Jr(e = " ", t = 0) {
+  return Ur(Fr, null, e, t);
+}
+function gt(e, t) {
+  let n = 0;
+  const { shapeFlag: r } = e;
+  if (t == null)
+    t = null;
+  else if (v(t))
+    n = 16;
+  else if (typeof t == "object")
+    if (r & 65) {
+      const o = t.default;
+      o && (o._c && (o._d = !1), gt(e, o()), o._c && (o._d = !0));
+      return;
+    } else
+      n = 32, !t._ && !Xt(t) && (t._ctx = ve);
+  else w(t) ? (t = { default: t, _ctx: ve }, n = 32) : (t = String(t), r & 64 ? (n = 16, t = [Jr(t)]) : n = 8);
+  e.children = t, e.shapeFlag |= n;
+}
+function Yr(...e) {
+  const t = {};
+  for (let n = 0; n < e.length; n++) {
+    const r = e[n];
+    for (const o in r)
+      if (o === "class")
+        t.class !== r.class && (t.class = it([t.class, r.class]));
+      else if (o === "style")
+        t.style = st([t.style, r.style]);
+      else if (Dn(o)) {
+        const s = t[o], i = r[o];
+        i && s !== i && !(v(s) && s.includes(i)) && (t[o] = s ? [].concat(s, i) : i);
+      } else o !== "" && (t[o] = r[o]);
+  }
+  return t;
+}
+let se = null;
+const on = () => se || ve;
+let et;
+{
+  const e = Pe(), t = (n, r) => {
+    let o;
+    return (o = e[n]) || (o = e[n] = []), o.push(r), (s) => {
+      o.length > 1 ? o.forEach((i) => i(s)) : o[0](s);
+    };
+  };
+  et = t(
+    "__VUE_INSTANCE_SETTERS__",
+    (n) => se = n
+  ), t(
+    "__VUE_SSR_SETTERS__",
+    (n) => ye = n
+  );
+}
+const Br = (e) => {
+  const t = se;
+  return et(e), e.scope.on(), () => {
+    e.scope.off(), et(t);
+  };
+};
+let ye = !1;
+process.env.NODE_ENV;
+const qr = /(?:^|[-_])\w/g, Gr = (e) => e.replace(qr, (t) => t.toUpperCase()).replace(/[-_]/g, "");
+function sn(e, t = !0) {
+  return w(e) ? e.displayName || e.name : e.name || t && e.__name;
+}
+function cn(e, t, n = !1) {
+  let r = sn(t);
+  if (!r && t.__file) {
+    const o = t.__file.match(/([^/\\]+)\.\w+$/);
+    o && (r = o[1]);
+  }
+  if (!r && e) {
+    const o = (s) => {
+      for (const i in s)
+        if (s[i] === t)
+          return i;
+    };
+    r = o(e.components) || e.parent && o(
+      e.parent.type.components
+    ) || o(e.appContext.components);
+  }
+  return r ? Gr(r) : n ? "App" : "Anonymous";
+}
+function an(e) {
+  return w(e) && "__vccOpts" in e;
+}
+const De = (e, t) => {
+  const n = ir(e, t, ye);
+  if (process.env.NODE_ENV !== "production") {
+    const r = on();
+    r && r.appContext.config.warnRecursiveComputed && (n._warnRecursive = !0);
+  }
+  return n;
+};
+function Qr() {
+  if (process.env.NODE_ENV === "production" || typeof window > "u")
+    return;
+  const e = { style: "color:#3ba776" }, t = { style: "color:#1677ff" }, n = { style: "color:#f5222d" }, r = { style: "color:#eb2f96" }, o = {
+    __vue_custom_formatter: !0,
+    header(a) {
+      if (!S(a))
+        return null;
+      if (a.__isVue)
+        return ["div", e, "VueInstance"];
+      if (D(a)) {
+        re();
+        const f = a.value;
+        return oe(), [
+          "div",
+          {},
+          ["span", e, d(a)],
+          "<",
+          c(f),
+          ">"
+        ];
+      } else {
+        if (ee(a))
+          return [
+            "div",
+            {},
+            ["span", e, N(a) ? "ShallowReactive" : "Reactive"],
+            "<",
+            c(a),
+            `>${C(a) ? " (readonly)" : ""}`
+          ];
+        if (C(a))
+          return [
+            "div",
+            {},
+            ["span", e, N(a) ? "ShallowReadonly" : "Readonly"],
+            "<",
+            c(a),
+            ">"
+          ];
+      }
+      return null;
+    },
+    hasBody(a) {
+      return a && a.__isVue;
+    },
+    body(a) {
+      if (a && a.__isVue)
+        return [
+          "div",
+          {},
+          ...s(a.$)
+        ];
+    }
+  };
+  function s(a) {
+    const f = [];
+    a.type.props && a.props && f.push(i("props", h(a.props))), a.setupState !== pe && f.push(i("setup", a.setupState)), a.data !== pe && f.push(i("data", h(a.data)));
+    const p = l(a, "computed");
+    p && f.push(i("computed", p));
+    const _ = l(a, "inject");
+    return _ && f.push(i("injected", _)), f.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: r.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: a }]
+    ]), f;
+  }
+  function i(a, f) {
+    return f = W({}, f), Object.keys(f).length ? [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        a
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(f).map((p) => [
+          "div",
+          {},
+          ["span", r, p + ": "],
+          c(f[p], !1)
+        ])
+      ]
+    ] : ["span", {}];
+  }
+  function c(a, f = !0) {
+    return typeof a == "number" ? ["span", t, a] : typeof a == "string" ? ["span", n, JSON.stringify(a)] : typeof a == "boolean" ? ["span", r, a] : S(a) ? ["object", { object: f ? h(a) : a }] : ["span", n, String(a)];
+  }
+  function l(a, f) {
+    const p = a.type;
+    if (w(p))
+      return;
+    const _ = {};
+    for (const T in a.ctx)
+      u(p, T, f) && (_[T] = a.ctx[T]);
+    return _;
+  }
+  function u(a, f, p) {
+    const _ = a[p];
+    if (v(_) && _.includes(f) || S(_) && f in _ || a.extends && u(a.extends, f, p) || a.mixins && a.mixins.some((T) => u(T, f, p)))
+      return !0;
+  }
+  function d(a) {
+    return N(a) ? "ShallowRef" : a.effect ? "ComputedRef" : "Ref";
+  }
+  window.devtoolsFormatters ? window.devtoolsFormatters.push(o) : window.devtoolsFormatters = [o];
+}
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+function Zr() {
+  Qr();
+}
+process.env.NODE_ENV !== "production" && Zr();
+const y = dt({
+  mode: "light",
+  variant: "default",
+  isChanging: !1
+});
+let St = !1, q = null;
+function ln() {
+  if (!St && typeof window < "u") {
+    const u = yn();
+    y.value = {
+      mode: u.mode,
+      variant: u.variant,
+      isChanging: !1
+    }, St = !0;
+  }
+  const e = De(() => y.value.mode), t = De(() => y.value.variant), n = De(() => y.value.mode === "dark"), r = De(() => y.value.isChanging), o = (u, d = {}) => {
+    y.value.isChanging = !0, ue({ mode: u }, d), y.value.mode = u, setTimeout(() => {
+      y.value.isChanging = !1;
+    }, 300);
+  }, s = (u, d = {}) => {
+    y.value.isChanging = !0, ue({ variant: u }, d), y.value.variant = u, setTimeout(() => {
+      y.value.isChanging = !1;
+    }, 300);
+  }, i = (u = {}) => {
+    const d = vn(u);
+    y.value.mode = d;
+  }, c = (u, d = {}) => {
+    y.value.isChanging = !0, ue(u, d), u.mode && (y.value.mode = u.mode), u.variant && (y.value.variant = u.variant), setTimeout(() => {
+      y.value.isChanging = !1;
+    }, 300);
+  }, l = () => bn(y.value.variant);
+  return {
+    theme: y.value,
+    mode: e.value,
+    variant: t.value,
+    isDark: n.value,
+    isChanging: r.value,
+    setMode: o,
+    setVariant: s,
+    toggleDarkMode: i,
+    setTheme: c,
+    getAvailableThemes: wn,
+    getCurrentThemeMetadata: l
+  };
+}
+function po(e = dt(!0)) {
+  const { setMode: t } = ln(), n = () => {
+    q && q(), q = En((o) => {
+      e.value && t(o, { transition: !0, persist: !1 });
+    });
+  }, r = () => {
+    q && (q(), q = null);
+  };
+  Dr(
+    e,
+    (o) => {
+      o ? n() : r();
+    },
+    { immediate: !0 }
+  ), Zt(() => {
+    r();
+  });
+}
+function ho(e) {
+  const t = dt(""), n = () => {
+    if (typeof window > "u") return;
+    const r = document.documentElement, o = getComputedStyle(r).getPropertyValue(`--${e}`).trim();
+    o && !o.startsWith("hsl") ? t.value = `hsl(${o})` : t.value = o;
+  };
+  return Cr(() => {
+    n();
+    const r = new MutationObserver(() => {
+      n();
+    });
+    r.observe(document.documentElement, {
+      attributes: !0,
+      attributeFilter: ["class", "data-theme"]
+    }), Zt(() => {
+      r.disconnect();
+    });
+  }), Ce(t);
+}
+function mo() {
+  const { isChanging: e } = ln();
+  return {
+    isTransitioning: e
+  };
+}
+export {
+  ae as CSS_CLASSES,
+  tt as DEFAULT_THEME_MODE,
+  Me as DEFAULT_THEME_VARIANT,
+  xe as HTML_ATTRIBUTES,
+  ne as STORAGE_KEYS,
+  Xr as THEMES_BY_CATEGORY,
+  nt as THEME_MAP,
+  le as THEME_METADATA,
+  Ye as THEME_TRANSITION_DURATION,
+  rt as applyCustomTheme,
+  hn as applyMode,
+  ue as applyTheme,
+  fo as applyThemeFromPrimary,
+  mn as applyVariant,
+  ao as clearCustomTheme,
+  eo as clearStoredTheme,
+  no as detectSystemTheme,
+  _n as disableTransition,
+  gn as enableTransition,
+  Tt as generateThemeFromPrimary,
+  wn as getAvailableThemes,
+  Sn as getCSSVariable,
+  Nt as getCurrentMode,
+  to as getCurrentVariant,
+  V as getHtmlElement,
+  Nn as getStoredCustomTheme,
+  un as getStoredMode,
+  fn as getStoredVariant,
+  so as getThemeColor,
+  bn as getThemeMetadata,
+  Tn as hexToHSL,
+  yn as initTheme,
+  co as isValidMode,
+  io as isValidVariant,
+  _t as parseHSL,
+  lo as restoreCustomTheme,
+  uo as rgbToHSL,
+  oo as setCSSVariable,
+  dn as storeMode,
+  pn as storeVariant,
+  ro as toHSLString,
+  vn as toggleDarkMode,
+  po as useSystemTheme,
+  ln as useTheme,
+  ho as useThemeColor,
+  mo as useThemeTransition,
+  En as watchSystemTheme
+};
 //# sourceMappingURL=index.js.map