iking-web-ui-pro 0.2.4 → 0.2.6

package/dist/Provider/ik.index.es.js

@@ -0,0 +1,1611 @@
+import { defineComponent as Gt, computed as z, renderSlot as Bt } from "vue";
+const Qt = (e, t) => {
+  if (e.install = (n) => {
+    for (const r of [e, ...Object.values(t ?? {})])
+      n.component(r.name, r);
+  }, t)
+    for (const [n, r] of Object.entries(t))
+      e[n] = r;
+  return e;
+};
+/**
+* @vue/shared v3.4.27
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function Xt(e, t) {
+  const n = new Set(e.split(","));
+  return t ? (r) => n.has(r.toLowerCase()) : (r) => n.has(r);
+}
+const P = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {};
+process.env.NODE_ENV !== "production" && Object.freeze([]);
+const J = () => {
+}, Zt = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
+(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), x = Object.assign, kt = Object.prototype.hasOwnProperty, g = (e, t) => kt.call(e, t), d = Array.isArray, B = (e) => Se(e) === "[object Map]", en = (e) => Se(e) === "[object Set]", E = (e) => typeof e == "function", v = (e) => typeof e == "string", ie = (e) => typeof e == "symbol", S = (e) => e !== null && typeof e == "object", tn = (e) => (S(e) || E(e)) && E(e.then) && E(e.catch), nn = Object.prototype.toString, Se = (e) => nn.call(e), Et = (e) => Se(e).slice(8, -1), rn = (e) => Se(e) === "[object Object]", Ke = (e) => v(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, on = (e) => {
+  const t = /* @__PURE__ */ Object.create(null);
+  return (n) => t[n] || (t[n] = e(n));
+}, sn = on((e) => e.charAt(0).toUpperCase() + e.slice(1)), X = (e, t) => !Object.is(e, t), cn = (e, t, n, r = !1) => {
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !1,
+    writable: r,
+    value: n
+  });
+};
+let nt;
+const mt = () => nt || (nt = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+function ze(e) {
+  if (d(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++) {
+      const r = e[n], o = v(r) ? fn(r) : ze(r);
+      if (o)
+        for (const s in o)
+          t[s] = o[s];
+    }
+    return t;
+  } else if (v(e) || S(e))
+    return e;
+}
+const ln = /;(?![^(]*\))/g, an = /:([^]+)/, un = /\/\*[^]*?\*\//g;
+function fn(e) {
+  const t = {};
+  return e.replace(un, "").split(ln).forEach((n) => {
+    if (n) {
+      const r = n.split(an);
+      r.length > 1 && (t[r[0].trim()] = r[1].trim());
+    }
+  }), t;
+}
+function We(e) {
+  let t = "";
+  if (v(e))
+    t = e;
+  else if (d(e))
+    for (let n = 0; n < e.length; n++) {
+      const r = We(e[n]);
+      r && (t += r + " ");
+    }
+  else if (S(e))
+    for (const n in e)
+      e[n] && (t += n + " ");
+  return t.trim();
+}
+/**
+* @vue/reactivity v3.4.27
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function oe(e, ...t) {
+  console.warn(`[Vue warn] ${e}`, ...t);
+}
+let pn;
+function dn(e, t = pn) {
+  t && t.active && t.effects.push(e);
+}
+let ee;
+class hn {
+  constructor(t, n, r, o) {
+    this.fn = t, this.trigger = n, this.scheduler = r, this.active = !0, this.deps = [], this._dirtyLevel = 4, this._trackId = 0, this._runnings = 0, this._shouldSchedule = !1, this._depsLength = 0, dn(this, o);
+  }
+  get dirty() {
+    if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
+      this._dirtyLevel = 1, Ve();
+      for (let t = 0; t < this._depsLength; t++) {
+        const n = this.deps[t];
+        if (n.computed && (_n(n.computed), this._dirtyLevel >= 4))
+          break;
+      }
+      this._dirtyLevel === 1 && (this._dirtyLevel = 0), xe();
+    }
+    return this._dirtyLevel >= 4;
+  }
+  set dirty(t) {
+    this._dirtyLevel = t ? 4 : 0;
+  }
+  run() {
+    if (this._dirtyLevel = 0, !this.active)
+      return this.fn();
+    let t = L, n = ee;
+    try {
+      return L = !0, ee = this, this._runnings++, rt(this), this.fn();
+    } finally {
+      ot(this), this._runnings--, ee = n, L = t;
+    }
+  }
+  stop() {
+    this.active && (rt(this), ot(this), this.onStop && this.onStop(), this.active = !1);
+  }
+}
+function _n(e) {
+  return e.value;
+}
+function rt(e) {
+  e._trackId++, e._depsLength = 0;
+}
+function ot(e) {
+  if (e.deps.length > e._depsLength) {
+    for (let t = e._depsLength; t < e.deps.length; t++)
+      wt(e.deps[t], e);
+    e.deps.length = e._depsLength;
+  }
+}
+function wt(e, t) {
+  const n = e.get(t);
+  n !== void 0 && t._trackId !== n && (e.delete(t), e.size === 0 && e.cleanup());
+}
+let L = !0, Te = 0;
+const Nt = [];
+function Ve() {
+  Nt.push(L), L = !1;
+}
+function xe() {
+  const e = Nt.pop();
+  L = e === void 0 ? !0 : e;
+}
+function qe() {
+  Te++;
+}
+function Je() {
+  for (Te--; !Te && $e.length; )
+    $e.shift()();
+}
+function gn(e, t, n) {
+  var r;
+  if (t.get(e) !== e._trackId) {
+    t.set(e, e._trackId);
+    const o = e.deps[e._depsLength];
+    o !== t ? (o && wt(o, e), e.deps[e._depsLength++] = t) : e._depsLength++, process.env.NODE_ENV !== "production" && ((r = e.onTrack) == null || r.call(e, x({ effect: e }, n)));
+  }
+}
+const $e = [];
+function En(e, t, n) {
+  var r;
+  qe();
+  for (const o of e.keys()) {
+    let s;
+    o._dirtyLevel < t && (s ?? (s = e.get(o) === o._trackId)) && (o._shouldSchedule || (o._shouldSchedule = o._dirtyLevel === 0), o._dirtyLevel = t), o._shouldSchedule && (s ?? (s = e.get(o) === o._trackId)) && (process.env.NODE_ENV !== "production" && ((r = o.onTrigger) == null || r.call(o, x({ effect: o }, n))), o.trigger(), (!o._runnings || o.allowRecurse) && o._dirtyLevel !== 2 && (o._shouldSchedule = !1, o.scheduler && $e.push(o.scheduler)));
+  }
+  Je();
+}
+const mn = (e, t) => {
+  const n = /* @__PURE__ */ new Map();
+  return n.cleanup = e, n.computed = t, n;
+}, Me = /* @__PURE__ */ new WeakMap(), F = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""), je = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : "");
+function m(e, t, n) {
+  if (L && ee) {
+    let r = Me.get(e);
+    r || Me.set(e, r = /* @__PURE__ */ new Map());
+    let o = r.get(n);
+    o || r.set(n, o = mn(() => r.delete(n))), gn(
+      ee,
+      o,
+      process.env.NODE_ENV !== "production" ? {
+        target: e,
+        type: t,
+        key: n
+      } : void 0
+    );
+  }
+}
+function M(e, t, n, r, o, s) {
+  const i = Me.get(e);
+  if (!i)
+    return;
+  let c = [];
+  if (t === "clear")
+    c = [...i.values()];
+  else if (n === "length" && d(e)) {
+    const l = Number(r);
+    i.forEach((a, h) => {
+      (h === "length" || !ie(h) && h >= l) && c.push(a);
+    });
+  } else
+    switch (n !== void 0 && c.push(i.get(n)), t) {
+      case "add":
+        d(e) ? Ke(n) && c.push(i.get("length")) : (c.push(i.get(F)), B(e) && c.push(i.get(je)));
+        break;
+      case "delete":
+        d(e) || (c.push(i.get(F)), B(e) && c.push(i.get(je)));
+        break;
+      case "set":
+        B(e) && c.push(i.get(F));
+        break;
+    }
+  qe();
+  for (const l of c)
+    l && En(
+      l,
+      4,
+      process.env.NODE_ENV !== "production" ? {
+        target: e,
+        type: t,
+        key: n,
+        newValue: r,
+        oldValue: o,
+        oldTarget: s
+      } : void 0
+    );
+  Je();
+}
+const wn = /* @__PURE__ */ Xt("__proto__,__v_isRef,__isVue"), Ot = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(ie)
+), st = /* @__PURE__ */ Nn();
+function Nn() {
+  const e = {};
+  return ["includes", "indexOf", "lastIndexOf"].forEach((t) => {
+    e[t] = function(...n) {
+      const r = f(this);
+      for (let s = 0, i = this.length; s < i; s++)
+        m(r, "get", s + "");
+      const o = r[t](...n);
+      return o === -1 || o === !1 ? r[t](...n.map(f)) : o;
+    };
+  }), ["push", "pop", "shift", "unshift", "splice"].forEach((t) => {
+    e[t] = function(...n) {
+      Ve(), qe();
+      const r = f(this)[t].apply(this, n);
+      return Je(), xe(), r;
+    };
+  }), e;
+}
+function On(e) {
+  ie(e) || (e = String(e));
+  const t = f(this);
+  return m(t, "has", e), t.hasOwnProperty(e);
+}
+class bt {
+  constructor(t = !1, n = !1) {
+    this._isReadonly = t, this._isShallow = n;
+  }
+  get(t, n, r) {
+    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 ? yt : xt : s ? $n : Vt).get(t) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the reciever is a user proxy of the reactive proxy
+      Object.getPrototypeOf(t) === Object.getPrototypeOf(r) ? t : void 0;
+    const i = d(t);
+    if (!o) {
+      if (i && g(st, n))
+        return Reflect.get(st, n, r);
+      if (n === "hasOwnProperty")
+        return On;
+    }
+    const c = Reflect.get(t, n, r);
+    return (ie(n) ? Ot.has(n) : wn(n)) || (o || m(t, "get", n), s) ? c : V(c) ? i && Ke(n) ? c : c.value : S(c) ? o ? It(c) : Ct(c) : c;
+  }
+}
+class bn extends bt {
+  constructor(t = !1) {
+    super(!1, t);
+  }
+  set(t, n, r, o) {
+    let s = t[n];
+    if (!this._isShallow) {
+      const l = we(s);
+      if (!Ae(r) && !we(r) && (s = f(s), r = f(r)), !d(t) && V(s) && !V(r))
+        return l ? !1 : (s.value = r, !0);
+    }
+    const i = d(t) && Ke(n) ? Number(n) < t.length : g(t, n), c = Reflect.set(t, n, r, o);
+    return t === f(o) && (i ? X(r, s) && M(t, "set", n, r, s) : M(t, "add", n, r)), c;
+  }
+  deleteProperty(t, n) {
+    const r = g(t, n), o = t[n], s = Reflect.deleteProperty(t, n);
+    return s && r && M(t, "delete", n, void 0, o), s;
+  }
+  has(t, n) {
+    const r = Reflect.has(t, n);
+    return (!ie(n) || !Ot.has(n)) && m(t, "has", n), r;
+  }
+  ownKeys(t) {
+    return m(
+      t,
+      "iterate",
+      d(t) ? "length" : F
+    ), Reflect.ownKeys(t);
+  }
+}
+class vt extends bt {
+  constructor(t = !1) {
+    super(!0, t);
+  }
+  set(t, n) {
+    return process.env.NODE_ENV !== "production" && oe(
+      `Set operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+  deleteProperty(t, n) {
+    return process.env.NODE_ENV !== "production" && oe(
+      `Delete operation on key "${String(n)}" failed: target is readonly.`,
+      t
+    ), !0;
+  }
+}
+const vn = /* @__PURE__ */ new bn(), Sn = /* @__PURE__ */ new vt(), Vn = /* @__PURE__ */ new vt(!0), Ye = (e) => e, ye = (e) => Reflect.getPrototypeOf(e);
+function ae(e, t, n = !1, r = !1) {
+  e = e.__v_raw;
+  const o = f(e), s = f(t);
+  n || (X(t, s) && m(o, "get", t), m(o, "get", s));
+  const { has: i } = ye(o), c = r ? Ye : n ? Xe : Qe;
+  if (i.call(o, t))
+    return c(e.get(t));
+  if (i.call(o, s))
+    return c(e.get(s));
+  e !== o && e.get(t);
+}
+function ue(e, t = !1) {
+  const n = this.__v_raw, r = f(n), o = f(e);
+  return t || (X(e, o) && m(r, "has", e), m(r, "has", o)), e === o ? n.has(e) : n.has(e) || n.has(o);
+}
+function fe(e, t = !1) {
+  return e = e.__v_raw, !t && m(f(e), "iterate", F), Reflect.get(e, "size", e);
+}
+function it(e) {
+  e = f(e);
+  const t = f(this);
+  return ye(t).has.call(t, e) || (t.add(e), M(t, "add", e, e)), this;
+}
+function ct(e, t) {
+  t = f(t);
+  const n = f(this), { has: r, get: o } = ye(n);
+  let s = r.call(n, e);
+  s ? process.env.NODE_ENV !== "production" && St(n, r, e) : (e = f(e), s = r.call(n, e));
+  const i = o.call(n, e);
+  return n.set(e, t), s ? X(t, i) && M(n, "set", e, t, i) : M(n, "add", e, t), this;
+}
+function lt(e) {
+  const t = f(this), { has: n, get: r } = ye(t);
+  let o = n.call(t, e);
+  o ? process.env.NODE_ENV !== "production" && St(t, n, e) : (e = f(e), o = n.call(t, e));
+  const s = r ? r.call(t, e) : void 0, i = t.delete(e);
+  return o && M(t, "delete", e, void 0, s), i;
+}
+function at() {
+  const e = f(this), t = e.size !== 0, n = process.env.NODE_ENV !== "production" ? B(e) ? new Map(e) : new Set(e) : void 0, r = e.clear();
+  return t && M(e, "clear", void 0, void 0, n), r;
+}
+function pe(e, t) {
+  return function(r, o) {
+    const s = this, i = s.__v_raw, c = f(i), l = t ? Ye : e ? Xe : Qe;
+    return !e && m(c, "iterate", F), i.forEach((a, h) => r.call(o, l(a), l(h), s));
+  };
+}
+function de(e, t, n) {
+  return function(...r) {
+    const o = this.__v_raw, s = f(o), i = B(s), c = e === "entries" || e === Symbol.iterator && i, l = e === "keys" && i, a = o[e](...r), h = n ? Ye : t ? Xe : Qe;
+    return !t && m(
+      s,
+      "iterate",
+      l ? je : F
+    ), {
+      // iterator protocol
+      next() {
+        const { value: _, done: O } = a.next();
+        return O ? { value: _, done: O } : {
+          value: c ? [h(_[0]), h(_[1])] : h(_),
+          done: O
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function D(e) {
+  return function(...t) {
+    if (process.env.NODE_ENV !== "production") {
+      const n = t[0] ? `on key "${t[0]}" ` : "";
+      oe(
+        `${sn(e)} operation ${n}failed: target is readonly.`,
+        f(this)
+      );
+    }
+    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
+  };
+}
+function xn() {
+  const e = {
+    get(s) {
+      return ae(this, s);
+    },
+    get size() {
+      return fe(this);
+    },
+    has: ue,
+    add: it,
+    set: ct,
+    delete: lt,
+    clear: at,
+    forEach: pe(!1, !1)
+  }, t = {
+    get(s) {
+      return ae(this, s, !1, !0);
+    },
+    get size() {
+      return fe(this);
+    },
+    has: ue,
+    add: it,
+    set: ct,
+    delete: lt,
+    clear: at,
+    forEach: pe(!1, !0)
+  }, n = {
+    get(s) {
+      return ae(this, s, !0);
+    },
+    get size() {
+      return fe(this, !0);
+    },
+    has(s) {
+      return ue.call(this, s, !0);
+    },
+    add: D("add"),
+    set: D("set"),
+    delete: D("delete"),
+    clear: D("clear"),
+    forEach: pe(!0, !1)
+  }, r = {
+    get(s) {
+      return ae(this, s, !0, !0);
+    },
+    get size() {
+      return fe(this, !0);
+    },
+    has(s) {
+      return ue.call(this, s, !0);
+    },
+    add: D("add"),
+    set: D("set"),
+    delete: D("delete"),
+    clear: D("clear"),
+    forEach: pe(!0, !0)
+  };
+  return [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((s) => {
+    e[s] = de(s, !1, !1), n[s] = de(s, !0, !1), t[s] = de(s, !1, !0), r[s] = de(
+      s,
+      !0,
+      !0
+    );
+  }), [
+    e,
+    n,
+    t,
+    r
+  ];
+}
+const [
+  yn,
+  Cn,
+  In,
+  Rn
+] = /* @__PURE__ */ xn();
+function Ge(e, t) {
+  const n = t ? e ? Rn : In : e ? Cn : yn;
+  return (r, o, s) => o === "__v_isReactive" ? !e : o === "__v_isReadonly" ? e : o === "__v_raw" ? r : Reflect.get(
+    g(n, o) && o in r ? n : r,
+    o,
+    s
+  );
+}
+const Dn = {
+  get: /* @__PURE__ */ Ge(!1, !1)
+}, Pn = {
+  get: /* @__PURE__ */ Ge(!0, !1)
+}, Tn = {
+  get: /* @__PURE__ */ Ge(!0, !0)
+};
+function St(e, t, n) {
+  const r = f(n);
+  if (r !== n && t.call(e, r)) {
+    const o = Et(e);
+    oe(
+      `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 Vt = /* @__PURE__ */ new WeakMap(), $n = /* @__PURE__ */ new WeakMap(), xt = /* @__PURE__ */ new WeakMap(), yt = /* @__PURE__ */ new WeakMap();
+function Mn(e) {
+  switch (e) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function jn(e) {
+  return e.__v_skip || !Object.isExtensible(e) ? 0 : Mn(Et(e));
+}
+function Ct(e) {
+  return we(e) ? e : Be(
+    e,
+    !1,
+    vn,
+    Dn,
+    Vt
+  );
+}
+function It(e) {
+  return Be(
+    e,
+    !0,
+    Sn,
+    Pn,
+    xt
+  );
+}
+function he(e) {
+  return Be(
+    e,
+    !0,
+    Vn,
+    Tn,
+    yt
+  );
+}
+function Be(e, t, n, r, o) {
+  if (!S(e))
+    return process.env.NODE_ENV !== "production" && oe(`value cannot be made reactive: ${String(e)}`), e;
+  if (e.__v_raw && !(t && e.__v_isReactive))
+    return e;
+  const s = o.get(e);
+  if (s)
+    return s;
+  const i = jn(e);
+  if (i === 0)
+    return e;
+  const c = new Proxy(
+    e,
+    i === 2 ? r : n
+  );
+  return o.set(e, c), c;
+}
+function te(e) {
+  return we(e) ? te(e.__v_raw) : !!(e && e.__v_isReactive);
+}
+function we(e) {
+  return !!(e && e.__v_isReadonly);
+}
+function Ae(e) {
+  return !!(e && e.__v_isShallow);
+}
+function Le(e) {
+  return e ? !!e.__v_raw : !1;
+}
+function f(e) {
+  const t = e && e.__v_raw;
+  return t ? f(t) : e;
+}
+function An(e) {
+  return Object.isExtensible(e) && cn(e, "__v_skip", !0), e;
+}
+const Qe = (e) => S(e) ? Ct(e) : e, Xe = (e) => S(e) ? It(e) : e;
+function V(e) {
+  return !!(e && e.__v_isRef === !0);
+}
+function Ln(e) {
+  return V(e) ? e.value : e;
+}
+const Fn = {
+  get: (e, t, n) => Ln(Reflect.get(e, t, n)),
+  set: (e, t, n, r) => {
+    const o = e[t];
+    return V(o) && !V(n) ? (o.value = n, !0) : Reflect.set(e, t, n, r);
+  }
+};
+function Hn(e) {
+  return te(e) ? e : new Proxy(e, Fn);
+}
+/**
+* @vue/runtime-core v3.4.27
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+const H = [];
+function Un(e) {
+  H.push(e);
+}
+function Kn() {
+  H.pop();
+}
+function p(e, ...t) {
+  Ve();
+  const n = H.length ? H[H.length - 1].component : null, r = n && n.appContext.config.warnHandler, o = zn();
+  if (r)
+    U(
+      r,
+      n,
+      11,
+      [
+        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 <${qt(n, s.type)}>`
+        ).join(`
+`),
+        o
+      ]
+    );
+  else {
+    const s = [`[Vue warn]: ${e}`, ...t];
+    o.length && s.push(`
+`, ...Wn(o)), console.warn(...s);
+  }
+  xe();
+}
+function zn() {
+  let e = H[H.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 Wn(e) {
+  const t = [];
+  return e.forEach((n, r) => {
+    t.push(...r === 0 ? [] : [`
+`], ...qn(n));
+  }), t;
+}
+function qn({ vnode: e, recurseCount: t }) {
+  const n = t > 0 ? `... (${t} recursive calls)` : "", r = e.component ? e.component.parent == null : !1, o = ` at <${qt(
+    e.component,
+    e.type,
+    r
+  )}`, s = ">" + n;
+  return e.props ? [o, ...Jn(e.props), s] : [o + s];
+}
+function Jn(e) {
+  const t = [], n = Object.keys(e);
+  return n.slice(0, 3).forEach((r) => {
+    t.push(...Rt(r, e[r]));
+  }), n.length > 3 && t.push(" ..."), t;
+}
+function Rt(e, t, n) {
+  return v(t) ? (t = JSON.stringify(t), n ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? n ? t : [`${e}=${t}`] : V(t) ? (t = Rt(e, f(t.value), !0), n ? t : [`${e}=Ref<`, t, ">"]) : E(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = f(t), n ? t : [`${e}=`, t]);
+}
+const Dt = {
+  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. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
+};
+function U(e, t, n, r) {
+  try {
+    return r ? e(...r) : e();
+  } catch (o) {
+    Ze(o, t, n);
+  }
+}
+function Ee(e, t, n, r) {
+  if (E(e)) {
+    const o = U(e, t, n, r);
+    return o && tn(o) && o.catch((s) => {
+      Ze(s, t, n);
+    }), o;
+  }
+  if (d(e)) {
+    const o = [];
+    for (let s = 0; s < e.length; s++)
+      o.push(Ee(e[s], t, n, r));
+    return o;
+  } else
+    process.env.NODE_ENV !== "production" && p(
+      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof e}`
+    );
+}
+function Ze(e, t, n, r = !0) {
+  const o = t ? t.vnode : null;
+  if (t) {
+    let s = t.parent;
+    const i = t.proxy, c = process.env.NODE_ENV !== "production" ? Dt[n] : `https://vuejs.org/error-reference/#runtime-${n}`;
+    for (; s; ) {
+      const a = s.ec;
+      if (a) {
+        for (let h = 0; h < a.length; h++)
+          if (a[h](e, i, c) === !1)
+            return;
+      }
+      s = s.parent;
+    }
+    const l = t.appContext.config.errorHandler;
+    if (l) {
+      Ve(), U(
+        l,
+        null,
+        10,
+        [e, i, c]
+      ), xe();
+      return;
+    }
+  }
+  Yn(e, n, o, r);
+}
+function Yn(e, t, n, r = !0) {
+  if (process.env.NODE_ENV !== "production") {
+    const o = Dt[t];
+    if (n && Un(n), p(`Unhandled error${o ? ` during execution of ${o}` : ""}`), n && Kn(), r)
+      throw e;
+    console.error(e);
+  } else
+    console.error(e);
+}
+let Ne = !1, Fe = !1;
+const b = [];
+let $ = 0;
+const Q = [];
+let y = null, T = 0;
+const Pt = /* @__PURE__ */ Promise.resolve();
+let ke = null;
+const Gn = 100;
+function Bn(e) {
+  const t = ke || Pt;
+  return e ? t.then(this ? e.bind(this) : e) : t;
+}
+function Qn(e) {
+  let t = $ + 1, n = b.length;
+  for (; t < n; ) {
+    const r = t + n >>> 1, o = b[r], s = se(o);
+    s < e || s === e && o.pre ? t = r + 1 : n = r;
+  }
+  return t;
+}
+function et(e) {
+  (!b.length || !b.includes(
+    e,
+    Ne && e.allowRecurse ? $ + 1 : $
+  )) && (e.id == null ? b.push(e) : b.splice(Qn(e.id), 0, e), Tt());
+}
+function Tt() {
+  !Ne && !Fe && (Fe = !0, ke = Pt.then(Mt));
+}
+function $t(e) {
+  d(e) ? Q.push(...e) : (!y || !y.includes(
+    e,
+    e.allowRecurse ? T + 1 : T
+  )) && Q.push(e), Tt();
+}
+function Xn(e) {
+  if (Q.length) {
+    const t = [...new Set(Q)].sort(
+      (n, r) => se(n) - se(r)
+    );
+    if (Q.length = 0, y) {
+      y.push(...t);
+      return;
+    }
+    for (y = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), T = 0; T < y.length; T++)
+      process.env.NODE_ENV !== "production" && jt(e, y[T]) || y[T]();
+    y = null, T = 0;
+  }
+}
+const se = (e) => e.id == null ? 1 / 0 : e.id, Zn = (e, t) => {
+  const n = se(e) - se(t);
+  if (n === 0) {
+    if (e.pre && !t.pre)
+      return -1;
+    if (t.pre && !e.pre)
+      return 1;
+  }
+  return n;
+};
+function Mt(e) {
+  Fe = !1, Ne = !0, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), b.sort(Zn);
+  const t = process.env.NODE_ENV !== "production" ? (n) => jt(e, n) : J;
+  try {
+    for ($ = 0; $ < b.length; $++) {
+      const n = b[$];
+      if (n && n.active !== !1) {
+        if (process.env.NODE_ENV !== "production" && t(n))
+          continue;
+        U(n, null, 14);
+      }
+    }
+  } finally {
+    $ = 0, b.length = 0, Xn(e), Ne = !1, ke = null, (b.length || Q.length) && Mt(e);
+  }
+}
+function jt(e, t) {
+  if (!e.has(t))
+    e.set(t, 1);
+  else {
+    const n = e.get(t);
+    if (n > Gn) {
+      const r = t.ownerInstance, o = r && Wt(r.type);
+      return Ze(
+        `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;
+    } else
+      e.set(t, n + 1);
+  }
+}
+const Z = /* @__PURE__ */ new Set();
+process.env.NODE_ENV !== "production" && (mt().__VUE_HMR_RUNTIME__ = {
+  createRecord: De(kn),
+  rerender: De(er),
+  reload: De(tr)
+});
+const Oe = /* @__PURE__ */ new Map();
+function kn(e, t) {
+  return Oe.has(e) ? !1 : (Oe.set(e, {
+    initialDef: ne(t),
+    instances: /* @__PURE__ */ new Set()
+  }), !0);
+}
+function ne(e) {
+  return Jt(e) ? e.__vccOpts : e;
+}
+function er(e, t) {
+  const n = Oe.get(e);
+  n && (n.initialDef.render = t, [...n.instances].forEach((r) => {
+    t && (r.render = t, ne(r.type).render = t), r.renderCache = [], r.effect.dirty = !0, r.update();
+  }));
+}
+function tr(e, t) {
+  const n = Oe.get(e);
+  if (!n)
+    return;
+  t = ne(t), ut(n.initialDef, t);
+  const r = [...n.instances];
+  for (const o of r) {
+    const s = ne(o.type);
+    Z.has(s) || (s !== n.initialDef && ut(s, t), Z.add(s)), o.appContext.propsCache.delete(o.type), o.appContext.emitsCache.delete(o.type), o.appContext.optionsCache.delete(o.type), o.ceReload ? (Z.add(s), o.ceReload(t.styles), Z.delete(s)) : o.parent ? (o.parent.effect.dirty = !0, et(o.parent.update)) : o.appContext.reload ? o.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn(
+      "[HMR] Root or manually mounted instance modified. Full reload required."
+    );
+  }
+  $t(() => {
+    for (const o of r)
+      Z.delete(
+        ne(o.type)
+      );
+  });
+}
+function ut(e, t) {
+  x(e, t);
+  for (const n in e)
+    n !== "__file" && !(n in t) && delete e[n];
+}
+function De(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, _e = [];
+function At(e, t) {
+  var n, r;
+  q = e, q ? (q.enabled = !0, _e.forEach(({ event: o, args: s }) => q.emit(o, ...s)), _e = []) : /* 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
+  !((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) => {
+    At(s, t);
+  }), setTimeout(() => {
+    q || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, _e = []);
+  }, 3e3)) : _e = [];
+}
+let I = null, nr = null;
+const rr = Symbol.for("v-ndc"), or = (e) => e.__isSuspense;
+function sr(e, t) {
+  t && t.pendingBranch ? d(e) ? t.effects.push(...e) : t.effects.push(e) : $t(e);
+}
+const ir = Symbol.for("v-scx"), cr = () => {
+  {
+    const e = Er(ir);
+    return e || process.env.NODE_ENV !== "production" && p(
+      "Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."
+    ), e;
+  }
+}, ge = {};
+function lr(e, t, {
+  immediate: n,
+  deep: r,
+  flush: o,
+  once: s,
+  onTrack: i,
+  onTrigger: c
+} = P) {
+  if (t && s) {
+    const u = t;
+    t = (...Re) => {
+      u(...Re), Ie();
+    };
+  }
+  process.env.NODE_ENV !== "production" && r !== void 0 && typeof r == "number" && p(
+    'watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.'
+  ), process.env.NODE_ENV !== "production" && !t && (n !== void 0 && p(
+    'watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'
+  ), r !== void 0 && p(
+    'watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'
+  ), s !== void 0 && p(
+    'watch() "once" option is only respected when using the watch(source, callback, options?) signature.'
+  ));
+  const l = (u) => {
+    p(
+      "Invalid watch source: ",
+      u,
+      "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."
+    );
+  }, a = C, h = (u) => r === !0 ? u : (
+    // for deep: false, only traverse root-level properties
+    Y(u, r === !1 ? 1 : void 0)
+  );
+  let _, O = !1, R = !1;
+  if (V(e) ? (_ = () => e.value, O = Ae(e)) : te(e) ? (_ = () => h(e), O = !0) : d(e) ? (R = !0, O = e.some((u) => te(u) || Ae(u)), _ = () => e.map((u) => {
+    if (V(u))
+      return u.value;
+    if (te(u))
+      return h(u);
+    if (E(u))
+      return U(u, a, 2);
+    process.env.NODE_ENV !== "production" && l(u);
+  })) : E(e) ? t ? _ = () => U(e, a, 2) : _ = () => (K && K(), Ee(
+    e,
+    a,
+    3,
+    [ce]
+  )) : (_ = J, process.env.NODE_ENV !== "production" && l(e)), t && r) {
+    const u = _;
+    _ = () => Y(u());
+  }
+  let K, ce = (u) => {
+    K = N.onStop = () => {
+      U(u, a, 4), K = N.onStop = void 0;
+    };
+  }, Ce;
+  if (zt)
+    if (ce = J, t ? n && Ee(t, a, 3, [
+      _(),
+      R ? [] : void 0,
+      ce
+    ]) : _(), o === "sync") {
+      const u = cr();
+      Ce = u.__watcherHandles || (u.__watcherHandles = []);
+    } else
+      return J;
+  let j = R ? new Array(e.length).fill(ge) : ge;
+  const A = () => {
+    if (!(!N.active || !N.dirty))
+      if (t) {
+        const u = N.run();
+        (r || O || (R ? u.some((Re, Yt) => X(Re, j[Yt])) : X(u, j))) && (K && K(), Ee(t, a, 3, [
+          u,
+          // pass undefined as the old value when it's changed for the first time
+          j === ge ? void 0 : R && j[0] === ge ? [] : j,
+          ce
+        ]), j = u);
+      } else
+        N.run();
+  };
+  A.allowRecurse = !!t;
+  let le;
+  o === "sync" ? le = A : o === "post" ? le = () => gt(A, a && a.suspense) : (A.pre = !0, a && (A.id = a.uid), le = () => et(A));
+  const N = new hn(_, J, le), Ie = () => {
+    N.stop();
+  };
+  return process.env.NODE_ENV !== "production" && (N.onTrack = i, N.onTrigger = c), t ? n ? A() : j = N.run() : o === "post" ? gt(
+    N.run.bind(N),
+    a && a.suspense
+  ) : N.run(), Ce && Ce.push(Ie), Ie;
+}
+function ar(e, t, n) {
+  const r = this.proxy, o = v(e) ? e.includes(".") ? ur(r, e) : () => r[e] : e.bind(r, r);
+  let s;
+  E(t) ? s = t : (s = t.handler, n = t);
+  const i = Ir(this), c = lr(o, s.bind(r), n);
+  return i(), c;
+}
+function ur(e, t) {
+  const n = t.split(".");
+  return () => {
+    let r = e;
+    for (let o = 0; o < n.length && r; o++)
+      r = r[n[o]];
+    return r;
+  };
+}
+function Y(e, t = 1 / 0, n) {
+  if (t <= 0 || !S(e) || e.__v_skip || (n = n || /* @__PURE__ */ new Set(), n.has(e)))
+    return e;
+  if (n.add(e), t--, V(e))
+    Y(e.value, t, n);
+  else if (d(e))
+    for (let r = 0; r < e.length; r++)
+      Y(e[r], t, n);
+  else if (en(e) || B(e))
+    e.forEach((r) => {
+      Y(r, t, n);
+    });
+  else if (rn(e))
+    for (const r in e)
+      Y(e[r], t, n);
+  return e;
+}
+const He = (e) => e ? Rr(e) ? Dr(e) || e.proxy : He(e.parent) : null, re = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ x(/* @__PURE__ */ Object.create(null), {
+    $: (e) => e,
+    $el: (e) => e.vnode.el,
+    $data: (e) => e.data,
+    $props: (e) => process.env.NODE_ENV !== "production" ? he(e.props) : e.props,
+    $attrs: (e) => process.env.NODE_ENV !== "production" ? he(e.attrs) : e.attrs,
+    $slots: (e) => process.env.NODE_ENV !== "production" ? he(e.slots) : e.slots,
+    $refs: (e) => process.env.NODE_ENV !== "production" ? he(e.refs) : e.refs,
+    $parent: (e) => He(e.parent),
+    $root: (e) => He(e.root),
+    $emit: (e) => e.emit,
+    $options: (e) => dr(e),
+    $forceUpdate: (e) => e.f || (e.f = () => {
+      e.effect.dirty = !0, et(e.update);
+    }),
+    $nextTick: (e) => e.n || (e.n = Bn.bind(e.proxy)),
+    $watch: (e) => ar.bind(e)
+  })
+), fr = (e) => e === "_" || e === "$", Pe = (e, t) => e !== P && !e.__isScriptSetup && g(e, t), pr = {
+  get({ _: e }, t) {
+    if (t === "__v_skip")
+      return !0;
+    const { ctx: n, setupState: r, data: o, props: s, accessCache: i, type: c, appContext: l } = e;
+    if (process.env.NODE_ENV !== "production" && t === "__isVue")
+      return !0;
+    let a;
+    if (t[0] !== "$") {
+      const R = i[t];
+      if (R !== void 0)
+        switch (R) {
+          case 1:
+            return r[t];
+          case 2:
+            return o[t];
+          case 4:
+            return n[t];
+          case 3:
+            return s[t];
+        }
+      else {
+        if (Pe(r, t))
+          return i[t] = 1, r[t];
+        if (o !== P && g(o, t))
+          return i[t] = 2, o[t];
+        if (
+          // only cache other properties when instance has declared (thus stable)
+          // props
+          (a = e.propsOptions[0]) && g(a, t)
+        )
+          return i[t] = 3, s[t];
+        if (n !== P && g(n, t))
+          return i[t] = 4, n[t];
+        i[t] = 0;
+      }
+    }
+    const h = re[t];
+    let _, O;
+    if (h)
+      return t === "$attrs" ? (m(e.attrs, "get", ""), process.env.NODE_ENV !== "production" && void 0) : process.env.NODE_ENV !== "production" && t === "$slots" && m(e, "get", t), h(e);
+    if (
+      // css module (injected by vue-loader)
+      (_ = c.__cssModules) && (_ = _[t])
+    )
+      return _;
+    if (n !== P && g(n, t))
+      return i[t] = 4, n[t];
+    if (
+      // global properties
+      O = l.config.globalProperties, g(O, t)
+    )
+      return O[t];
+    process.env.NODE_ENV !== "production" && I && (!v(t) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+    // to infinite warning loop
+    t.indexOf("__v") !== 0) && (o !== P && fr(t[0]) && g(o, t) ? p(
+      `Property ${JSON.stringify(
+        t
+      )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+    ) : e === I && p(
+      `Property ${JSON.stringify(t)} was accessed during render but is not defined on instance.`
+    ));
+  },
+  set({ _: e }, t, n) {
+    const { data: r, setupState: o, ctx: s } = e;
+    return Pe(o, t) ? (o[t] = n, !0) : process.env.NODE_ENV !== "production" && o.__isScriptSetup && g(o, t) ? (p(`Cannot mutate <script setup> binding "${t}" from Options API.`), !1) : r !== P && g(r, t) ? (r[t] = n, !0) : g(e.props, t) ? (process.env.NODE_ENV !== "production" && p(`Attempting to mutate prop "${t}". Props are readonly.`), !1) : t[0] === "$" && t.slice(1) in e ? (process.env.NODE_ENV !== "production" && p(
+      `Attempting to mutate public property "${t}". Properties starting with $ are reserved and readonly.`
+    ), !1) : (process.env.NODE_ENV !== "production" && t in e.appContext.config.globalProperties ? Object.defineProperty(s, t, {
+      enumerable: !0,
+      configurable: !0,
+      value: n
+    }) : s[t] = n, !0);
+  },
+  has({
+    _: { data: e, setupState: t, accessCache: n, ctx: r, appContext: o, propsOptions: s }
+  }, i) {
+    let c;
+    return !!n[i] || e !== P && g(e, i) || Pe(t, i) || (c = s[0]) && g(c, i) || g(r, i) || g(re, i) || g(o.config.globalProperties, i);
+  },
+  defineProperty(e, t, n) {
+    return n.get != null ? e._.accessCache[t] = 0 : g(n, "value") && this.set(e, t, n.value, null), Reflect.defineProperty(e, t, n);
+  }
+};
+process.env.NODE_ENV !== "production" && (pr.ownKeys = (e) => (p(
+  "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)));
+function ft(e) {
+  return d(e) ? e.reduce(
+    (t, n) => (t[n] = null, t),
+    {}
+  ) : e;
+}
+function dr(e) {
+  const t = e.type, { mixins: n, extends: r } = t, {
+    mixins: o,
+    optionsCache: s,
+    config: { optionMergeStrategies: i }
+  } = e.appContext, c = s.get(t);
+  let l;
+  return c ? l = c : !o.length && !n && !r ? l = t : (l = {}, o.length && o.forEach(
+    (a) => be(l, a, i, !0)
+  ), be(l, t, i)), S(t) && s.set(t, l), l;
+}
+function be(e, t, n, r = !1) {
+  const { mixins: o, extends: s } = t;
+  s && be(e, s, n, !0), o && o.forEach(
+    (i) => be(e, i, n, !0)
+  );
+  for (const i in t)
+    if (r && i === "expose")
+      process.env.NODE_ENV !== "production" && p(
+        '"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.'
+      );
+    else {
+      const c = hr[i] || n && n[i];
+      e[i] = c ? c(e[i], t[i]) : t[i];
+    }
+  return e;
+}
+const hr = {
+  data: pt,
+  props: ht,
+  emits: ht,
+  // objects
+  methods: k,
+  computed: k,
+  // lifecycle
+  beforeCreate: w,
+  created: w,
+  beforeMount: w,
+  mounted: w,
+  beforeUpdate: w,
+  updated: w,
+  beforeDestroy: w,
+  beforeUnmount: w,
+  destroyed: w,
+  unmounted: w,
+  activated: w,
+  deactivated: w,
+  errorCaptured: w,
+  serverPrefetch: w,
+  // assets
+  components: k,
+  directives: k,
+  // watch
+  watch: gr,
+  // provide / inject
+  provide: pt,
+  inject: _r
+};
+function pt(e, t) {
+  return t ? e ? function() {
+    return x(
+      E(e) ? e.call(this, this) : e,
+      E(t) ? t.call(this, this) : t
+    );
+  } : t : e;
+}
+function _r(e, t) {
+  return k(dt(e), dt(t));
+}
+function dt(e) {
+  if (d(e)) {
+    const t = {};
+    for (let n = 0; n < e.length; n++)
+      t[e[n]] = e[n];
+    return t;
+  }
+  return e;
+}
+function w(e, t) {
+  return e ? [...new Set([].concat(e, t))] : t;
+}
+function k(e, t) {
+  return e ? x(/* @__PURE__ */ Object.create(null), e, t) : t;
+}
+function ht(e, t) {
+  return e ? d(e) && d(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : x(
+    /* @__PURE__ */ Object.create(null),
+    ft(e),
+    ft(t ?? {})
+  ) : t;
+}
+function gr(e, t) {
+  if (!e)
+    return t;
+  if (!t)
+    return e;
+  const n = x(/* @__PURE__ */ Object.create(null), e);
+  for (const r in t)
+    n[r] = w(e[r], t[r]);
+  return n;
+}
+let _t = null;
+function W(e, t) {
+  if (!C)
+    process.env.NODE_ENV !== "production" && p("provide() can only be used inside setup().");
+  else {
+    let n = C.provides;
+    const r = C.parent && C.parent.provides;
+    r === n && (n = C.provides = Object.create(r)), n[e] = t;
+  }
+}
+function Er(e, t, n = !1) {
+  const r = C || I;
+  if (r || _t) {
+    const o = r ? r.parent == null ? r.vnode.appContext && r.vnode.appContext.provides : r.parent.provides : _t._context.provides;
+    if (o && e in o)
+      return o[e];
+    if (arguments.length > 1)
+      return n && E(t) ? t.call(r && r.proxy) : t;
+    process.env.NODE_ENV !== "production" && p(`injection "${String(e)}" not found.`);
+  } else
+    process.env.NODE_ENV !== "production" && p("inject() can only be used inside setup() or functional components.");
+}
+const mr = {}, Lt = (e) => Object.getPrototypeOf(e) === mr, gt = sr, wr = (e) => e.__isTeleport, Ft = Symbol.for("v-fgt"), Nr = Symbol.for("v-txt"), Or = Symbol.for("v-cmt");
+let G = null;
+function br(e) {
+  return e ? e.__v_isVNode === !0 : !1;
+}
+const vr = (...e) => Ut(
+  ...e
+), Ht = ({ key: e }) => e ?? null, me = ({
+  ref: e,
+  ref_key: t,
+  ref_for: n
+}) => (typeof e == "number" && (e = "" + e), e != null ? v(e) || V(e) || E(e) ? { i: I, r: e, k: t, f: !!n } : e : null);
+function Sr(e, t = null, n = null, r = 0, o = null, s = e === Ft ? 0 : 1, i = !1, c = !1) {
+  const l = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e,
+    props: t,
+    key: t && Ht(t),
+    ref: t && me(t),
+    scopeId: nr,
+    slotScopeIds: null,
+    children: n,
+    component: null,
+    suspense: null,
+    ssContent: null,
+    ssFallback: null,
+    dirs: null,
+    transition: null,
+    el: null,
+    anchor: null,
+    target: null,
+    targetAnchor: null,
+    staticCount: 0,
+    shapeFlag: s,
+    patchFlag: r,
+    dynamicProps: o,
+    dynamicChildren: null,
+    appContext: null,
+    ctx: I
+  };
+  return c ? (tt(l, n), s & 128 && e.normalize(l)) : n && (l.shapeFlag |= v(n) ? 8 : 16), process.env.NODE_ENV !== "production" && l.key !== l.key && p("VNode created with invalid key (NaN). VNode type:", l.type), // avoid a block node from tracking itself
+  !i && // has current parent block
+  G && // presence of a patch flag indicates this node needs patching on updates.
+  // component nodes also should always be patched, because even if the
+  // component doesn't need to update, it needs to persist the instance on to
+  // the next vnode so that it can be properly unmounted later.
+  (l.patchFlag > 0 || s & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+  // vnode should not be considered dynamic due to handler caching.
+  l.patchFlag !== 32 && G.push(l), l;
+}
+const Vr = process.env.NODE_ENV !== "production" ? vr : Ut;
+function Ut(e, t = null, n = null, r = 0, o = null, s = !1) {
+  if ((!e || e === rr) && (process.env.NODE_ENV !== "production" && !e && p(`Invalid vnode type when creating vnode: ${e}.`), e = Or), br(e)) {
+    const c = ve(
+      e,
+      t,
+      !0
+      /* mergeRef: true */
+    );
+    return n && tt(c, n), !s && G && (c.shapeFlag & 6 ? G[G.indexOf(e)] = c : G.push(c)), c.patchFlag |= -2, c;
+  }
+  if (Jt(e) && (e = e.__vccOpts), t) {
+    t = xr(t);
+    let { class: c, style: l } = t;
+    c && !v(c) && (t.class = We(c)), S(l) && (Le(l) && !d(l) && (l = x({}, l)), t.style = ze(l));
+  }
+  const i = v(e) ? 1 : or(e) ? 128 : wr(e) ? 64 : S(e) ? 4 : E(e) ? 2 : 0;
+  return process.env.NODE_ENV !== "production" && i & 4 && Le(e) && (e = f(e), p(
+    "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
+  )), Sr(
+    e,
+    t,
+    n,
+    r,
+    o,
+    i,
+    s,
+    !0
+  );
+}
+function xr(e) {
+  return e ? Le(e) || Lt(e) ? x({}, e) : e : null;
+}
+function ve(e, t, n = !1, r = !1) {
+  const { props: o, ref: s, patchFlag: i, children: c, transition: l } = e, a = t ? Cr(o || {}, t) : o, h = {
+    __v_isVNode: !0,
+    __v_skip: !0,
+    type: e.type,
+    props: a,
+    key: a && Ht(a),
+    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 ? d(s) ? s.concat(me(t)) : [s, me(t)] : me(t)
+    ) : s,
+    scopeId: e.scopeId,
+    slotScopeIds: e.slotScopeIds,
+    children: process.env.NODE_ENV !== "production" && i === -1 && d(c) ? c.map(Kt) : c,
+    target: e.target,
+    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 !== Ft ? 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 && ve(e.ssContent),
+    ssFallback: e.ssFallback && ve(e.ssFallback),
+    el: e.el,
+    anchor: e.anchor,
+    ctx: e.ctx,
+    ce: e.ce
+  };
+  return l && r && (h.transition = l.clone(h)), h;
+}
+function Kt(e) {
+  const t = ve(e);
+  return d(e.children) && (t.children = e.children.map(Kt)), t;
+}
+function yr(e = " ", t = 0) {
+  return Vr(Nr, null, e, t);
+}
+function tt(e, t) {
+  let n = 0;
+  const { shapeFlag: r } = e;
+  if (t == null)
+    t = null;
+  else if (d(t))
+    n = 16;
+  else if (typeof t == "object")
+    if (r & 65) {
+      const o = t.default;
+      o && (o._c && (o._d = !1), tt(e, o()), o._c && (o._d = !0));
+      return;
+    } else {
+      n = 32;
+      const o = t._;
+      !o && !Lt(t) ? t._ctx = I : o === 3 && I && (I.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024));
+    }
+  else
+    E(t) ? (t = { default: t, _ctx: I }, n = 32) : (t = String(t), r & 64 ? (n = 16, t = [yr(t)]) : n = 8);
+  e.children = t, e.shapeFlag |= n;
+}
+function Cr(...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 = We([t.class, r.class]));
+      else if (o === "style")
+        t.style = ze([t.style, r.style]);
+      else if (Zt(o)) {
+        const s = t[o], i = r[o];
+        i && s !== i && !(d(s) && s.includes(i)) && (t[o] = s ? [].concat(s, i) : i);
+      } else
+        o !== "" && (t[o] = r[o]);
+  }
+  return t;
+}
+let C = null, Ue;
+{
+  const e = mt(), 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);
+    };
+  };
+  Ue = t(
+    "__VUE_INSTANCE_SETTERS__",
+    (n) => C = n
+  ), t(
+    "__VUE_SSR_SETTERS__",
+    (n) => zt = n
+  );
+}
+const Ir = (e) => {
+  const t = C;
+  return Ue(e), e.scope.on(), () => {
+    e.scope.off(), Ue(t);
+  };
+};
+function Rr(e) {
+  return e.vnode.shapeFlag & 4;
+}
+let zt = !1;
+process.env.NODE_ENV;
+function Dr(e) {
+  if (e.exposed)
+    return e.exposeProxy || (e.exposeProxy = new Proxy(Hn(An(e.exposed)), {
+      get(t, n) {
+        if (n in t)
+          return t[n];
+        if (n in re)
+          return re[n](e);
+      },
+      has(t, n) {
+        return n in t || n in re;
+      }
+    }));
+}
+const Pr = /(?:^|[-_])(\w)/g, Tr = (e) => e.replace(Pr, (t) => t.toUpperCase()).replace(/[-_]/g, "");
+function Wt(e, t = !0) {
+  return E(e) ? e.displayName || e.name : e.name || t && e.__name;
+}
+function qt(e, t, n = !1) {
+  let r = Wt(t);
+  if (!r && t.__file) {
+    const o = t.__file.match(/([^/\\]+)\.\w+$/);
+    o && (r = o[1]);
+  }
+  if (!r && e && e.parent) {
+    const o = (s) => {
+      for (const i in s)
+        if (s[i] === t)
+          return i;
+    };
+    r = o(
+      e.components || e.parent.type.components
+    ) || o(e.appContext.components);
+  }
+  return r ? Tr(r) : n ? "App" : "Anonymous";
+}
+function Jt(e) {
+  return E(e) && "__vccOpts" in e;
+}
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+process.env.NODE_ENV;
+const $r = /* @__PURE__ */ Gt({
+  __name: "ProviderConfig",
+  props: {
+    // onlyoffice配置
+    onlyofficeConfig: {
+      type: Object,
+      default: () => null
+    },
+    // 平台token
+    token: {
+      type: String,
+      default: ""
+    },
+    // 平台用户信息
+    userInfo: {
+      type: Object,
+      default: () => null
+    },
+    // 资源加载地址
+    loadUrl: {
+      type: String,
+      default: ""
+    },
+    // 资源上传地址
+    uploadUrl: {
+      type: String,
+      default: ""
+    },
+    iconConfig: {
+      type: Object,
+      default: () => null
+    }
+  },
+  setup(e) {
+    const t = e;
+    return W("onlyofficeConfig", z(() => t.onlyofficeConfig)), W("token", z(() => t.token)), W("userInfo", z(() => t.userInfo)), W("loadUrl", z(() => t.loadUrl)), W("uploadUrl", z(() => t.uploadUrl)), W("iconConfig", z(() => t.iconConfig)), (n, r) => Bt(n.$slots, "default");
+  }
+}), jr = Qt($r);
+export {
+  jr as IkProviderConfig,
+  jr as default
+};