diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts index 669a793..9ab3784 100644 --- a/frontend/vite.config.ts +++ b/frontend/vite.config.ts @@ -20,6 +20,7 @@ export default defineConfig({ plugins: [vue()], define: { __APP_VERSION__: JSON.stringify(APP_VERSION), + 'process.env.NODE_ENV': JSON.stringify('production'), }, test: { globals: true, @@ -41,12 +42,7 @@ export default defineConfig({ // ComfyUI scripts (relative from js/ output dir) '../../scripts/app.js', '../../scripts/api.js', - // Runtime-provided dependencies - 'vue', - 'vue-i18n', - 'pinia', - /^primevue\/?.*/, - /^@primevue\/themes\/?.*/, + // Vue and dependencies are now bundled (import map removed in ComfyUI frontend v1.33.9+) ], output: { dir: '../js', diff --git a/js/comfygit-panel.js b/js/comfygit-panel.js index dc4e1e8..fd8839f 100644 --- a/js/comfygit-panel.js +++ b/js/comfygit-panel.js @@ -1,44 +1,4851 @@ -import { app as Ft } from "../../scripts/app.js"; -import { defineComponent as te, createElementBlock as o, openBlock as s, createCommentVNode as r, createElementVNode as e, renderSlot as Te, createBlock as P, resolveDynamicComponent as Ns, normalizeClass as fe, withCtx as l, toDisplayString as a, createVNode as _, createTextVNode as h, computed as L, Fragment as W, renderList as ae, normalizeStyle as Lt, ref as y, onMounted as Oe, watch as ut, Teleport as et, withModifiers as Be, Transition as Po, createSlots as Kt, withKeys as wt, reactive as ms, onUnmounted as Cs, readonly as To, unref as Se, withDirectives as Re, vModelText as kt, vModelRadio as Tt, vModelCheckbox as ks, nextTick as As, vModelSelect as Dt, vModelDynamic as xs, TransitionGroup as Ro, createApp as Bs, h as Fs } from "vue"; -const Mo = { class: "panel-layout" }, Do = { +import { app as Ds } from "../../scripts/app.js"; +/** +* @vue/shared v3.5.24 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +// @__NO_SIDE_EFFECTS__ +function Sa(e) { + const t = /* @__PURE__ */ Object.create(null); + for (const o of e.split(",")) t[o] = 1; + return (o) => o in t; +} +const et = {}, lo = [], fs = () => { +}, Jl = () => !1, Pn = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter +(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), Ia = (e) => e.startsWith("onUpdate:"), mt = Object.assign, Ea = (e, t) => { + const o = e.indexOf(t); + o > -1 && e.splice(o, 1); +}, zr = Object.prototype.hasOwnProperty, Xe = (e, t) => zr.call(e, t), Ae = Array.isArray, io = (e) => qo(e) === "[object Map]", go = (e) => qo(e) === "[object Set]", tl = (e) => qo(e) === "[object Date]", ze = (e) => typeof e == "function", it = (e) => typeof e == "string", Zt = (e) => typeof e == "symbol", Ze = (e) => e !== null && typeof e == "object", Xl = (e) => (Ze(e) || ze(e)) && ze(e.then) && ze(e.catch), Ql = Object.prototype.toString, qo = (e) => Ql.call(e), Fr = (e) => qo(e).slice(8, -1), Zl = (e) => qo(e) === "[object Object]", Ta = (e) => it(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, Po = /* @__PURE__ */ Sa( + // the leading comma is intentional so empty string "" is also included + ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" +), Rn = (e) => { + const t = /* @__PURE__ */ Object.create(null); + return ((o) => t[o] || (t[o] = e(o))); +}, Br = /-\w/g, Vt = Rn( + (e) => e.replace(Br, (t) => t.slice(1).toUpperCase()) +), Vr = /\B([A-Z])/g, Us = Rn( + (e) => e.replace(Vr, "-$1").toLowerCase() +), Mn = Rn((e) => e.charAt(0).toUpperCase() + e.slice(1)), jn = Rn( + (e) => e ? `on${Mn(e)}` : "" +), Ls = (e, t) => !Object.is(e, t), un = (e, ...t) => { + for (let o = 0; o < e.length; o++) + e[o](...t); +}, ei = (e, t, o, n = !1) => { + Object.defineProperty(e, t, { + configurable: !0, + enumerable: !1, + writable: n, + value: o + }); +}, Dn = (e) => { + const t = parseFloat(e); + return isNaN(t) ? e : t; +}, Wr = (e) => { + const t = it(e) ? Number(e) : NaN; + return isNaN(t) ? e : t; +}; +let sl; +const Ln = () => sl || (sl = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {}); +function Wt(e) { + if (Ae(e)) { + const t = {}; + for (let o = 0; o < e.length; o++) { + const n = e[o], l = it(n) ? Kr(n) : Wt(n); + if (l) + for (const i in l) + t[i] = l[i]; + } + return t; + } else if (it(e) || Ze(e)) + return e; +} +const Gr = /;(?![^(]*\))/g, jr = /:([^]+)/, Hr = /\/\*[^]*?\*\//g; +function Kr(e) { + const t = {}; + return e.replace(Hr, "").split(Gr).forEach((o) => { + if (o) { + const n = o.split(jr); + n.length > 1 && (t[n[0].trim()] = n[1].trim()); + } + }), t; +} +function xe(e) { + let t = ""; + if (it(e)) + t = e; + else if (Ae(e)) + for (let o = 0; o < e.length; o++) { + const n = xe(e[o]); + n && (t += n + " "); + } + else if (Ze(e)) + for (const o in e) + e[o] && (t += o + " "); + return t.trim(); +} +const qr = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", Yr = /* @__PURE__ */ Sa(qr); +function ti(e) { + return !!e || e === ""; +} +function Jr(e, t) { + if (e.length !== t.length) return !1; + let o = !0; + for (let n = 0; o && n < e.length; n++) + o = Js(e[n], t[n]); + return o; +} +function Js(e, t) { + if (e === t) return !0; + let o = tl(e), n = tl(t); + if (o || n) + return o && n ? e.getTime() === t.getTime() : !1; + if (o = Zt(e), n = Zt(t), o || n) + return e === t; + if (o = Ae(e), n = Ae(t), o || n) + return o && n ? Jr(e, t) : !1; + if (o = Ze(e), n = Ze(t), o || n) { + if (!o || !n) + return !1; + const l = Object.keys(e).length, i = Object.keys(t).length; + if (l !== i) + return !1; + for (const r in e) { + const u = e.hasOwnProperty(r), d = t.hasOwnProperty(r); + if (u && !d || !u && d || !Js(e[r], t[r])) + return !1; + } + } + return String(e) === String(t); +} +function Pa(e, t) { + return e.findIndex((o) => Js(o, t)); +} +const si = (e) => !!(e && e.__v_isRef === !0), f = (e) => it(e) ? e : e == null ? "" : Ae(e) || Ze(e) && (e.toString === Ql || !ze(e.toString)) ? si(e) ? f(e.value) : JSON.stringify(e, oi, 2) : String(e), oi = (e, t) => si(t) ? oi(e, t.value) : io(t) ? { + [`Map(${t.size})`]: [...t.entries()].reduce( + (o, [n, l], i) => (o[Hn(n, i) + " =>"] = l, o), + {} + ) +} : go(t) ? { + [`Set(${t.size})`]: [...t.values()].map((o) => Hn(o)) +} : Zt(t) ? Hn(t) : Ze(t) && !Ae(t) && !Zl(t) ? String(t) : t, Hn = (e, t = "") => { + var o; + return ( + // Symbol.description in es2019+ so we need to cast here to pass + // the lib: es2016 check + Zt(e) ? `Symbol(${(o = e.description) != null ? o : t})` : e + ); +}; +/** +* @vue/reactivity v3.5.24 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +let Dt; +class Xr { + constructor(t = !1) { + this.detached = t, this._active = !0, this._on = 0, this.effects = [], this.cleanups = [], this._isPaused = !1, this.parent = Dt, !t && Dt && (this.index = (Dt.scopes || (Dt.scopes = [])).push( + this + ) - 1); + } + get active() { + return this._active; + } + pause() { + if (this._active) { + this._isPaused = !0; + let t, o; + if (this.scopes) + for (t = 0, o = this.scopes.length; t < o; t++) + this.scopes[t].pause(); + for (t = 0, o = this.effects.length; t < o; t++) + this.effects[t].pause(); + } + } + /** + * Resumes the effect scope, including all child scopes and effects. + */ + resume() { + if (this._active && this._isPaused) { + this._isPaused = !1; + let t, o; + if (this.scopes) + for (t = 0, o = this.scopes.length; t < o; t++) + this.scopes[t].resume(); + for (t = 0, o = this.effects.length; t < o; t++) + this.effects[t].resume(); + } + } + run(t) { + if (this._active) { + const o = Dt; + try { + return Dt = this, t(); + } finally { + Dt = o; + } + } + } + /** + * This should only be called on non-detached scopes + * @internal + */ + on() { + ++this._on === 1 && (this.prevScope = Dt, Dt = this); + } + /** + * This should only be called on non-detached scopes + * @internal + */ + off() { + this._on > 0 && --this._on === 0 && (Dt = this.prevScope, this.prevScope = void 0); + } + stop(t) { + if (this._active) { + this._active = !1; + let o, n; + for (o = 0, n = this.effects.length; o < n; o++) + this.effects[o].stop(); + for (this.effects.length = 0, o = 0, n = this.cleanups.length; o < n; o++) + this.cleanups[o](); + if (this.cleanups.length = 0, this.scopes) { + for (o = 0, n = this.scopes.length; o < n; o++) + this.scopes[o].stop(!0); + this.scopes.length = 0; + } + if (!this.detached && this.parent && !t) { + const l = this.parent.scopes.pop(); + l && l !== this && (this.parent.scopes[this.index] = l, l.index = this.index); + } + this.parent = void 0; + } + } +} +function Qr() { + return Dt; +} +let st; +const Kn = /* @__PURE__ */ new WeakSet(); +class ni { + constructor(t) { + this.fn = t, this.deps = void 0, this.depsTail = void 0, this.flags = 5, this.next = void 0, this.cleanup = void 0, this.scheduler = void 0, Dt && Dt.active && Dt.effects.push(this); + } + pause() { + this.flags |= 64; + } + resume() { + this.flags & 64 && (this.flags &= -65, Kn.has(this) && (Kn.delete(this), this.trigger())); + } + /** + * @internal + */ + notify() { + this.flags & 2 && !(this.flags & 32) || this.flags & 8 || li(this); + } + run() { + if (!(this.flags & 1)) + return this.fn(); + this.flags |= 2, ol(this), ii(this); + const t = st, o = Jt; + st = this, Jt = !0; + try { + return this.fn(); + } finally { + ri(this), st = t, Jt = o, this.flags &= -3; + } + } + stop() { + if (this.flags & 1) { + for (let t = this.deps; t; t = t.nextDep) + Da(t); + this.deps = this.depsTail = void 0, ol(this), this.onStop && this.onStop(), this.flags &= -2; + } + } + trigger() { + this.flags & 64 ? Kn.add(this) : this.scheduler ? this.scheduler() : this.runIfDirty(); + } + /** + * @internal + */ + runIfDirty() { + ua(this) && this.run(); + } + get dirty() { + return ua(this); + } +} +let ai = 0, Ro, Mo; +function li(e, t = !1) { + if (e.flags |= 8, t) { + e.next = Mo, Mo = e; + return; + } + e.next = Ro, Ro = e; +} +function Ra() { + ai++; +} +function Ma() { + if (--ai > 0) + return; + if (Mo) { + let t = Mo; + for (Mo = void 0; t; ) { + const o = t.next; + t.next = void 0, t.flags &= -9, t = o; + } + } + let e; + for (; Ro; ) { + let t = Ro; + for (Ro = void 0; t; ) { + const o = t.next; + if (t.next = void 0, t.flags &= -9, t.flags & 1) + try { + t.trigger(); + } catch (n) { + e || (e = n); + } + t = o; + } + } + if (e) throw e; +} +function ii(e) { + for (let t = e.deps; t; t = t.nextDep) + t.version = -1, t.prevActiveLink = t.dep.activeLink, t.dep.activeLink = t; +} +function ri(e) { + let t, o = e.depsTail, n = o; + for (; n; ) { + const l = n.prevDep; + n.version === -1 ? (n === o && (o = l), Da(n), Zr(n)) : t = n, n.dep.activeLink = n.prevActiveLink, n.prevActiveLink = void 0, n = l; + } + e.deps = t, e.depsTail = o; +} +function ua(e) { + for (let t = e.deps; t; t = t.nextDep) + if (t.dep.version !== t.version || t.dep.computed && (ci(t.dep.computed) || t.dep.version !== t.version)) + return !0; + return !!e._dirty; +} +function ci(e) { + if (e.flags & 4 && !(e.flags & 16) || (e.flags &= -17, e.globalVersion === Fo) || (e.globalVersion = Fo, !e.isSSR && e.flags & 128 && (!e.deps && !e._dirty || !ua(e)))) + return; + e.flags |= 2; + const t = e.dep, o = st, n = Jt; + st = e, Jt = !0; + try { + ii(e); + const l = e.fn(e._value); + (t.version === 0 || Ls(l, e._value)) && (e.flags |= 128, e._value = l, t.version++); + } catch (l) { + throw t.version++, l; + } finally { + st = o, Jt = n, ri(e), e.flags &= -3; + } +} +function Da(e, t = !1) { + const { dep: o, prevSub: n, nextSub: l } = e; + if (n && (n.nextSub = l, e.prevSub = void 0), l && (l.prevSub = n, e.nextSub = void 0), o.subs === e && (o.subs = n, !n && o.computed)) { + o.computed.flags &= -5; + for (let i = o.computed.deps; i; i = i.nextDep) + Da(i, !0); + } + !t && !--o.sc && o.map && o.map.delete(o.key); +} +function Zr(e) { + const { prevDep: t, nextDep: o } = e; + t && (t.nextDep = o, e.prevDep = void 0), o && (o.prevDep = t, e.nextDep = void 0); +} +let Jt = !0; +const ui = []; +function $s() { + ui.push(Jt), Jt = !1; +} +function Cs() { + const e = ui.pop(); + Jt = e === void 0 ? !0 : e; +} +function ol(e) { + const { cleanup: t } = e; + if (e.cleanup = void 0, t) { + const o = st; + st = void 0; + try { + t(); + } finally { + st = o; + } + } +} +let Fo = 0; +class ec { + constructor(t, o) { + this.sub = t, this.dep = o, this.version = o.version, this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0; + } +} +class La { + // 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; + } + track(t) { + if (!st || !Jt || st === this.computed) + return; + let o = this.activeLink; + if (o === void 0 || o.sub !== st) + o = this.activeLink = new ec(st, this), st.deps ? (o.prevDep = st.depsTail, st.depsTail.nextDep = o, st.depsTail = o) : st.deps = st.depsTail = o, di(o); + else if (o.version === -1 && (o.version = this.version, o.nextDep)) { + const n = o.nextDep; + n.prevDep = o.prevDep, o.prevDep && (o.prevDep.nextDep = n), o.prevDep = st.depsTail, o.nextDep = void 0, st.depsTail.nextDep = o, st.depsTail = o, st.deps === o && (st.deps = n); + } + return o; + } + trigger(t) { + this.version++, Fo++, this.notify(t); + } + notify(t) { + Ra(); + try { + for (let o = this.subs; o; o = o.prevSub) + o.sub.notify() && o.sub.dep.notify(); + } finally { + Ma(); + } + } +} +function di(e) { + if (e.dep.sc++, e.sub.flags & 4) { + const t = e.dep.computed; + if (t && !e.dep.subs) { + t.flags |= 20; + for (let n = t.deps; n; n = n.nextDep) + di(n); + } + const o = e.dep.subs; + o !== e && (e.prevSub = o, o && (o.nextSub = e)), e.dep.subs = e; + } +} +const da = /* @__PURE__ */ new WeakMap(), Ys = Symbol( + "" +), fa = Symbol( + "" +), Bo = Symbol( + "" +); +function _t(e, t, o) { + if (Jt && st) { + let n = da.get(e); + n || da.set(e, n = /* @__PURE__ */ new Map()); + let l = n.get(o); + l || (n.set(o, l = new La()), l.map = n, l.key = o), l.track(); + } +} +function bs(e, t, o, n, l, i) { + const r = da.get(e); + if (!r) { + Fo++; + return; + } + const u = (d) => { + d && d.trigger(); + }; + if (Ra(), t === "clear") + r.forEach(u); + else { + const d = Ae(e), m = d && Ta(o); + if (d && o === "length") { + const v = Number(n); + r.forEach((h, w) => { + (w === "length" || w === Bo || !Zt(w) && w >= v) && u(h); + }); + } else + switch ((o !== void 0 || r.has(void 0)) && u(r.get(o)), m && u(r.get(Bo)), t) { + case "add": + d ? m && u(r.get("length")) : (u(r.get(Ys)), io(e) && u(r.get(fa))); + break; + case "delete": + d || (u(r.get(Ys)), io(e) && u(r.get(fa))); + break; + case "set": + io(e) && u(r.get(Ys)); + break; + } + } + Ma(); +} +function eo(e) { + const t = Ye(e); + return t === e ? t : (_t(t, "iterate", Bo), Ft(e) ? t : t.map(gt)); +} +function On(e) { + return _t(e = Ye(e), "iterate", Bo), e; +} +const tc = { + __proto__: null, + [Symbol.iterator]() { + return qn(this, Symbol.iterator, gt); + }, + concat(...e) { + return eo(this).concat( + ...e.map((t) => Ae(t) ? eo(t) : t) + ); + }, + entries() { + return qn(this, "entries", (e) => (e[1] = gt(e[1]), e)); + }, + every(e, t) { + return hs(this, "every", e, t, void 0, arguments); + }, + filter(e, t) { + return hs(this, "filter", e, t, (o) => o.map(gt), arguments); + }, + find(e, t) { + return hs(this, "find", e, t, gt, arguments); + }, + findIndex(e, t) { + return hs(this, "findIndex", e, t, void 0, arguments); + }, + findLast(e, t) { + return hs(this, "findLast", e, t, gt, arguments); + }, + findLastIndex(e, t) { + return hs(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 hs(this, "forEach", e, t, void 0, arguments); + }, + includes(...e) { + return Yn(this, "includes", e); + }, + indexOf(...e) { + return Yn(this, "indexOf", e); + }, + join(e) { + return eo(this).join(e); + }, + // keys() iterator only reads `length`, no optimization required + lastIndexOf(...e) { + return Yn(this, "lastIndexOf", e); + }, + map(e, t) { + return hs(this, "map", e, t, void 0, arguments); + }, + pop() { + return $o(this, "pop"); + }, + push(...e) { + return $o(this, "push", e); + }, + reduce(e, ...t) { + return nl(this, "reduce", e, t); + }, + reduceRight(e, ...t) { + return nl(this, "reduceRight", e, t); + }, + shift() { + return $o(this, "shift"); + }, + // slice could use ARRAY_ITERATE but also seems to beg for range tracking + some(e, t) { + return hs(this, "some", e, t, void 0, arguments); + }, + splice(...e) { + return $o(this, "splice", e); + }, + toReversed() { + return eo(this).toReversed(); + }, + toSorted(e) { + return eo(this).toSorted(e); + }, + toSpliced(...e) { + return eo(this).toSpliced(...e); + }, + unshift(...e) { + return $o(this, "unshift", e); + }, + values() { + return qn(this, "values", gt); + } +}; +function qn(e, t, o) { + const n = On(e), l = n[t](); + return n !== e && !Ft(e) && (l._next = l.next, l.next = () => { + const i = l._next(); + return i.done || (i.value = o(i.value)), i; + }), l; +} +const sc = Array.prototype; +function hs(e, t, o, n, l, i) { + const r = On(e), u = r !== e && !Ft(e), d = r[t]; + if (d !== sc[t]) { + const h = d.apply(e, i); + return u ? gt(h) : h; + } + let m = o; + r !== e && (u ? m = function(h, w) { + return o.call(this, gt(h), w, e); + } : o.length > 2 && (m = function(h, w) { + return o.call(this, h, w, e); + })); + const v = d.call(r, m, n); + return u && l ? l(v) : v; +} +function nl(e, t, o, n) { + const l = On(e); + let i = o; + return l !== e && (Ft(e) ? o.length > 3 && (i = function(r, u, d) { + return o.call(this, r, u, d, e); + }) : i = function(r, u, d) { + return o.call(this, r, gt(u), d, e); + }), l[t](i, ...n); +} +function Yn(e, t, o) { + const n = Ye(e); + _t(n, "iterate", Bo); + const l = n[t](...o); + return (l === -1 || l === !1) && Aa(o[0]) ? (o[0] = Ye(o[0]), n[t](...o)) : l; +} +function $o(e, t, o = []) { + $s(), Ra(); + const n = Ye(e)[t].apply(e, o); + return Ma(), Cs(), n; +} +const oc = /* @__PURE__ */ Sa("__proto__,__v_isRef,__isVue"), fi = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(Zt) +); +function nc(e) { + Zt(e) || (e = String(e)); + const t = Ye(this); + return _t(t, "has", e), t.hasOwnProperty(e); +} +class mi { + constructor(t = !1, o = !1) { + this._isReadonly = t, this._isShallow = o; + } + get(t, o, n) { + if (o === "__v_skip") return t.__v_skip; + const l = this._isReadonly, i = this._isShallow; + if (o === "__v_isReactive") + return !l; + if (o === "__v_isReadonly") + return l; + if (o === "__v_isShallow") + return i; + if (o === "__v_raw") + return n === (l ? i ? vc : hi : i ? gi : pi).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(n) ? t : void 0; + const r = Ae(t); + if (!l) { + let d; + if (r && (d = tc[o])) + return d; + if (o === "hasOwnProperty") + return nc; + } + const u = Reflect.get( + t, + o, + // 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 + Ct(t) ? t : n + ); + if ((Zt(o) ? fi.has(o) : oc(o)) || (l || _t(t, "get", o), i)) + return u; + if (Ct(u)) { + const d = r && Ta(o) ? u : u.value; + return l && Ze(d) ? hn(d) : d; + } + return Ze(u) ? l ? hn(u) : zs(u) : u; + } +} +class vi extends mi { + constructor(t = !1) { + super(!1, t); + } + set(t, o, n, l) { + let i = t[o]; + if (!this._isShallow) { + const d = Os(i); + if (!Ft(n) && !Os(n) && (i = Ye(i), n = Ye(n)), !Ae(t) && Ct(i) && !Ct(n)) + return d || (i.value = n), !0; + } + const r = Ae(t) && Ta(o) ? Number(o) < t.length : Xe(t, o), u = Reflect.set( + t, + o, + n, + Ct(t) ? t : l + ); + return t === Ye(l) && (r ? Ls(n, i) && bs(t, "set", o, n) : bs(t, "add", o, n)), u; + } + deleteProperty(t, o) { + const n = Xe(t, o); + t[o]; + const l = Reflect.deleteProperty(t, o); + return l && n && bs(t, "delete", o, void 0), l; + } + has(t, o) { + const n = Reflect.has(t, o); + return (!Zt(o) || !fi.has(o)) && _t(t, "has", o), n; + } + ownKeys(t) { + return _t( + t, + "iterate", + Ae(t) ? "length" : Ys + ), Reflect.ownKeys(t); + } +} +class ac extends mi { + constructor(t = !1) { + super(!0, t); + } + set(t, o) { + return !0; + } + deleteProperty(t, o) { + return !0; + } +} +const lc = /* @__PURE__ */ new vi(), ic = /* @__PURE__ */ new ac(), rc = /* @__PURE__ */ new vi(!0); +const ma = (e) => e, en = (e) => Reflect.getPrototypeOf(e); +function cc(e, t, o) { + return function(...n) { + const l = this.__v_raw, i = Ye(l), r = io(i), u = e === "entries" || e === Symbol.iterator && r, d = e === "keys" && r, m = l[e](...n), v = o ? ma : t ? yn : gt; + return !t && _t( + i, + "iterate", + d ? fa : Ys + ), { + // iterator protocol + next() { + const { value: h, done: w } = m.next(); + return w ? { value: h, done: w } : { + value: u ? [v(h[0]), v(h[1])] : v(h), + done: w + }; + }, + // iterable protocol + [Symbol.iterator]() { + return this; + } + }; + }; +} +function tn(e) { + return function(...t) { + return e === "delete" ? !1 : e === "clear" ? void 0 : this; + }; +} +function uc(e, t) { + const o = { + get(l) { + const i = this.__v_raw, r = Ye(i), u = Ye(l); + e || (Ls(l, u) && _t(r, "get", l), _t(r, "get", u)); + const { has: d } = en(r), m = t ? ma : e ? yn : gt; + if (d.call(r, l)) + return m(i.get(l)); + if (d.call(r, u)) + return m(i.get(u)); + i !== r && i.get(l); + }, + get size() { + const l = this.__v_raw; + return !e && _t(Ye(l), "iterate", Ys), l.size; + }, + has(l) { + const i = this.__v_raw, r = Ye(i), u = Ye(l); + return e || (Ls(l, u) && _t(r, "has", l), _t(r, "has", u)), l === u ? i.has(l) : i.has(l) || i.has(u); + }, + forEach(l, i) { + const r = this, u = r.__v_raw, d = Ye(u), m = t ? ma : e ? yn : gt; + return !e && _t(d, "iterate", Ys), u.forEach((v, h) => l.call(i, m(v), m(h), r)); + } + }; + return mt( + o, + e ? { + add: tn("add"), + set: tn("set"), + delete: tn("delete"), + clear: tn("clear") + } : { + add(l) { + !t && !Ft(l) && !Os(l) && (l = Ye(l)); + const i = Ye(this); + return en(i).has.call(i, l) || (i.add(l), bs(i, "add", l, l)), this; + }, + set(l, i) { + !t && !Ft(i) && !Os(i) && (i = Ye(i)); + const r = Ye(this), { has: u, get: d } = en(r); + let m = u.call(r, l); + m || (l = Ye(l), m = u.call(r, l)); + const v = d.call(r, l); + return r.set(l, i), m ? Ls(i, v) && bs(r, "set", l, i) : bs(r, "add", l, i), this; + }, + delete(l) { + const i = Ye(this), { has: r, get: u } = en(i); + let d = r.call(i, l); + d || (l = Ye(l), d = r.call(i, l)), u && u.call(i, l); + const m = i.delete(l); + return d && bs(i, "delete", l, void 0), m; + }, + clear() { + const l = Ye(this), i = l.size !== 0, r = l.clear(); + return i && bs( + l, + "clear", + void 0, + void 0 + ), r; + } + } + ), [ + "keys", + "values", + "entries", + Symbol.iterator + ].forEach((l) => { + o[l] = cc(l, e, t); + }), o; +} +function Oa(e, t) { + const o = uc(e, t); + return (n, l, i) => l === "__v_isReactive" ? !e : l === "__v_isReadonly" ? e : l === "__v_raw" ? n : Reflect.get( + Xe(o, l) && l in n ? o : n, + l, + i + ); +} +const dc = { + get: /* @__PURE__ */ Oa(!1, !1) +}, fc = { + get: /* @__PURE__ */ Oa(!1, !0) +}, mc = { + get: /* @__PURE__ */ Oa(!0, !1) +}; +const pi = /* @__PURE__ */ new WeakMap(), gi = /* @__PURE__ */ new WeakMap(), hi = /* @__PURE__ */ new WeakMap(), vc = /* @__PURE__ */ new WeakMap(); +function pc(e) { + switch (e) { + case "Object": + case "Array": + return 1; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": + return 2; + default: + return 0; + } +} +function gc(e) { + return e.__v_skip || !Object.isExtensible(e) ? 0 : pc(Fr(e)); +} +function zs(e) { + return Os(e) ? e : Na( + e, + !1, + lc, + dc, + pi + ); +} +function hc(e) { + return Na( + e, + !1, + rc, + fc, + gi + ); +} +function hn(e) { + return Na( + e, + !0, + ic, + mc, + hi + ); +} +function Na(e, t, o, n, l) { + if (!Ze(e) || e.__v_raw && !(t && e.__v_isReactive)) + return e; + const i = gc(e); + if (i === 0) + return e; + const r = l.get(e); + if (r) + return r; + const u = new Proxy( + e, + i === 2 ? n : o + ); + return l.set(e, u), u; +} +function ro(e) { + return Os(e) ? ro(e.__v_raw) : !!(e && e.__v_isReactive); +} +function Os(e) { + return !!(e && e.__v_isReadonly); +} +function Ft(e) { + return !!(e && e.__v_isShallow); +} +function Aa(e) { + return e ? !!e.__v_raw : !1; +} +function Ye(e) { + const t = e && e.__v_raw; + return t ? Ye(t) : e; +} +function yc(e) { + return !Xe(e, "__v_skip") && Object.isExtensible(e) && ei(e, "__v_skip", !0), e; +} +const gt = (e) => Ze(e) ? zs(e) : e, yn = (e) => Ze(e) ? hn(e) : e; +function Ct(e) { + return e ? e.__v_isRef === !0 : !1; +} +function k(e) { + return wc(e, !1); +} +function wc(e, t) { + return Ct(e) ? e : new bc(e, t); +} +class bc { + constructor(t, o) { + this.dep = new La(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = o ? t : Ye(t), this._value = o ? t : gt(t), this.__v_isShallow = o; + } + get value() { + return this.dep.track(), this._value; + } + set value(t) { + const o = this._rawValue, n = this.__v_isShallow || Ft(t) || Os(t); + t = n ? t : Ye(t), Ls(t, o) && (this._rawValue = t, this._value = n ? t : gt(t), this.dep.trigger()); + } +} +function Ue(e) { + return Ct(e) ? e.value : e; +} +const _c = { + get: (e, t, o) => t === "__v_raw" ? e : Ue(Reflect.get(e, t, o)), + set: (e, t, o, n) => { + const l = e[t]; + return Ct(l) && !Ct(o) ? (l.value = o, !0) : Reflect.set(e, t, o, n); + } +}; +function yi(e) { + return ro(e) ? e : new Proxy(e, _c); +} +class kc { + constructor(t, o, n) { + this.fn = t, this.setter = o, this._value = void 0, this.dep = new La(this), this.__v_isRef = !0, this.deps = void 0, this.depsTail = void 0, this.flags = 16, this.globalVersion = Fo - 1, this.next = void 0, this.effect = this, this.__v_isReadonly = !o, this.isSSR = n; + } + /** + * @internal + */ + notify() { + if (this.flags |= 16, !(this.flags & 8) && // avoid infinite self recursion + st !== this) + return li(this, !0), !0; + } + get value() { + const t = this.dep.track(); + return ci(this), t && (t.version = this.dep.version), this._value; + } + set value(t) { + this.setter && this.setter(t); + } +} +function $c(e, t, o = !1) { + let n, l; + return ze(e) ? n = e : (n = e.get, l = e.set), new kc(n, l, o); +} +const sn = {}, wn = /* @__PURE__ */ new WeakMap(); +let Ks; +function Cc(e, t = !1, o = Ks) { + if (o) { + let n = wn.get(o); + n || wn.set(o, n = []), n.push(e); + } +} +function xc(e, t, o = et) { + const { immediate: n, deep: l, once: i, scheduler: r, augmentJob: u, call: d } = o, m = (S) => l ? S : Ft(S) || l === !1 || l === 0 ? _s(S, 1) : _s(S); + let v, h, w, p, _ = !1, x = !1; + if (Ct(e) ? (h = () => e.value, _ = Ft(e)) : ro(e) ? (h = () => m(e), _ = !0) : Ae(e) ? (x = !0, _ = e.some((S) => ro(S) || Ft(S)), h = () => e.map((S) => { + if (Ct(S)) + return S.value; + if (ro(S)) + return m(S); + if (ze(S)) + return d ? d(S, 2) : S(); + })) : ze(e) ? t ? h = d ? () => d(e, 2) : e : h = () => { + if (w) { + $s(); + try { + w(); + } finally { + Cs(); + } + } + const S = Ks; + Ks = v; + try { + return d ? d(e, 3, [p]) : e(p); + } finally { + Ks = S; + } + } : h = fs, t && l) { + const S = h, q = l === !0 ? 1 / 0 : l; + h = () => _s(S(), q); + } + const $ = Qr(), P = () => { + v.stop(), $ && $.active && Ea($.effects, v); + }; + if (i && t) { + const S = t; + t = (...q) => { + S(...q), P(); + }; + } + let N = x ? new Array(e.length).fill(sn) : sn; + const T = (S) => { + if (!(!(v.flags & 1) || !v.dirty && !S)) + if (t) { + const q = v.run(); + if (l || _ || (x ? q.some((B, A) => Ls(B, N[A])) : Ls(q, N))) { + w && w(); + const B = Ks; + Ks = v; + try { + const A = [ + q, + // pass undefined as the old value when it's changed for the first time + N === sn ? void 0 : x && N[0] === sn ? [] : N, + p + ]; + N = q, d ? d(t, 3, A) : ( + // @ts-expect-error + t(...A) + ); + } finally { + Ks = B; + } + } + } else + v.run(); + }; + return u && u(T), v = new ni(h), v.scheduler = r ? () => r(T, !1) : T, p = (S) => Cc(S, !1, v), w = v.onStop = () => { + const S = wn.get(v); + if (S) { + if (d) + d(S, 4); + else + for (const q of S) q(); + wn.delete(v); + } + }, t ? n ? T(!0) : N = v.run() : r ? r(T.bind(null, !0), !0) : v.run(), P.pause = v.pause.bind(v), P.resume = v.resume.bind(v), P.stop = P, P; +} +function _s(e, t = 1 / 0, o) { + if (t <= 0 || !Ze(e) || e.__v_skip || (o = o || /* @__PURE__ */ new Map(), (o.get(e) || 0) >= t)) + return e; + if (o.set(e, t), t--, Ct(e)) + _s(e.value, t, o); + else if (Ae(e)) + for (let n = 0; n < e.length; n++) + _s(e[n], t, o); + else if (go(e) || io(e)) + e.forEach((n) => { + _s(n, t, o); + }); + else if (Zl(e)) { + for (const n in e) + _s(e[n], t, o); + for (const n of Object.getOwnPropertySymbols(e)) + Object.prototype.propertyIsEnumerable.call(e, n) && _s(e[n], t, o); + } + return e; +} +/** +* @vue/runtime-core v3.5.24 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +function Yo(e, t, o, n) { + try { + return n ? e(...n) : e(); + } catch (l) { + Nn(l, t, o); + } +} +function es(e, t, o, n) { + if (ze(e)) { + const l = Yo(e, t, o, n); + return l && Xl(l) && l.catch((i) => { + Nn(i, t, o); + }), l; + } + if (Ae(e)) { + const l = []; + for (let i = 0; i < e.length; i++) + l.push(es(e[i], t, o, n)); + return l; + } +} +function Nn(e, t, o, n = !0) { + const l = t ? t.vnode : null, { errorHandler: i, throwUnhandledErrorInProduction: r } = t && t.appContext.config || et; + if (t) { + let u = t.parent; + const d = t.proxy, m = `https://vuejs.org/error-reference/#runtime-${o}`; + for (; u; ) { + const v = u.ec; + if (v) { + for (let h = 0; h < v.length; h++) + if (v[h](e, d, m) === !1) + return; + } + u = u.parent; + } + if (i) { + $s(), Yo(i, null, 10, [ + e, + d, + m + ]), Cs(); + return; + } + } + Sc(e, o, l, n, r); +} +function Sc(e, t, o, n = !0, l = !1) { + if (l) + throw e; + console.error(e); +} +const Et = []; +let cs = -1; +const co = []; +let Rs = null, oo = 0; +const wi = /* @__PURE__ */ Promise.resolve(); +let bn = null; +function Jo(e) { + const t = bn || wi; + return e ? t.then(this ? e.bind(this) : e) : t; +} +function Ic(e) { + let t = cs + 1, o = Et.length; + for (; t < o; ) { + const n = t + o >>> 1, l = Et[n], i = Vo(l); + i < e || i === e && l.flags & 2 ? t = n + 1 : o = n; + } + return t; +} +function Ua(e) { + if (!(e.flags & 1)) { + const t = Vo(e), o = Et[Et.length - 1]; + !o || // fast path when the job id is larger than the tail + !(e.flags & 2) && t >= Vo(o) ? Et.push(e) : Et.splice(Ic(t), 0, e), e.flags |= 1, bi(); + } +} +function bi() { + bn || (bn = wi.then(ki)); +} +function Ec(e) { + Ae(e) ? co.push(...e) : Rs && e.id === -1 ? Rs.splice(oo + 1, 0, e) : e.flags & 1 || (co.push(e), e.flags |= 1), bi(); +} +function al(e, t, o = cs + 1) { + for (; o < Et.length; o++) { + const n = Et[o]; + if (n && n.flags & 2) { + if (e && n.id !== e.uid) + continue; + Et.splice(o, 1), o--, n.flags & 4 && (n.flags &= -2), n(), n.flags & 4 || (n.flags &= -2); + } + } +} +function _i(e) { + if (co.length) { + const t = [...new Set(co)].sort( + (o, n) => Vo(o) - Vo(n) + ); + if (co.length = 0, Rs) { + Rs.push(...t); + return; + } + for (Rs = t, oo = 0; oo < Rs.length; oo++) { + const o = Rs[oo]; + o.flags & 4 && (o.flags &= -2), o.flags & 8 || o(), o.flags &= -2; + } + Rs = null, oo = 0; + } +} +const Vo = (e) => e.id == null ? e.flags & 2 ? -1 : 1 / 0 : e.id; +function ki(e) { + try { + for (cs = 0; cs < Et.length; cs++) { + const t = Et[cs]; + t && !(t.flags & 8) && (t.flags & 4 && (t.flags &= -2), Yo( + t, + t.i, + t.i ? 15 : 14 + ), t.flags & 4 || (t.flags &= -2)); + } + } finally { + for (; cs < Et.length; cs++) { + const t = Et[cs]; + t && (t.flags &= -2); + } + cs = -1, Et.length = 0, _i(), bn = null, (Et.length || co.length) && ki(); + } +} +let ht = null, $i = null; +function _n(e) { + const t = ht; + return ht = e, $i = e && e.type.__scopeId || null, t; +} +function g(e, t = ht, o) { + if (!t || e._n) + return e; + const n = (...l) => { + n._d && Cn(-1); + const i = _n(t); + let r; + try { + r = e(...l); + } finally { + _n(i), n._d && Cn(1); + } + return r; + }; + return n._n = !0, n._c = !0, n._d = !0, n; +} +function He(e, t) { + if (ht === null) + return e; + const o = Bn(ht), n = e.dirs || (e.dirs = []); + for (let l = 0; l < t.length; l++) { + let [i, r, u, d = et] = t[l]; + i && (ze(i) && (i = { + mounted: i, + updated: i + }), i.deep && _s(r), n.push({ + dir: i, + instance: o, + value: r, + oldValue: void 0, + arg: u, + modifiers: d + })); + } + return e; +} +function Ws(e, t, o, n) { + const l = e.dirs, i = t && t.dirs; + for (let r = 0; r < l.length; r++) { + const u = l[r]; + i && (u.oldValue = i[r].value); + let d = u.dir[n]; + d && ($s(), es(d, o, 8, [ + e.el, + u, + e, + t + ]), Cs()); + } +} +const Ci = Symbol("_vte"), xi = (e) => e.__isTeleport, Do = (e) => e && (e.disabled || e.disabled === ""), ll = (e) => e && (e.defer || e.defer === ""), il = (e) => typeof SVGElement < "u" && e instanceof SVGElement, rl = (e) => typeof MathMLElement == "function" && e instanceof MathMLElement, va = (e, t) => { + const o = e && e.to; + return it(o) ? t ? t(o) : null : o; +}, Si = { + name: "Teleport", + __isTeleport: !0, + process(e, t, o, n, l, i, r, u, d, m) { + const { + mc: v, + pc: h, + pbc: w, + o: { insert: p, querySelector: _, createText: x, createComment: $ } + } = m, P = Do(t.props); + let { shapeFlag: N, children: T, dynamicChildren: S } = t; + if (e == null) { + const q = t.el = x(""), B = t.anchor = x(""); + p(q, o, n), p(B, o, n); + const A = (E, O) => { + N & 16 && v( + T, + E, + O, + l, + i, + r, + u, + d + ); + }, I = () => { + const E = t.target = va(t.props, _), O = Ii(E, t, x, p); + E && (r !== "svg" && il(E) ? r = "svg" : r !== "mathml" && rl(E) && (r = "mathml"), l && l.isCE && (l.ce._teleportTargets || (l.ce._teleportTargets = /* @__PURE__ */ new Set())).add(E), P || (A(E, O), dn(t, !1))); + }; + P && (A(o, B), dn(t, !0)), ll(t.props) ? (t.el.__isMounted = !1, It(() => { + I(), delete t.el.__isMounted; + }, i)) : I(); + } else { + if (ll(t.props) && e.el.__isMounted === !1) { + It(() => { + Si.process( + e, + t, + o, + n, + l, + i, + r, + u, + d, + m + ); + }, i); + return; + } + t.el = e.el, t.targetStart = e.targetStart; + const q = t.anchor = e.anchor, B = t.target = e.target, A = t.targetAnchor = e.targetAnchor, I = Do(e.props), E = I ? o : B, O = I ? q : A; + if (r === "svg" || il(B) ? r = "svg" : (r === "mathml" || rl(B)) && (r = "mathml"), S ? (w( + e.dynamicChildren, + S, + E, + l, + i, + r, + u + ), Wa(e, t, !0)) : d || h( + e, + t, + E, + O, + l, + i, + r, + u, + !1 + ), P) + I ? t.props && e.props && t.props.to !== e.props.to && (t.props.to = e.props.to) : on( + t, + o, + q, + m, + 1 + ); + else if ((t.props && t.props.to) !== (e.props && e.props.to)) { + const re = t.target = va( + t.props, + _ + ); + re && on( + t, + re, + null, + m, + 0 + ); + } else I && on( + t, + B, + A, + m, + 1 + ); + dn(t, P); + } + }, + remove(e, t, o, { um: n, o: { remove: l } }, i) { + const { + shapeFlag: r, + children: u, + anchor: d, + targetStart: m, + targetAnchor: v, + target: h, + props: w + } = e; + if (h && (l(m), l(v)), i && l(d), r & 16) { + const p = i || !Do(w); + for (let _ = 0; _ < u.length; _++) { + const x = u[_]; + n( + x, + t, + o, + p, + !!x.dynamicChildren + ); + } + } + }, + move: on, + hydrate: Tc +}; +function on(e, t, o, { o: { insert: n }, m: l }, i = 2) { + i === 0 && n(e.targetAnchor, t, o); + const { el: r, anchor: u, shapeFlag: d, children: m, props: v } = e, h = i === 2; + if (h && n(r, t, o), (!h || Do(v)) && d & 16) + for (let w = 0; w < m.length; w++) + l( + m[w], + t, + o, + 2 + ); + h && n(u, t, o); +} +function Tc(e, t, o, n, l, i, { + o: { nextSibling: r, parentNode: u, querySelector: d, insert: m, createText: v } +}, h) { + function w(x, $, P, N) { + $.anchor = h( + r(x), + $, + u(x), + o, + n, + l, + i + ), $.targetStart = P, $.targetAnchor = N; + } + const p = t.target = va( + t.props, + d + ), _ = Do(t.props); + if (p) { + const x = p._lpa || p.firstChild; + if (t.shapeFlag & 16) + if (_) + w( + e, + t, + x, + x && r(x) + ); + else { + t.anchor = r(e); + let $ = x; + for (; $; ) { + if ($ && $.nodeType === 8) { + if ($.data === "teleport start anchor") + t.targetStart = $; + else if ($.data === "teleport anchor") { + t.targetAnchor = $, p._lpa = t.targetAnchor && r(t.targetAnchor); + break; + } + } + $ = r($); + } + t.targetAnchor || Ii(p, t, v, m), h( + x && r(x), + t, + p, + o, + n, + l, + i + ); + } + dn(t, _); + } else _ && t.shapeFlag & 16 && w(e, t, e, r(e)); + return t.anchor && r(t.anchor); +} +const yt = Si; +function dn(e, t) { + const o = e.ctx; + if (o && o.ut) { + let n, l; + for (t ? (n = e.el, l = e.anchor) : (n = e.targetStart, l = e.targetAnchor); n && n !== l; ) + n.nodeType === 1 && n.setAttribute("data-v-owner", o.uid), n = n.nextSibling; + o.ut(); + } +} +function Ii(e, t, o, n) { + const l = t.targetStart = o(""), i = t.targetAnchor = o(""); + return l[Ci] = i, e && (n(l, e), n(i, e)), i; +} +const ws = Symbol("_leaveCb"), nn = Symbol("_enterCb"); +function Ei() { + const e = { + isMounted: !1, + isLeaving: !1, + isUnmounting: !1, + leavingVNodes: /* @__PURE__ */ new Map() + }; + return Qe(() => { + e.isMounted = !0; + }), Ni(() => { + e.isUnmounting = !0; + }), e; +} +const Ut = [Function, Array], Ti = { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: Ut, + onEnter: Ut, + onAfterEnter: Ut, + onEnterCancelled: Ut, + // leave + onBeforeLeave: Ut, + onLeave: Ut, + onAfterLeave: Ut, + onLeaveCancelled: Ut, + // appear + onBeforeAppear: Ut, + onAppear: Ut, + onAfterAppear: Ut, + onAppearCancelled: Ut +}, Pi = (e) => { + const t = e.subTree; + return t.component ? Pi(t.component) : t; +}, Pc = { + name: "BaseTransition", + props: Ti, + setup(e, { slots: t }) { + const o = ja(), n = Ei(); + return () => { + const l = t.default && za(t.default(), !0); + if (!l || !l.length) + return; + const i = Ri(l), r = Ye(e), { mode: u } = r; + if (n.isLeaving) + return Jn(i); + const d = cl(i); + if (!d) + return Jn(i); + let m = Wo( + d, + r, + n, + o, + // #11061, ensure enterHooks is fresh after clone + (h) => m = h + ); + d.type !== kt && Xs(d, m); + let v = o.subTree && cl(o.subTree); + if (v && v.type !== kt && !qs(v, d) && Pi(o).type !== kt) { + let h = Wo( + v, + r, + n, + o + ); + if (Xs(v, h), u === "out-in" && d.type !== kt) + return n.isLeaving = !0, h.afterLeave = () => { + n.isLeaving = !1, o.job.flags & 8 || o.update(), delete h.afterLeave, v = void 0; + }, Jn(i); + u === "in-out" && d.type !== kt ? h.delayLeave = (w, p, _) => { + const x = Mi( + n, + v + ); + x[String(v.key)] = v, w[ws] = () => { + p(), w[ws] = void 0, delete m.delayedLeave, v = void 0; + }, m.delayedLeave = () => { + _(), delete m.delayedLeave, v = void 0; + }; + } : v = void 0; + } else v && (v = void 0); + return i; + }; + } +}; +function Ri(e) { + let t = e[0]; + if (e.length > 1) { + for (const o of e) + if (o.type !== kt) { + t = o; + break; + } + } + return t; +} +const Rc = Pc; +function Mi(e, t) { + const { leavingVNodes: o } = e; + let n = o.get(t.type); + return n || (n = /* @__PURE__ */ Object.create(null), o.set(t.type, n)), n; +} +function Wo(e, t, o, n, l) { + const { + appear: i, + mode: r, + persisted: u = !1, + onBeforeEnter: d, + onEnter: m, + onAfterEnter: v, + onEnterCancelled: h, + onBeforeLeave: w, + onLeave: p, + onAfterLeave: _, + onLeaveCancelled: x, + onBeforeAppear: $, + onAppear: P, + onAfterAppear: N, + onAppearCancelled: T + } = t, S = String(e.key), q = Mi(o, e), B = (E, O) => { + E && es( + E, + n, + 9, + O + ); + }, A = (E, O) => { + const re = O[1]; + B(E, O), Ae(E) ? E.every((Y) => Y.length <= 1) && re() : E.length <= 1 && re(); + }, I = { + mode: r, + persisted: u, + beforeEnter(E) { + let O = d; + if (!o.isMounted) + if (i) + O = $ || d; + else + return; + E[ws] && E[ws]( + !0 + /* cancelled */ + ); + const re = q[S]; + re && qs(e, re) && re.el[ws] && re.el[ws](), B(O, [E]); + }, + enter(E) { + let O = m, re = v, Y = h; + if (!o.isMounted) + if (i) + O = P || m, re = N || v, Y = T || h; + else + return; + let H = !1; + const te = E[nn] = (Z) => { + H || (H = !0, Z ? B(Y, [E]) : B(re, [E]), I.delayedLeave && I.delayedLeave(), E[nn] = void 0); + }; + O ? A(O, [E, te]) : te(); + }, + leave(E, O) { + const re = String(e.key); + if (E[nn] && E[nn]( + !0 + /* cancelled */ + ), o.isUnmounting) + return O(); + B(w, [E]); + let Y = !1; + const H = E[ws] = (te) => { + Y || (Y = !0, O(), te ? B(x, [E]) : B(_, [E]), E[ws] = void 0, q[re] === e && delete q[re]); + }; + q[re] = e, p ? A(p, [E, H]) : H(); + }, + clone(E) { + const O = Wo( + E, + t, + o, + n, + l + ); + return l && l(O), O; + } + }; + return I; +} +function Jn(e) { + if (An(e)) + return e = Ns(e), e.children = null, e; +} +function cl(e) { + if (!An(e)) + return xi(e.type) && e.children ? Ri(e.children) : e; + if (e.component) + return e.component.subTree; + const { shapeFlag: t, children: o } = e; + if (o) { + if (t & 16) + return o[0]; + if (t & 32 && ze(o.default)) + return o.default(); + } +} +function Xs(e, t) { + e.shapeFlag & 6 && e.component ? (e.transition = t, Xs(e.component.subTree, t)) : e.shapeFlag & 128 ? (e.ssContent.transition = t.clone(e.ssContent), e.ssFallback.transition = t.clone(e.ssFallback)) : e.transition = t; +} +function za(e, t = !1, o) { + let n = [], l = 0; + for (let i = 0; i < e.length; i++) { + let r = e[i]; + const u = o == null ? r.key : String(o) + String(r.key != null ? r.key : i); + r.type === j ? (r.patchFlag & 128 && l++, n = n.concat( + za(r.children, t, u) + )) : (t || r.type !== kt) && n.push(u != null ? Ns(r, { key: u }) : r); + } + if (l > 1) + for (let i = 0; i < n.length; i++) + n[i].patchFlag = -2; + return n; +} +// @__NO_SIDE_EFFECTS__ +function me(e, t) { + return ze(e) ? ( + // #8236: extend call and options.name access are considered side-effects + // by Rollup, so we have to wrap it in a pure-annotated IIFE. + mt({ name: e.name }, t, { setup: e }) + ) : e; +} +function Di(e) { + e.ids = [e.ids[0] + e.ids[2]++ + "-", 0, 0]; +} +const kn = /* @__PURE__ */ new WeakMap(); +function Lo(e, t, o, n, l = !1) { + if (Ae(e)) { + e.forEach( + (_, x) => Lo( + _, + t && (Ae(t) ? t[x] : t), + o, + n, + l + ) + ); + return; + } + if (uo(n) && !l) { + n.shapeFlag & 512 && n.type.__asyncResolved && n.component.subTree.component && Lo(e, t, o, n.component.subTree); + return; + } + const i = n.shapeFlag & 4 ? Bn(n.component) : n.el, r = l ? null : i, { i: u, r: d } = e, m = t && t.r, v = u.refs === et ? u.refs = {} : u.refs, h = u.setupState, w = Ye(h), p = h === et ? Jl : (_) => Xe(w, _); + if (m != null && m !== d) { + if (ul(t), it(m)) + v[m] = null, p(m) && (h[m] = null); + else if (Ct(m)) { + m.value = null; + const _ = t; + _.k && (v[_.k] = null); + } + } + if (ze(d)) + Yo(d, u, 12, [r, v]); + else { + const _ = it(d), x = Ct(d); + if (_ || x) { + const $ = () => { + if (e.f) { + const P = _ ? p(d) ? h[d] : v[d] : d.value; + if (l) + Ae(P) && Ea(P, i); + else if (Ae(P)) + P.includes(i) || P.push(i); + else if (_) + v[d] = [i], p(d) && (h[d] = v[d]); + else { + const N = [i]; + d.value = N, e.k && (v[e.k] = N); + } + } else _ ? (v[d] = r, p(d) && (h[d] = r)) : x && (d.value = r, e.k && (v[e.k] = r)); + }; + if (r) { + const P = () => { + $(), kn.delete(e); + }; + P.id = -1, kn.set(e, P), It(P, o); + } else + ul(e), $(); + } + } +} +function ul(e) { + const t = kn.get(e); + t && (t.flags |= 8, kn.delete(e)); +} +Ln().requestIdleCallback; +Ln().cancelIdleCallback; +const uo = (e) => !!e.type.__asyncLoader, An = (e) => e.type.__isKeepAlive; +function Mc(e, t) { + Li(e, "a", t); +} +function Dc(e, t) { + Li(e, "da", t); +} +function Li(e, t, o = $t) { + const n = e.__wdc || (e.__wdc = () => { + let l = o; + for (; l; ) { + if (l.isDeactivated) + return; + l = l.parent; + } + return e(); + }); + if (Un(t, n, o), o) { + let l = o.parent; + for (; l && l.parent; ) + An(l.parent.vnode) && Lc(n, t, o, l), l = l.parent; + } +} +function Lc(e, t, o, n) { + const l = Un( + t, + e, + n, + !0 + /* prepend */ + ); + ho(() => { + Ea(n[t], l); + }, o); +} +function Un(e, t, o = $t, n = !1) { + if (o) { + const l = o[e] || (o[e] = []), i = t.__weh || (t.__weh = (...r) => { + $s(); + const u = Xo(o), d = es(t, o, e, r); + return u(), Cs(), d; + }); + return n ? l.unshift(i) : l.push(i), i; + } +} +const xs = (e) => (t, o = $t) => { + (!Ho || e === "sp") && Un(e, (...n) => t(...n), o); +}, Oc = xs("bm"), Qe = xs("m"), Nc = xs( + "bu" +), Oi = xs("u"), Ni = xs( + "bum" +), ho = xs("um"), Ac = xs( + "sp" +), Uc = xs("rtg"), zc = xs("rtc"); +function Fc(e, t = $t) { + Un("ec", e, t); +} +const Bc = "components", Ai = Symbol.for("v-ndc"); +function Fa(e) { + return it(e) ? Vc(Bc, e, !1) || e : e || Ai; +} +function Vc(e, t, o = !0, n = !1) { + const l = ht || $t; + if (l) { + const i = l.type; + { + const u = Pu( + i, + !1 + ); + if (u && (u === t || u === Vt(t) || u === Mn(Vt(t)))) + return i; + } + const r = ( + // local registration + // check instance[type] first which is resolved for options API + dl(l[e] || i[e], t) || // global registration + dl(l.appContext[e], t) + ); + return !r && n ? i : r; + } +} +function dl(e, t) { + return e && (e[t] || e[Vt(t)] || e[Mn(Vt(t))]); +} +function ge(e, t, o, n) { + let l; + const i = o, r = Ae(e); + if (r || it(e)) { + const u = r && ro(e); + let d = !1, m = !1; + u && (d = !Ft(e), m = Os(e), e = On(e)), l = new Array(e.length); + for (let v = 0, h = e.length; v < h; v++) + l[v] = t( + d ? m ? yn(gt(e[v])) : gt(e[v]) : e[v], + v, + void 0, + i + ); + } else if (typeof e == "number") { + l = new Array(e); + for (let u = 0; u < e; u++) + l[u] = t(u + 1, u, void 0, i); + } else if (Ze(e)) + if (e[Symbol.iterator]) + l = Array.from( + e, + (u, d) => t(u, d, void 0, i) + ); + else { + const u = Object.keys(e); + l = new Array(u.length); + for (let d = 0, m = u.length; d < m; d++) { + const v = u[d]; + l[d] = t(e[v], v, d, i); + } + } + else + l = []; + return l; +} +function Qs(e, t) { + for (let o = 0; o < t.length; o++) { + const n = t[o]; + if (Ae(n)) + for (let l = 0; l < n.length; l++) + e[n[l].name] = n[l].fn; + else n && (e[n.name] = n.key ? (...l) => { + const i = n.fn(...l); + return i && (i.key = n.key), i; + } : n.fn); + } + return e; +} +function Ge(e, t, o = {}, n, l) { + if (ht.ce || ht.parent && uo(ht.parent) && ht.parent.ce) { + const m = Object.keys(o).length > 0; + return t !== "default" && (o.name = t), a(), M( + j, + null, + [C("slot", o, n && n())], + m ? -2 : 64 + ); + } + let i = e[t]; + i && i._c && (i._d = !1), a(); + const r = i && Ui(i(o)), u = o.key || // slot content array of a dynamic conditional slot may have a branch + // key attached in the `createSlots` helper, respect that + r && r.key, d = M( + j, + { + key: (u && !Zt(u) ? u : `_${t}`) + // #7256 force differentiate fallback content from actual content + (!r && n ? "_fb" : "") + }, + r || (n ? n() : []), + r && e._ === 1 ? 64 : -2 + ); + return i && i._c && (i._d = !0), d; +} +function Ui(e) { + return e.some((t) => jo(t) ? !(t.type === kt || t.type === j && !Ui(t.children)) : !0) ? e : null; +} +const pa = (e) => e ? or(e) ? Bn(e) : pa(e.parent) : null, Oo = ( + // Move PURE marker to new line to workaround compiler discarding it + // due to type annotation + /* @__PURE__ */ mt(/* @__PURE__ */ Object.create(null), { + $: (e) => e, + $el: (e) => e.vnode.el, + $data: (e) => e.data, + $props: (e) => e.props, + $attrs: (e) => e.attrs, + $slots: (e) => e.slots, + $refs: (e) => e.refs, + $parent: (e) => pa(e.parent), + $root: (e) => pa(e.root), + $host: (e) => e.ce, + $emit: (e) => e.emit, + $options: (e) => Fi(e), + $forceUpdate: (e) => e.f || (e.f = () => { + Ua(e.update); + }), + $nextTick: (e) => e.n || (e.n = Jo.bind(e.proxy)), + $watch: (e) => uu.bind(e) + }) +), Xn = (e, t) => e !== et && !e.__isScriptSetup && Xe(e, t), Wc = { + get({ _: e }, t) { + if (t === "__v_skip") + return !0; + const { ctx: o, setupState: n, data: l, props: i, accessCache: r, type: u, appContext: d } = e; + let m; + if (t[0] !== "$") { + const p = r[t]; + if (p !== void 0) + switch (p) { + case 1: + return n[t]; + case 2: + return l[t]; + case 4: + return o[t]; + case 3: + return i[t]; + } + else { + if (Xn(n, t)) + return r[t] = 1, n[t]; + if (l !== et && Xe(l, t)) + return r[t] = 2, l[t]; + if ( + // only cache other properties when instance has declared (thus stable) + // props + (m = e.propsOptions[0]) && Xe(m, t) + ) + return r[t] = 3, i[t]; + if (o !== et && Xe(o, t)) + return r[t] = 4, o[t]; + ga && (r[t] = 0); + } + } + const v = Oo[t]; + let h, w; + if (v) + return t === "$attrs" && _t(e.attrs, "get", ""), v(e); + if ( + // css module (injected by vue-loader) + (h = u.__cssModules) && (h = h[t]) + ) + return h; + if (o !== et && Xe(o, t)) + return r[t] = 4, o[t]; + if ( + // global properties + w = d.config.globalProperties, Xe(w, t) + ) + return w[t]; + }, + set({ _: e }, t, o) { + const { data: n, setupState: l, ctx: i } = e; + return Xn(l, t) ? (l[t] = o, !0) : n !== et && Xe(n, t) ? (n[t] = o, !0) : Xe(e.props, t) || t[0] === "$" && t.slice(1) in e ? !1 : (i[t] = o, !0); + }, + has({ + _: { data: e, setupState: t, accessCache: o, ctx: n, appContext: l, propsOptions: i, type: r } + }, u) { + let d, m; + return !!(o[u] || e !== et && u[0] !== "$" && Xe(e, u) || Xn(t, u) || (d = i[0]) && Xe(d, u) || Xe(n, u) || Xe(Oo, u) || Xe(l.config.globalProperties, u) || (m = r.__cssModules) && m[u]); + }, + defineProperty(e, t, o) { + return o.get != null ? e._.accessCache[t] = 0 : Xe(o, "value") && this.set(e, t, o.value, null), Reflect.defineProperty(e, t, o); + } +}; +function fl(e) { + return Ae(e) ? e.reduce( + (t, o) => (t[o] = null, t), + {} + ) : e; +} +let ga = !0; +function Gc(e) { + const t = Fi(e), o = e.proxy, n = e.ctx; + ga = !1, t.beforeCreate && ml(t.beforeCreate, e, "bc"); + const { + // state + data: l, + computed: i, + methods: r, + watch: u, + provide: d, + inject: m, + // lifecycle + created: v, + beforeMount: h, + mounted: w, + beforeUpdate: p, + updated: _, + activated: x, + deactivated: $, + beforeDestroy: P, + beforeUnmount: N, + destroyed: T, + unmounted: S, + render: q, + renderTracked: B, + renderTriggered: A, + errorCaptured: I, + serverPrefetch: E, + // public API + expose: O, + inheritAttrs: re, + // assets + components: Y, + directives: H, + filters: te + } = t; + if (m && jc(m, n, null), r) + for (const z in r) { + const R = r[z]; + ze(R) && (n[z] = R.bind(o)); + } + if (l) { + const z = l.call(o, o); + Ze(z) && (e.data = zs(z)); + } + if (ga = !0, i) + for (const z in i) { + const R = i[z], be = ze(R) ? R.bind(o, o) : ze(R.get) ? R.get.bind(o, o) : fs, ve = !ze(R) && ze(R.set) ? R.set.bind(o) : fs, Ee = F({ + get: be, + set: ve + }); + Object.defineProperty(n, z, { + enumerable: !0, + configurable: !0, + get: () => Ee.value, + set: (De) => Ee.value = De + }); + } + if (u) + for (const z in u) + zi(u[z], n, o, z); + if (d) { + const z = ze(d) ? d.call(o) : d; + Reflect.ownKeys(z).forEach((R) => { + Xc(R, z[R]); + }); + } + v && ml(v, e, "c"); + function U(z, R) { + Ae(R) ? R.forEach((be) => z(be.bind(o))) : R && z(R.bind(o)); + } + if (U(Oc, h), U(Qe, w), U(Nc, p), U(Oi, _), U(Mc, x), U(Dc, $), U(Fc, I), U(zc, B), U(Uc, A), U(Ni, N), U(ho, S), U(Ac, E), Ae(O)) + if (O.length) { + const z = e.exposed || (e.exposed = {}); + O.forEach((R) => { + Object.defineProperty(z, R, { + get: () => o[R], + set: (be) => o[R] = be, + enumerable: !0 + }); + }); + } else e.exposed || (e.exposed = {}); + q && e.render === fs && (e.render = q), re != null && (e.inheritAttrs = re), Y && (e.components = Y), H && (e.directives = H), E && Di(e); +} +function jc(e, t, o = fs) { + Ae(e) && (e = ha(e)); + for (const n in e) { + const l = e[n]; + let i; + Ze(l) ? "default" in l ? i = fn( + l.from || n, + l.default, + !0 + ) : i = fn(l.from || n) : i = fn(l), Ct(i) ? Object.defineProperty(t, n, { + enumerable: !0, + configurable: !0, + get: () => i.value, + set: (r) => i.value = r + }) : t[n] = i; + } +} +function ml(e, t, o) { + es( + Ae(e) ? e.map((n) => n.bind(t.proxy)) : e.bind(t.proxy), + t, + o + ); +} +function zi(e, t, o, n) { + let l = n.includes(".") ? Qi(o, n) : () => o[n]; + if (it(e)) { + const i = t[e]; + ze(i) && xt(l, i); + } else if (ze(e)) + xt(l, e.bind(o)); + else if (Ze(e)) + if (Ae(e)) + e.forEach((i) => zi(i, t, o, n)); + else { + const i = ze(e.handler) ? e.handler.bind(o) : t[e.handler]; + ze(i) && xt(l, i, e); + } +} +function Fi(e) { + const t = e.type, { mixins: o, extends: n } = t, { + mixins: l, + optionsCache: i, + config: { optionMergeStrategies: r } + } = e.appContext, u = i.get(t); + let d; + return u ? d = u : !l.length && !o && !n ? d = t : (d = {}, l.length && l.forEach( + (m) => $n(d, m, r, !0) + ), $n(d, t, r)), Ze(t) && i.set(t, d), d; +} +function $n(e, t, o, n = !1) { + const { mixins: l, extends: i } = t; + i && $n(e, i, o, !0), l && l.forEach( + (r) => $n(e, r, o, !0) + ); + for (const r in t) + if (!(n && r === "expose")) { + const u = Hc[r] || o && o[r]; + e[r] = u ? u(e[r], t[r]) : t[r]; + } + return e; +} +const Hc = { + data: vl, + props: pl, + emits: pl, + // objects + methods: To, + computed: To, + // lifecycle + beforeCreate: St, + created: St, + beforeMount: St, + mounted: St, + beforeUpdate: St, + updated: St, + beforeDestroy: St, + beforeUnmount: St, + destroyed: St, + unmounted: St, + activated: St, + deactivated: St, + errorCaptured: St, + serverPrefetch: St, + // assets + components: To, + directives: To, + // watch + watch: qc, + // provide / inject + provide: vl, + inject: Kc +}; +function vl(e, t) { + return t ? e ? function() { + return mt( + ze(e) ? e.call(this, this) : e, + ze(t) ? t.call(this, this) : t + ); + } : t : e; +} +function Kc(e, t) { + return To(ha(e), ha(t)); +} +function ha(e) { + if (Ae(e)) { + const t = {}; + for (let o = 0; o < e.length; o++) + t[e[o]] = e[o]; + return t; + } + return e; +} +function St(e, t) { + return e ? [...new Set([].concat(e, t))] : t; +} +function To(e, t) { + return e ? mt(/* @__PURE__ */ Object.create(null), e, t) : t; +} +function pl(e, t) { + return e ? Ae(e) && Ae(t) ? [.../* @__PURE__ */ new Set([...e, ...t])] : mt( + /* @__PURE__ */ Object.create(null), + fl(e), + fl(t ?? {}) + ) : t; +} +function qc(e, t) { + if (!e) return t; + if (!t) return e; + const o = mt(/* @__PURE__ */ Object.create(null), e); + for (const n in t) + o[n] = St(e[n], t[n]); + return o; +} +function Bi() { + return { + app: null, + config: { + isNativeTag: Jl, + performance: !1, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: void 0, + warnHandler: void 0, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: /* @__PURE__ */ Object.create(null), + optionsCache: /* @__PURE__ */ new WeakMap(), + propsCache: /* @__PURE__ */ new WeakMap(), + emitsCache: /* @__PURE__ */ new WeakMap() + }; +} +let Yc = 0; +function Jc(e, t) { + return function(n, l = null) { + ze(n) || (n = mt({}, n)), l != null && !Ze(l) && (l = null); + const i = Bi(), r = /* @__PURE__ */ new WeakSet(), u = []; + let d = !1; + const m = i.app = { + _uid: Yc++, + _component: n, + _props: l, + _container: null, + _context: i, + _instance: null, + version: Mu, + get config() { + return i.config; + }, + set config(v) { + }, + use(v, ...h) { + return r.has(v) || (v && ze(v.install) ? (r.add(v), v.install(m, ...h)) : ze(v) && (r.add(v), v(m, ...h))), m; + }, + mixin(v) { + return i.mixins.includes(v) || i.mixins.push(v), m; + }, + component(v, h) { + return h ? (i.components[v] = h, m) : i.components[v]; + }, + directive(v, h) { + return h ? (i.directives[v] = h, m) : i.directives[v]; + }, + mount(v, h, w) { + if (!d) { + const p = m._ceVNode || C(n, l); + return p.appContext = i, w === !0 ? w = "svg" : w === !1 && (w = void 0), e(p, v, w), d = !0, m._container = v, v.__vue_app__ = m, Bn(p.component); + } + }, + onUnmount(v) { + u.push(v); + }, + unmount() { + d && (es( + u, + m._instance, + 16 + ), e(null, m._container), delete m._container.__vue_app__); + }, + provide(v, h) { + return i.provides[v] = h, m; + }, + runWithContext(v) { + const h = fo; + fo = m; + try { + return v(); + } finally { + fo = h; + } + } + }; + return m; + }; +} +let fo = null; +function Xc(e, t) { + if ($t) { + let o = $t.provides; + const n = $t.parent && $t.parent.provides; + n === o && (o = $t.provides = Object.create(n)), o[e] = t; + } +} +function fn(e, t, o = !1) { + const n = ja(); + if (n || fo) { + let l = fo ? fo._context.provides : n ? n.parent == null || n.ce ? n.vnode.appContext && n.vnode.appContext.provides : n.parent.provides : void 0; + if (l && e in l) + return l[e]; + if (arguments.length > 1) + return o && ze(t) ? t.call(n && n.proxy) : t; + } +} +const Vi = {}, Wi = () => Object.create(Vi), Gi = (e) => Object.getPrototypeOf(e) === Vi; +function Qc(e, t, o, n = !1) { + const l = {}, i = Wi(); + e.propsDefaults = /* @__PURE__ */ Object.create(null), ji(e, t, l, i); + for (const r in e.propsOptions[0]) + r in l || (l[r] = void 0); + o ? e.props = n ? l : hc(l) : e.type.props ? e.props = l : e.props = i, e.attrs = i; +} +function Zc(e, t, o, n) { + const { + props: l, + attrs: i, + vnode: { patchFlag: r } + } = e, u = Ye(l), [d] = e.propsOptions; + let m = !1; + if ( + // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + (n || r > 0) && !(r & 16) + ) { + if (r & 8) { + const v = e.vnode.dynamicProps; + for (let h = 0; h < v.length; h++) { + let w = v[h]; + if (zn(e.emitsOptions, w)) + continue; + const p = t[w]; + if (d) + if (Xe(i, w)) + p !== i[w] && (i[w] = p, m = !0); + else { + const _ = Vt(w); + l[_] = ya( + d, + u, + _, + p, + e, + !1 + ); + } + else + p !== i[w] && (i[w] = p, m = !0); + } + } + } else { + ji(e, t, l, i) && (m = !0); + let v; + for (const h in u) + (!t || // for camelCase + !Xe(t, h) && // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + ((v = Us(h)) === h || !Xe(t, v))) && (d ? o && // for camelCase + (o[h] !== void 0 || // for kebab-case + o[v] !== void 0) && (l[h] = ya( + d, + u, + h, + void 0, + e, + !0 + )) : delete l[h]); + if (i !== u) + for (const h in i) + (!t || !Xe(t, h)) && (delete i[h], m = !0); + } + m && bs(e.attrs, "set", ""); +} +function ji(e, t, o, n) { + const [l, i] = e.propsOptions; + let r = !1, u; + if (t) + for (let d in t) { + if (Po(d)) + continue; + const m = t[d]; + let v; + l && Xe(l, v = Vt(d)) ? !i || !i.includes(v) ? o[v] = m : (u || (u = {}))[v] = m : zn(e.emitsOptions, d) || (!(d in n) || m !== n[d]) && (n[d] = m, r = !0); + } + if (i) { + const d = Ye(o), m = u || et; + for (let v = 0; v < i.length; v++) { + const h = i[v]; + o[h] = ya( + l, + d, + h, + m[h], + e, + !Xe(m, h) + ); + } + } + return r; +} +function ya(e, t, o, n, l, i) { + const r = e[o]; + if (r != null) { + const u = Xe(r, "default"); + if (u && n === void 0) { + const d = r.default; + if (r.type !== Function && !r.skipFactory && ze(d)) { + const { propsDefaults: m } = l; + if (o in m) + n = m[o]; + else { + const v = Xo(l); + n = m[o] = d.call( + null, + t + ), v(); + } + } else + n = d; + l.ce && l.ce._setProp(o, n); + } + r[ + 0 + /* shouldCast */ + ] && (i && !u ? n = !1 : r[ + 1 + /* shouldCastTrue */ + ] && (n === "" || n === Us(o)) && (n = !0)); + } + return n; +} +const eu = /* @__PURE__ */ new WeakMap(); +function Hi(e, t, o = !1) { + const n = o ? eu : t.propsCache, l = n.get(e); + if (l) + return l; + const i = e.props, r = {}, u = []; + let d = !1; + if (!ze(e)) { + const v = (h) => { + d = !0; + const [w, p] = Hi(h, t, !0); + mt(r, w), p && u.push(...p); + }; + !o && t.mixins.length && t.mixins.forEach(v), e.extends && v(e.extends), e.mixins && e.mixins.forEach(v); + } + if (!i && !d) + return Ze(e) && n.set(e, lo), lo; + if (Ae(i)) + for (let v = 0; v < i.length; v++) { + const h = Vt(i[v]); + gl(h) && (r[h] = et); + } + else if (i) + for (const v in i) { + const h = Vt(v); + if (gl(h)) { + const w = i[v], p = r[h] = Ae(w) || ze(w) ? { type: w } : mt({}, w), _ = p.type; + let x = !1, $ = !0; + if (Ae(_)) + for (let P = 0; P < _.length; ++P) { + const N = _[P], T = ze(N) && N.name; + if (T === "Boolean") { + x = !0; + break; + } else T === "String" && ($ = !1); + } + else + x = ze(_) && _.name === "Boolean"; + p[ + 0 + /* shouldCast */ + ] = x, p[ + 1 + /* shouldCastTrue */ + ] = $, (x || Xe(p, "default")) && u.push(h); + } + } + const m = [r, u]; + return Ze(e) && n.set(e, m), m; +} +function gl(e) { + return e[0] !== "$" && !Po(e); +} +const Ba = (e) => e === "_" || e === "_ctx" || e === "$stable", Va = (e) => Ae(e) ? e.map(ds) : [ds(e)], tu = (e, t, o) => { + if (t._n) + return t; + const n = g((...l) => Va(t(...l)), o); + return n._c = !1, n; +}, Ki = (e, t, o) => { + const n = e._ctx; + for (const l in e) { + if (Ba(l)) continue; + const i = e[l]; + if (ze(i)) + t[l] = tu(l, i, n); + else if (i != null) { + const r = Va(i); + t[l] = () => r; + } + } +}, qi = (e, t) => { + const o = Va(t); + e.slots.default = () => o; +}, Yi = (e, t, o) => { + for (const n in t) + (o || !Ba(n)) && (e[n] = t[n]); +}, su = (e, t, o) => { + const n = e.slots = Wi(); + if (e.vnode.shapeFlag & 32) { + const l = t._; + l ? (Yi(n, t, o), o && ei(n, "_", l, !0)) : Ki(t, n); + } else t && qi(e, t); +}, ou = (e, t, o) => { + const { vnode: n, slots: l } = e; + let i = !0, r = et; + if (n.shapeFlag & 32) { + const u = t._; + u ? o && u === 1 ? i = !1 : Yi(l, t, o) : (i = !t.$stable, Ki(t, l)), r = t; + } else t && (qi(e, t), r = { default: 1 }); + if (i) + for (const u in l) + !Ba(u) && r[u] == null && delete l[u]; +}, It = yu; +function nu(e) { + return au(e); +} +function au(e, t) { + const o = Ln(); + o.__VUE__ = !0; + const { + insert: n, + remove: l, + patchProp: i, + createElement: r, + createText: u, + createComment: d, + setText: m, + setElementText: v, + parentNode: h, + nextSibling: w, + setScopeId: p = fs, + insertStaticContent: _ + } = e, x = (L, V, oe, ae = null, de = null, fe = null, ke = void 0, $e = null, ne = !!V.dynamicChildren) => { + if (L === V) + return; + L && !qs(L, V) && (ae = Ve(L), De(L, de, fe, !0), L = null), V.patchFlag === -2 && (ne = !1, V.dynamicChildren = null); + const { type: ue, ref: Re, shapeFlag: Ce } = V; + switch (ue) { + case Fn: + $(L, V, oe, ae); + break; + case kt: + P(L, V, oe, ae); + break; + case Zn: + L == null && N(V, oe, ae, ke); + break; + case j: + Y( + L, + V, + oe, + ae, + de, + fe, + ke, + $e, + ne + ); + break; + default: + Ce & 1 ? q( + L, + V, + oe, + ae, + de, + fe, + ke, + $e, + ne + ) : Ce & 6 ? H( + L, + V, + oe, + ae, + de, + fe, + ke, + $e, + ne + ) : (Ce & 64 || Ce & 128) && ue.process( + L, + V, + oe, + ae, + de, + fe, + ke, + $e, + ne, + Fe + ); + } + Re != null && de ? Lo(Re, L && L.ref, fe, V || L, !V) : Re == null && L && L.ref != null && Lo(L.ref, null, fe, L, !0); + }, $ = (L, V, oe, ae) => { + if (L == null) + n( + V.el = u(V.children), + oe, + ae + ); + else { + const de = V.el = L.el; + V.children !== L.children && m(de, V.children); + } + }, P = (L, V, oe, ae) => { + L == null ? n( + V.el = d(V.children || ""), + oe, + ae + ) : V.el = L.el; + }, N = (L, V, oe, ae) => { + [L.el, L.anchor] = _( + L.children, + V, + oe, + ae, + L.el, + L.anchor + ); + }, T = ({ el: L, anchor: V }, oe, ae) => { + let de; + for (; L && L !== V; ) + de = w(L), n(L, oe, ae), L = de; + n(V, oe, ae); + }, S = ({ el: L, anchor: V }) => { + let oe; + for (; L && L !== V; ) + oe = w(L), l(L), L = oe; + l(V); + }, q = (L, V, oe, ae, de, fe, ke, $e, ne) => { + if (V.type === "svg" ? ke = "svg" : V.type === "math" && (ke = "mathml"), L == null) + B( + V, + oe, + ae, + de, + fe, + ke, + $e, + ne + ); + else { + const ue = L.el && L.el._isVueCE ? L.el : null; + try { + ue && ue._beginPatch(), E( + L, + V, + de, + fe, + ke, + $e, + ne + ); + } finally { + ue && ue._endPatch(); + } + } + }, B = (L, V, oe, ae, de, fe, ke, $e) => { + let ne, ue; + const { props: Re, shapeFlag: Ce, transition: ee, dirs: K } = L; + if (ne = L.el = r( + L.type, + fe, + Re && Re.is, + Re + ), Ce & 8 ? v(ne, L.children) : Ce & 16 && I( + L.children, + ne, + null, + ae, + de, + Qn(L, fe), + ke, + $e + ), K && Ws(L, null, ae, "created"), A(ne, L, L.scopeId, ke, ae), Re) { + for (const D in Re) + D !== "value" && !Po(D) && i(ne, D, null, Re[D], fe, ae); + "value" in Re && i(ne, "value", null, Re.value, fe), (ue = Re.onVnodeBeforeMount) && ls(ue, ae, L); + } + K && Ws(L, null, ae, "beforeMount"); + const X = lu(de, ee); + X && ee.beforeEnter(ne), n(ne, V, oe), ((ue = Re && Re.onVnodeMounted) || X || K) && It(() => { + ue && ls(ue, ae, L), X && ee.enter(ne), K && Ws(L, null, ae, "mounted"); + }, de); + }, A = (L, V, oe, ae, de) => { + if (oe && p(L, oe), ae) + for (let fe = 0; fe < ae.length; fe++) + p(L, ae[fe]); + if (de) { + let fe = de.subTree; + if (V === fe || er(fe.type) && (fe.ssContent === V || fe.ssFallback === V)) { + const ke = de.vnode; + A( + L, + ke, + ke.scopeId, + ke.slotScopeIds, + de.parent + ); + } + } + }, I = (L, V, oe, ae, de, fe, ke, $e, ne = 0) => { + for (let ue = ne; ue < L.length; ue++) { + const Re = L[ue] = $e ? Ms(L[ue]) : ds(L[ue]); + x( + null, + Re, + V, + oe, + ae, + de, + fe, + ke, + $e + ); + } + }, E = (L, V, oe, ae, de, fe, ke) => { + const $e = V.el = L.el; + let { patchFlag: ne, dynamicChildren: ue, dirs: Re } = V; + ne |= L.patchFlag & 16; + const Ce = L.props || et, ee = V.props || et; + let K; + if (oe && Gs(oe, !1), (K = ee.onVnodeBeforeUpdate) && ls(K, oe, V, L), Re && Ws(V, L, oe, "beforeUpdate"), oe && Gs(oe, !0), (Ce.innerHTML && ee.innerHTML == null || Ce.textContent && ee.textContent == null) && v($e, ""), ue ? O( + L.dynamicChildren, + ue, + $e, + oe, + ae, + Qn(V, de), + fe + ) : ke || R( + L, + V, + $e, + null, + oe, + ae, + Qn(V, de), + fe, + !1 + ), ne > 0) { + if (ne & 16) + re($e, Ce, ee, oe, de); + else if (ne & 2 && Ce.class !== ee.class && i($e, "class", null, ee.class, de), ne & 4 && i($e, "style", Ce.style, ee.style, de), ne & 8) { + const X = V.dynamicProps; + for (let D = 0; D < X.length; D++) { + const W = X[D], ce = Ce[W], Te = ee[W]; + (Te !== ce || W === "value") && i($e, W, ce, Te, de, oe); + } + } + ne & 1 && L.children !== V.children && v($e, V.children); + } else !ke && ue == null && re($e, Ce, ee, oe, de); + ((K = ee.onVnodeUpdated) || Re) && It(() => { + K && ls(K, oe, V, L), Re && Ws(V, L, oe, "updated"); + }, ae); + }, O = (L, V, oe, ae, de, fe, ke) => { + for (let $e = 0; $e < V.length; $e++) { + const ne = L[$e], ue = V[$e], Re = ( + // oldVNode may be an errored async setup() component inside Suspense + // which will not have a mounted element + ne.el && // - In the case of a Fragment, we need to provide the actual parent + // of the Fragment itself so it can move its children. + (ne.type === j || // - In the case of different nodes, there is going to be a replacement + // which also requires the correct parent container + !qs(ne, ue) || // - In the case of a component, it could contain anything. + ne.shapeFlag & 198) ? h(ne.el) : ( + // In other cases, the parent container is not actually used so we + // just pass the block element here to avoid a DOM parentNode call. + oe + ) + ); + x( + ne, + ue, + Re, + null, + ae, + de, + fe, + ke, + !0 + ); + } + }, re = (L, V, oe, ae, de) => { + if (V !== oe) { + if (V !== et) + for (const fe in V) + !Po(fe) && !(fe in oe) && i( + L, + fe, + V[fe], + null, + de, + ae + ); + for (const fe in oe) { + if (Po(fe)) continue; + const ke = oe[fe], $e = V[fe]; + ke !== $e && fe !== "value" && i(L, fe, $e, ke, de, ae); + } + "value" in oe && i(L, "value", V.value, oe.value, de); + } + }, Y = (L, V, oe, ae, de, fe, ke, $e, ne) => { + const ue = V.el = L ? L.el : u(""), Re = V.anchor = L ? L.anchor : u(""); + let { patchFlag: Ce, dynamicChildren: ee, slotScopeIds: K } = V; + K && ($e = $e ? $e.concat(K) : K), L == null ? (n(ue, oe, ae), n(Re, oe, ae), I( + // #10007 + // such fragment like `<>` will be compiled into + // a fragment which doesn't have a children. + // In this case fallback to an empty array + V.children || [], + oe, + Re, + de, + fe, + ke, + $e, + ne + )) : Ce > 0 && Ce & 64 && ee && // #2715 the previous fragment could've been a BAILed one as a result + // of renderSlot() with no valid children + L.dynamicChildren ? (O( + L.dynamicChildren, + ee, + oe, + de, + fe, + ke, + $e + ), // #2080 if the stable fragment has a key, it's a