@i18n-micro/astro 1.0.1 → 1.1.0

package/dist/client/vue.js

@@ -0,0 +1,1558 @@
+import { h as wt, t as yt } from "../core-D32Y48CN.js";
+import { FormatService as St, defaultPlural as Ot } from "@i18n-micro/core";
+// @__NO_SIDE_EFFECTS__
+function Rt(e) {
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const n of e.split(",")) t[n] = 1;
+  return (n) => n in t;
+}
+const Ee = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {};
+process.env.NODE_ENV !== "production" && Object.freeze([]);
+const He = () => {
+}, Dt = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
+(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), j = Object.assign, xt = Object.prototype.hasOwnProperty, be = (e, t) => xt.call(e, t), _ = Array.isArray, Y = (e) => Ke(e) === "[object Map]", T = (e) => typeof e == "function", D = (e) => typeof e == "string", ee = (e) => typeof e == "symbol", E = (e) => e !== null && typeof e == "object", Vt = Object.prototype.toString, Ke = (e) => Vt.call(e), We = (e) => Ke(e).slice(8, -1), Re = (e) => D(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, Tt = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return ((n) => t[n] || (t[n] = e(n)));
+}, It = Tt((e) => e.charAt(0).toUpperCase() + e.slice(1)), z = (e, t) => !Object.is(e, t);
+let $e;
+const le = () => $e || ($e = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function De(e) {
+  if (_(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++) {
+      const s = e[n], r = D(s) ? Pt(s) : De(s);
+      if (r)
+        for (const o in r)
+          t[o] = r[o];
+    }
+    return t;
+  } else if (D(e) || E(e))
+    return e;
+}
+const Ct = /;(?![^(]*\))/g, At = /:([^]+)/, Mt = /\/\*[^]*?\*\//g;
+function Pt(e) {
+  const t = {};
+  return e.replace(Mt, "").split(Ct).forEach((n) => {
+    if (n) {
+      const s = n.split(At);
+      s.length > 1 && (t[s[0].trim()] = s[1].trim());
+    }
+  }), t;
+}
+function xe(e) {
+  let t = "";
+  if (D(e))
+    t = e;
+  else if (_(e))
+    for (let n = 0; n < e.length; n++) {
+      const s = xe(e[n]);
+      s && (t += s + " ");
+    }
+  else if (E(e))
+    for (const n in e)
+      e[n] && (t += n + " ");
+  return t.trim();
+}
+function L(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let h, ze = 0, J, B;
+function $t(e, t = !1) {
+  if (e.flags |= 8, t) {
+    e.next = B, B = e;
+    return;
+  }
+  e.next = J, J = e;
+}
+function Ve() {
+  ze++;
+}
+function Te() {
+  if (--ze > 0)
+    return;
+  if (B) {
+    let t = B;
+    for (B = void 0; t; ) {
+      const n = t.next;
+      t.next = void 0, t.flags &= -9, t = n;
+    }
+  }
+  let e;
+  for (; J; ) {
+    let t = J;
+    for (J = void 0; t; ) {
+      const n = t.next;
+      if (t.next = void 0, t.flags &= -9, t.flags & 1)
+        try {
+          t.trigger();
+        } catch (s) {
+          e || (e = s);
+        }
+      t = n;
+    }
+  }
+  if (e) throw e;
+}
+function Ft(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t;
+}
+function jt(e) {
+  let t, n = e.depsTail, s = n;
+  for (; s; ) {
+    const r = s.prevDep;
+    s.version === -1 ? (s === n && (n = r), ke(s), Ht(s)) : t = s, s.dep.activeLink = s.prevActiveLink, s.prevActiveLink = void 0, s = r;
+  }
+  e.deps = t, e.depsTail = n;
+}
+function Lt(e) {
+  for (let t = e.deps; t; t = t.nextDep)
+    if (t.dep.version !== t.version || t.dep.computed && (Ue(t.dep.computed) || t.dep.version !== t.version))
+      return !0;
+  return !!e._dirty;
+}
+function Ue(e) {
+  if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === q) || (e.globalVersion = q, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !Lt(e))))
+    return;
+  e.flags |= 2;
+  const t = e.dep, n = h, s = M;
+  h = e, M = !0;
+  try {
+    Ft(e);
+    const r = e.fn(e._value);
+    (t.version === 0 || z(r, e._value)) && (e.flags |= 128, e._value = r, t.version++);
+  } catch (r) {
+    throw t.version++, r;
+  } finally {
+    h = n, M = s, jt(e), e.flags &= -3;
+  }
+}
+function ke(e, t = !1) {
+  const { dep: n, prevSub: s, nextSub: r } = e;
+  if (s && (s.nextSub = r, e.prevSub = void 0), r && (r.prevSub = s, e.nextSub = void 0), process.env.NODE_ENV !== "production" && n.subsHead === e && (n.subsHead = r), n.subs === e && (n.subs = s, !s && n.computed)) {
+    n.computed.flags &= -5;
+    for (let o = n.computed.deps; o; o = o.nextDep)
+      ke(o, !0);
+  }
+  !t && !--n.sc && n.map && n.map.delete(n.key);
+}
+function Ht(e) {
+  const { prevDep: t, nextDep: n } = e;
+  t && (t.nextDep = n, e.prevDep = void 0), n && (n.prevDep = t, e.nextDep = void 0);
+}
+let M = !0;
+const Ye = [];
+function ue() {
+  Ye.push(M), M = !1;
+}
+function fe() {
+  const e = Ye.pop();
+  M = e === void 0 ? !0 : e;
+}
+let q = 0;
+class Kt {
+  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 Ie {
+  // 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 (!h || !M || h === this.computed)
+      return;
+    let n = this.activeLink;
+    if (n === void 0 || n.sub !== h)
+      n = this.activeLink = new Kt(h, this), h.deps ? (n.prevDep = h.depsTail, h.depsTail.nextDep = n, h.depsTail = n) : h.deps = h.depsTail = n, Je(n);
+    else if (n.version === -1 && (n.version = this.version, n.nextDep)) {
+      const s = n.nextDep;
+      s.prevDep = n.prevDep, n.prevDep && (n.prevDep.nextDep = s), n.prevDep = h.depsTail, n.nextDep = void 0, h.depsTail.nextDep = n, h.depsTail = n, h.deps === n && (h.deps = s);
+    }
+    return process.env.NODE_ENV !== "production" && h.onTrack && h.onTrack(
+      j(
+        {
+          effect: h
+        },
+        t
+      )
+    ), n;
+  }
+  trigger(t) {
+    this.version++, q++, this.notify(t);
+  }
+  notify(t) {
+    Ve();
+    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(
+            j(
+              {
+                effect: n.sub
+              },
+              t
+            )
+          );
+      for (let n = this.subs; n; n = n.prevSub)
+        n.sub.notify() && n.sub.dep.notify();
+    } finally {
+      Te();
+    }
+  }
+}
+function Je(e) {
+  if (e.dep.sc++, e.sub.flags & 4) {
+    const t = e.dep.computed;
+    if (t && !e.dep.subs) {
+      t.flags |= 20;
+      for (let s = t.deps; s; s = s.nextDep)
+        Je(s);
+    }
+    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 Ne = /* @__PURE__ */ new WeakMap(), $ = Symbol(
+  process.env.NODE_ENV !== "production" ? "Object iterate" : ""
+), we = Symbol(
+  process.env.NODE_ENV !== "production" ? "Map keys iterate" : ""
+), G = Symbol(
+  process.env.NODE_ENV !== "production" ? "Array iterate" : ""
+);
+function v(e, t, n) {
+  if (M && h) {
+    let s = Ne.get(e);
+    s || Ne.set(e, s = /* @__PURE__ */ new Map());
+    let r = s.get(n);
+    r || (s.set(n, r = new Ie()), r.map = s, r.key = n), process.env.NODE_ENV !== "production" ? r.track({
+      target: e,
+      type: t,
+      key: n
+    }) : r.track();
+  }
+}
+function A(e, t, n, s, r, o) {
+  const i = Ne.get(e);
+  if (!i) {
+    q++;
+    return;
+  }
+  const c = (a) => {
+    a && (process.env.NODE_ENV !== "production" ? a.trigger({
+      target: e,
+      type: t,
+      key: n,
+      newValue: s,
+      oldValue: r,
+      oldTarget: o
+    }) : a.trigger());
+  };
+  if (Ve(), t === "clear")
+    i.forEach(c);
+  else {
+    const a = _(e), u = a && Re(n);
+    if (a && n === "length") {
+      const d = Number(s);
+      i.forEach((l, f) => {
+        (f === "length" || f === G || !ee(f) && f >= d) && c(l);
+      });
+    } else
+      switch ((n !== void 0 || i.has(void 0)) && c(i.get(n)), u && c(i.get(G)), t) {
+        case "add":
+          a ? u && c(i.get("length")) : (c(i.get($)), Y(e) && c(i.get(we)));
+          break;
+        case "delete":
+          a || (c(i.get($)), Y(e) && c(i.get(we)));
+          break;
+        case "set":
+          Y(e) && c(i.get($));
+          break;
+      }
+  }
+  Te();
+}
+function H(e) {
+  const t = p(e);
+  return t === e ? t : (v(t, "iterate", G), N(e) ? t : t.map(x));
+}
+function Ce(e) {
+  return v(e = p(e), "iterate", G), e;
+}
+function I(e, t) {
+  return w(e) ? Ae(e) ? Q(x(t)) : Q(t) : x(t);
+}
+const Wt = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return pe(this, Symbol.iterator, (e) => I(this, e));
+  },
+  concat(...e) {
+    return H(this).concat(
+      ...e.map((t) => _(t) ? H(t) : t)
+    );
+  },
+  entries() {
+    return pe(this, "entries", (e) => (e[1] = I(this, e[1]), e));
+  },
+  every(e, t) {
+    return y(this, "every", e, t, void 0, arguments);
+  },
+  filter(e, t) {
+    return y(
+      this,
+      "filter",
+      e,
+      t,
+      (n) => n.map((s) => I(this, s)),
+      arguments
+    );
+  },
+  find(e, t) {
+    return y(
+      this,
+      "find",
+      e,
+      t,
+      (n) => I(this, n),
+      arguments
+    );
+  },
+  findIndex(e, t) {
+    return y(this, "findIndex", e, t, void 0, arguments);
+  },
+  findLast(e, t) {
+    return y(
+      this,
+      "findLast",
+      e,
+      t,
+      (n) => I(this, n),
+      arguments
+    );
+  },
+  findLastIndex(e, t) {
+    return y(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 y(this, "forEach", e, t, void 0, arguments);
+  },
+  includes(...e) {
+    return de(this, "includes", e);
+  },
+  indexOf(...e) {
+    return de(this, "indexOf", e);
+  },
+  join(e) {
+    return H(this).join(e);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...e) {
+    return de(this, "lastIndexOf", e);
+  },
+  map(e, t) {
+    return y(this, "map", e, t, void 0, arguments);
+  },
+  pop() {
+    return k(this, "pop");
+  },
+  push(...e) {
+    return k(this, "push", e);
+  },
+  reduce(e, ...t) {
+    return Fe(this, "reduce", e, t);
+  },
+  reduceRight(e, ...t) {
+    return Fe(this, "reduceRight", e, t);
+  },
+  shift() {
+    return k(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(e, t) {
+    return y(this, "some", e, t, void 0, arguments);
+  },
+  splice(...e) {
+    return k(this, "splice", e);
+  },
+  toReversed() {
+    return H(this).toReversed();
+  },
+  toSorted(e) {
+    return H(this).toSorted(e);
+  },
+  toSpliced(...e) {
+    return H(this).toSpliced(...e);
+  },
+  unshift(...e) {
+    return k(this, "unshift", e);
+  },
+  values() {
+    return pe(this, "values", (e) => I(this, e));
+  }
+};
+function pe(e, t, n) {
+  const s = Ce(e), r = s[t]();
+  return s !== e && !N(e) && (r._next = r.next, r.next = () => {
+    const o = r._next();
+    return o.done || (o.value = n(o.value)), o;
+  }), r;
+}
+const zt = Array.prototype;
+function y(e, t, n, s, r, o) {
+  const i = Ce(e), c = i !== e && !N(e), a = i[t];
+  if (a !== zt[t]) {
+    const l = a.apply(e, o);
+    return c ? x(l) : l;
+  }
+  let u = n;
+  i !== e && (c ? u = function(l, f) {
+    return n.call(this, I(e, l), f, e);
+  } : n.length > 2 && (u = function(l, f) {
+    return n.call(this, l, f, e);
+  }));
+  const d = a.call(i, u, s);
+  return c && r ? r(d) : d;
+}
+function Fe(e, t, n, s) {
+  const r = Ce(e);
+  let o = n;
+  return r !== e && (N(e) ? n.length > 3 && (o = function(i, c, a) {
+    return n.call(this, i, c, a, e);
+  }) : o = function(i, c, a) {
+    return n.call(this, i, I(e, c), a, e);
+  }), r[t](o, ...s);
+}
+function de(e, t, n) {
+  const s = p(e);
+  v(s, "iterate", G);
+  const r = s[t](...n);
+  return (r === -1 || r === !1) && oe(n[0]) ? (n[0] = p(n[0]), s[t](...n)) : r;
+}
+function k(e, t, n = []) {
+  ue(), Ve();
+  const s = p(e)[t].apply(e, n);
+  return Te(), fe(), s;
+}
+const Ut = /* @__PURE__ */ Rt("__proto__,__v_isRef,__isVue"), Be = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(ee)
+);
+function kt(e) {
+  ee(e) || (e = String(e));
+  const t = p(this);
+  return v(t, "has", e), t.hasOwnProperty(e);
+}
+class qe {
+  constructor(t = !1, n = !1) {
+    this._isReadonly = t, this._isShallow = n;
+  }
+  get(t, n, s) {
+    if (n === "__v_skip") return t.__v_skip;
+    const r = this._isReadonly, o = this._isShallow;
+    if (n === "__v_isReactive")
+      return !r;
+    if (n === "__v_isReadonly")
+      return r;
+    if (n === "__v_isShallow")
+      return o;
+    if (n === "__v_raw")
+      return s === (r ? o ? tn : Xe : o ? en : Qe).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(s) ? t : void 0;
+    const i = _(t);
+    if (!r) {
+      let a;
+      if (i && (a = Wt[n]))
+        return a;
+      if (n === "hasOwnProperty")
+        return kt;
+    }
+    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
+      R(t) ? t : s
+    );
+    if ((ee(n) ? Be.has(n) : Ut(n)) || (r || v(t, "get", n), o))
+      return c;
+    if (R(c)) {
+      const a = i && Re(n) ? c : c.value;
+      return r && E(a) ? Se(a) : a;
+    }
+    return E(c) ? r ? Se(c) : Ze(c) : c;
+  }
+}
+class Yt extends qe {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, n, s, r) {
+    let o = t[n];
+    const i = _(t) && Re(n);
+    if (!this._isShallow) {
+      const u = w(o);
+      if (!N(s) && !w(s) && (o = p(o), s = p(s)), !i && R(o) && !R(s))
+        return u ? (process.env.NODE_ENV !== "production" && L(
+          `Set operation on key "${String(n)}" failed: target is readonly.`,
+          t[n]
+        ), !0) : (o.value = s, !0);
+    }
+    const c = i ? Number(n) < t.length : be(t, n), a = Reflect.set(
+      t,
+      n,
+      s,
+      R(t) ? t : r
+    );
+    return t === p(r) && (c ? z(s, o) && A(t, "set", n, s, o) : A(t, "add", n, s)), a;
+  }
+  deleteProperty(t, n) {
+    const s = be(t, n), r = t[n], o = Reflect.deleteProperty(t, n);
+    return o && s && A(t, "delete", n, void 0, r), o;
+  }
+  has(t, n) {
+    const s = Reflect.has(t, n);
+    return (!ee(n) || !Be.has(n)) && v(t, "has", n), s;
+  }
+  ownKeys(t) {
+    return v(
+      t,
+      "iterate",
+      _(t) ? "length" : $
+    ), Reflect.ownKeys(t);
+  }
+}
+class Jt extends qe {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, n) {
+    return process.env.NODE_ENV !== "production" && L(
+      `Set operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+  deleteProperty(t, n) {
+    return process.env.NODE_ENV !== "production" && L(
+      `Delete operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+}
+const Bt = /* @__PURE__ */ new Yt(), qt = /* @__PURE__ */ new Jt(), ye = (e) => e, te = (e) => Reflect.getPrototypeOf(e);
+function Gt(e, t, n) {
+  return function(...s) {
+    const r = this.__v_raw, o = p(r), i = Y(o), c = e === "entries" || e === Symbol.iterator && i, a = e === "keys" && i, u = r[e](...s), d = n ? ye : t ? Q : x;
+    return !t && v(
+      o,
+      "iterate",
+      a ? we : $
+    ), {
+      // iterator protocol
+      next() {
+        const { value: l, done: f } = u.next();
+        return f ? { value: l, done: f } : {
+          value: c ? [d(l[0]), d(l[1])] : d(l),
+          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]}" ` : "";
+      L(
+        `${It(e)} operation ${n}failed: target is readonly.`,
+        p(this)
+      );
+    }
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function Qt(e, t) {
+  const n = {
+    get(r) {
+      const o = this.__v_raw, i = p(o), c = p(r);
+      e || (z(r, c) && v(i, "get", r), v(i, "get", c));
+      const { has: a } = te(i), u = t ? ye : e ? Q : x;
+      if (a.call(i, r))
+        return u(o.get(r));
+      if (a.call(i, c))
+        return u(o.get(c));
+      o !== i && o.get(r);
+    },
+    get size() {
+      const r = this.__v_raw;
+      return !e && v(p(r), "iterate", $), r.size;
+    },
+    has(r) {
+      const o = this.__v_raw, i = p(o), c = p(r);
+      return e || (z(r, c) && v(i, "has", r), v(i, "has", c)), r === c ? o.has(r) : o.has(r) || o.has(c);
+    },
+    forEach(r, o) {
+      const i = this, c = i.__v_raw, a = p(c), u = t ? ye : e ? Q : x;
+      return !e && v(a, "iterate", $), c.forEach((d, l) => r.call(o, u(d), u(l), i));
+    }
+  };
+  return j(
+    n,
+    e ? {
+      add: ne("add"),
+      set: ne("set"),
+      delete: ne("delete"),
+      clear: ne("clear")
+    } : {
+      add(r) {
+        !t && !N(r) && !w(r) && (r = p(r));
+        const o = p(this);
+        return te(o).has.call(o, r) || (o.add(r), A(o, "add", r, r)), this;
+      },
+      set(r, o) {
+        !t && !N(o) && !w(o) && (o = p(o));
+        const i = p(this), { has: c, get: a } = te(i);
+        let u = c.call(i, r);
+        u ? process.env.NODE_ENV !== "production" && je(i, c, r) : (r = p(r), u = c.call(i, r));
+        const d = a.call(i, r);
+        return i.set(r, o), u ? z(o, d) && A(i, "set", r, o, d) : A(i, "add", r, o), this;
+      },
+      delete(r) {
+        const o = p(this), { has: i, get: c } = te(o);
+        let a = i.call(o, r);
+        a ? process.env.NODE_ENV !== "production" && je(o, i, r) : (r = p(r), a = i.call(o, r));
+        const u = c ? c.call(o, r) : void 0, d = o.delete(r);
+        return a && A(o, "delete", r, void 0, u), d;
+      },
+      clear() {
+        const r = p(this), o = r.size !== 0, i = process.env.NODE_ENV !== "production" ? Y(r) ? new Map(r) : new Set(r) : void 0, c = r.clear();
+        return o && A(
+          r,
+          "clear",
+          void 0,
+          void 0,
+          i
+        ), c;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((r) => {
+    n[r] = Gt(r, e, t);
+  }), n;
+}
+function Ge(e, t) {
+  const n = Qt(e, t);
+  return (s, r, o) => r === "__v_isReactive" ? !e : r === "__v_isReadonly" ? e : r === "__v_raw" ? s : Reflect.get(
+    be(n, r) && r in s ? n : s,
+    r,
+    o
+  );
+}
+const Xt = {
+  get: /* @__PURE__ */ Ge(!1, !1)
+}, Zt = {
+  get: /* @__PURE__ */ Ge(!0, !1)
+};
+function je(e, t, n) {
+  const s = p(n);
+  if (s !== n && t.call(e, s)) {
+    const r = We(e);
+    L(
+      `Reactive ${r} contains both the raw and reactive versions of the same object${r === "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 Qe = /* @__PURE__ */ new WeakMap(), en = /* @__PURE__ */ new WeakMap(), Xe = /* @__PURE__ */ new WeakMap(), tn = /* @__PURE__ */ new WeakMap();
+function nn(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function rn(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : nn(We(e));
+}
+function Ze(e) {
+  return w(e) ? e : et(
+    e,
+    !1,
+    Bt,
+    Xt,
+    Qe
+  );
+}
+function Se(e) {
+  return et(
+    e,
+    !0,
+    qt,
+    Zt,
+    Xe
+  );
+}
+function et(e, t, n, s, r) {
+  if (!E(e))
+    return process.env.NODE_ENV !== "production" && L(
+      `value cannot be made ${t ? "readonly" : "reactive"}: ${String(
+        e
+      )}`
+    ), e;
+  if (e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const o = rn(e);
+  if (o === 0)
+    return e;
+  const i = r.get(e);
+  if (i)
+    return i;
+  const c = new Proxy(
+    e,
+    o === 2 ? s : n
+  );
+  return r.set(e, c), c;
+}
+function Ae(e) {
+  return w(e) ? Ae(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function w(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function N(e) {
+  return !!(e && e.__v_isShallow);
+}
+function oe(e) {
+  return e ? !!e.__v_raw : !1;
+}
+function p(e) {
+  const t = e && e.__v_raw;
+  return t ? p(t) : e;
+}
+const x = (e) => E(e) ? Ze(e) : e, Q = (e) => E(e) ? Se(e) : e;
+function R(e) {
+  return e ? e.__v_isRef === !0 : !1;
+}
+function sn(e) {
+  return on(e, !1);
+}
+function on(e, t) {
+  return R(e) ? e : new cn(e, t);
+}
+class cn {
+  constructor(t, n) {
+    this.dep = new Ie(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = n ? t : p(t), this._value = n ? t : x(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, s = this.__v_isShallow || N(t) || w(t);
+    t = s ? t : p(t), z(t, n) && (this._rawValue = t, this._value = s ? t : x(t), process.env.NODE_ENV !== "production" ? this.dep.trigger({
+      target: this,
+      type: "set",
+      key: "value",
+      newValue: t,
+      oldValue: n
+    }) : this.dep.trigger());
+  }
+}
+class an {
+  constructor(t, n, s) {
+    this.fn = t, this.setter = n, this._value = void 0, this.dep = new Ie(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = q - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !n, this.isSSR = s;
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion
+    h !== this)
+      return $t(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 Ue(this), t && (t.version = this.dep.version), this._value;
+  }
+  set value(t) {
+    this.setter ? this.setter(t) : process.env.NODE_ENV !== "production" && L("Write operation failed: computed value is readonly");
+  }
+}
+function ln(e, t, n = !1) {
+  let s, r;
+  T(e) ? s = e : (s = e.get, r = e.set);
+  const o = new an(s, r, n);
+  return process.env.NODE_ENV, o;
+}
+const F = [];
+function un(e) {
+  F.push(e);
+}
+function fn() {
+  F.pop();
+}
+let he = !1;
+function V(e, ...t) {
+  if (he) return;
+  he = !0, ue();
+  const n = F.length ? F[F.length - 1].component : null, s = n && n.appContext.config.warnHandler, r = pn();
+  if (s)
+    Me(
+      s,
+      n,
+      11,
+      [
+        // eslint-disable-next-line no-restricted-syntax
+        e + t.map((o) => {
+          var i, c;
+          return (c = (i = o.toString) == null ? void 0 : i.call(o)) != null ? c : JSON.stringify(o);
+        }).join(""),
+        n && n.proxy,
+        r.map(
+          ({ vnode: o }) => `at <${vt(n, o.type)}>`
+        ).join(`
+`),
+        r
+      ]
+    );
+  else {
+    const o = [`[Vue warn]: ${e}`, ...t];
+    r.length && o.push(`
+`, ...dn(r)), console.warn(...o);
+  }
+  fe(), he = !1;
+}
+function pn() {
+  let e = F[F.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 s = e.component && e.component.parent;
+    e = s && s.vnode;
+  }
+  return t;
+}
+function dn(e) {
+  const t = [];
+  return e.forEach((n, s) => {
+    t.push(...s === 0 ? [] : [`
+`], ...hn(n));
+  }), t;
+}
+function hn({ vnode: e, recurseCount: t }) {
+  const n = t > 0 ? `... (${t} recursive calls)` : "", s = e.component ? e.component.parent == null : !1, r = ` at <${vt(
+    e.component,
+    e.type,
+    s
+  )}`, o = ">" + n;
+  return e.props ? [r, ..._n(e.props), o] : [r + o];
+}
+function _n(e) {
+  const t = [], n = Object.keys(e);
+  return n.slice(0, 3).forEach((s) => {
+    t.push(...tt(s, e[s]));
+  }), n.length > 3 && t.push(" ..."), t;
+}
+function tt(e, t, n) {
+  return D(t) ? (t = JSON.stringify(t), n ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? n ? t : [`${e}=${t}`] : R(t) ? (t = tt(e, p(t.value), !0), n ? t : [`${e}=Ref<`, t, ">"]) : T(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = p(t), n ? t : [`${e}=`, t]);
+}
+const nt = {
+  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 Me(e, t, n, s) {
+  try {
+    return s ? e(...s) : e();
+  } catch (r) {
+    rt(r, t, n);
+  }
+}
+function rt(e, t, n, s = !0) {
+  const r = t ? t.vnode : null, { errorHandler: o, throwUnhandledErrorInProduction: i } = t && t.appContext.config || Ee;
+  if (t) {
+    let c = t.parent;
+    const a = t.proxy, u = process.env.NODE_ENV !== "production" ? nt[n] : `https://vuejs.org/error-reference/#runtime-${n}`;
+    for (; c; ) {
+      const d = c.ec;
+      if (d) {
+        for (let l = 0; l < d.length; l++)
+          if (d[l](e, a, u) === !1)
+            return;
+      }
+      c = c.parent;
+    }
+    if (o) {
+      ue(), Me(o, null, 10, [
+        e,
+        a,
+        u
+      ]), fe();
+      return;
+    }
+  }
+  gn(e, n, r, s, i);
+}
+function gn(e, t, n, s = !0, r = !1) {
+  if (process.env.NODE_ENV !== "production") {
+    const o = nt[t];
+    if (n && un(n), V(`Unhandled error${o ? ` during execution of ${o}` : ""}`), n && fn(), s)
+      throw e;
+    console.error(e);
+  } else {
+    if (r)
+      throw e;
+    console.error(e);
+  }
+}
+const m = [];
+let S = -1;
+const U = [];
+let C = null, K = 0;
+const vn = /* @__PURE__ */ Promise.resolve();
+let Oe = null;
+const mn = 100;
+function En(e) {
+  let t = S + 1, n = m.length;
+  for (; t < n; ) {
+    const s = t + n >>> 1, r = m[s], o = X(r);
+    o < e || o === e && r.flags & 2 ? t = s + 1 : n = s;
+  }
+  return t;
+}
+function bn(e) {
+  if (!(e.flags & 1)) {
+    const t = X(e), n = m[m.length - 1];
+    !n || // fast path when the job id is larger than the tail
+    !(e.flags & 2) && t >= X(n) ? m.push(e) : m.splice(En(t), 0, e), e.flags |= 1, st();
+  }
+}
+function st() {
+  Oe || (Oe = vn.then(ot));
+}
+function Nn(e) {
+  _(e) ? U.push(...e) : C && e.id === -1 ? C.splice(K + 1, 0, e) : e.flags & 1 || (U.push(e), e.flags |= 1), st();
+}
+function wn(e) {
+  if (U.length) {
+    const t = [...new Set(U)].sort(
+      (n, s) => X(n) - X(s)
+    );
+    if (U.length = 0, C) {
+      C.push(...t);
+      return;
+    }
+    for (C = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), K = 0; K < C.length; K++) {
+      const n = C[K];
+      process.env.NODE_ENV !== "production" && it(e, n) || (n.flags & 4 && (n.flags &= -2), n.flags & 8 || n(), n.flags &= -2);
+    }
+    C = null, K = 0;
+  }
+}
+const X = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id;
+function ot(e) {
+  process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map());
+  const t = process.env.NODE_ENV !== "production" ? (n) => it(e, n) : He;
+  try {
+    for (S = 0; S < m.length; S++) {
+      const n = m[S];
+      if (n && !(n.flags & 8)) {
+        if (process.env.NODE_ENV !== "production" && t(n))
+          continue;
+        n.flags & 4 && (n.flags &= -2), Me(
+          n,
+          n.i,
+          n.i ? 15 : 14
+        ), n.flags & 4 || (n.flags &= -2);
+      }
+    }
+  } finally {
+    for (; S < m.length; S++) {
+      const n = m[S];
+      n && (n.flags &= -2);
+    }
+    S = -1, m.length = 0, wn(e), Oe = null, (m.length || U.length) && ot(e);
+  }
+}
+function it(e, t) {
+  const n = e.get(t) || 0;
+  if (n > mn) {
+    const s = t.i, r = s && gt(s.type);
+    return rt(
+      `Maximum recursive updates exceeded${r ? ` in component <${r}>` : ""}. 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 _e = /* @__PURE__ */ new Map();
+process.env.NODE_ENV !== "production" && (le().__VUE_HMR_RUNTIME__ = {
+  createRecord: ge(yn),
+  rerender: ge(Sn),
+  reload: ge(On)
+});
+const ie = /* @__PURE__ */ new Map();
+function yn(e, t) {
+  return ie.has(e) ? !1 : (ie.set(e, {
+    initialDef: ce(t),
+    instances: /* @__PURE__ */ new Set()
+  }), !0);
+}
+function ce(e) {
+  return mt(e) ? e.__vccOpts : e;
+}
+function Sn(e, t) {
+  const n = ie.get(e);
+  n && (n.initialDef.render = t, [...n.instances].forEach((s) => {
+    t && (s.render = t, ce(s.type).render = t), s.renderCache = [], s.job.flags & 8 || s.update();
+  }));
+}
+function On(e, t) {
+  const n = ie.get(e);
+  if (!n) return;
+  t = ce(t), Le(n.initialDef, t);
+  const s = [...n.instances];
+  for (let r = 0; r < s.length; r++) {
+    const o = s[r], i = ce(o.type);
+    let c = _e.get(i);
+    c || (i !== n.initialDef && Le(i, t), _e.set(i, c = /* @__PURE__ */ new Set())), c.add(o), o.appContext.propsCache.delete(o.type), o.appContext.emitsCache.delete(o.type), o.appContext.optionsCache.delete(o.type), o.ceReload ? (c.add(o), o.ceReload(t.styles), c.delete(o)) : o.parent ? bn(() => {
+      o.job.flags & 8 || (o.parent.update(), c.delete(o));
+    }) : o.appContext.reload ? o.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn(
+      "[HMR] Root or manually mounted instance modified. Full reload required."
+    ), o.root.ce && o !== o.root && o.root.ce._removeChildStyle(i);
+  }
+  Nn(() => {
+    _e.clear();
+  });
+}
+function Le(e, t) {
+  j(e, t);
+  for (const n in e)
+    n !== "__file" && !(n in t) && delete e[n];
+}
+function ge(e) {
+  return (t, n) => {
+    try {
+      return e(t, n);
+    } catch (s) {
+      console.error(s), console.warn(
+        "[HMR] Something went wrong during Vue component hot-reload. Full reload required."
+      );
+    }
+  };
+}
+let W, re = [];
+function ct(e, t) {
+  var n, s;
+  W = e, W ? (W.enabled = !0, re.forEach(({ event: r, args: o }) => W.emit(r, ...o)), re = []) : /* 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
+  !((s = (n = window.navigator) == null ? void 0 : n.userAgent) != null && s.includes("jsdom")) ? ((t.__VUE_DEVTOOLS_HOOK_REPLAY__ = t.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((o) => {
+    ct(o, t);
+  }), setTimeout(() => {
+    W || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, re = []);
+  }, 3e3)) : re = [];
+}
+let Z = null, Rn = null;
+const Dn = (e) => e.__isTeleport;
+function at(e, t) {
+  e.shapeFlag & 6 && e.component ? (e.transition = t, at(e.component.subTree, t)) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t;
+}
+le().requestIdleCallback;
+le().cancelIdleCallback;
+const xn = Symbol.for("v-ndc"), Vn = {};
+process.env.NODE_ENV !== "production" && (Vn.ownKeys = (e) => (V(
+  "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 Tn = null;
+function In(e, t) {
+  if (process.env.NODE_ENV !== "production" && (!O || O.isMounted) && V("provide() can only be used inside setup()."), O) {
+    let n = O.provides;
+    const s = O.parent && O.parent.provides;
+    s === n && (n = O.provides = Object.create(s)), n[e] = t;
+  }
+}
+function Cn(e, t, n = !1) {
+  const s = ht();
+  if (s || Tn) {
+    let r = s ? s.parent == null || s.ce ? s.vnode.appContext && s.vnode.appContext.provides : s.parent.provides : void 0;
+    if (r && e in r)
+      return r[e];
+    if (arguments.length > 1)
+      return n && T(t) ? t.call(s && s.proxy) : t;
+    process.env.NODE_ENV !== "production" && V(`injection "${String(e)}" not found.`);
+  } else process.env.NODE_ENV !== "production" && V("inject() can only be used inside setup() or functional components.");
+}
+const An = {}, lt = (e) => Object.getPrototypeOf(e) === An, Mn = (e) => e.__isSuspense, ut = Symbol.for("v-fgt"), Pn = Symbol.for("v-txt"), $n = Symbol.for("v-cmt");
+function Fn(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+const jn = (...e) => pt(
+  ...e
+), ft = ({ key: e }) => e ?? null, se = ({
+  ref: e,
+  ref_key: t,
+  ref_for: n
+}) => (typeof e == "number" && (e = "" + e), e != null ? D(e) || R(e) || T(e) ? { i: Z, r: e, k: t, f: !!n } : e : null);
+function Ln(e, t = null, n = null, s = 0, r = null, o = e === ut ? 0 : 1, i = !1, c = !1) {
+  const a = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && ft(t),
+    ref: t && se(t),
+    scopeId: Rn,
+    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: o,
+    patchFlag: s,
+    dynamicProps: r,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: Z
+  };
+  return c ? (Pe(a, n), o & 128 && e.normalize(a)) : n && (a.shapeFlag |= D(n) ? 8 : 16), process.env.NODE_ENV !== "production" && a.key !== a.key && V("VNode created with invalid key (NaN). VNode type:", a.type), a;
+}
+const Hn = process.env.NODE_ENV !== "production" ? jn : pt;
+function pt(e, t = null, n = null, s = 0, r = null, o = !1) {
+  if ((!e || e === xn) && (process.env.NODE_ENV !== "production" && !e && V(`Invalid vnode type when creating vnode: ${e}.`), e = $n), Fn(e)) {
+    const c = ae(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return n && Pe(c, n), c.patchFlag = -2, c;
+  }
+  if (mt(e) && (e = e.__vccOpts), t) {
+    t = Kn(t);
+    let { class: c, style: a } = t;
+    c && !D(c) && (t.class = xe(c)), E(a) && (oe(a) && !_(a) && (a = j({}, a)), t.style = De(a));
+  }
+  const i = D(e) ? 1 : Mn(e) ? 128 : Dn(e) ? 64 : E(e) ? 4 : T(e) ? 2 : 0;
+  return process.env.NODE_ENV !== "production" && i & 4 && oe(e) && (e = p(e), V(
+    "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
+  )), Ln(
+    e,
+    t,
+    n,
+    s,
+    r,
+    i,
+    o,
+    !0
+  );
+}
+function Kn(e) {
+  return e ? oe(e) || lt(e) ? j({}, e) : e : null;
+}
+function ae(e, t, n = !1, s = !1) {
+  const { props: r, ref: o, patchFlag: i, children: c, transition: a } = e, u = t ? zn(r || {}, t) : r, d = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: u,
+    key: u && ft(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 && o ? _(o) ? o.concat(se(t)) : [o, se(t)] : se(t)
+    ) : o,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: process.env.NODE_ENV !== "production" && i === -1 && _(c) ? c.map(dt) : 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 !== ut ? i === -1 ? 16 : i | 16 : i,
+    dynamicProps: e.dynamicProps,
+    dynamicChildren: e.dynamicChildren,
+    appContext: e.appContext,
+    dirs: e.dirs,
+    transition: a,
+    // 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 && ae(e.ssContent),
+    ssFallback: e.ssFallback && ae(e.ssFallback),
+    placeholder: e.placeholder,
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+  return a && s && at(
+    d,
+    a.clone(d)
+  ), d;
+}
+function dt(e) {
+  const t = ae(e);
+  return _(e.children) && (t.children = e.children.map(dt)), t;
+}
+function Wn(e = " ", t = 0) {
+  return Hn(Pn, null, e, t);
+}
+function Pe(e, t) {
+  let n = 0;
+  const { shapeFlag: s } = e;
+  if (t == null)
+    t = null;
+  else if (_(t))
+    n = 16;
+  else if (typeof t == "object")
+    if (s & 65) {
+      const r = t.default;
+      r && (r._c && (r._d = !1), Pe(e, r()), r._c && (r._d = !0));
+      return;
+    } else
+      n = 32, !t._ && !lt(t) && (t._ctx = Z);
+  else T(t) ? (t = { default: t, _ctx: Z }, n = 32) : (t = String(t), s & 64 ? (n = 16, t = [Wn(t)]) : n = 8);
+  e.children = t, e.shapeFlag |= n;
+}
+function zn(...e) {
+  const t = {};
+  for (let n = 0; n < e.length; n++) {
+    const s = e[n];
+    for (const r in s)
+      if (r === "class")
+        t.class !== s.class && (t.class = xe([t.class, s.class]));
+      else if (r === "style")
+        t.style = De([t.style, s.style]);
+      else if (Dt(r)) {
+        const o = t[r], i = s[r];
+        i && o !== i && !(_(o) && o.includes(i)) && (t[r] = o ? [].concat(o, i) : i);
+      } else r !== "" && (t[r] = s[r]);
+  }
+  return t;
+}
+let O = null;
+const ht = () => O || Z;
+{
+  const e = le(), t = (n, s) => {
+    let r;
+    return (r = e[n]) || (r = e[n] = []), r.push(s), (o) => {
+      r.length > 1 ? r.forEach((i) => i(o)) : r[0](o);
+    };
+  };
+  t(
+    "__VUE_INSTANCE_SETTERS__",
+    (n) => O = n
+  ), t(
+    "__VUE_SSR_SETTERS__",
+    (n) => _t = n
+  );
+}
+let _t = !1;
+process.env.NODE_ENV;
+const Un = /(?:^|[-_])\w/g, kn = (e) => e.replace(Un, (t) => t.toUpperCase()).replace(/[-_]/g, "");
+function gt(e, t = !0) {
+  return T(e) ? e.displayName || e.name : e.name || t && e.__name;
+}
+function vt(e, t, n = !1) {
+  let s = gt(t);
+  if (!s && t.__file) {
+    const r = t.__file.match(/([^/\\]+)\.\w+$/);
+    r && (s = r[1]);
+  }
+  if (!s && e) {
+    const r = (o) => {
+      for (const i in o)
+        if (o[i] === t)
+          return i;
+    };
+    s = r(e.components) || e.parent && r(
+      e.parent.type.components
+    ) || r(e.appContext.components);
+  }
+  return s ? kn(s) : n ? "App" : "Anonymous";
+}
+function mt(e) {
+  return T(e) && "__vccOpts" in e;
+}
+const ve = (e, t) => {
+  const n = ln(e, t, _t);
+  if (process.env.NODE_ENV !== "production") {
+    const s = ht();
+    s && s.appContext.config.warnRecursiveComputed && (n._warnRecursive = !0);
+  }
+  return n;
+};
+function Yn() {
+  if (process.env.NODE_ENV === "production" || typeof window > "u")
+    return;
+  const e = { style: "color:#3ba776" }, t = { style: "color:#1677ff" }, n = { style: "color:#f5222d" }, s = { style: "color:#eb2f96" }, r = {
+    __vue_custom_formatter: !0,
+    header(l) {
+      if (!E(l))
+        return null;
+      if (l.__isVue)
+        return ["div", e, "VueInstance"];
+      if (R(l)) {
+        ue();
+        const f = l.value;
+        return fe(), [
+          "div",
+          {},
+          ["span", e, d(l)],
+          "<",
+          c(f),
+          ">"
+        ];
+      } else {
+        if (Ae(l))
+          return [
+            "div",
+            {},
+            ["span", e, N(l) ? "ShallowReactive" : "Reactive"],
+            "<",
+            c(l),
+            `>${w(l) ? " (readonly)" : ""}`
+          ];
+        if (w(l))
+          return [
+            "div",
+            {},
+            ["span", e, N(l) ? "ShallowReadonly" : "Readonly"],
+            "<",
+            c(l),
+            ">"
+          ];
+      }
+      return null;
+    },
+    hasBody(l) {
+      return l && l.__isVue;
+    },
+    body(l) {
+      if (l && l.__isVue)
+        return [
+          "div",
+          {},
+          ...o(l.$)
+        ];
+    }
+  };
+  function o(l) {
+    const f = [];
+    l.type.props && l.props && f.push(i("props", p(l.props))), l.setupState !== Ee && f.push(i("setup", l.setupState)), l.data !== Ee && f.push(i("data", p(l.data)));
+    const g = a(l, "computed");
+    g && f.push(i("computed", g));
+    const b = a(l, "inject");
+    return b && f.push(i("injected", b)), f.push([
+      "div",
+      {},
+      [
+        "span",
+        {
+          style: s.style + ";opacity:0.66"
+        },
+        "$ (internal): "
+      ],
+      ["object", { object: l }]
+    ]), f;
+  }
+  function i(l, f) {
+    return f = j({}, f), Object.keys(f).length ? [
+      "div",
+      { style: "line-height:1.25em;margin-bottom:0.6em" },
+      [
+        "div",
+        {
+          style: "color:#476582"
+        },
+        l
+      ],
+      [
+        "div",
+        {
+          style: "padding-left:1.25em"
+        },
+        ...Object.keys(f).map((g) => [
+          "div",
+          {},
+          ["span", s, g + ": "],
+          c(f[g], !1)
+        ])
+      ]
+    ] : ["span", {}];
+  }
+  function c(l, f = !0) {
+    return typeof l == "number" ? ["span", t, l] : typeof l == "string" ? ["span", n, JSON.stringify(l)] : typeof l == "boolean" ? ["span", s, l] : E(l) ? ["object", { object: f ? p(l) : l }] : ["span", n, String(l)];
+  }
+  function a(l, f) {
+    const g = l.type;
+    if (T(g))
+      return;
+    const b = {};
+    for (const P in l.ctx)
+      u(g, P, f) && (b[P] = l.ctx[P]);
+    return b;
+  }
+  function u(l, f, g) {
+    const b = l[g];
+    if (_(b) && b.includes(f) || E(b) && f in b || l.extends && u(l.extends, f, g) || l.mixins && l.mixins.some((P) => u(P, f, g)))
+      return !0;
+  }
+  function d(l) {
+    return N(l) ? "ShallowRef" : l.effect ? "ComputedRef" : "Ref";
+  }
+  window.devtoolsFormatters ? window.devtoolsFormatters.push(r) : window.devtoolsFormatters = [r];
+}
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+function Jn() {
+  Yn();
+}
+process.env.NODE_ENV !== "production" && Jn();
+const me = new St(), Et = Symbol("i18n-astro");
+function Gn(e) {
+  const t = sn({
+    locale: e.locale,
+    fallbackLocale: e.fallbackLocale,
+    translations: e.translations,
+    currentRoute: e.currentRoute
+  });
+  return In(Et, t), t;
+}
+function Qn() {
+  const e = Cn(Et);
+  if (!e)
+    throw new Error("useAstroI18n must be used within a component that calls provideI18n");
+  const t = (a, u, d, l) => yt(e.value, a, u, d, l);
+  return {
+    // Translation methods
+    t,
+    ts: (a, u, d, l) => t(a, u, d, l)?.toString() ?? d ?? a,
+    tc: (a, u, d) => {
+      const { count: l, ...f } = typeof u == "number" ? { count: u } : u;
+      if (l === void 0)
+        return d ?? a;
+      const g = (P, bt, Nt) => t(P, bt, Nt);
+      return Ot(
+        a,
+        Number.parseInt(l.toString(), 10),
+        f,
+        e.value.locale,
+        g
+      ) ?? d ?? a;
+    },
+    tn: (a, u) => me.formatNumber(a, e.value.locale, u),
+    td: (a, u) => me.formatDate(a, e.value.locale, u),
+    tdr: (a, u) => me.formatRelativeTime(a, e.value.locale, u),
+    has: (a, u) => wt(e.value, a, u),
+    // Reactive locale state
+    locale: ve({
+      get: () => e.value.locale,
+      set: (a) => {
+        e.value = { ...e.value, locale: a };
+      }
+    }),
+    fallbackLocale: ve(() => e.value.fallbackLocale),
+    currentRoute: ve({
+      get: () => e.value.currentRoute,
+      set: (a) => {
+        e.value = { ...e.value, currentRoute: a };
+      }
+    }),
+    // Route management
+    setLocale: (a) => {
+      e.value = { ...e.value, locale: a };
+    },
+    setRoute: (a) => {
+      e.value = { ...e.value, currentRoute: a };
+    },
+    getRoute: () => e.value.currentRoute
+  };
+}
+export {
+  Gn as provideI18n,
+  Qn as useAstroI18n
+};