|
|
@@ -0,0 +1,9447 @@
|
|
|
+/**
|
|
|
+ * Minified by jsDelivr using Terser v5.15.1.
|
|
|
+ * Original file: /npm/vue@3.2.45/dist/vue.global.js
|
|
|
+ *
|
|
|
+ * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
|
|
|
+ */
|
|
|
+var Vue = (function (e) {
|
|
|
+ 'use strict'
|
|
|
+ function t(e, t) {
|
|
|
+ const n = Object.create(null),
|
|
|
+ o = e.split(',')
|
|
|
+ for (let e = 0; e < o.length; e++) n[o[e]] = !0
|
|
|
+ return t ? (e) => !!n[e.toLowerCase()] : (e) => !!n[e]
|
|
|
+ }
|
|
|
+ const n = {
|
|
|
+ 1: 'TEXT',
|
|
|
+ 2: 'CLASS',
|
|
|
+ 4: 'STYLE',
|
|
|
+ 8: 'PROPS',
|
|
|
+ 16: 'FULL_PROPS',
|
|
|
+ 32: 'HYDRATE_EVENTS',
|
|
|
+ 64: 'STABLE_FRAGMENT',
|
|
|
+ 128: 'KEYED_FRAGMENT',
|
|
|
+ 256: 'UNKEYED_FRAGMENT',
|
|
|
+ 512: 'NEED_PATCH',
|
|
|
+ 1024: 'DYNAMIC_SLOTS',
|
|
|
+ 2048: 'DEV_ROOT_FRAGMENT',
|
|
|
+ [-1]: 'HOISTED',
|
|
|
+ [-2]: 'BAIL'
|
|
|
+ },
|
|
|
+ o = {
|
|
|
+ 1: 'STABLE',
|
|
|
+ 2: 'DYNAMIC',
|
|
|
+ 3: 'FORWARDED'
|
|
|
+ },
|
|
|
+ r = t(
|
|
|
+ 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt'
|
|
|
+ )
|
|
|
+ function s(e) {
|
|
|
+ if (O(e)) {
|
|
|
+ const t = {}
|
|
|
+ for (let n = 0; n < e.length; n++) {
|
|
|
+ const o = e[n],
|
|
|
+ r = P(o) ? a(o) : s(o)
|
|
|
+ if (r) for (const e in r) t[e] = r[e]
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ return P(e) || j(e) ? e : void 0
|
|
|
+ }
|
|
|
+ const i = /;(?![^(]*\))/g,
|
|
|
+ c = /:([^]+)/,
|
|
|
+ l = /\/\*.*?\*\//gs
|
|
|
+ function a(e) {
|
|
|
+ const t = {}
|
|
|
+ return (
|
|
|
+ e
|
|
|
+ .replace(l, '')
|
|
|
+ .split(i)
|
|
|
+ .forEach((e) => {
|
|
|
+ if (e) {
|
|
|
+ const n = e.split(c)
|
|
|
+ n.length > 1 && (t[n[0].trim()] = n[1].trim())
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function u(e) {
|
|
|
+ let t = ''
|
|
|
+ if (P(e)) t = e
|
|
|
+ else if (O(e))
|
|
|
+ for (let n = 0; n < e.length; n++) {
|
|
|
+ const o = u(e[n])
|
|
|
+ o && (t += o + ' ')
|
|
|
+ }
|
|
|
+ else if (j(e)) for (const n in e) e[n] && (t += n + ' ')
|
|
|
+ return t.trim()
|
|
|
+ }
|
|
|
+ const p = t(
|
|
|
+ 'html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot'
|
|
|
+ ),
|
|
|
+ d = t(
|
|
|
+ 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view'
|
|
|
+ ),
|
|
|
+ f = t('area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr'),
|
|
|
+ h = t('itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly')
|
|
|
+ function m(e) {
|
|
|
+ return !!e || '' === e
|
|
|
+ }
|
|
|
+ function g(e, t) {
|
|
|
+ if (e === t) return !0
|
|
|
+ let n = R(e),
|
|
|
+ o = R(t)
|
|
|
+ if (n || o) return !(!n || !o) && e.getTime() === t.getTime()
|
|
|
+ if (((n = F(e)), (o = F(t)), n || o)) return e === t
|
|
|
+ if (((n = O(e)), (o = O(t)), n || o))
|
|
|
+ return (
|
|
|
+ !(!n || !o) &&
|
|
|
+ (function (e, t) {
|
|
|
+ if (e.length !== t.length) return !1
|
|
|
+ let n = !0
|
|
|
+ for (let o = 0; n && o < e.length; o++) n = g(e[o], t[o])
|
|
|
+ return n
|
|
|
+ })(e, t)
|
|
|
+ )
|
|
|
+ if (((n = j(e)), (o = j(t)), n || o)) {
|
|
|
+ if (!n || !o) return !1
|
|
|
+ if (Object.keys(e).length !== Object.keys(t).length) return !1
|
|
|
+ for (const n in e) {
|
|
|
+ const o = e.hasOwnProperty(n),
|
|
|
+ r = t.hasOwnProperty(n)
|
|
|
+ if ((o && !r) || (!o && r) || !g(e[n], t[n])) return !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return String(e) === String(t)
|
|
|
+ }
|
|
|
+ function y(e, t) {
|
|
|
+ return e.findIndex((e) => g(e, t))
|
|
|
+ }
|
|
|
+ const v = (e, t) =>
|
|
|
+ t && t.__v_isRef
|
|
|
+ ? v(e, t.value)
|
|
|
+ : A(t)
|
|
|
+ ? {
|
|
|
+ [`Map(${t.size})`]: [...t.entries()].reduce((e, [t, n]) => ((e[`${t} =>`] = n), e), {})
|
|
|
+ }
|
|
|
+ : I(t)
|
|
|
+ ? {
|
|
|
+ [`Set(${t.size})`]: [...t.values()]
|
|
|
+ }
|
|
|
+ : !j(t) || O(t) || D(t)
|
|
|
+ ? t
|
|
|
+ : String(t),
|
|
|
+ b = Object.freeze({}),
|
|
|
+ _ = Object.freeze([]),
|
|
|
+ w = () => {},
|
|
|
+ x = () => !1,
|
|
|
+ S = /^on[^a-z]/,
|
|
|
+ C = (e) => S.test(e),
|
|
|
+ k = (e) => e.startsWith('onUpdate:'),
|
|
|
+ T = Object.assign,
|
|
|
+ $ = (e, t) => {
|
|
|
+ const n = e.indexOf(t)
|
|
|
+ n > -1 && e.splice(n, 1)
|
|
|
+ },
|
|
|
+ E = Object.prototype.hasOwnProperty,
|
|
|
+ N = (e, t) => E.call(e, t),
|
|
|
+ O = Array.isArray,
|
|
|
+ A = (e) => '[object Map]' === B(e),
|
|
|
+ I = (e) => '[object Set]' === B(e),
|
|
|
+ R = (e) => '[object Date]' === B(e),
|
|
|
+ M = (e) => 'function' == typeof e,
|
|
|
+ P = (e) => 'string' == typeof e,
|
|
|
+ F = (e) => 'symbol' == typeof e,
|
|
|
+ j = (e) => null !== e && 'object' == typeof e,
|
|
|
+ V = (e) => j(e) && M(e.then) && M(e.catch),
|
|
|
+ L = Object.prototype.toString,
|
|
|
+ B = (e) => L.call(e),
|
|
|
+ U = (e) => B(e).slice(8, -1),
|
|
|
+ D = (e) => '[object Object]' === B(e),
|
|
|
+ H = (e) => P(e) && 'NaN' !== e && '-' !== e[0] && '' + parseInt(e, 10) === e,
|
|
|
+ z = t(
|
|
|
+ ',key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted'
|
|
|
+ ),
|
|
|
+ W = t('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo'),
|
|
|
+ K = (e) => {
|
|
|
+ const t = Object.create(null)
|
|
|
+ return (n) => t[n] || (t[n] = e(n))
|
|
|
+ },
|
|
|
+ G = /-(\w)/g,
|
|
|
+ J = K((e) => e.replace(G, (e, t) => (t ? t.toUpperCase() : ''))),
|
|
|
+ q = /\B([A-Z])/g,
|
|
|
+ Y = K((e) => e.replace(q, '-$1').toLowerCase()),
|
|
|
+ Z = K((e) => e.charAt(0).toUpperCase() + e.slice(1)),
|
|
|
+ X = K((e) => (e ? `on${Z(e)}` : '')),
|
|
|
+ Q = (e, t) => !Object.is(e, t),
|
|
|
+ ee = (e, t) => {
|
|
|
+ for (let n = 0; n < e.length; n++) e[n](t)
|
|
|
+ },
|
|
|
+ te = (e, t, n) => {
|
|
|
+ Object.defineProperty(e, t, {
|
|
|
+ configurable: !0,
|
|
|
+ enumerable: !1,
|
|
|
+ value: n
|
|
|
+ })
|
|
|
+ },
|
|
|
+ ne = (e) => {
|
|
|
+ const t = parseFloat(e)
|
|
|
+ return isNaN(t) ? e : t
|
|
|
+ }
|
|
|
+ let oe
|
|
|
+ const re = () =>
|
|
|
+ oe ||
|
|
|
+ (oe =
|
|
|
+ 'undefined' != typeof globalThis
|
|
|
+ ? globalThis
|
|
|
+ : 'undefined' != typeof self
|
|
|
+ ? self
|
|
|
+ : 'undefined' != typeof window
|
|
|
+ ? window
|
|
|
+ : 'undefined' != typeof global
|
|
|
+ ? global
|
|
|
+ : {})
|
|
|
+ function se(e, ...t) {
|
|
|
+ console.warn(`[Vue warn] ${e}`, ...t)
|
|
|
+ }
|
|
|
+ let ie
|
|
|
+ class ce {
|
|
|
+ constructor(e = !1) {
|
|
|
+ ;(this.detached = e),
|
|
|
+ (this.active = !0),
|
|
|
+ (this.effects = []),
|
|
|
+ (this.cleanups = []),
|
|
|
+ (this.parent = ie),
|
|
|
+ !e && ie && (this.index = (ie.scopes || (ie.scopes = [])).push(this) - 1)
|
|
|
+ }
|
|
|
+ run(e) {
|
|
|
+ if (this.active) {
|
|
|
+ const t = ie
|
|
|
+ try {
|
|
|
+ return (ie = this), e()
|
|
|
+ } finally {
|
|
|
+ ie = t
|
|
|
+ }
|
|
|
+ } else se('cannot run an inactive effect scope.')
|
|
|
+ }
|
|
|
+ on() {
|
|
|
+ ie = this
|
|
|
+ }
|
|
|
+ off() {
|
|
|
+ ie = this.parent
|
|
|
+ }
|
|
|
+ stop(e) {
|
|
|
+ if (this.active) {
|
|
|
+ let t, n
|
|
|
+ for (t = 0, n = this.effects.length; t < n; t++) this.effects[t].stop()
|
|
|
+ for (t = 0, n = this.cleanups.length; t < n; t++) this.cleanups[t]()
|
|
|
+ if (this.scopes) for (t = 0, n = this.scopes.length; t < n; t++) this.scopes[t].stop(!0)
|
|
|
+ if (!this.detached && this.parent && !e) {
|
|
|
+ const e = this.parent.scopes.pop()
|
|
|
+ e && e !== this && ((this.parent.scopes[this.index] = e), (e.index = this.index))
|
|
|
+ }
|
|
|
+ ;(this.parent = void 0), (this.active = !1)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function le(e, t = ie) {
|
|
|
+ t && t.active && t.effects.push(e)
|
|
|
+ }
|
|
|
+ const ae = (e) => {
|
|
|
+ const t = new Set(e)
|
|
|
+ return (t.w = 0), (t.n = 0), t
|
|
|
+ },
|
|
|
+ ue = (e) => (e.w & he) > 0,
|
|
|
+ pe = (e) => (e.n & he) > 0,
|
|
|
+ de = new WeakMap()
|
|
|
+ let fe = 0,
|
|
|
+ he = 1
|
|
|
+ let me
|
|
|
+ const ge = Symbol('iterate'),
|
|
|
+ ye = Symbol('Map key iterate')
|
|
|
+ class ve {
|
|
|
+ constructor(e, t = null, n) {
|
|
|
+ ;(this.fn = e),
|
|
|
+ (this.scheduler = t),
|
|
|
+ (this.active = !0),
|
|
|
+ (this.deps = []),
|
|
|
+ (this.parent = void 0),
|
|
|
+ le(this, n)
|
|
|
+ }
|
|
|
+ run() {
|
|
|
+ if (!this.active) return this.fn()
|
|
|
+ let e = me,
|
|
|
+ t = _e
|
|
|
+ for (; e; ) {
|
|
|
+ if (e === this) return
|
|
|
+ e = e.parent
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ return (
|
|
|
+ (this.parent = me),
|
|
|
+ (me = this),
|
|
|
+ (_e = !0),
|
|
|
+ (he = 1 << ++fe),
|
|
|
+ fe <= 30
|
|
|
+ ? (({ deps: e }) => {
|
|
|
+ if (e.length) for (let t = 0; t < e.length; t++) e[t].w |= he
|
|
|
+ })(this)
|
|
|
+ : be(this),
|
|
|
+ this.fn()
|
|
|
+ )
|
|
|
+ } finally {
|
|
|
+ fe <= 30 &&
|
|
|
+ ((e) => {
|
|
|
+ const { deps: t } = e
|
|
|
+ if (t.length) {
|
|
|
+ let n = 0
|
|
|
+ for (let o = 0; o < t.length; o++) {
|
|
|
+ const r = t[o]
|
|
|
+ ue(r) && !pe(r) ? r.delete(e) : (t[n++] = r), (r.w &= ~he), (r.n &= ~he)
|
|
|
+ }
|
|
|
+ t.length = n
|
|
|
+ }
|
|
|
+ })(this),
|
|
|
+ (he = 1 << --fe),
|
|
|
+ (me = this.parent),
|
|
|
+ (_e = t),
|
|
|
+ (this.parent = void 0),
|
|
|
+ this.deferStop && this.stop()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ stop() {
|
|
|
+ me === this
|
|
|
+ ? (this.deferStop = !0)
|
|
|
+ : this.active && (be(this), this.onStop && this.onStop(), (this.active = !1))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function be(e) {
|
|
|
+ const { deps: t } = e
|
|
|
+ if (t.length) {
|
|
|
+ for (let n = 0; n < t.length; n++) t[n].delete(e)
|
|
|
+ t.length = 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let _e = !0
|
|
|
+ const we = []
|
|
|
+ function xe() {
|
|
|
+ we.push(_e), (_e = !1)
|
|
|
+ }
|
|
|
+ function Se() {
|
|
|
+ const e = we.pop()
|
|
|
+ _e = void 0 === e || e
|
|
|
+ }
|
|
|
+ function Ce(e, t, n) {
|
|
|
+ if (_e && me) {
|
|
|
+ let o = de.get(e)
|
|
|
+ o || de.set(e, (o = new Map()))
|
|
|
+ let r = o.get(n)
|
|
|
+ r || o.set(n, (r = ae()))
|
|
|
+ ke(r, {
|
|
|
+ effect: me,
|
|
|
+ target: e,
|
|
|
+ type: t,
|
|
|
+ key: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ke(e, t) {
|
|
|
+ let n = !1
|
|
|
+ fe <= 30 ? pe(e) || ((e.n |= he), (n = !ue(e))) : (n = !e.has(me)),
|
|
|
+ n &&
|
|
|
+ (e.add(me),
|
|
|
+ me.deps.push(e),
|
|
|
+ me.onTrack &&
|
|
|
+ me.onTrack(
|
|
|
+ Object.assign(
|
|
|
+ {
|
|
|
+ effect: me
|
|
|
+ },
|
|
|
+ t
|
|
|
+ )
|
|
|
+ ))
|
|
|
+ }
|
|
|
+ function Te(e, t, n, o, r, s) {
|
|
|
+ const i = de.get(e)
|
|
|
+ if (!i) return
|
|
|
+ let c = []
|
|
|
+ if ('clear' === t) c = [...i.values()]
|
|
|
+ else if ('length' === n && O(e)) {
|
|
|
+ const e = ne(o)
|
|
|
+ i.forEach((t, n) => {
|
|
|
+ ;('length' === n || n >= e) && c.push(t)
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ switch ((void 0 !== n && c.push(i.get(n)), t)) {
|
|
|
+ case 'add':
|
|
|
+ O(e) ? H(n) && c.push(i.get('length')) : (c.push(i.get(ge)), A(e) && c.push(i.get(ye)))
|
|
|
+ break
|
|
|
+ case 'delete':
|
|
|
+ O(e) || (c.push(i.get(ge)), A(e) && c.push(i.get(ye)))
|
|
|
+ break
|
|
|
+ case 'set':
|
|
|
+ A(e) && c.push(i.get(ge))
|
|
|
+ }
|
|
|
+ const l = {
|
|
|
+ target: e,
|
|
|
+ type: t,
|
|
|
+ key: n,
|
|
|
+ newValue: o,
|
|
|
+ oldValue: r,
|
|
|
+ oldTarget: s
|
|
|
+ }
|
|
|
+ if (1 === c.length) c[0] && $e(c[0], l)
|
|
|
+ else {
|
|
|
+ const e = []
|
|
|
+ for (const t of c) t && e.push(...t)
|
|
|
+ $e(ae(e), l)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function $e(e, t) {
|
|
|
+ const n = O(e) ? e : [...e]
|
|
|
+ for (const e of n) e.computed && Ee(e, t)
|
|
|
+ for (const e of n) e.computed || Ee(e, t)
|
|
|
+ }
|
|
|
+ function Ee(e, t) {
|
|
|
+ ;(e !== me || e.allowRecurse) &&
|
|
|
+ (e.onTrigger &&
|
|
|
+ e.onTrigger(
|
|
|
+ T(
|
|
|
+ {
|
|
|
+ effect: e
|
|
|
+ },
|
|
|
+ t
|
|
|
+ )
|
|
|
+ ),
|
|
|
+ e.scheduler ? e.scheduler() : e.run())
|
|
|
+ }
|
|
|
+ const Ne = t('__proto__,__v_isRef,__isVue'),
|
|
|
+ Oe = new Set(
|
|
|
+ Object.getOwnPropertyNames(Symbol)
|
|
|
+ .filter((e) => 'arguments' !== e && 'caller' !== e)
|
|
|
+ .map((e) => Symbol[e])
|
|
|
+ .filter(F)
|
|
|
+ ),
|
|
|
+ Ae = je(),
|
|
|
+ Ie = je(!1, !0),
|
|
|
+ Re = je(!0),
|
|
|
+ Me = je(!0, !0),
|
|
|
+ Pe = Fe()
|
|
|
+ function Fe() {
|
|
|
+ const e = {}
|
|
|
+ return (
|
|
|
+ ['includes', 'indexOf', 'lastIndexOf'].forEach((t) => {
|
|
|
+ e[t] = function (...e) {
|
|
|
+ const n = kt(this)
|
|
|
+ for (let e = 0, t = this.length; e < t; e++) Ce(n, 'get', e + '')
|
|
|
+ const o = n[t](...e)
|
|
|
+ return -1 === o || !1 === o ? n[t](...e.map(kt)) : o
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ ['push', 'pop', 'shift', 'unshift', 'splice'].forEach((t) => {
|
|
|
+ e[t] = function (...e) {
|
|
|
+ xe()
|
|
|
+ const n = kt(this)[t].apply(this, e)
|
|
|
+ return Se(), n
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function je(e = !1, t = !1) {
|
|
|
+ return function (n, o, r) {
|
|
|
+ if ('__v_isReactive' === o) return !e
|
|
|
+ if ('__v_isReadonly' === o) return e
|
|
|
+ if ('__v_isShallow' === o) return t
|
|
|
+ if ('__v_raw' === o && r === (e ? (t ? mt : ht) : t ? ft : dt).get(n)) return n
|
|
|
+ const s = O(n)
|
|
|
+ if (!e && s && N(Pe, o)) return Reflect.get(Pe, o, r)
|
|
|
+ const i = Reflect.get(n, o, r)
|
|
|
+ return (F(o) ? Oe.has(o) : Ne(o))
|
|
|
+ ? i
|
|
|
+ : (e || Ce(n, 'get', o),
|
|
|
+ t ? i : At(i) ? (s && H(o) ? i : i.value) : j(i) ? (e ? vt(i) : gt(i)) : i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ve(e = !1) {
|
|
|
+ return function (t, n, o, r) {
|
|
|
+ let s = t[n]
|
|
|
+ if (xt(s) && At(s) && !At(o)) return !1
|
|
|
+ if (!e && (St(o) || xt(o) || ((s = kt(s)), (o = kt(o))), !O(t) && At(s) && !At(o)))
|
|
|
+ return (s.value = o), !0
|
|
|
+ const i = O(t) && H(n) ? Number(n) < t.length : N(t, n),
|
|
|
+ c = Reflect.set(t, n, o, r)
|
|
|
+ return t === kt(r) && (i ? Q(o, s) && Te(t, 'set', n, o, s) : Te(t, 'add', n, o)), c
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Le = {
|
|
|
+ get: Ae,
|
|
|
+ set: Ve(),
|
|
|
+ deleteProperty: function (e, t) {
|
|
|
+ const n = N(e, t),
|
|
|
+ o = e[t],
|
|
|
+ r = Reflect.deleteProperty(e, t)
|
|
|
+ return r && n && Te(e, 'delete', t, void 0, o), r
|
|
|
+ },
|
|
|
+ has: function (e, t) {
|
|
|
+ const n = Reflect.has(e, t)
|
|
|
+ return (F(t) && Oe.has(t)) || Ce(e, 'has', t), n
|
|
|
+ },
|
|
|
+ ownKeys: function (e) {
|
|
|
+ return Ce(e, 'iterate', O(e) ? 'length' : ge), Reflect.ownKeys(e)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Be = {
|
|
|
+ get: Re,
|
|
|
+ set: (e, t) => (se(`Set operation on key "${String(t)}" failed: target is readonly.`, e), !0),
|
|
|
+ deleteProperty: (e, t) => (
|
|
|
+ se(`Delete operation on key "${String(t)}" failed: target is readonly.`, e), !0
|
|
|
+ )
|
|
|
+ },
|
|
|
+ Ue = T({}, Le, {
|
|
|
+ get: Ie,
|
|
|
+ set: Ve(!0)
|
|
|
+ }),
|
|
|
+ De = T({}, Be, {
|
|
|
+ get: Me
|
|
|
+ }),
|
|
|
+ He = (e) => e,
|
|
|
+ ze = (e) => Reflect.getPrototypeOf(e)
|
|
|
+ function We(e, t, n = !1, o = !1) {
|
|
|
+ const r = kt((e = e.__v_raw)),
|
|
|
+ s = kt(t)
|
|
|
+ n || (t !== s && Ce(r, 'get', t), Ce(r, 'get', s))
|
|
|
+ const { has: i } = ze(r),
|
|
|
+ c = o ? He : n ? Et : $t
|
|
|
+ return i.call(r, t) ? c(e.get(t)) : i.call(r, s) ? c(e.get(s)) : void (e !== r && e.get(t))
|
|
|
+ }
|
|
|
+ function Ke(e, t = !1) {
|
|
|
+ const n = this.__v_raw,
|
|
|
+ o = kt(n),
|
|
|
+ r = kt(e)
|
|
|
+ return (
|
|
|
+ t || (e !== r && Ce(o, 'has', e), Ce(o, 'has', r)), e === r ? n.has(e) : n.has(e) || n.has(r)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Ge(e, t = !1) {
|
|
|
+ return (e = e.__v_raw), !t && Ce(kt(e), 'iterate', ge), Reflect.get(e, 'size', e)
|
|
|
+ }
|
|
|
+ function Je(e) {
|
|
|
+ e = kt(e)
|
|
|
+ const t = kt(this)
|
|
|
+ return ze(t).has.call(t, e) || (t.add(e), Te(t, 'add', e, e)), this
|
|
|
+ }
|
|
|
+ function qe(e, t) {
|
|
|
+ t = kt(t)
|
|
|
+ const n = kt(this),
|
|
|
+ { has: o, get: r } = ze(n)
|
|
|
+ let s = o.call(n, e)
|
|
|
+ s ? pt(n, o, e) : ((e = kt(e)), (s = o.call(n, e)))
|
|
|
+ const i = r.call(n, e)
|
|
|
+ return n.set(e, t), s ? Q(t, i) && Te(n, 'set', e, t, i) : Te(n, 'add', e, t), this
|
|
|
+ }
|
|
|
+ function Ye(e) {
|
|
|
+ const t = kt(this),
|
|
|
+ { has: n, get: o } = ze(t)
|
|
|
+ let r = n.call(t, e)
|
|
|
+ r ? pt(t, n, e) : ((e = kt(e)), (r = n.call(t, e)))
|
|
|
+ const s = o ? o.call(t, e) : void 0,
|
|
|
+ i = t.delete(e)
|
|
|
+ return r && Te(t, 'delete', e, void 0, s), i
|
|
|
+ }
|
|
|
+ function Ze() {
|
|
|
+ const e = kt(this),
|
|
|
+ t = 0 !== e.size,
|
|
|
+ n = A(e) ? new Map(e) : new Set(e),
|
|
|
+ o = e.clear()
|
|
|
+ return t && Te(e, 'clear', void 0, void 0, n), o
|
|
|
+ }
|
|
|
+ function Xe(e, t) {
|
|
|
+ return function (n, o) {
|
|
|
+ const r = this,
|
|
|
+ s = r.__v_raw,
|
|
|
+ i = kt(s),
|
|
|
+ c = t ? He : e ? Et : $t
|
|
|
+ return !e && Ce(i, 'iterate', ge), s.forEach((e, t) => n.call(o, c(e), c(t), r))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Qe(e, t, n) {
|
|
|
+ return function (...o) {
|
|
|
+ const r = this.__v_raw,
|
|
|
+ s = kt(r),
|
|
|
+ i = A(s),
|
|
|
+ c = 'entries' === e || (e === Symbol.iterator && i),
|
|
|
+ l = 'keys' === e && i,
|
|
|
+ a = r[e](...o),
|
|
|
+ u = n ? He : t ? Et : $t
|
|
|
+ return (
|
|
|
+ !t && Ce(s, 'iterate', l ? ye : ge),
|
|
|
+ {
|
|
|
+ next() {
|
|
|
+ const { value: e, done: t } = a.next()
|
|
|
+ return t
|
|
|
+ ? {
|
|
|
+ value: e,
|
|
|
+ done: t
|
|
|
+ }
|
|
|
+ : {
|
|
|
+ value: c ? [u(e[0]), u(e[1])] : u(e),
|
|
|
+ done: t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ [Symbol.iterator]() {
|
|
|
+ return this
|
|
|
+ }
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function et(e) {
|
|
|
+ return function (...t) {
|
|
|
+ {
|
|
|
+ const n = t[0] ? `on key "${t[0]}" ` : ''
|
|
|
+ console.warn(`${Z(e)} operation ${n}failed: target is readonly.`, kt(this))
|
|
|
+ }
|
|
|
+ return 'delete' !== e && this
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function tt() {
|
|
|
+ const e = {
|
|
|
+ get(e) {
|
|
|
+ return We(this, e)
|
|
|
+ },
|
|
|
+ get size() {
|
|
|
+ return Ge(this)
|
|
|
+ },
|
|
|
+ has: Ke,
|
|
|
+ add: Je,
|
|
|
+ set: qe,
|
|
|
+ delete: Ye,
|
|
|
+ clear: Ze,
|
|
|
+ forEach: Xe(!1, !1)
|
|
|
+ },
|
|
|
+ t = {
|
|
|
+ get(e) {
|
|
|
+ return We(this, e, !1, !0)
|
|
|
+ },
|
|
|
+ get size() {
|
|
|
+ return Ge(this)
|
|
|
+ },
|
|
|
+ has: Ke,
|
|
|
+ add: Je,
|
|
|
+ set: qe,
|
|
|
+ delete: Ye,
|
|
|
+ clear: Ze,
|
|
|
+ forEach: Xe(!1, !0)
|
|
|
+ },
|
|
|
+ n = {
|
|
|
+ get(e) {
|
|
|
+ return We(this, e, !0)
|
|
|
+ },
|
|
|
+ get size() {
|
|
|
+ return Ge(this, !0)
|
|
|
+ },
|
|
|
+ has(e) {
|
|
|
+ return Ke.call(this, e, !0)
|
|
|
+ },
|
|
|
+ add: et('add'),
|
|
|
+ set: et('set'),
|
|
|
+ delete: et('delete'),
|
|
|
+ clear: et('clear'),
|
|
|
+ forEach: Xe(!0, !1)
|
|
|
+ },
|
|
|
+ o = {
|
|
|
+ get(e) {
|
|
|
+ return We(this, e, !0, !0)
|
|
|
+ },
|
|
|
+ get size() {
|
|
|
+ return Ge(this, !0)
|
|
|
+ },
|
|
|
+ has(e) {
|
|
|
+ return Ke.call(this, e, !0)
|
|
|
+ },
|
|
|
+ add: et('add'),
|
|
|
+ set: et('set'),
|
|
|
+ delete: et('delete'),
|
|
|
+ clear: et('clear'),
|
|
|
+ forEach: Xe(!0, !0)
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ ['keys', 'values', 'entries', Symbol.iterator].forEach((r) => {
|
|
|
+ ;(e[r] = Qe(r, !1, !1)),
|
|
|
+ (n[r] = Qe(r, !0, !1)),
|
|
|
+ (t[r] = Qe(r, !1, !0)),
|
|
|
+ (o[r] = Qe(r, !0, !0))
|
|
|
+ }),
|
|
|
+ [e, n, t, o]
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const [nt, ot, rt, st] = tt()
|
|
|
+ function it(e, t) {
|
|
|
+ const n = t ? (e ? st : rt) : e ? ot : nt
|
|
|
+ return (t, o, r) =>
|
|
|
+ '__v_isReactive' === o
|
|
|
+ ? !e
|
|
|
+ : '__v_isReadonly' === o
|
|
|
+ ? e
|
|
|
+ : '__v_raw' === o
|
|
|
+ ? t
|
|
|
+ : Reflect.get(N(n, o) && o in t ? n : t, o, r)
|
|
|
+ }
|
|
|
+ const ct = {
|
|
|
+ get: it(!1, !1)
|
|
|
+ },
|
|
|
+ lt = {
|
|
|
+ get: it(!1, !0)
|
|
|
+ },
|
|
|
+ at = {
|
|
|
+ get: it(!0, !1)
|
|
|
+ },
|
|
|
+ ut = {
|
|
|
+ get: it(!0, !0)
|
|
|
+ }
|
|
|
+ function pt(e, t, n) {
|
|
|
+ const o = kt(n)
|
|
|
+ if (o !== n && t.call(e, o)) {
|
|
|
+ const t = U(e)
|
|
|
+ console.warn(
|
|
|
+ `Reactive ${t} contains both the raw and reactive versions of the same object${
|
|
|
+ 'Map' === t ? ' 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 dt = new WeakMap(),
|
|
|
+ ft = new WeakMap(),
|
|
|
+ ht = new WeakMap(),
|
|
|
+ mt = new WeakMap()
|
|
|
+ function gt(e) {
|
|
|
+ return xt(e) ? e : _t(e, !1, Le, ct, dt)
|
|
|
+ }
|
|
|
+ function yt(e) {
|
|
|
+ return _t(e, !1, Ue, lt, ft)
|
|
|
+ }
|
|
|
+ function vt(e) {
|
|
|
+ return _t(e, !0, Be, at, ht)
|
|
|
+ }
|
|
|
+ function bt(e) {
|
|
|
+ return _t(e, !0, De, ut, mt)
|
|
|
+ }
|
|
|
+ function _t(e, t, n, o, r) {
|
|
|
+ if (!j(e)) return console.warn(`value cannot be made reactive: ${String(e)}`), e
|
|
|
+ if (e.__v_raw && (!t || !e.__v_isReactive)) return e
|
|
|
+ const s = r.get(e)
|
|
|
+ if (s) return s
|
|
|
+ const i =
|
|
|
+ (c = e).__v_skip || !Object.isExtensible(c)
|
|
|
+ ? 0
|
|
|
+ : (function (e) {
|
|
|
+ switch (e) {
|
|
|
+ case 'Object':
|
|
|
+ case 'Array':
|
|
|
+ return 1
|
|
|
+ case 'Map':
|
|
|
+ case 'Set':
|
|
|
+ case 'WeakMap':
|
|
|
+ case 'WeakSet':
|
|
|
+ return 2
|
|
|
+ default:
|
|
|
+ return 0
|
|
|
+ }
|
|
|
+ })(U(c))
|
|
|
+ var c
|
|
|
+ if (0 === i) return e
|
|
|
+ const l = new Proxy(e, 2 === i ? o : n)
|
|
|
+ return r.set(e, l), l
|
|
|
+ }
|
|
|
+ function wt(e) {
|
|
|
+ return xt(e) ? wt(e.__v_raw) : !(!e || !e.__v_isReactive)
|
|
|
+ }
|
|
|
+ function xt(e) {
|
|
|
+ return !(!e || !e.__v_isReadonly)
|
|
|
+ }
|
|
|
+ function St(e) {
|
|
|
+ return !(!e || !e.__v_isShallow)
|
|
|
+ }
|
|
|
+ function Ct(e) {
|
|
|
+ return wt(e) || xt(e)
|
|
|
+ }
|
|
|
+ function kt(e) {
|
|
|
+ const t = e && e.__v_raw
|
|
|
+ return t ? kt(t) : e
|
|
|
+ }
|
|
|
+ function Tt(e) {
|
|
|
+ return te(e, '__v_skip', !0), e
|
|
|
+ }
|
|
|
+ const $t = (e) => (j(e) ? gt(e) : e),
|
|
|
+ Et = (e) => (j(e) ? vt(e) : e)
|
|
|
+ function Nt(e) {
|
|
|
+ _e &&
|
|
|
+ me &&
|
|
|
+ ke((e = kt(e)).dep || (e.dep = ae()), {
|
|
|
+ target: e,
|
|
|
+ type: 'get',
|
|
|
+ key: 'value'
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ot(e, t) {
|
|
|
+ ;(e = kt(e)).dep &&
|
|
|
+ $e(e.dep, {
|
|
|
+ target: e,
|
|
|
+ type: 'set',
|
|
|
+ key: 'value',
|
|
|
+ newValue: t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function At(e) {
|
|
|
+ return !(!e || !0 !== e.__v_isRef)
|
|
|
+ }
|
|
|
+ function It(e) {
|
|
|
+ return Rt(e, !1)
|
|
|
+ }
|
|
|
+ function Rt(e, t) {
|
|
|
+ return At(e) ? e : new Mt(e, t)
|
|
|
+ }
|
|
|
+ class Mt {
|
|
|
+ constructor(e, t) {
|
|
|
+ ;(this.__v_isShallow = t),
|
|
|
+ (this.dep = void 0),
|
|
|
+ (this.__v_isRef = !0),
|
|
|
+ (this._rawValue = t ? e : kt(e)),
|
|
|
+ (this._value = t ? e : $t(e))
|
|
|
+ }
|
|
|
+ get value() {
|
|
|
+ return Nt(this), this._value
|
|
|
+ }
|
|
|
+ set value(e) {
|
|
|
+ const t = this.__v_isShallow || St(e) || xt(e)
|
|
|
+ ;(e = t ? e : kt(e)),
|
|
|
+ Q(e, this._rawValue) && ((this._rawValue = e), (this._value = t ? e : $t(e)), Ot(this, e))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Pt(e) {
|
|
|
+ return At(e) ? e.value : e
|
|
|
+ }
|
|
|
+ const Ft = {
|
|
|
+ get: (e, t, n) => Pt(Reflect.get(e, t, n)),
|
|
|
+ set: (e, t, n, o) => {
|
|
|
+ const r = e[t]
|
|
|
+ return At(r) && !At(n) ? ((r.value = n), !0) : Reflect.set(e, t, n, o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function jt(e) {
|
|
|
+ return wt(e) ? e : new Proxy(e, Ft)
|
|
|
+ }
|
|
|
+ class Vt {
|
|
|
+ constructor(e) {
|
|
|
+ ;(this.dep = void 0), (this.__v_isRef = !0)
|
|
|
+ const { get: t, set: n } = e(
|
|
|
+ () => Nt(this),
|
|
|
+ () => Ot(this)
|
|
|
+ )
|
|
|
+ ;(this._get = t), (this._set = n)
|
|
|
+ }
|
|
|
+ get value() {
|
|
|
+ return this._get()
|
|
|
+ }
|
|
|
+ set value(e) {
|
|
|
+ this._set(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ class Lt {
|
|
|
+ constructor(e, t, n) {
|
|
|
+ ;(this._object = e), (this._key = t), (this._defaultValue = n), (this.__v_isRef = !0)
|
|
|
+ }
|
|
|
+ get value() {
|
|
|
+ const e = this._object[this._key]
|
|
|
+ return void 0 === e ? this._defaultValue : e
|
|
|
+ }
|
|
|
+ set value(e) {
|
|
|
+ this._object[this._key] = e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Bt(e, t, n) {
|
|
|
+ const o = e[t]
|
|
|
+ return At(o) ? o : new Lt(e, t, n)
|
|
|
+ }
|
|
|
+ var Ut
|
|
|
+ class Dt {
|
|
|
+ constructor(e, t, n, o) {
|
|
|
+ ;(this._setter = t),
|
|
|
+ (this.dep = void 0),
|
|
|
+ (this.__v_isRef = !0),
|
|
|
+ (this[Ut] = !1),
|
|
|
+ (this._dirty = !0),
|
|
|
+ (this.effect = new ve(e, () => {
|
|
|
+ this._dirty || ((this._dirty = !0), Ot(this))
|
|
|
+ })),
|
|
|
+ (this.effect.computed = this),
|
|
|
+ (this.effect.active = this._cacheable = !o),
|
|
|
+ (this.__v_isReadonly = n)
|
|
|
+ }
|
|
|
+ get value() {
|
|
|
+ const e = kt(this)
|
|
|
+ return (
|
|
|
+ Nt(e),
|
|
|
+ (!e._dirty && e._cacheable) || ((e._dirty = !1), (e._value = e.effect.run())),
|
|
|
+ e._value
|
|
|
+ )
|
|
|
+ }
|
|
|
+ set value(e) {
|
|
|
+ this._setter(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ut = '__v_isReadonly'
|
|
|
+ const Ht = []
|
|
|
+ function zt(e) {
|
|
|
+ Ht.push(e)
|
|
|
+ }
|
|
|
+ function Wt() {
|
|
|
+ Ht.pop()
|
|
|
+ }
|
|
|
+ function Kt(e, ...t) {
|
|
|
+ xe()
|
|
|
+ const n = Ht.length ? Ht[Ht.length - 1].component : null,
|
|
|
+ o = n && n.appContext.config.warnHandler,
|
|
|
+ r = (function () {
|
|
|
+ let e = Ht[Ht.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 o = e.component && e.component.parent
|
|
|
+ e = o && o.vnode
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ })()
|
|
|
+ if (o)
|
|
|
+ Yt(o, n, 11, [
|
|
|
+ e + t.join(''),
|
|
|
+ n && n.proxy,
|
|
|
+ r.map(({ vnode: e }) => `at <${si(n, e.type)}>`).join('\n'),
|
|
|
+ r
|
|
|
+ ])
|
|
|
+ else {
|
|
|
+ const n = [`[Vue warn]: ${e}`, ...t]
|
|
|
+ r.length &&
|
|
|
+ n.push(
|
|
|
+ '\n',
|
|
|
+ ...(function (e) {
|
|
|
+ const t = []
|
|
|
+ return (
|
|
|
+ e.forEach((e, n) => {
|
|
|
+ t.push(
|
|
|
+ ...(0 === n ? [] : ['\n']),
|
|
|
+ ...(function ({ vnode: e, recurseCount: t }) {
|
|
|
+ const n = t > 0 ? `... (${t} recursive calls)` : '',
|
|
|
+ o = !!e.component && null == e.component.parent,
|
|
|
+ r = ` at <${si(e.component, e.type, o)}`,
|
|
|
+ s = '>' + n
|
|
|
+ return e.props ? [r, ...Gt(e.props), s] : [r + s]
|
|
|
+ })(e)
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ })(r)
|
|
|
+ ),
|
|
|
+ console.warn(...n)
|
|
|
+ }
|
|
|
+ Se()
|
|
|
+ }
|
|
|
+ function Gt(e) {
|
|
|
+ const t = [],
|
|
|
+ n = Object.keys(e)
|
|
|
+ return (
|
|
|
+ n.slice(0, 3).forEach((n) => {
|
|
|
+ t.push(...Jt(n, e[n]))
|
|
|
+ }),
|
|
|
+ n.length > 3 && t.push(' ...'),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Jt(e, t, n) {
|
|
|
+ return P(t)
|
|
|
+ ? ((t = JSON.stringify(t)), n ? t : [`${e}=${t}`])
|
|
|
+ : 'number' == typeof t || 'boolean' == typeof t || null == t
|
|
|
+ ? n
|
|
|
+ ? t
|
|
|
+ : [`${e}=${t}`]
|
|
|
+ : At(t)
|
|
|
+ ? ((t = Jt(e, kt(t.value), !0)), n ? t : [`${e}=Ref<`, t, '>'])
|
|
|
+ : M(t)
|
|
|
+ ? [`${e}=fn${t.name ? `<${t.name}>` : ''}`]
|
|
|
+ : ((t = kt(t)), n ? t : [`${e}=`, t])
|
|
|
+ }
|
|
|
+ const qt = {
|
|
|
+ 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://new-issue.vuejs.org/?repo=vuejs/core'
|
|
|
+ }
|
|
|
+ function Yt(e, t, n, o) {
|
|
|
+ let r
|
|
|
+ try {
|
|
|
+ r = o ? e(...o) : e()
|
|
|
+ } catch (e) {
|
|
|
+ Xt(e, t, n)
|
|
|
+ }
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ function Zt(e, t, n, o) {
|
|
|
+ if (M(e)) {
|
|
|
+ const r = Yt(e, t, n, o)
|
|
|
+ return (
|
|
|
+ r &&
|
|
|
+ V(r) &&
|
|
|
+ r.catch((e) => {
|
|
|
+ Xt(e, t, n)
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const r = []
|
|
|
+ for (let s = 0; s < e.length; s++) r.push(Zt(e[s], t, n, o))
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ function Xt(e, t, n, o = !0) {
|
|
|
+ const r = t ? t.vnode : null
|
|
|
+ if (t) {
|
|
|
+ let o = t.parent
|
|
|
+ const r = t.proxy,
|
|
|
+ s = qt[n]
|
|
|
+ for (; o; ) {
|
|
|
+ const t = o.ec
|
|
|
+ if (t) for (let n = 0; n < t.length; n++) if (!1 === t[n](e, r, s)) return
|
|
|
+ o = o.parent
|
|
|
+ }
|
|
|
+ const i = t.appContext.config.errorHandler
|
|
|
+ if (i) return void Yt(i, null, 10, [e, r, s])
|
|
|
+ }
|
|
|
+ !(function (e, t, n, o = !0) {
|
|
|
+ {
|
|
|
+ const r = qt[t]
|
|
|
+ if (
|
|
|
+ (n && zt(n), Kt('Unhandled error' + (r ? ` during execution of ${r}` : '')), n && Wt(), o)
|
|
|
+ )
|
|
|
+ throw e
|
|
|
+ console.error(e)
|
|
|
+ }
|
|
|
+ })(e, n, r, o)
|
|
|
+ }
|
|
|
+ let Qt = !1,
|
|
|
+ en = !1
|
|
|
+ const tn = []
|
|
|
+ let nn = 0
|
|
|
+ const on = []
|
|
|
+ let rn = null,
|
|
|
+ sn = 0
|
|
|
+ const cn = Promise.resolve()
|
|
|
+ let ln = null
|
|
|
+ function an(e) {
|
|
|
+ const t = ln || cn
|
|
|
+ return e ? t.then(this ? e.bind(this) : e) : t
|
|
|
+ }
|
|
|
+ function un(e) {
|
|
|
+ ;(tn.length && tn.includes(e, Qt && e.allowRecurse ? nn + 1 : nn)) ||
|
|
|
+ (null == e.id
|
|
|
+ ? tn.push(e)
|
|
|
+ : tn.splice(
|
|
|
+ (function (e) {
|
|
|
+ let t = nn + 1,
|
|
|
+ n = tn.length
|
|
|
+ for (; t < n; ) {
|
|
|
+ const o = (t + n) >>> 1
|
|
|
+ mn(tn[o]) < e ? (t = o + 1) : (n = o)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ })(e.id),
|
|
|
+ 0,
|
|
|
+ e
|
|
|
+ ),
|
|
|
+ pn())
|
|
|
+ }
|
|
|
+ function pn() {
|
|
|
+ Qt || en || ((en = !0), (ln = cn.then(yn)))
|
|
|
+ }
|
|
|
+ function dn(e) {
|
|
|
+ O(e) ? on.push(...e) : (rn && rn.includes(e, e.allowRecurse ? sn + 1 : sn)) || on.push(e), pn()
|
|
|
+ }
|
|
|
+ function fn(e, t = Qt ? nn + 1 : 0) {
|
|
|
+ for (e = e || new Map(); t < tn.length; t++) {
|
|
|
+ const n = tn[t]
|
|
|
+ if (n && n.pre) {
|
|
|
+ if (vn(e, n)) continue
|
|
|
+ tn.splice(t, 1), t--, n()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function hn(e) {
|
|
|
+ if (on.length) {
|
|
|
+ const t = [...new Set(on)]
|
|
|
+ if (((on.length = 0), rn)) return void rn.push(...t)
|
|
|
+ for (
|
|
|
+ rn = t, e = e || new Map(), rn.sort((e, t) => mn(e) - mn(t)), sn = 0;
|
|
|
+ sn < rn.length;
|
|
|
+ sn++
|
|
|
+ )
|
|
|
+ vn(e, rn[sn]) || rn[sn]()
|
|
|
+ ;(rn = null), (sn = 0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const mn = (e) => (null == e.id ? 1 / 0 : e.id),
|
|
|
+ gn = (e, t) => {
|
|
|
+ const n = mn(e) - mn(t)
|
|
|
+ if (0 === n) {
|
|
|
+ if (e.pre && !t.pre) return -1
|
|
|
+ if (t.pre && !e.pre) return 1
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function yn(e) {
|
|
|
+ ;(en = !1), (Qt = !0), (e = e || new Map()), tn.sort(gn)
|
|
|
+ const t = (t) => vn(e, t)
|
|
|
+ try {
|
|
|
+ for (nn = 0; nn < tn.length; nn++) {
|
|
|
+ const e = tn[nn]
|
|
|
+ if (e && !1 !== e.active) {
|
|
|
+ if (t(e)) continue
|
|
|
+ Yt(e, null, 14)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } finally {
|
|
|
+ ;(nn = 0), (tn.length = 0), hn(e), (Qt = !1), (ln = null), (tn.length || on.length) && yn(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function vn(e, t) {
|
|
|
+ if (e.has(t)) {
|
|
|
+ const n = e.get(t)
|
|
|
+ if (n > 100) {
|
|
|
+ const e = t.ownerInstance,
|
|
|
+ n = e && ri(e.type)
|
|
|
+ return (
|
|
|
+ Kt(
|
|
|
+ `Maximum recursive updates exceeded${
|
|
|
+ n ? ` in component <${n}>` : ''
|
|
|
+ }. 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.`
|
|
|
+ ),
|
|
|
+ !0
|
|
|
+ )
|
|
|
+ }
|
|
|
+ e.set(t, n + 1)
|
|
|
+ } else e.set(t, 1)
|
|
|
+ }
|
|
|
+ let bn = !1
|
|
|
+ const _n = new Set()
|
|
|
+ re().__VUE_HMR_RUNTIME__ = {
|
|
|
+ createRecord: kn(xn),
|
|
|
+ rerender: kn(function (e, t) {
|
|
|
+ const n = wn.get(e)
|
|
|
+ if (!n) return
|
|
|
+ ;(n.initialDef.render = t),
|
|
|
+ [...n.instances].forEach((e) => {
|
|
|
+ t && ((e.render = t), (Sn(e.type).render = t)),
|
|
|
+ (e.renderCache = []),
|
|
|
+ (bn = !0),
|
|
|
+ e.update(),
|
|
|
+ (bn = !1)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ reload: kn(function (e, t) {
|
|
|
+ const n = wn.get(e)
|
|
|
+ if (!n) return
|
|
|
+ ;(t = Sn(t)), Cn(n.initialDef, t)
|
|
|
+ const o = [...n.instances]
|
|
|
+ for (const e of o) {
|
|
|
+ const o = Sn(e.type)
|
|
|
+ _n.has(o) || (o !== n.initialDef && Cn(o, t), _n.add(o)),
|
|
|
+ e.appContext.optionsCache.delete(e.type),
|
|
|
+ e.ceReload
|
|
|
+ ? (_n.add(o), e.ceReload(t.styles), _n.delete(o))
|
|
|
+ : e.parent
|
|
|
+ ? un(e.parent.update)
|
|
|
+ : e.appContext.reload
|
|
|
+ ? e.appContext.reload()
|
|
|
+ : 'undefined' != typeof window
|
|
|
+ ? window.location.reload()
|
|
|
+ : console.warn(
|
|
|
+ '[HMR] Root or manually mounted instance modified. Full reload required.'
|
|
|
+ )
|
|
|
+ }
|
|
|
+ dn(() => {
|
|
|
+ for (const e of o) _n.delete(Sn(e.type))
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ const wn = new Map()
|
|
|
+ function xn(e, t) {
|
|
|
+ return (
|
|
|
+ !wn.has(e) &&
|
|
|
+ (wn.set(e, {
|
|
|
+ initialDef: Sn(t),
|
|
|
+ instances: new Set()
|
|
|
+ }),
|
|
|
+ !0)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Sn(e) {
|
|
|
+ return ii(e) ? e.__vccOpts : e
|
|
|
+ }
|
|
|
+ function Cn(e, t) {
|
|
|
+ T(e, t)
|
|
|
+ for (const n in e) '__file' === n || n in t || delete e[n]
|
|
|
+ }
|
|
|
+ function kn(e) {
|
|
|
+ return (t, n) => {
|
|
|
+ try {
|
|
|
+ return e(t, n)
|
|
|
+ } catch (e) {
|
|
|
+ console.error(e),
|
|
|
+ console.warn(
|
|
|
+ '[HMR] Something went wrong during Vue component hot-reload. Full reload required.'
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let Tn = [],
|
|
|
+ $n = !1
|
|
|
+ function En(t, ...n) {
|
|
|
+ e.devtools
|
|
|
+ ? e.devtools.emit(t, ...n)
|
|
|
+ : $n ||
|
|
|
+ Tn.push({
|
|
|
+ event: t,
|
|
|
+ args: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Nn(t, n) {
|
|
|
+ var o, r
|
|
|
+ if (((e.devtools = t), e.devtools))
|
|
|
+ (e.devtools.enabled = !0),
|
|
|
+ Tn.forEach(({ event: t, args: n }) => e.devtools.emit(t, ...n)),
|
|
|
+ (Tn = [])
|
|
|
+ else if (
|
|
|
+ 'undefined' != typeof window &&
|
|
|
+ window.HTMLElement &&
|
|
|
+ !(null === (r = null === (o = window.navigator) || void 0 === o ? void 0 : o.userAgent) ||
|
|
|
+ void 0 === r
|
|
|
+ ? void 0
|
|
|
+ : r.includes('jsdom'))
|
|
|
+ ) {
|
|
|
+ ;(n.__VUE_DEVTOOLS_HOOK_REPLAY__ = n.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((e) => {
|
|
|
+ Nn(e, n)
|
|
|
+ }),
|
|
|
+ setTimeout(() => {
|
|
|
+ e.devtools || ((n.__VUE_DEVTOOLS_HOOK_REPLAY__ = null), ($n = !0), (Tn = []))
|
|
|
+ }, 3e3)
|
|
|
+ } else ($n = !0), (Tn = [])
|
|
|
+ }
|
|
|
+ const On = Rn('component:added'),
|
|
|
+ An = Rn('component:updated'),
|
|
|
+ In = Rn('component:removed')
|
|
|
+ function Rn(e) {
|
|
|
+ return (t) => {
|
|
|
+ En(e, t.appContext.app, t.uid, t.parent ? t.parent.uid : void 0, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Mn = Fn('perf:start'),
|
|
|
+ Pn = Fn('perf:end')
|
|
|
+ function Fn(e) {
|
|
|
+ return (t, n, o) => {
|
|
|
+ En(e, t.appContext.app, t.uid, t, n, o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function jn(e, t, ...n) {
|
|
|
+ if (e.isUnmounted) return
|
|
|
+ const o = e.vnode.props || b
|
|
|
+ {
|
|
|
+ const {
|
|
|
+ emitsOptions: o,
|
|
|
+ propsOptions: [r]
|
|
|
+ } = e
|
|
|
+ if (o)
|
|
|
+ if (t in o) {
|
|
|
+ const e = o[t]
|
|
|
+ if (M(e)) {
|
|
|
+ e(...n) || Kt(`Invalid event arguments: event validation failed for event "${t}".`)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ (r && X(t) in r) ||
|
|
|
+ Kt(
|
|
|
+ `Component emitted event "${t}" but it is neither declared in the emits option nor as an "${X(
|
|
|
+ t
|
|
|
+ )}" prop.`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ let r = n
|
|
|
+ const s = t.startsWith('update:'),
|
|
|
+ i = s && t.slice(7)
|
|
|
+ if (i && i in o) {
|
|
|
+ const e = `${'modelValue' === i ? 'model' : i}Modifiers`,
|
|
|
+ { number: t, trim: s } = o[e] || b
|
|
|
+ s && (r = n.map((e) => (P(e) ? e.trim() : e))), t && (r = n.map(ne))
|
|
|
+ }
|
|
|
+ !(function (e, t, n) {
|
|
|
+ En('component:emit', e.appContext.app, e, t, n)
|
|
|
+ })(e, t, r)
|
|
|
+ {
|
|
|
+ const n = t.toLowerCase()
|
|
|
+ n !== t &&
|
|
|
+ o[X(n)] &&
|
|
|
+ Kt(
|
|
|
+ `Event "${n}" is emitted in component ${si(
|
|
|
+ e,
|
|
|
+ e.type
|
|
|
+ )} but the handler is registered for "${t}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${Y(
|
|
|
+ t
|
|
|
+ )}" instead of "${t}".`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ let c,
|
|
|
+ l = o[(c = X(t))] || o[(c = X(J(t)))]
|
|
|
+ !l && s && (l = o[(c = X(Y(t)))]), l && Zt(l, e, 6, r)
|
|
|
+ const a = o[c + 'Once']
|
|
|
+ if (a) {
|
|
|
+ if (e.emitted) {
|
|
|
+ if (e.emitted[c]) return
|
|
|
+ } else e.emitted = {}
|
|
|
+ ;(e.emitted[c] = !0), Zt(a, e, 6, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Vn(e, t, n = !1) {
|
|
|
+ const o = t.emitsCache,
|
|
|
+ r = o.get(e)
|
|
|
+ if (void 0 !== r) return r
|
|
|
+ const s = e.emits
|
|
|
+ let i = {},
|
|
|
+ c = !1
|
|
|
+ if (!M(e)) {
|
|
|
+ const o = (e) => {
|
|
|
+ const n = Vn(e, t, !0)
|
|
|
+ n && ((c = !0), T(i, n))
|
|
|
+ }
|
|
|
+ !n && t.mixins.length && t.mixins.forEach(o),
|
|
|
+ e.extends && o(e.extends),
|
|
|
+ e.mixins && e.mixins.forEach(o)
|
|
|
+ }
|
|
|
+ return s || c
|
|
|
+ ? (O(s) ? s.forEach((e) => (i[e] = null)) : T(i, s), j(e) && o.set(e, i), i)
|
|
|
+ : (j(e) && o.set(e, null), null)
|
|
|
+ }
|
|
|
+ function Ln(e, t) {
|
|
|
+ return (
|
|
|
+ !(!e || !C(t)) &&
|
|
|
+ ((t = t.slice(2).replace(/Once$/, '')),
|
|
|
+ N(e, t[0].toLowerCase() + t.slice(1)) || N(e, Y(t)) || N(e, t))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ let Bn = null,
|
|
|
+ Un = null
|
|
|
+ function Dn(e) {
|
|
|
+ const t = Bn
|
|
|
+ return (Bn = e), (Un = (e && e.type.__scopeId) || null), t
|
|
|
+ }
|
|
|
+ function Hn(e, t = Bn, n) {
|
|
|
+ if (!t) return e
|
|
|
+ if (e._n) return e
|
|
|
+ const o = (...n) => {
|
|
|
+ o._d && _s(-1)
|
|
|
+ const r = Dn(t)
|
|
|
+ let s
|
|
|
+ try {
|
|
|
+ s = e(...n)
|
|
|
+ } finally {
|
|
|
+ Dn(r), o._d && _s(1)
|
|
|
+ }
|
|
|
+ return An(t), s
|
|
|
+ }
|
|
|
+ return (o._n = !0), (o._c = !0), (o._d = !0), o
|
|
|
+ }
|
|
|
+ let zn = !1
|
|
|
+ function Wn() {
|
|
|
+ zn = !0
|
|
|
+ }
|
|
|
+ function Kn(e) {
|
|
|
+ const {
|
|
|
+ type: t,
|
|
|
+ vnode: n,
|
|
|
+ proxy: o,
|
|
|
+ withProxy: r,
|
|
|
+ props: s,
|
|
|
+ propsOptions: [i],
|
|
|
+ slots: c,
|
|
|
+ attrs: l,
|
|
|
+ emit: a,
|
|
|
+ render: u,
|
|
|
+ renderCache: p,
|
|
|
+ data: d,
|
|
|
+ setupState: f,
|
|
|
+ ctx: h,
|
|
|
+ inheritAttrs: m
|
|
|
+ } = e
|
|
|
+ let g, y
|
|
|
+ const v = Dn(e)
|
|
|
+ zn = !1
|
|
|
+ try {
|
|
|
+ if (4 & n.shapeFlag) {
|
|
|
+ const e = r || o
|
|
|
+ ;(g = Ms(u.call(e, e, p, s, f, d, h))), (y = l)
|
|
|
+ } else {
|
|
|
+ const e = t
|
|
|
+ l === s && Wn(),
|
|
|
+ (g = Ms(
|
|
|
+ e.length > 1
|
|
|
+ ? e(s, {
|
|
|
+ get attrs() {
|
|
|
+ return Wn(), l
|
|
|
+ },
|
|
|
+ slots: c,
|
|
|
+ emit: a
|
|
|
+ })
|
|
|
+ : e(s, null)
|
|
|
+ )),
|
|
|
+ (y = t.props ? l : qn(l))
|
|
|
+ }
|
|
|
+ } catch (t) {
|
|
|
+ ;(hs.length = 0), Xt(t, e, 1), (g = Ns(ds))
|
|
|
+ }
|
|
|
+ let b,
|
|
|
+ _ = g
|
|
|
+ if ((g.patchFlag > 0 && 2048 & g.patchFlag && ([_, b] = Gn(g)), y && !1 !== m)) {
|
|
|
+ const e = Object.keys(y),
|
|
|
+ { shapeFlag: t } = _
|
|
|
+ if (e.length)
|
|
|
+ if (7 & t) i && e.some(k) && (y = Yn(y, i)), (_ = As(_, y))
|
|
|
+ else if (!zn && _.type !== ds) {
|
|
|
+ const e = Object.keys(l),
|
|
|
+ t = [],
|
|
|
+ n = []
|
|
|
+ for (let o = 0, r = e.length; o < r; o++) {
|
|
|
+ const r = e[o]
|
|
|
+ C(r) ? k(r) || t.push(r[2].toLowerCase() + r.slice(3)) : n.push(r)
|
|
|
+ }
|
|
|
+ n.length &&
|
|
|
+ Kt(
|
|
|
+ `Extraneous non-props attributes (${n.join(
|
|
|
+ ', '
|
|
|
+ )}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
|
|
|
+ ),
|
|
|
+ t.length &&
|
|
|
+ Kt(
|
|
|
+ `Extraneous non-emits event listeners (${t.join(
|
|
|
+ ', '
|
|
|
+ )}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ n.dirs &&
|
|
|
+ (Zn(_) ||
|
|
|
+ Kt(
|
|
|
+ 'Runtime directive used on component with non-element root node. The directives will not function as intended.'
|
|
|
+ ),
|
|
|
+ (_ = As(_)),
|
|
|
+ (_.dirs = _.dirs ? _.dirs.concat(n.dirs) : n.dirs)),
|
|
|
+ n.transition &&
|
|
|
+ (Zn(_) ||
|
|
|
+ Kt(
|
|
|
+ 'Component inside <Transition> renders non-element root node that cannot be animated.'
|
|
|
+ ),
|
|
|
+ (_.transition = n.transition)),
|
|
|
+ b ? b(_) : (g = _),
|
|
|
+ Dn(v),
|
|
|
+ g
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Gn = (e) => {
|
|
|
+ const t = e.children,
|
|
|
+ n = e.dynamicChildren,
|
|
|
+ o = Jn(t)
|
|
|
+ if (!o) return [e, void 0]
|
|
|
+ const r = t.indexOf(o),
|
|
|
+ s = n ? n.indexOf(o) : -1
|
|
|
+ return [
|
|
|
+ Ms(o),
|
|
|
+ (o) => {
|
|
|
+ ;(t[r] = o), n && (s > -1 ? (n[s] = o) : o.patchFlag > 0 && (e.dynamicChildren = [...n, o]))
|
|
|
+ }
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ function Jn(e) {
|
|
|
+ let t
|
|
|
+ for (let n = 0; n < e.length; n++) {
|
|
|
+ const o = e[n]
|
|
|
+ if (!Ss(o)) return
|
|
|
+ if (o.type !== ds || 'v-if' === o.children) {
|
|
|
+ if (t) return
|
|
|
+ t = o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ const qn = (e) => {
|
|
|
+ let t
|
|
|
+ for (const n in e) ('class' === n || 'style' === n || C(n)) && ((t || (t = {}))[n] = e[n])
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ Yn = (e, t) => {
|
|
|
+ const n = {}
|
|
|
+ for (const o in e) (k(o) && o.slice(9) in t) || (n[o] = e[o])
|
|
|
+ return n
|
|
|
+ },
|
|
|
+ Zn = (e) => 7 & e.shapeFlag || e.type === ds
|
|
|
+ function Xn(e, t, n) {
|
|
|
+ const o = Object.keys(t)
|
|
|
+ if (o.length !== Object.keys(e).length) return !0
|
|
|
+ for (let r = 0; r < o.length; r++) {
|
|
|
+ const s = o[r]
|
|
|
+ if (t[s] !== e[s] && !Ln(n, s)) return !0
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ function Qn({ vnode: e, parent: t }, n) {
|
|
|
+ for (; t && t.subTree === e; ) ((e = t.vnode).el = n), (t = t.parent)
|
|
|
+ }
|
|
|
+ const eo = (e) => e.__isSuspense,
|
|
|
+ to = {
|
|
|
+ name: 'Suspense',
|
|
|
+ __isSuspense: !0,
|
|
|
+ process(e, t, n, o, r, s, i, c, l, a) {
|
|
|
+ null == e
|
|
|
+ ? (function (e, t, n, o, r, s, i, c, l) {
|
|
|
+ const {
|
|
|
+ p: a,
|
|
|
+ o: { createElement: u }
|
|
|
+ } = l,
|
|
|
+ p = u('div'),
|
|
|
+ d = (e.suspense = ro(e, r, o, t, p, n, s, i, c, l))
|
|
|
+ a(null, (d.pendingBranch = e.ssContent), p, null, o, d, s, i),
|
|
|
+ d.deps > 0
|
|
|
+ ? (no(e, 'onPending'),
|
|
|
+ no(e, 'onFallback'),
|
|
|
+ a(null, e.ssFallback, t, n, o, null, s, i),
|
|
|
+ co(d, e.ssFallback))
|
|
|
+ : d.resolve()
|
|
|
+ })(t, n, o, r, s, i, c, l, a)
|
|
|
+ : (function (e, t, n, o, r, s, i, c, { p: l, um: a, o: { createElement: u } }) {
|
|
|
+ const p = (t.suspense = e.suspense)
|
|
|
+ ;(p.vnode = t), (t.el = e.el)
|
|
|
+ const d = t.ssContent,
|
|
|
+ f = t.ssFallback,
|
|
|
+ { activeBranch: h, pendingBranch: m, isInFallback: g, isHydrating: y } = p
|
|
|
+ if (m)
|
|
|
+ (p.pendingBranch = d),
|
|
|
+ Cs(d, m)
|
|
|
+ ? (l(m, d, p.hiddenContainer, null, r, p, s, i, c),
|
|
|
+ p.deps <= 0 ? p.resolve() : g && (l(h, f, n, o, r, null, s, i, c), co(p, f)))
|
|
|
+ : (p.pendingId++,
|
|
|
+ y ? ((p.isHydrating = !1), (p.activeBranch = m)) : a(m, r, p),
|
|
|
+ (p.deps = 0),
|
|
|
+ (p.effects.length = 0),
|
|
|
+ (p.hiddenContainer = u('div')),
|
|
|
+ g
|
|
|
+ ? (l(null, d, p.hiddenContainer, null, r, p, s, i, c),
|
|
|
+ p.deps <= 0 ? p.resolve() : (l(h, f, n, o, r, null, s, i, c), co(p, f)))
|
|
|
+ : h && Cs(d, h)
|
|
|
+ ? (l(h, d, n, o, r, p, s, i, c), p.resolve(!0))
|
|
|
+ : (l(null, d, p.hiddenContainer, null, r, p, s, i, c),
|
|
|
+ p.deps <= 0 && p.resolve()))
|
|
|
+ else if (h && Cs(d, h)) l(h, d, n, o, r, p, s, i, c), co(p, d)
|
|
|
+ else if (
|
|
|
+ (no(t, 'onPending'),
|
|
|
+ (p.pendingBranch = d),
|
|
|
+ p.pendingId++,
|
|
|
+ l(null, d, p.hiddenContainer, null, r, p, s, i, c),
|
|
|
+ p.deps <= 0)
|
|
|
+ )
|
|
|
+ p.resolve()
|
|
|
+ else {
|
|
|
+ const { timeout: e, pendingId: t } = p
|
|
|
+ e > 0
|
|
|
+ ? setTimeout(() => {
|
|
|
+ p.pendingId === t && p.fallback(f)
|
|
|
+ }, e)
|
|
|
+ : 0 === e && p.fallback(f)
|
|
|
+ }
|
|
|
+ })(e, t, n, o, r, i, c, l, a)
|
|
|
+ },
|
|
|
+ hydrate: function (e, t, n, o, r, s, i, c, l) {
|
|
|
+ const a = (t.suspense = ro(
|
|
|
+ t,
|
|
|
+ o,
|
|
|
+ n,
|
|
|
+ e.parentNode,
|
|
|
+ document.createElement('div'),
|
|
|
+ null,
|
|
|
+ r,
|
|
|
+ s,
|
|
|
+ i,
|
|
|
+ c,
|
|
|
+ !0
|
|
|
+ )),
|
|
|
+ u = l(e, (a.pendingBranch = t.ssContent), n, a, s, i)
|
|
|
+ 0 === a.deps && a.resolve()
|
|
|
+ return u
|
|
|
+ },
|
|
|
+ create: ro,
|
|
|
+ normalize: function (e) {
|
|
|
+ const { shapeFlag: t, children: n } = e,
|
|
|
+ o = 32 & t
|
|
|
+ ;(e.ssContent = so(o ? n.default : n)), (e.ssFallback = o ? so(n.fallback) : Ns(ds))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function no(e, t) {
|
|
|
+ const n = e.props && e.props[t]
|
|
|
+ M(n) && n()
|
|
|
+ }
|
|
|
+ let oo = !1
|
|
|
+ function ro(e, t, n, o, r, s, i, c, l, a, u = !1) {
|
|
|
+ oo ||
|
|
|
+ ((oo = !0),
|
|
|
+ console[console.info ? 'info' : 'log'](
|
|
|
+ '<Suspense> is an experimental feature and its API will likely change.'
|
|
|
+ ))
|
|
|
+ const {
|
|
|
+ p: p,
|
|
|
+ m: d,
|
|
|
+ um: f,
|
|
|
+ n: h,
|
|
|
+ o: { parentNode: m, remove: g }
|
|
|
+ } = a,
|
|
|
+ y = ne(e.props && e.props.timeout),
|
|
|
+ v = {
|
|
|
+ vnode: e,
|
|
|
+ parent: t,
|
|
|
+ parentComponent: n,
|
|
|
+ isSVG: i,
|
|
|
+ container: o,
|
|
|
+ hiddenContainer: r,
|
|
|
+ anchor: s,
|
|
|
+ deps: 0,
|
|
|
+ pendingId: 0,
|
|
|
+ timeout: 'number' == typeof y ? y : -1,
|
|
|
+ activeBranch: null,
|
|
|
+ pendingBranch: null,
|
|
|
+ isInFallback: !0,
|
|
|
+ isHydrating: u,
|
|
|
+ isUnmounted: !1,
|
|
|
+ effects: [],
|
|
|
+ resolve(e = !1) {
|
|
|
+ if (!e && !v.pendingBranch)
|
|
|
+ throw new Error('suspense.resolve() is called without a pending branch.')
|
|
|
+ if (v.isUnmounted)
|
|
|
+ throw new Error(
|
|
|
+ 'suspense.resolve() is called on an already unmounted suspense boundary.'
|
|
|
+ )
|
|
|
+ const {
|
|
|
+ vnode: t,
|
|
|
+ activeBranch: n,
|
|
|
+ pendingBranch: o,
|
|
|
+ pendingId: r,
|
|
|
+ effects: s,
|
|
|
+ parentComponent: i,
|
|
|
+ container: c
|
|
|
+ } = v
|
|
|
+ if (v.isHydrating) v.isHydrating = !1
|
|
|
+ else if (!e) {
|
|
|
+ const e = n && o.transition && 'out-in' === o.transition.mode
|
|
|
+ e &&
|
|
|
+ (n.transition.afterLeave = () => {
|
|
|
+ r === v.pendingId && d(o, c, t, 0)
|
|
|
+ })
|
|
|
+ let { anchor: t } = v
|
|
|
+ n && ((t = h(n)), f(n, i, v, !0)), e || d(o, c, t, 0)
|
|
|
+ }
|
|
|
+ co(v, o), (v.pendingBranch = null), (v.isInFallback = !1)
|
|
|
+ let l = v.parent,
|
|
|
+ a = !1
|
|
|
+ for (; l; ) {
|
|
|
+ if (l.pendingBranch) {
|
|
|
+ l.effects.push(...s), (a = !0)
|
|
|
+ break
|
|
|
+ }
|
|
|
+ l = l.parent
|
|
|
+ }
|
|
|
+ a || dn(s), (v.effects = []), no(t, 'onResolve')
|
|
|
+ },
|
|
|
+ fallback(e) {
|
|
|
+ if (!v.pendingBranch) return
|
|
|
+ const { vnode: t, activeBranch: n, parentComponent: o, container: r, isSVG: s } = v
|
|
|
+ no(t, 'onFallback')
|
|
|
+ const i = h(n),
|
|
|
+ a = () => {
|
|
|
+ v.isInFallback && (p(null, e, r, i, o, null, s, c, l), co(v, e))
|
|
|
+ },
|
|
|
+ u = e.transition && 'out-in' === e.transition.mode
|
|
|
+ u && (n.transition.afterLeave = a), (v.isInFallback = !0), f(n, o, null, !0), u || a()
|
|
|
+ },
|
|
|
+ move(e, t, n) {
|
|
|
+ v.activeBranch && d(v.activeBranch, e, t, n), (v.container = e)
|
|
|
+ },
|
|
|
+ next: () => v.activeBranch && h(v.activeBranch),
|
|
|
+ registerDep(e, t) {
|
|
|
+ const n = !!v.pendingBranch
|
|
|
+ n && v.deps++
|
|
|
+ const o = e.vnode.el
|
|
|
+ e.asyncDep
|
|
|
+ .catch((t) => {
|
|
|
+ Xt(t, e, 0)
|
|
|
+ })
|
|
|
+ .then((r) => {
|
|
|
+ if (e.isUnmounted || v.isUnmounted || v.pendingId !== e.suspenseId) return
|
|
|
+ e.asyncResolved = !0
|
|
|
+ const { vnode: s } = e
|
|
|
+ zt(s), Zs(e, r, !1), o && (s.el = o)
|
|
|
+ const c = !o && e.subTree.el
|
|
|
+ t(e, s, m(o || e.subTree.el), o ? null : h(e.subTree), v, i, l),
|
|
|
+ c && g(c),
|
|
|
+ Qn(e, s.el),
|
|
|
+ Wt(),
|
|
|
+ n && 0 == --v.deps && v.resolve()
|
|
|
+ })
|
|
|
+ },
|
|
|
+ unmount(e, t) {
|
|
|
+ ;(v.isUnmounted = !0),
|
|
|
+ v.activeBranch && f(v.activeBranch, n, e, t),
|
|
|
+ v.pendingBranch && f(v.pendingBranch, n, e, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return v
|
|
|
+ }
|
|
|
+ function so(e) {
|
|
|
+ let t
|
|
|
+ if (M(e)) {
|
|
|
+ const n = bs && e._c
|
|
|
+ n && ((e._d = !1), gs()), (e = e()), n && ((e._d = !0), (t = ms), ys())
|
|
|
+ }
|
|
|
+ if (O(e)) {
|
|
|
+ const t = Jn(e)
|
|
|
+ t || Kt('<Suspense> slots expect a single root node.'), (e = t)
|
|
|
+ }
|
|
|
+ return (e = Ms(e)), t && !e.dynamicChildren && (e.dynamicChildren = t.filter((t) => t !== e)), e
|
|
|
+ }
|
|
|
+ function io(e, t) {
|
|
|
+ t && t.pendingBranch ? (O(e) ? t.effects.push(...e) : t.effects.push(e)) : dn(e)
|
|
|
+ }
|
|
|
+ function co(e, t) {
|
|
|
+ e.activeBranch = t
|
|
|
+ const { vnode: n, parentComponent: o } = e,
|
|
|
+ r = (n.el = t.el)
|
|
|
+ o && o.subTree === n && ((o.vnode.el = r), Qn(o, r))
|
|
|
+ }
|
|
|
+ function lo(e, t) {
|
|
|
+ if (Us) {
|
|
|
+ let n = Us.provides
|
|
|
+ const o = Us.parent && Us.parent.provides
|
|
|
+ o === n && (n = Us.provides = Object.create(o)), (n[e] = t)
|
|
|
+ } else Kt('provide() can only be used inside setup().')
|
|
|
+ }
|
|
|
+ function ao(e, t, n = !1) {
|
|
|
+ const o = Us || Bn
|
|
|
+ if (o) {
|
|
|
+ const r =
|
|
|
+ null == o.parent ? o.vnode.appContext && o.vnode.appContext.provides : o.parent.provides
|
|
|
+ if (r && e in r) return r[e]
|
|
|
+ if (arguments.length > 1) return n && M(t) ? t.call(o.proxy) : t
|
|
|
+ Kt(`injection "${String(e)}" not found.`)
|
|
|
+ } else Kt('inject() can only be used inside setup() or functional components.')
|
|
|
+ }
|
|
|
+ function uo(e, t) {
|
|
|
+ return ho(
|
|
|
+ e,
|
|
|
+ null,
|
|
|
+ Object.assign(Object.assign({}, t), {
|
|
|
+ flush: 'post'
|
|
|
+ })
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const po = {}
|
|
|
+ function fo(e, t, n) {
|
|
|
+ return (
|
|
|
+ M(t) ||
|
|
|
+ Kt(
|
|
|
+ '`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature.'
|
|
|
+ ),
|
|
|
+ ho(e, t, n)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ho(e, t, { immediate: n, deep: o, flush: r, onTrack: s, onTrigger: i } = b) {
|
|
|
+ t ||
|
|
|
+ (void 0 !== n &&
|
|
|
+ Kt(
|
|
|
+ 'watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'
|
|
|
+ ),
|
|
|
+ void 0 !== o &&
|
|
|
+ Kt(
|
|
|
+ 'watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'
|
|
|
+ ))
|
|
|
+ const c = (e) => {
|
|
|
+ Kt(
|
|
|
+ 'Invalid watch source: ',
|
|
|
+ e,
|
|
|
+ 'A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.'
|
|
|
+ )
|
|
|
+ },
|
|
|
+ l = Us
|
|
|
+ let a,
|
|
|
+ u,
|
|
|
+ p = !1,
|
|
|
+ d = !1
|
|
|
+ if (
|
|
|
+ (At(e)
|
|
|
+ ? ((a = () => e.value), (p = St(e)))
|
|
|
+ : wt(e)
|
|
|
+ ? ((a = () => e), (o = !0))
|
|
|
+ : O(e)
|
|
|
+ ? ((d = !0),
|
|
|
+ (p = e.some((e) => wt(e) || St(e))),
|
|
|
+ (a = () =>
|
|
|
+ e.map((e) => (At(e) ? e.value : wt(e) ? yo(e) : M(e) ? Yt(e, l, 2) : void c(e)))))
|
|
|
+ : M(e)
|
|
|
+ ? (a = t
|
|
|
+ ? () => Yt(e, l, 2)
|
|
|
+ : () => {
|
|
|
+ if (!l || !l.isUnmounted) return u && u(), Zt(e, l, 3, [f])
|
|
|
+ })
|
|
|
+ : ((a = w), c(e)),
|
|
|
+ t && o)
|
|
|
+ ) {
|
|
|
+ const e = a
|
|
|
+ a = () => yo(e())
|
|
|
+ }
|
|
|
+ let f = (e) => {
|
|
|
+ u = y.onStop = () => {
|
|
|
+ Yt(e, l, 4)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ h = d ? new Array(e.length).fill(po) : po
|
|
|
+ const m = () => {
|
|
|
+ if (y.active)
|
|
|
+ if (t) {
|
|
|
+ const e = y.run()
|
|
|
+ ;(o || p || (d ? e.some((e, t) => Q(e, h[t])) : Q(e, h))) &&
|
|
|
+ (u && u(), Zt(t, l, 3, [e, h === po ? void 0 : d && h[0] === po ? [] : h, f]), (h = e))
|
|
|
+ } else y.run()
|
|
|
+ }
|
|
|
+ let g
|
|
|
+ ;(m.allowRecurse = !!t),
|
|
|
+ 'sync' === r
|
|
|
+ ? (g = m)
|
|
|
+ : 'post' === r
|
|
|
+ ? (g = () => Xr(m, l && l.suspense))
|
|
|
+ : ((m.pre = !0), l && (m.id = l.uid), (g = () => un(m)))
|
|
|
+ const y = new ve(a, g)
|
|
|
+ ;(y.onTrack = s),
|
|
|
+ (y.onTrigger = i),
|
|
|
+ t ? (n ? m() : (h = y.run())) : 'post' === r ? Xr(y.run.bind(y), l && l.suspense) : y.run()
|
|
|
+ return () => {
|
|
|
+ y.stop(), l && l.scope && $(l.scope.effects, y)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function mo(e, t, n) {
|
|
|
+ const o = this.proxy,
|
|
|
+ r = P(e) ? (e.includes('.') ? go(o, e) : () => o[e]) : e.bind(o, o)
|
|
|
+ let s
|
|
|
+ M(t) ? (s = t) : ((s = t.handler), (n = t))
|
|
|
+ const i = Us
|
|
|
+ Hs(this)
|
|
|
+ const c = ho(r, s.bind(o), n)
|
|
|
+ return i ? Hs(i) : zs(), c
|
|
|
+ }
|
|
|
+ function go(e, t) {
|
|
|
+ const n = t.split('.')
|
|
|
+ return () => {
|
|
|
+ let t = e
|
|
|
+ for (let e = 0; e < n.length && t; e++) t = t[n[e]]
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yo(e, t) {
|
|
|
+ if (!j(e) || e.__v_skip) return e
|
|
|
+ if ((t = t || new Set()).has(e)) return e
|
|
|
+ if ((t.add(e), At(e))) yo(e.value, t)
|
|
|
+ else if (O(e)) for (let n = 0; n < e.length; n++) yo(e[n], t)
|
|
|
+ else if (I(e) || A(e))
|
|
|
+ e.forEach((e) => {
|
|
|
+ yo(e, t)
|
|
|
+ })
|
|
|
+ else if (D(e)) for (const n in e) yo(e[n], t)
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function vo() {
|
|
|
+ const e = {
|
|
|
+ isMounted: !1,
|
|
|
+ isLeaving: !1,
|
|
|
+ isUnmounting: !1,
|
|
|
+ leavingVNodes: new Map()
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ Do(() => {
|
|
|
+ e.isMounted = !0
|
|
|
+ }),
|
|
|
+ Wo(() => {
|
|
|
+ e.isUnmounting = !0
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const bo = [Function, Array],
|
|
|
+ _o = {
|
|
|
+ name: 'BaseTransition',
|
|
|
+ props: {
|
|
|
+ mode: String,
|
|
|
+ appear: Boolean,
|
|
|
+ persisted: Boolean,
|
|
|
+ onBeforeEnter: bo,
|
|
|
+ onEnter: bo,
|
|
|
+ onAfterEnter: bo,
|
|
|
+ onEnterCancelled: bo,
|
|
|
+ onBeforeLeave: bo,
|
|
|
+ onLeave: bo,
|
|
|
+ onAfterLeave: bo,
|
|
|
+ onLeaveCancelled: bo,
|
|
|
+ onBeforeAppear: bo,
|
|
|
+ onAppear: bo,
|
|
|
+ onAfterAppear: bo,
|
|
|
+ onAppearCancelled: bo
|
|
|
+ },
|
|
|
+ setup(e, { slots: t }) {
|
|
|
+ const n = Ds(),
|
|
|
+ o = vo()
|
|
|
+ let r
|
|
|
+ return () => {
|
|
|
+ const s = t.default && To(t.default(), !0)
|
|
|
+ if (!s || !s.length) return
|
|
|
+ let i = s[0]
|
|
|
+ if (s.length > 1) {
|
|
|
+ let e = !1
|
|
|
+ for (const t of s)
|
|
|
+ if (t.type !== ds) {
|
|
|
+ if (e) {
|
|
|
+ Kt(
|
|
|
+ '<transition> can only be used on a single element or component. Use <transition-group> for lists.'
|
|
|
+ )
|
|
|
+ break
|
|
|
+ }
|
|
|
+ ;(i = t), (e = !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const c = kt(e),
|
|
|
+ { mode: l } = c
|
|
|
+ if (
|
|
|
+ (l &&
|
|
|
+ 'in-out' !== l &&
|
|
|
+ 'out-in' !== l &&
|
|
|
+ 'default' !== l &&
|
|
|
+ Kt(`invalid <transition> mode: ${l}`),
|
|
|
+ o.isLeaving)
|
|
|
+ )
|
|
|
+ return So(i)
|
|
|
+ const a = Co(i)
|
|
|
+ if (!a) return So(i)
|
|
|
+ const u = xo(a, c, o, n)
|
|
|
+ ko(a, u)
|
|
|
+ const p = n.subTree,
|
|
|
+ d = p && Co(p)
|
|
|
+ let f = !1
|
|
|
+ const { getTransitionKey: h } = a.type
|
|
|
+ if (h) {
|
|
|
+ const e = h()
|
|
|
+ void 0 === r ? (r = e) : e !== r && ((r = e), (f = !0))
|
|
|
+ }
|
|
|
+ if (d && d.type !== ds && (!Cs(a, d) || f)) {
|
|
|
+ const e = xo(d, c, o, n)
|
|
|
+ if ((ko(d, e), 'out-in' === l))
|
|
|
+ return (
|
|
|
+ (o.isLeaving = !0),
|
|
|
+ (e.afterLeave = () => {
|
|
|
+ ;(o.isLeaving = !1), !1 !== n.update.active && n.update()
|
|
|
+ }),
|
|
|
+ So(i)
|
|
|
+ )
|
|
|
+ 'in-out' === l &&
|
|
|
+ a.type !== ds &&
|
|
|
+ (e.delayLeave = (e, t, n) => {
|
|
|
+ ;(wo(o, d)[String(d.key)] = d),
|
|
|
+ (e._leaveCb = () => {
|
|
|
+ t(), (e._leaveCb = void 0), delete u.delayedLeave
|
|
|
+ }),
|
|
|
+ (u.delayedLeave = n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function wo(e, t) {
|
|
|
+ const { leavingVNodes: n } = e
|
|
|
+ let o = n.get(t.type)
|
|
|
+ return o || ((o = Object.create(null)), n.set(t.type, o)), o
|
|
|
+ }
|
|
|
+ function xo(e, t, n, o) {
|
|
|
+ const {
|
|
|
+ appear: r,
|
|
|
+ mode: s,
|
|
|
+ persisted: i = !1,
|
|
|
+ onBeforeEnter: c,
|
|
|
+ onEnter: l,
|
|
|
+ onAfterEnter: a,
|
|
|
+ onEnterCancelled: u,
|
|
|
+ onBeforeLeave: p,
|
|
|
+ onLeave: d,
|
|
|
+ onAfterLeave: f,
|
|
|
+ onLeaveCancelled: h,
|
|
|
+ onBeforeAppear: m,
|
|
|
+ onAppear: g,
|
|
|
+ onAfterAppear: y,
|
|
|
+ onAppearCancelled: v
|
|
|
+ } = t,
|
|
|
+ b = String(e.key),
|
|
|
+ _ = wo(n, e),
|
|
|
+ w = (e, t) => {
|
|
|
+ e && Zt(e, o, 9, t)
|
|
|
+ },
|
|
|
+ x = (e, t) => {
|
|
|
+ const n = t[1]
|
|
|
+ w(e, t), O(e) ? e.every((e) => e.length <= 1) && n() : e.length <= 1 && n()
|
|
|
+ },
|
|
|
+ S = {
|
|
|
+ mode: s,
|
|
|
+ persisted: i,
|
|
|
+ beforeEnter(t) {
|
|
|
+ let o = c
|
|
|
+ if (!n.isMounted) {
|
|
|
+ if (!r) return
|
|
|
+ o = m || c
|
|
|
+ }
|
|
|
+ t._leaveCb && t._leaveCb(!0)
|
|
|
+ const s = _[b]
|
|
|
+ s && Cs(e, s) && s.el._leaveCb && s.el._leaveCb(), w(o, [t])
|
|
|
+ },
|
|
|
+ enter(e) {
|
|
|
+ let t = l,
|
|
|
+ o = a,
|
|
|
+ s = u
|
|
|
+ if (!n.isMounted) {
|
|
|
+ if (!r) return
|
|
|
+ ;(t = g || l), (o = y || a), (s = v || u)
|
|
|
+ }
|
|
|
+ let i = !1
|
|
|
+ const c = (e._enterCb = (t) => {
|
|
|
+ i ||
|
|
|
+ ((i = !0),
|
|
|
+ w(t ? s : o, [e]),
|
|
|
+ S.delayedLeave && S.delayedLeave(),
|
|
|
+ (e._enterCb = void 0))
|
|
|
+ })
|
|
|
+ t ? x(t, [e, c]) : c()
|
|
|
+ },
|
|
|
+ leave(t, o) {
|
|
|
+ const r = String(e.key)
|
|
|
+ if ((t._enterCb && t._enterCb(!0), n.isUnmounting)) return o()
|
|
|
+ w(p, [t])
|
|
|
+ let s = !1
|
|
|
+ const i = (t._leaveCb = (n) => {
|
|
|
+ s ||
|
|
|
+ ((s = !0), o(), w(n ? h : f, [t]), (t._leaveCb = void 0), _[r] === e && delete _[r])
|
|
|
+ })
|
|
|
+ ;(_[r] = e), d ? x(d, [t, i]) : i()
|
|
|
+ },
|
|
|
+ clone: (e) => xo(e, t, n, o)
|
|
|
+ }
|
|
|
+ return S
|
|
|
+ }
|
|
|
+ function So(e) {
|
|
|
+ if (Oo(e)) return ((e = As(e)).children = null), e
|
|
|
+ }
|
|
|
+ function Co(e) {
|
|
|
+ return Oo(e) ? (e.children ? e.children[0] : void 0) : e
|
|
|
+ }
|
|
|
+ function ko(e, t) {
|
|
|
+ 6 & e.shapeFlag && e.component
|
|
|
+ ? ko(e.component.subTree, t)
|
|
|
+ : 128 & e.shapeFlag
|
|
|
+ ? ((e.ssContent.transition = t.clone(e.ssContent)),
|
|
|
+ (e.ssFallback.transition = t.clone(e.ssFallback)))
|
|
|
+ : (e.transition = t)
|
|
|
+ }
|
|
|
+ function To(e, t = !1, n) {
|
|
|
+ let o = [],
|
|
|
+ r = 0
|
|
|
+ for (let s = 0; s < e.length; s++) {
|
|
|
+ let i = e[s]
|
|
|
+ const c = null == n ? i.key : String(n) + String(null != i.key ? i.key : s)
|
|
|
+ i.type === us
|
|
|
+ ? (128 & i.patchFlag && r++, (o = o.concat(To(i.children, t, c))))
|
|
|
+ : (t || i.type !== ds) &&
|
|
|
+ o.push(
|
|
|
+ null != c
|
|
|
+ ? As(i, {
|
|
|
+ key: c
|
|
|
+ })
|
|
|
+ : i
|
|
|
+ )
|
|
|
+ }
|
|
|
+ if (r > 1) for (let e = 0; e < o.length; e++) o[e].patchFlag = -2
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function $o(e) {
|
|
|
+ return M(e)
|
|
|
+ ? {
|
|
|
+ setup: e,
|
|
|
+ name: e.name
|
|
|
+ }
|
|
|
+ : e
|
|
|
+ }
|
|
|
+ const Eo = (e) => !!e.type.__asyncLoader
|
|
|
+ function No(e, t) {
|
|
|
+ const { ref: n, props: o, children: r, ce: s } = t.vnode,
|
|
|
+ i = Ns(e, o, r)
|
|
|
+ return (i.ref = n), (i.ce = s), delete t.vnode.ce, i
|
|
|
+ }
|
|
|
+ const Oo = (e) => e.type.__isKeepAlive,
|
|
|
+ Ao = {
|
|
|
+ name: 'KeepAlive',
|
|
|
+ __isKeepAlive: !0,
|
|
|
+ props: {
|
|
|
+ include: [String, RegExp, Array],
|
|
|
+ exclude: [String, RegExp, Array],
|
|
|
+ max: [String, Number]
|
|
|
+ },
|
|
|
+ setup(e, { slots: t }) {
|
|
|
+ const n = Ds(),
|
|
|
+ o = n.ctx,
|
|
|
+ r = new Map(),
|
|
|
+ s = new Set()
|
|
|
+ let i = null
|
|
|
+ n.__v_cache = r
|
|
|
+ const c = n.suspense,
|
|
|
+ {
|
|
|
+ renderer: {
|
|
|
+ p: l,
|
|
|
+ m: a,
|
|
|
+ um: u,
|
|
|
+ o: { createElement: p }
|
|
|
+ }
|
|
|
+ } = o,
|
|
|
+ d = p('div')
|
|
|
+ function f(e) {
|
|
|
+ jo(e), u(e, n, c, !0)
|
|
|
+ }
|
|
|
+ function h(e) {
|
|
|
+ r.forEach((t, n) => {
|
|
|
+ const o = ri(t.type)
|
|
|
+ !o || (e && e(o)) || m(n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function m(e) {
|
|
|
+ const t = r.get(e)
|
|
|
+ i && t.type === i.type ? i && jo(i) : f(t), r.delete(e), s.delete(e)
|
|
|
+ }
|
|
|
+ ;(o.activate = (e, t, n, o, r) => {
|
|
|
+ const s = e.component
|
|
|
+ a(e, t, n, 0, c),
|
|
|
+ l(s.vnode, e, t, n, s, c, o, e.slotScopeIds, r),
|
|
|
+ Xr(() => {
|
|
|
+ ;(s.isDeactivated = !1), s.a && ee(s.a)
|
|
|
+ const t = e.props && e.props.onVnodeMounted
|
|
|
+ t && Vs(t, s.parent, e)
|
|
|
+ }, c),
|
|
|
+ On(s)
|
|
|
+ }),
|
|
|
+ (o.deactivate = (e) => {
|
|
|
+ const t = e.component
|
|
|
+ a(e, d, null, 1, c),
|
|
|
+ Xr(() => {
|
|
|
+ t.da && ee(t.da)
|
|
|
+ const n = e.props && e.props.onVnodeUnmounted
|
|
|
+ n && Vs(n, t.parent, e), (t.isDeactivated = !0)
|
|
|
+ }, c),
|
|
|
+ On(t)
|
|
|
+ }),
|
|
|
+ fo(
|
|
|
+ () => [e.include, e.exclude],
|
|
|
+ ([e, t]) => {
|
|
|
+ e && h((t) => Io(e, t)), t && h((e) => !Io(t, e))
|
|
|
+ },
|
|
|
+ {
|
|
|
+ flush: 'post',
|
|
|
+ deep: !0
|
|
|
+ }
|
|
|
+ )
|
|
|
+ let g = null
|
|
|
+ const y = () => {
|
|
|
+ null != g && r.set(g, Vo(n.subTree))
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ Do(y),
|
|
|
+ zo(y),
|
|
|
+ Wo(() => {
|
|
|
+ r.forEach((e) => {
|
|
|
+ const { subTree: t, suspense: o } = n,
|
|
|
+ r = Vo(t)
|
|
|
+ if (e.type !== r.type) f(e)
|
|
|
+ else {
|
|
|
+ jo(r)
|
|
|
+ const e = r.component.da
|
|
|
+ e && Xr(e, o)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ () => {
|
|
|
+ if (((g = null), !t.default)) return null
|
|
|
+ const n = t.default(),
|
|
|
+ o = n[0]
|
|
|
+ if (n.length > 1)
|
|
|
+ return Kt('KeepAlive should contain exactly one component child.'), (i = null), n
|
|
|
+ if (!(Ss(o) && (4 & o.shapeFlag || 128 & o.shapeFlag))) return (i = null), o
|
|
|
+ let c = Vo(o)
|
|
|
+ const l = c.type,
|
|
|
+ a = ri(Eo(c) ? c.type.__asyncResolved || {} : l),
|
|
|
+ { include: u, exclude: p, max: d } = e
|
|
|
+ if ((u && (!a || !Io(u, a))) || (p && a && Io(p, a))) return (i = c), o
|
|
|
+ const f = null == c.key ? l : c.key,
|
|
|
+ h = r.get(f)
|
|
|
+ return (
|
|
|
+ c.el && ((c = As(c)), 128 & o.shapeFlag && (o.ssContent = c)),
|
|
|
+ (g = f),
|
|
|
+ h
|
|
|
+ ? ((c.el = h.el),
|
|
|
+ (c.component = h.component),
|
|
|
+ c.transition && ko(c, c.transition),
|
|
|
+ (c.shapeFlag |= 512),
|
|
|
+ s.delete(f),
|
|
|
+ s.add(f))
|
|
|
+ : (s.add(f), d && s.size > parseInt(d, 10) && m(s.values().next().value)),
|
|
|
+ (c.shapeFlag |= 256),
|
|
|
+ (i = c),
|
|
|
+ eo(o.type) ? o : c
|
|
|
+ )
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Io(e, t) {
|
|
|
+ return O(e) ? e.some((e) => Io(e, t)) : P(e) ? e.split(',').includes(t) : !!e.test && e.test(t)
|
|
|
+ }
|
|
|
+ function Ro(e, t) {
|
|
|
+ Po(e, 'a', t)
|
|
|
+ }
|
|
|
+ function Mo(e, t) {
|
|
|
+ Po(e, 'da', t)
|
|
|
+ }
|
|
|
+ function Po(e, t, n = Us) {
|
|
|
+ const o =
|
|
|
+ e.__wdc ||
|
|
|
+ (e.__wdc = () => {
|
|
|
+ let t = n
|
|
|
+ for (; t; ) {
|
|
|
+ if (t.isDeactivated) return
|
|
|
+ t = t.parent
|
|
|
+ }
|
|
|
+ return e()
|
|
|
+ })
|
|
|
+ if ((Lo(t, o, n), n)) {
|
|
|
+ let e = n.parent
|
|
|
+ for (; e && e.parent; ) Oo(e.parent.vnode) && Fo(o, t, n, e), (e = e.parent)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Fo(e, t, n, o) {
|
|
|
+ const r = Lo(t, e, o, !0)
|
|
|
+ Ko(() => {
|
|
|
+ $(o[t], r)
|
|
|
+ }, n)
|
|
|
+ }
|
|
|
+ function jo(e) {
|
|
|
+ ;(e.shapeFlag &= -257), (e.shapeFlag &= -513)
|
|
|
+ }
|
|
|
+ function Vo(e) {
|
|
|
+ return 128 & e.shapeFlag ? e.ssContent : e
|
|
|
+ }
|
|
|
+ function Lo(e, t, n = Us, o = !1) {
|
|
|
+ if (n) {
|
|
|
+ const r = n[e] || (n[e] = []),
|
|
|
+ s =
|
|
|
+ t.__weh ||
|
|
|
+ (t.__weh = (...o) => {
|
|
|
+ if (n.isUnmounted) return
|
|
|
+ xe(), Hs(n)
|
|
|
+ const r = Zt(t, n, e, o)
|
|
|
+ return zs(), Se(), r
|
|
|
+ })
|
|
|
+ return o ? r.unshift(s) : r.push(s), s
|
|
|
+ }
|
|
|
+ Kt(
|
|
|
+ `${X(
|
|
|
+ qt[e].replace(/ hook$/, '')
|
|
|
+ )} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Bo =
|
|
|
+ (e) =>
|
|
|
+ (t, n = Us) =>
|
|
|
+ (!Ys || 'sp' === e) && Lo(e, (...e) => t(...e), n),
|
|
|
+ Uo = Bo('bm'),
|
|
|
+ Do = Bo('m'),
|
|
|
+ Ho = Bo('bu'),
|
|
|
+ zo = Bo('u'),
|
|
|
+ Wo = Bo('bum'),
|
|
|
+ Ko = Bo('um'),
|
|
|
+ Go = Bo('sp'),
|
|
|
+ Jo = Bo('rtg'),
|
|
|
+ qo = Bo('rtc')
|
|
|
+ function Yo(e, t = Us) {
|
|
|
+ Lo('ec', e, t)
|
|
|
+ }
|
|
|
+ function Zo(e) {
|
|
|
+ W(e) && Kt('Do not use built-in directive ids as custom directive id: ' + e)
|
|
|
+ }
|
|
|
+ function Xo(e, t, n, o) {
|
|
|
+ const r = e.dirs,
|
|
|
+ s = t && t.dirs
|
|
|
+ for (let i = 0; i < r.length; i++) {
|
|
|
+ const c = r[i]
|
|
|
+ s && (c.oldValue = s[i].value)
|
|
|
+ let l = c.dir[o]
|
|
|
+ l && (xe(), Zt(l, n, 8, [e.el, c, e, t]), Se())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Qo = 'components'
|
|
|
+ const er = Symbol()
|
|
|
+ function tr(e, t, n = !0, o = !1) {
|
|
|
+ const r = Bn || Us
|
|
|
+ if (r) {
|
|
|
+ const s = r.type
|
|
|
+ if (e === Qo) {
|
|
|
+ const e = ri(s, !1)
|
|
|
+ if (e && (e === t || e === J(t) || e === Z(J(t)))) return s
|
|
|
+ }
|
|
|
+ const i = nr(r[e] || s[e], t) || nr(r.appContext[e], t)
|
|
|
+ if (!i && o) return s
|
|
|
+ if (n && !i) {
|
|
|
+ const n =
|
|
|
+ e === Qo
|
|
|
+ ? '\nIf this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.'
|
|
|
+ : ''
|
|
|
+ Kt(`Failed to resolve ${e.slice(0, -1)}: ${t}${n}`)
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ Kt(`resolve${Z(e.slice(0, -1))} can only be used in render() or setup().`)
|
|
|
+ }
|
|
|
+ function nr(e, t) {
|
|
|
+ return e && (e[t] || e[J(t)] || e[Z(J(t))])
|
|
|
+ }
|
|
|
+ function or(e) {
|
|
|
+ return e.some((e) => !Ss(e) || (e.type !== ds && !(e.type === us && !or(e.children))))
|
|
|
+ ? e
|
|
|
+ : null
|
|
|
+ }
|
|
|
+ const rr = (e) => (e ? (Gs(e) ? ni(e) || e.proxy : rr(e.parent)) : null),
|
|
|
+ sr = T(Object.create(null), {
|
|
|
+ $: (e) => e,
|
|
|
+ $el: (e) => e.vnode.el,
|
|
|
+ $data: (e) => e.data,
|
|
|
+ $props: (e) => bt(e.props),
|
|
|
+ $attrs: (e) => bt(e.attrs),
|
|
|
+ $slots: (e) => bt(e.slots),
|
|
|
+ $refs: (e) => bt(e.refs),
|
|
|
+ $parent: (e) => rr(e.parent),
|
|
|
+ $root: (e) => rr(e.root),
|
|
|
+ $emit: (e) => e.emit,
|
|
|
+ $options: (e) => hr(e),
|
|
|
+ $forceUpdate: (e) => e.f || (e.f = () => un(e.update)),
|
|
|
+ $nextTick: (e) => e.n || (e.n = an.bind(e.proxy)),
|
|
|
+ $watch: (e) => mo.bind(e)
|
|
|
+ }),
|
|
|
+ ir = (e) => '_' === e || '$' === e,
|
|
|
+ cr = (e, t) => e !== b && !e.__isScriptSetup && N(e, t),
|
|
|
+ lr = {
|
|
|
+ get({ _: e }, t) {
|
|
|
+ const {
|
|
|
+ ctx: n,
|
|
|
+ setupState: o,
|
|
|
+ data: r,
|
|
|
+ props: s,
|
|
|
+ accessCache: i,
|
|
|
+ type: c,
|
|
|
+ appContext: l
|
|
|
+ } = e
|
|
|
+ if ('__isVue' === t) return !0
|
|
|
+ let a
|
|
|
+ if ('$' !== t[0]) {
|
|
|
+ const c = i[t]
|
|
|
+ if (void 0 !== c)
|
|
|
+ switch (c) {
|
|
|
+ case 1:
|
|
|
+ return o[t]
|
|
|
+ case 2:
|
|
|
+ return r[t]
|
|
|
+ case 4:
|
|
|
+ return n[t]
|
|
|
+ case 3:
|
|
|
+ return s[t]
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if (cr(o, t)) return (i[t] = 1), o[t]
|
|
|
+ if (r !== b && N(r, t)) return (i[t] = 2), r[t]
|
|
|
+ if ((a = e.propsOptions[0]) && N(a, t)) return (i[t] = 3), s[t]
|
|
|
+ if (n !== b && N(n, t)) return (i[t] = 4), n[t]
|
|
|
+ ur && (i[t] = 0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const u = sr[t]
|
|
|
+ let p, d
|
|
|
+ return u
|
|
|
+ ? ('$attrs' === t && (Ce(e, 'get', t), Wn()), u(e))
|
|
|
+ : (p = c.__cssModules) && (p = p[t])
|
|
|
+ ? p
|
|
|
+ : n !== b && N(n, t)
|
|
|
+ ? ((i[t] = 4), n[t])
|
|
|
+ : ((d = l.config.globalProperties),
|
|
|
+ N(d, t)
|
|
|
+ ? d[t]
|
|
|
+ : void (
|
|
|
+ !Bn ||
|
|
|
+ (P(t) && 0 === t.indexOf('__v')) ||
|
|
|
+ (r !== b && ir(t[0]) && N(r, t)
|
|
|
+ ? Kt(
|
|
|
+ `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 === Bn &&
|
|
|
+ Kt(
|
|
|
+ `Property ${JSON.stringify(
|
|
|
+ t
|
|
|
+ )} was accessed during render but is not defined on instance.`
|
|
|
+ ))
|
|
|
+ ))
|
|
|
+ },
|
|
|
+ set({ _: e }, t, n) {
|
|
|
+ const { data: o, setupState: r, ctx: s } = e
|
|
|
+ return cr(r, t)
|
|
|
+ ? ((r[t] = n), !0)
|
|
|
+ : r.__isScriptSetup && N(r, t)
|
|
|
+ ? (Kt(`Cannot mutate <script setup> binding "${t}" from Options API.`), !1)
|
|
|
+ : o !== b && N(o, t)
|
|
|
+ ? ((o[t] = n), !0)
|
|
|
+ : N(e.props, t)
|
|
|
+ ? (Kt(`Attempting to mutate prop "${t}". Props are readonly.`), !1)
|
|
|
+ : '$' === t[0] && t.slice(1) in e
|
|
|
+ ? (Kt(
|
|
|
+ `Attempting to mutate public property "${t}". Properties starting with $ are reserved and readonly.`
|
|
|
+ ),
|
|
|
+ !1)
|
|
|
+ : (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: o, appContext: r, propsOptions: s } },
|
|
|
+ i
|
|
|
+ ) {
|
|
|
+ let c
|
|
|
+ return (
|
|
|
+ !!n[i] ||
|
|
|
+ (e !== b && N(e, i)) ||
|
|
|
+ cr(t, i) ||
|
|
|
+ ((c = s[0]) && N(c, i)) ||
|
|
|
+ N(o, i) ||
|
|
|
+ N(sr, i) ||
|
|
|
+ N(r.config.globalProperties, i)
|
|
|
+ )
|
|
|
+ },
|
|
|
+ defineProperty(e, t, n) {
|
|
|
+ return (
|
|
|
+ null != n.get ? (e._.accessCache[t] = 0) : N(n, 'value') && this.set(e, t, n.value, null),
|
|
|
+ Reflect.defineProperty(e, t, n)
|
|
|
+ )
|
|
|
+ },
|
|
|
+ ownKeys: (e) => (
|
|
|
+ Kt(
|
|
|
+ '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)
|
|
|
+ )
|
|
|
+ },
|
|
|
+ ar = T({}, lr, {
|
|
|
+ get(e, t) {
|
|
|
+ if (t !== Symbol.unscopables) return lr.get(e, t, e)
|
|
|
+ },
|
|
|
+ has(e, t) {
|
|
|
+ const n = '_' !== t[0] && !r(t)
|
|
|
+ return (
|
|
|
+ !n &&
|
|
|
+ lr.has(e, t) &&
|
|
|
+ Kt(
|
|
|
+ `Property ${JSON.stringify(
|
|
|
+ t
|
|
|
+ )} should not start with _ which is a reserved prefix for Vue internals.`
|
|
|
+ ),
|
|
|
+ n
|
|
|
+ )
|
|
|
+ }
|
|
|
+ })
|
|
|
+ let ur = !0
|
|
|
+ function pr(e) {
|
|
|
+ const t = hr(e),
|
|
|
+ n = e.proxy,
|
|
|
+ o = e.ctx
|
|
|
+ ;(ur = !1), t.beforeCreate && dr(t.beforeCreate, e, 'bc')
|
|
|
+ const {
|
|
|
+ data: r,
|
|
|
+ computed: s,
|
|
|
+ methods: i,
|
|
|
+ watch: c,
|
|
|
+ provide: l,
|
|
|
+ inject: a,
|
|
|
+ created: u,
|
|
|
+ beforeMount: p,
|
|
|
+ mounted: d,
|
|
|
+ beforeUpdate: f,
|
|
|
+ updated: h,
|
|
|
+ activated: m,
|
|
|
+ deactivated: g,
|
|
|
+ beforeDestroy: y,
|
|
|
+ beforeUnmount: v,
|
|
|
+ destroyed: b,
|
|
|
+ unmounted: _,
|
|
|
+ render: x,
|
|
|
+ renderTracked: S,
|
|
|
+ renderTriggered: C,
|
|
|
+ errorCaptured: k,
|
|
|
+ serverPrefetch: T,
|
|
|
+ expose: $,
|
|
|
+ inheritAttrs: E,
|
|
|
+ components: N,
|
|
|
+ directives: A,
|
|
|
+ filters: I
|
|
|
+ } = t,
|
|
|
+ R = (function () {
|
|
|
+ const e = Object.create(null)
|
|
|
+ return (t, n) => {
|
|
|
+ e[n] ? Kt(`${t} property "${n}" is already defined in ${e[n]}.`) : (e[n] = t)
|
|
|
+ }
|
|
|
+ })()
|
|
|
+ {
|
|
|
+ const [t] = e.propsOptions
|
|
|
+ if (t) for (const e in t) R('Props', e)
|
|
|
+ }
|
|
|
+ if (
|
|
|
+ (a &&
|
|
|
+ (function (e, t, n = w, o = !1) {
|
|
|
+ O(e) && (e = vr(e))
|
|
|
+ for (const r in e) {
|
|
|
+ const s = e[r]
|
|
|
+ let i
|
|
|
+ ;(i = j(s)
|
|
|
+ ? 'default' in s
|
|
|
+ ? ao(s.from || r, s.default, !0)
|
|
|
+ : ao(s.from || r)
|
|
|
+ : ao(s)),
|
|
|
+ At(i)
|
|
|
+ ? o
|
|
|
+ ? Object.defineProperty(t, r, {
|
|
|
+ enumerable: !0,
|
|
|
+ configurable: !0,
|
|
|
+ get: () => i.value,
|
|
|
+ set: (e) => (i.value = e)
|
|
|
+ })
|
|
|
+ : (Kt(
|
|
|
+ `injected property "${r}" is a ref and will be auto-unwrapped and no longer needs \`.value\` in the next minor release. To opt-in to the new behavior now, set \`app.config.unwrapInjectedRef = true\` (this config is temporary and will not be needed in the future.)`
|
|
|
+ ),
|
|
|
+ (t[r] = i))
|
|
|
+ : (t[r] = i),
|
|
|
+ n('Inject', r)
|
|
|
+ }
|
|
|
+ })(a, o, R, e.appContext.config.unwrapInjectedRef),
|
|
|
+ i)
|
|
|
+ )
|
|
|
+ for (const e in i) {
|
|
|
+ const t = i[e]
|
|
|
+ M(t)
|
|
|
+ ? (Object.defineProperty(o, e, {
|
|
|
+ value: t.bind(n),
|
|
|
+ configurable: !0,
|
|
|
+ enumerable: !0,
|
|
|
+ writable: !0
|
|
|
+ }),
|
|
|
+ R('Methods', e))
|
|
|
+ : Kt(
|
|
|
+ `Method "${e}" has type "${typeof t}" in the component definition. Did you reference the function correctly?`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ if (r) {
|
|
|
+ M(r) || Kt('The data option must be a function. Plain object usage is no longer supported.')
|
|
|
+ const t = r.call(n, n)
|
|
|
+ if (
|
|
|
+ (V(t) &&
|
|
|
+ Kt(
|
|
|
+ 'data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.'
|
|
|
+ ),
|
|
|
+ j(t))
|
|
|
+ ) {
|
|
|
+ e.data = gt(t)
|
|
|
+ for (const e in t)
|
|
|
+ R('Data', e),
|
|
|
+ ir(e[0]) ||
|
|
|
+ Object.defineProperty(o, e, {
|
|
|
+ configurable: !0,
|
|
|
+ enumerable: !0,
|
|
|
+ get: () => t[e],
|
|
|
+ set: w
|
|
|
+ })
|
|
|
+ } else Kt('data() should return an object.')
|
|
|
+ }
|
|
|
+ if (((ur = !0), s))
|
|
|
+ for (const e in s) {
|
|
|
+ const t = s[e],
|
|
|
+ r = M(t) ? t.bind(n, n) : M(t.get) ? t.get.bind(n, n) : w
|
|
|
+ r === w && Kt(`Computed property "${e}" has no getter.`)
|
|
|
+ const i =
|
|
|
+ !M(t) && M(t.set)
|
|
|
+ ? t.set.bind(n)
|
|
|
+ : () => {
|
|
|
+ Kt(`Write operation failed: computed property "${e}" is readonly.`)
|
|
|
+ },
|
|
|
+ c = ci({
|
|
|
+ get: r,
|
|
|
+ set: i
|
|
|
+ })
|
|
|
+ Object.defineProperty(o, e, {
|
|
|
+ enumerable: !0,
|
|
|
+ configurable: !0,
|
|
|
+ get: () => c.value,
|
|
|
+ set: (e) => (c.value = e)
|
|
|
+ }),
|
|
|
+ R('Computed', e)
|
|
|
+ }
|
|
|
+ if (c) for (const e in c) fr(c[e], o, n, e)
|
|
|
+ if (l) {
|
|
|
+ const e = M(l) ? l.call(n) : l
|
|
|
+ Reflect.ownKeys(e).forEach((t) => {
|
|
|
+ lo(t, e[t])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function P(e, t) {
|
|
|
+ O(t) ? t.forEach((t) => e(t.bind(n))) : t && e(t.bind(n))
|
|
|
+ }
|
|
|
+ if (
|
|
|
+ (u && dr(u, e, 'c'),
|
|
|
+ P(Uo, p),
|
|
|
+ P(Do, d),
|
|
|
+ P(Ho, f),
|
|
|
+ P(zo, h),
|
|
|
+ P(Ro, m),
|
|
|
+ P(Mo, g),
|
|
|
+ P(Yo, k),
|
|
|
+ P(qo, S),
|
|
|
+ P(Jo, C),
|
|
|
+ P(Wo, v),
|
|
|
+ P(Ko, _),
|
|
|
+ P(Go, T),
|
|
|
+ O($))
|
|
|
+ )
|
|
|
+ if ($.length) {
|
|
|
+ const t = e.exposed || (e.exposed = {})
|
|
|
+ $.forEach((e) => {
|
|
|
+ Object.defineProperty(t, e, {
|
|
|
+ get: () => n[e],
|
|
|
+ set: (t) => (n[e] = t)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ } else e.exposed || (e.exposed = {})
|
|
|
+ x && e.render === w && (e.render = x),
|
|
|
+ null != E && (e.inheritAttrs = E),
|
|
|
+ N && (e.components = N),
|
|
|
+ A && (e.directives = A)
|
|
|
+ }
|
|
|
+ function dr(e, t, n) {
|
|
|
+ Zt(O(e) ? e.map((e) => e.bind(t.proxy)) : e.bind(t.proxy), t, n)
|
|
|
+ }
|
|
|
+ function fr(e, t, n, o) {
|
|
|
+ const r = o.includes('.') ? go(n, o) : () => n[o]
|
|
|
+ if (P(e)) {
|
|
|
+ const n = t[e]
|
|
|
+ M(n) ? fo(r, n) : Kt(`Invalid watch handler specified by key "${e}"`, n)
|
|
|
+ } else if (M(e)) fo(r, e.bind(n))
|
|
|
+ else if (j(e))
|
|
|
+ if (O(e)) e.forEach((e) => fr(e, t, n, o))
|
|
|
+ else {
|
|
|
+ const o = M(e.handler) ? e.handler.bind(n) : t[e.handler]
|
|
|
+ M(o) ? fo(r, o, e) : Kt(`Invalid watch handler specified by key "${e.handler}"`, o)
|
|
|
+ }
|
|
|
+ else Kt(`Invalid watch option: "${o}"`, e)
|
|
|
+ }
|
|
|
+ function hr(e) {
|
|
|
+ const t = e.type,
|
|
|
+ { mixins: n, extends: o } = t,
|
|
|
+ {
|
|
|
+ mixins: r,
|
|
|
+ optionsCache: s,
|
|
|
+ config: { optionMergeStrategies: i }
|
|
|
+ } = e.appContext,
|
|
|
+ c = s.get(t)
|
|
|
+ let l
|
|
|
+ return (
|
|
|
+ c
|
|
|
+ ? (l = c)
|
|
|
+ : r.length || n || o
|
|
|
+ ? ((l = {}), r.length && r.forEach((e) => mr(l, e, i, !0)), mr(l, t, i))
|
|
|
+ : (l = t),
|
|
|
+ j(t) && s.set(t, l),
|
|
|
+ l
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function mr(e, t, n, o = !1) {
|
|
|
+ const { mixins: r, extends: s } = t
|
|
|
+ s && mr(e, s, n, !0), r && r.forEach((t) => mr(e, t, n, !0))
|
|
|
+ for (const r in t)
|
|
|
+ if (o && 'expose' === r)
|
|
|
+ Kt(
|
|
|
+ '"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.'
|
|
|
+ )
|
|
|
+ else {
|
|
|
+ const o = gr[r] || (n && n[r])
|
|
|
+ e[r] = o ? o(e[r], t[r]) : t[r]
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ const gr = {
|
|
|
+ data: yr,
|
|
|
+ props: _r,
|
|
|
+ emits: _r,
|
|
|
+ methods: _r,
|
|
|
+ computed: _r,
|
|
|
+ beforeCreate: br,
|
|
|
+ created: br,
|
|
|
+ beforeMount: br,
|
|
|
+ mounted: br,
|
|
|
+ beforeUpdate: br,
|
|
|
+ updated: br,
|
|
|
+ beforeDestroy: br,
|
|
|
+ beforeUnmount: br,
|
|
|
+ destroyed: br,
|
|
|
+ unmounted: br,
|
|
|
+ activated: br,
|
|
|
+ deactivated: br,
|
|
|
+ errorCaptured: br,
|
|
|
+ serverPrefetch: br,
|
|
|
+ components: _r,
|
|
|
+ directives: _r,
|
|
|
+ watch: function (e, t) {
|
|
|
+ if (!e) return t
|
|
|
+ if (!t) return e
|
|
|
+ const n = T(Object.create(null), e)
|
|
|
+ for (const o in t) n[o] = br(e[o], t[o])
|
|
|
+ return n
|
|
|
+ },
|
|
|
+ provide: yr,
|
|
|
+ inject: function (e, t) {
|
|
|
+ return _r(vr(e), vr(t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yr(e, t) {
|
|
|
+ return t
|
|
|
+ ? e
|
|
|
+ ? function () {
|
|
|
+ return T(M(e) ? e.call(this, this) : e, M(t) ? t.call(this, this) : t)
|
|
|
+ }
|
|
|
+ : t
|
|
|
+ : e
|
|
|
+ }
|
|
|
+ function vr(e) {
|
|
|
+ if (O(e)) {
|
|
|
+ const t = {}
|
|
|
+ for (let n = 0; n < e.length; n++) t[e[n]] = e[n]
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function br(e, t) {
|
|
|
+ return e ? [...new Set([].concat(e, t))] : t
|
|
|
+ }
|
|
|
+ function _r(e, t) {
|
|
|
+ return e ? T(T(Object.create(null), e), t) : t
|
|
|
+ }
|
|
|
+ function wr(e, t, n, o) {
|
|
|
+ const [r, s] = e.propsOptions
|
|
|
+ let i,
|
|
|
+ c = !1
|
|
|
+ if (t)
|
|
|
+ for (let l in t) {
|
|
|
+ if (z(l)) continue
|
|
|
+ const a = t[l]
|
|
|
+ let u
|
|
|
+ r && N(r, (u = J(l)))
|
|
|
+ ? s && s.includes(u)
|
|
|
+ ? ((i || (i = {}))[u] = a)
|
|
|
+ : (n[u] = a)
|
|
|
+ : Ln(e.emitsOptions, l) || (l in o && a === o[l]) || ((o[l] = a), (c = !0))
|
|
|
+ }
|
|
|
+ if (s) {
|
|
|
+ const t = kt(n),
|
|
|
+ o = i || b
|
|
|
+ for (let i = 0; i < s.length; i++) {
|
|
|
+ const c = s[i]
|
|
|
+ n[c] = xr(r, t, c, o[c], e, !N(o, c))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return c
|
|
|
+ }
|
|
|
+ function xr(e, t, n, o, r, s) {
|
|
|
+ const i = e[n]
|
|
|
+ if (null != i) {
|
|
|
+ const e = N(i, 'default')
|
|
|
+ if (e && void 0 === o) {
|
|
|
+ const e = i.default
|
|
|
+ if (i.type !== Function && M(e)) {
|
|
|
+ const { propsDefaults: s } = r
|
|
|
+ n in s ? (o = s[n]) : (Hs(r), (o = s[n] = e.call(null, t)), zs())
|
|
|
+ } else o = e
|
|
|
+ }
|
|
|
+ i[0] && (s && !e ? (o = !1) : !i[1] || ('' !== o && o !== Y(n)) || (o = !0))
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function Sr(e, t, n = !1) {
|
|
|
+ const o = t.propsCache,
|
|
|
+ r = o.get(e)
|
|
|
+ if (r) return r
|
|
|
+ const s = e.props,
|
|
|
+ i = {},
|
|
|
+ c = []
|
|
|
+ let l = !1
|
|
|
+ if (!M(e)) {
|
|
|
+ const o = (e) => {
|
|
|
+ l = !0
|
|
|
+ const [n, o] = Sr(e, t, !0)
|
|
|
+ T(i, n), o && c.push(...o)
|
|
|
+ }
|
|
|
+ !n && t.mixins.length && t.mixins.forEach(o),
|
|
|
+ e.extends && o(e.extends),
|
|
|
+ e.mixins && e.mixins.forEach(o)
|
|
|
+ }
|
|
|
+ if (!s && !l) return j(e) && o.set(e, _), _
|
|
|
+ if (O(s))
|
|
|
+ for (let e = 0; e < s.length; e++) {
|
|
|
+ P(s[e]) || Kt('props must be strings when using array syntax.', s[e])
|
|
|
+ const t = J(s[e])
|
|
|
+ Cr(t) && (i[t] = b)
|
|
|
+ }
|
|
|
+ else if (s) {
|
|
|
+ j(s) || Kt('invalid props options', s)
|
|
|
+ for (const e in s) {
|
|
|
+ const t = J(e)
|
|
|
+ if (Cr(t)) {
|
|
|
+ const n = s[e],
|
|
|
+ o = (i[t] =
|
|
|
+ O(n) || M(n)
|
|
|
+ ? {
|
|
|
+ type: n
|
|
|
+ }
|
|
|
+ : Object.assign({}, n))
|
|
|
+ if (o) {
|
|
|
+ const e = $r(Boolean, o.type),
|
|
|
+ n = $r(String, o.type)
|
|
|
+ ;(o[0] = e > -1), (o[1] = n < 0 || e < n), (e > -1 || N(o, 'default')) && c.push(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const a = [i, c]
|
|
|
+ return j(e) && o.set(e, a), a
|
|
|
+ }
|
|
|
+ function Cr(e) {
|
|
|
+ return '$' !== e[0] || (Kt(`Invalid prop name: "${e}" is a reserved property.`), !1)
|
|
|
+ }
|
|
|
+ function kr(e) {
|
|
|
+ const t = e && e.toString().match(/^\s*function (\w+)/)
|
|
|
+ return t ? t[1] : null === e ? 'null' : ''
|
|
|
+ }
|
|
|
+ function Tr(e, t) {
|
|
|
+ return kr(e) === kr(t)
|
|
|
+ }
|
|
|
+ function $r(e, t) {
|
|
|
+ return O(t) ? t.findIndex((t) => Tr(t, e)) : M(t) && Tr(t, e) ? 0 : -1
|
|
|
+ }
|
|
|
+ function Er(e, t, n) {
|
|
|
+ const o = kt(t),
|
|
|
+ r = n.propsOptions[0]
|
|
|
+ for (const t in r) {
|
|
|
+ let n = r[t]
|
|
|
+ null != n && Nr(t, o[t], n, !N(e, t) && !N(e, Y(t)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Nr(e, t, n, o) {
|
|
|
+ const { type: r, required: s, validator: i } = n
|
|
|
+ if (s && o) Kt('Missing required prop: "' + e + '"')
|
|
|
+ else if (null != t || n.required) {
|
|
|
+ if (null != r && !0 !== r) {
|
|
|
+ let n = !1
|
|
|
+ const o = O(r) ? r : [r],
|
|
|
+ s = []
|
|
|
+ for (let e = 0; e < o.length && !n; e++) {
|
|
|
+ const { valid: r, expectedType: i } = Ar(t, o[e])
|
|
|
+ s.push(i || ''), (n = r)
|
|
|
+ }
|
|
|
+ if (!n)
|
|
|
+ return void Kt(
|
|
|
+ (function (e, t, n) {
|
|
|
+ let o = `Invalid prop: type check failed for prop "${e}". Expected ${n
|
|
|
+ .map(Z)
|
|
|
+ .join(' | ')}`
|
|
|
+ const r = n[0],
|
|
|
+ s = U(t),
|
|
|
+ i = Ir(t, r),
|
|
|
+ c = Ir(t, s)
|
|
|
+ 1 === n.length &&
|
|
|
+ Rr(r) &&
|
|
|
+ !(function (...e) {
|
|
|
+ return e.some((e) => 'boolean' === e.toLowerCase())
|
|
|
+ })(r, s) &&
|
|
|
+ (o += ` with value ${i}`)
|
|
|
+ ;(o += `, got ${s} `), Rr(s) && (o += `with value ${c}.`)
|
|
|
+ return o
|
|
|
+ })(e, t, s)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ i && !i(t) && Kt('Invalid prop: custom validator check failed for prop "' + e + '".')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Or = t('String,Number,Boolean,Function,Symbol,BigInt')
|
|
|
+ function Ar(e, t) {
|
|
|
+ let n
|
|
|
+ const o = kr(t)
|
|
|
+ if (Or(o)) {
|
|
|
+ const r = typeof e
|
|
|
+ ;(n = r === o.toLowerCase()), n || 'object' !== r || (n = e instanceof t)
|
|
|
+ } else
|
|
|
+ n = 'Object' === o ? j(e) : 'Array' === o ? O(e) : 'null' === o ? null === e : e instanceof t
|
|
|
+ return {
|
|
|
+ valid: n,
|
|
|
+ expectedType: o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ir(e, t) {
|
|
|
+ return 'String' === t ? `"${e}"` : 'Number' === t ? `${Number(e)}` : `${e}`
|
|
|
+ }
|
|
|
+ function Rr(e) {
|
|
|
+ return ['string', 'number', 'boolean'].some((t) => e.toLowerCase() === t)
|
|
|
+ }
|
|
|
+ const Mr = (e) => '_' === e[0] || '$stable' === e,
|
|
|
+ Pr = (e) => (O(e) ? e.map(Ms) : [Ms(e)]),
|
|
|
+ Fr = (e, t, n) => {
|
|
|
+ if (t._n) return t
|
|
|
+ const o = Hn(
|
|
|
+ (...n) => (
|
|
|
+ Us &&
|
|
|
+ Kt(
|
|
|
+ `Slot "${e}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
|
|
|
+ ),
|
|
|
+ Pr(t(...n))
|
|
|
+ ),
|
|
|
+ n
|
|
|
+ )
|
|
|
+ return (o._c = !1), o
|
|
|
+ },
|
|
|
+ jr = (e, t, n) => {
|
|
|
+ const o = e._ctx
|
|
|
+ for (const n in e) {
|
|
|
+ if (Mr(n)) continue
|
|
|
+ const r = e[n]
|
|
|
+ if (M(r)) t[n] = Fr(n, r, o)
|
|
|
+ else if (null != r) {
|
|
|
+ Kt(
|
|
|
+ `Non-function value encountered for slot "${n}". Prefer function slots for better performance.`
|
|
|
+ )
|
|
|
+ const e = Pr(r)
|
|
|
+ t[n] = () => e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Vr = (e, t) => {
|
|
|
+ Oo(e.vnode) ||
|
|
|
+ Kt(
|
|
|
+ 'Non-function value encountered for default slot. Prefer function slots for better performance.'
|
|
|
+ )
|
|
|
+ const n = Pr(t)
|
|
|
+ e.slots.default = () => n
|
|
|
+ }
|
|
|
+ function Lr() {
|
|
|
+ return {
|
|
|
+ app: null,
|
|
|
+ config: {
|
|
|
+ isNativeTag: x,
|
|
|
+ performance: !1,
|
|
|
+ globalProperties: {},
|
|
|
+ optionMergeStrategies: {},
|
|
|
+ errorHandler: void 0,
|
|
|
+ warnHandler: void 0,
|
|
|
+ compilerOptions: {}
|
|
|
+ },
|
|
|
+ mixins: [],
|
|
|
+ components: {},
|
|
|
+ directives: {},
|
|
|
+ provides: Object.create(null),
|
|
|
+ optionsCache: new WeakMap(),
|
|
|
+ propsCache: new WeakMap(),
|
|
|
+ emitsCache: new WeakMap()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let Br = 0
|
|
|
+ function Ur(e, t) {
|
|
|
+ return function (n, o = null) {
|
|
|
+ M(n) || (n = Object.assign({}, n)),
|
|
|
+ null == o || j(o) || (Kt('root props passed to app.mount() must be an object.'), (o = null))
|
|
|
+ const r = Lr(),
|
|
|
+ s = new Set()
|
|
|
+ let i = !1
|
|
|
+ const c = (r.app = {
|
|
|
+ _uid: Br++,
|
|
|
+ _component: n,
|
|
|
+ _props: o,
|
|
|
+ _container: null,
|
|
|
+ _context: r,
|
|
|
+ _instance: null,
|
|
|
+ version: hi,
|
|
|
+ get config() {
|
|
|
+ return r.config
|
|
|
+ },
|
|
|
+ set config(e) {
|
|
|
+ Kt('app.config cannot be replaced. Modify individual options instead.')
|
|
|
+ },
|
|
|
+ use: (e, ...t) => (
|
|
|
+ s.has(e)
|
|
|
+ ? Kt('Plugin has already been applied to target app.')
|
|
|
+ : e && M(e.install)
|
|
|
+ ? (s.add(e), e.install(c, ...t))
|
|
|
+ : M(e)
|
|
|
+ ? (s.add(e), e(c, ...t))
|
|
|
+ : Kt('A plugin must either be a function or an object with an "install" function.'),
|
|
|
+ c
|
|
|
+ ),
|
|
|
+ mixin: (e) => (
|
|
|
+ r.mixins.includes(e)
|
|
|
+ ? Kt('Mixin has already been applied to target app' + (e.name ? `: ${e.name}` : ''))
|
|
|
+ : r.mixins.push(e),
|
|
|
+ c
|
|
|
+ ),
|
|
|
+ component: (e, t) => (
|
|
|
+ Ks(e, r.config),
|
|
|
+ t
|
|
|
+ ? (r.components[e] && Kt(`Component "${e}" has already been registered in target app.`),
|
|
|
+ (r.components[e] = t),
|
|
|
+ c)
|
|
|
+ : r.components[e]
|
|
|
+ ),
|
|
|
+ directive: (e, t) => (
|
|
|
+ Zo(e),
|
|
|
+ t
|
|
|
+ ? (r.directives[e] && Kt(`Directive "${e}" has already been registered in target app.`),
|
|
|
+ (r.directives[e] = t),
|
|
|
+ c)
|
|
|
+ : r.directives[e]
|
|
|
+ ),
|
|
|
+ mount(s, l, a) {
|
|
|
+ if (!i) {
|
|
|
+ s.__vue_app__ &&
|
|
|
+ Kt(
|
|
|
+ 'There is already an app instance mounted on the host container.\n If you want to mount another app on the same host container, you need to unmount the previous app by calling `app.unmount()` first.'
|
|
|
+ )
|
|
|
+ const u = Ns(n, o)
|
|
|
+ return (
|
|
|
+ (u.appContext = r),
|
|
|
+ (r.reload = () => {
|
|
|
+ e(As(u), s, a)
|
|
|
+ }),
|
|
|
+ l && t ? t(u, s) : e(u, s, a),
|
|
|
+ (i = !0),
|
|
|
+ (c._container = s),
|
|
|
+ (s.__vue_app__ = c),
|
|
|
+ (c._instance = u.component),
|
|
|
+ (function (e, t) {
|
|
|
+ En('app:init', e, t, {
|
|
|
+ Fragment: us,
|
|
|
+ Text: ps,
|
|
|
+ Comment: ds,
|
|
|
+ Static: fs
|
|
|
+ })
|
|
|
+ })(c, hi),
|
|
|
+ ni(u.component) || u.component.proxy
|
|
|
+ )
|
|
|
+ }
|
|
|
+ Kt(
|
|
|
+ 'App has already been mounted.\nIf you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. `const createMyApp = () => createApp(App)`'
|
|
|
+ )
|
|
|
+ },
|
|
|
+ unmount() {
|
|
|
+ i
|
|
|
+ ? (e(null, c._container),
|
|
|
+ (c._instance = null),
|
|
|
+ (function (e) {
|
|
|
+ En('app:unmount', e)
|
|
|
+ })(c),
|
|
|
+ delete c._container.__vue_app__)
|
|
|
+ : Kt('Cannot unmount an app that is not mounted.')
|
|
|
+ },
|
|
|
+ provide: (e, t) => (
|
|
|
+ e in r.provides &&
|
|
|
+ Kt(
|
|
|
+ `App already provides property with key "${String(
|
|
|
+ e
|
|
|
+ )}". It will be overwritten with the new value.`
|
|
|
+ ),
|
|
|
+ (r.provides[e] = t),
|
|
|
+ c
|
|
|
+ )
|
|
|
+ })
|
|
|
+ return c
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Dr(e, t, n, o, r = !1) {
|
|
|
+ if (O(e)) return void e.forEach((e, s) => Dr(e, t && (O(t) ? t[s] : t), n, o, r))
|
|
|
+ if (Eo(o) && !r) return
|
|
|
+ const s = 4 & o.shapeFlag ? ni(o.component) || o.component.proxy : o.el,
|
|
|
+ i = r ? null : s,
|
|
|
+ { i: c, r: l } = e
|
|
|
+ if (!c)
|
|
|
+ return void Kt(
|
|
|
+ 'Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.'
|
|
|
+ )
|
|
|
+ const a = t && t.r,
|
|
|
+ u = c.refs === b ? (c.refs = {}) : c.refs,
|
|
|
+ p = c.setupState
|
|
|
+ if (
|
|
|
+ (null != a &&
|
|
|
+ a !== l &&
|
|
|
+ (P(a) ? ((u[a] = null), N(p, a) && (p[a] = null)) : At(a) && (a.value = null)),
|
|
|
+ M(l))
|
|
|
+ )
|
|
|
+ Yt(l, c, 12, [i, u])
|
|
|
+ else {
|
|
|
+ const t = P(l),
|
|
|
+ o = At(l)
|
|
|
+ if (t || o) {
|
|
|
+ const c = () => {
|
|
|
+ if (e.f) {
|
|
|
+ const n = t ? (N(p, l) ? p[l] : u[l]) : l.value
|
|
|
+ r
|
|
|
+ ? O(n) && $(n, s)
|
|
|
+ : O(n)
|
|
|
+ ? n.includes(s) || n.push(s)
|
|
|
+ : t
|
|
|
+ ? ((u[l] = [s]), N(p, l) && (p[l] = u[l]))
|
|
|
+ : ((l.value = [s]), e.k && (u[e.k] = l.value))
|
|
|
+ } else
|
|
|
+ t
|
|
|
+ ? ((u[l] = i), N(p, l) && (p[l] = i))
|
|
|
+ : o
|
|
|
+ ? ((l.value = i), e.k && (u[e.k] = i))
|
|
|
+ : Kt('Invalid template ref type:', l, `(${typeof l})`)
|
|
|
+ }
|
|
|
+ i ? ((c.id = -1), Xr(c, n)) : c()
|
|
|
+ } else Kt('Invalid template ref type:', l, `(${typeof l})`)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let Hr = !1
|
|
|
+ const zr = (e) => /svg/.test(e.namespaceURI) && 'foreignObject' !== e.tagName,
|
|
|
+ Wr = (e) => 8 === e.nodeType
|
|
|
+ function Kr(e) {
|
|
|
+ const {
|
|
|
+ mt: t,
|
|
|
+ p: n,
|
|
|
+ o: {
|
|
|
+ patchProp: o,
|
|
|
+ createText: r,
|
|
|
+ nextSibling: s,
|
|
|
+ parentNode: i,
|
|
|
+ remove: c,
|
|
|
+ insert: l,
|
|
|
+ createComment: a
|
|
|
+ }
|
|
|
+ } = e,
|
|
|
+ u = (n, o, c, a, g, y = !1) => {
|
|
|
+ const v = Wr(n) && '[' === n.data,
|
|
|
+ b = () => h(n, o, c, a, g, v),
|
|
|
+ { type: _, ref: w, shapeFlag: x, patchFlag: S } = o
|
|
|
+ let C = n.nodeType
|
|
|
+ ;(o.el = n), -2 === S && ((y = !1), (o.dynamicChildren = null))
|
|
|
+ let k = null
|
|
|
+ switch (_) {
|
|
|
+ case ps:
|
|
|
+ 3 !== C
|
|
|
+ ? '' === o.children
|
|
|
+ ? (l((o.el = r('')), i(n), n), (k = n))
|
|
|
+ : (k = b())
|
|
|
+ : (n.data !== o.children &&
|
|
|
+ ((Hr = !0),
|
|
|
+ Kt(
|
|
|
+ `Hydration text mismatch:\n- Client: ${JSON.stringify(
|
|
|
+ n.data
|
|
|
+ )}\n- Server: ${JSON.stringify(o.children)}`
|
|
|
+ ),
|
|
|
+ (n.data = o.children)),
|
|
|
+ (k = s(n)))
|
|
|
+ break
|
|
|
+ case ds:
|
|
|
+ k = 8 !== C || v ? b() : s(n)
|
|
|
+ break
|
|
|
+ case fs:
|
|
|
+ if ((v && (C = (n = s(n)).nodeType), 1 === C || 3 === C)) {
|
|
|
+ k = n
|
|
|
+ const e = !o.children.length
|
|
|
+ for (let t = 0; t < o.staticCount; t++)
|
|
|
+ e && (o.children += 1 === k.nodeType ? k.outerHTML : k.data),
|
|
|
+ t === o.staticCount - 1 && (o.anchor = k),
|
|
|
+ (k = s(k))
|
|
|
+ return v ? s(k) : k
|
|
|
+ }
|
|
|
+ b()
|
|
|
+ break
|
|
|
+ case us:
|
|
|
+ k = v ? f(n, o, c, a, g, y) : b()
|
|
|
+ break
|
|
|
+ default:
|
|
|
+ if (1 & x)
|
|
|
+ k =
|
|
|
+ 1 !== C || o.type.toLowerCase() !== n.tagName.toLowerCase()
|
|
|
+ ? b()
|
|
|
+ : p(n, o, c, a, g, y)
|
|
|
+ else if (6 & x) {
|
|
|
+ o.slotScopeIds = g
|
|
|
+ const e = i(n)
|
|
|
+ if (
|
|
|
+ (t(o, e, null, c, a, zr(e), y),
|
|
|
+ (k = v ? m(n) : s(n)),
|
|
|
+ k && Wr(k) && 'teleport end' === k.data && (k = s(k)),
|
|
|
+ Eo(o))
|
|
|
+ ) {
|
|
|
+ let t
|
|
|
+ v
|
|
|
+ ? ((t = Ns(us)), (t.anchor = k ? k.previousSibling : e.lastChild))
|
|
|
+ : (t = 3 === n.nodeType ? Rs('') : Ns('div')),
|
|
|
+ (t.el = n),
|
|
|
+ (o.component.subTree = t)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ 64 & x
|
|
|
+ ? (k = 8 !== C ? b() : o.type.hydrate(n, o, c, a, g, y, e, d))
|
|
|
+ : 128 & x
|
|
|
+ ? (k = o.type.hydrate(n, o, c, a, zr(i(n)), g, y, e, u))
|
|
|
+ : Kt('Invalid HostVNode type:', _, `(${typeof _})`)
|
|
|
+ }
|
|
|
+ return null != w && Dr(w, null, a, o), k
|
|
|
+ },
|
|
|
+ p = (e, t, n, r, s, i) => {
|
|
|
+ i = i || !!t.dynamicChildren
|
|
|
+ const { type: l, props: a, patchFlag: u, shapeFlag: p, dirs: f } = t,
|
|
|
+ h = ('input' === l && f) || 'option' === l
|
|
|
+ {
|
|
|
+ if ((f && Xo(t, null, n, 'created'), a))
|
|
|
+ if (h || !i || 48 & u)
|
|
|
+ for (const t in a)
|
|
|
+ ((h && t.endsWith('value')) || (C(t) && !z(t))) &&
|
|
|
+ o(e, t, null, a[t], !1, void 0, n)
|
|
|
+ else a.onClick && o(e, 'onClick', null, a.onClick, !1, void 0, n)
|
|
|
+ let l
|
|
|
+ if (
|
|
|
+ ((l = a && a.onVnodeBeforeMount) && Vs(l, n, t),
|
|
|
+ f && Xo(t, null, n, 'beforeMount'),
|
|
|
+ ((l = a && a.onVnodeMounted) || f) &&
|
|
|
+ io(() => {
|
|
|
+ l && Vs(l, n, t), f && Xo(t, null, n, 'mounted')
|
|
|
+ }, r),
|
|
|
+ 16 & p && (!a || (!a.innerHTML && !a.textContent)))
|
|
|
+ ) {
|
|
|
+ let o = d(e.firstChild, t, e, n, r, s, i),
|
|
|
+ l = !1
|
|
|
+ for (; o; ) {
|
|
|
+ ;(Hr = !0),
|
|
|
+ l ||
|
|
|
+ (Kt(
|
|
|
+ `Hydration children mismatch in <${t.type}>: server rendered element contains more child nodes than client vdom.`
|
|
|
+ ),
|
|
|
+ (l = !0))
|
|
|
+ const e = o
|
|
|
+ ;(o = o.nextSibling), c(e)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ 8 & p &&
|
|
|
+ e.textContent !== t.children &&
|
|
|
+ ((Hr = !0),
|
|
|
+ Kt(
|
|
|
+ `Hydration text content mismatch in <${t.type}>:\n- Client: ${e.textContent}\n- Server: ${t.children}`
|
|
|
+ ),
|
|
|
+ (e.textContent = t.children))
|
|
|
+ }
|
|
|
+ return e.nextSibling
|
|
|
+ },
|
|
|
+ d = (e, t, o, r, s, i, c) => {
|
|
|
+ c = c || !!t.dynamicChildren
|
|
|
+ const l = t.children,
|
|
|
+ a = l.length
|
|
|
+ let p = !1
|
|
|
+ for (let t = 0; t < a; t++) {
|
|
|
+ const a = c ? l[t] : (l[t] = Ms(l[t]))
|
|
|
+ if (e) e = u(e, a, r, s, i, c)
|
|
|
+ else {
|
|
|
+ if (a.type === ps && !a.children) continue
|
|
|
+ ;(Hr = !0),
|
|
|
+ p ||
|
|
|
+ (Kt(
|
|
|
+ `Hydration children mismatch in <${o.tagName.toLowerCase()}>: server rendered element contains fewer child nodes than client vdom.`
|
|
|
+ ),
|
|
|
+ (p = !0)),
|
|
|
+ n(null, a, o, null, r, s, zr(o), i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ f = (e, t, n, o, r, c) => {
|
|
|
+ const { slotScopeIds: u } = t
|
|
|
+ u && (r = r ? r.concat(u) : u)
|
|
|
+ const p = i(e),
|
|
|
+ f = d(s(e), t, p, n, o, r, c)
|
|
|
+ return f && Wr(f) && ']' === f.data
|
|
|
+ ? s((t.anchor = f))
|
|
|
+ : ((Hr = !0), l((t.anchor = a(']')), p, f), f)
|
|
|
+ },
|
|
|
+ h = (e, t, o, r, l, a) => {
|
|
|
+ if (
|
|
|
+ ((Hr = !0),
|
|
|
+ Kt(
|
|
|
+ 'Hydration node mismatch:\n- Client vnode:',
|
|
|
+ t.type,
|
|
|
+ '\n- Server rendered DOM:',
|
|
|
+ e,
|
|
|
+ 3 === e.nodeType ? '(text)' : Wr(e) && '[' === e.data ? '(start of fragment)' : ''
|
|
|
+ ),
|
|
|
+ (t.el = null),
|
|
|
+ a)
|
|
|
+ ) {
|
|
|
+ const t = m(e)
|
|
|
+ for (;;) {
|
|
|
+ const n = s(e)
|
|
|
+ if (!n || n === t) break
|
|
|
+ c(n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const u = s(e),
|
|
|
+ p = i(e)
|
|
|
+ return c(e), n(null, t, p, u, o, r, zr(p), l), u
|
|
|
+ },
|
|
|
+ m = (e) => {
|
|
|
+ let t = 0
|
|
|
+ for (; e; )
|
|
|
+ if ((e = s(e)) && Wr(e) && ('[' === e.data && t++, ']' === e.data)) {
|
|
|
+ if (0 === t) return s(e)
|
|
|
+ t--
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ return [
|
|
|
+ (e, t) => {
|
|
|
+ if (!t.hasChildNodes())
|
|
|
+ return (
|
|
|
+ Kt(
|
|
|
+ 'Attempting to hydrate existing markup but container is empty. Performing full mount instead.'
|
|
|
+ ),
|
|
|
+ n(null, e, t),
|
|
|
+ hn(),
|
|
|
+ void (t._vnode = e)
|
|
|
+ )
|
|
|
+ ;(Hr = !1),
|
|
|
+ u(t.firstChild, e, null, null, null),
|
|
|
+ hn(),
|
|
|
+ (t._vnode = e),
|
|
|
+ Hr && console.error('Hydration completed but contains mismatches.')
|
|
|
+ },
|
|
|
+ u
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ let Gr, Jr
|
|
|
+ function qr(e, t) {
|
|
|
+ e.appContext.config.performance && Zr() && Jr.mark(`vue-${t}-${e.uid}`),
|
|
|
+ Mn(e, t, Zr() ? Jr.now() : Date.now())
|
|
|
+ }
|
|
|
+ function Yr(e, t) {
|
|
|
+ if (e.appContext.config.performance && Zr()) {
|
|
|
+ const n = `vue-${t}-${e.uid}`,
|
|
|
+ o = n + ':end'
|
|
|
+ Jr.mark(o), Jr.measure(`<${si(e, e.type)}> ${t}`, n, o), Jr.clearMarks(n), Jr.clearMarks(o)
|
|
|
+ }
|
|
|
+ Pn(e, t, Zr() ? Jr.now() : Date.now())
|
|
|
+ }
|
|
|
+ function Zr() {
|
|
|
+ return (
|
|
|
+ void 0 !== Gr ||
|
|
|
+ ('undefined' != typeof window && window.performance
|
|
|
+ ? ((Gr = !0), (Jr = window.performance))
|
|
|
+ : (Gr = !1)),
|
|
|
+ Gr
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Xr = io
|
|
|
+ function Qr(e) {
|
|
|
+ return ts(e)
|
|
|
+ }
|
|
|
+ function es(e) {
|
|
|
+ return ts(e, Kr)
|
|
|
+ }
|
|
|
+ function ts(t, n) {
|
|
|
+ const o = re()
|
|
|
+ ;(o.__VUE__ = !0), Nn(o.__VUE_DEVTOOLS_GLOBAL_HOOK__, o)
|
|
|
+ const {
|
|
|
+ insert: r,
|
|
|
+ remove: s,
|
|
|
+ patchProp: i,
|
|
|
+ createElement: c,
|
|
|
+ createText: l,
|
|
|
+ createComment: a,
|
|
|
+ setText: u,
|
|
|
+ setElementText: p,
|
|
|
+ parentNode: d,
|
|
|
+ nextSibling: f,
|
|
|
+ setScopeId: h = w,
|
|
|
+ insertStaticContent: m
|
|
|
+ } = t,
|
|
|
+ g = (
|
|
|
+ e,
|
|
|
+ t,
|
|
|
+ n,
|
|
|
+ o = null,
|
|
|
+ r = null,
|
|
|
+ s = null,
|
|
|
+ i = !1,
|
|
|
+ c = null,
|
|
|
+ l = !bn && !!t.dynamicChildren
|
|
|
+ ) => {
|
|
|
+ if (e === t) return
|
|
|
+ e && !Cs(e, t) && ((o = Q(e)), K(e, r, s, !0), (e = null)),
|
|
|
+ -2 === t.patchFlag && ((l = !1), (t.dynamicChildren = null))
|
|
|
+ const { type: a, ref: u, shapeFlag: p } = t
|
|
|
+ switch (a) {
|
|
|
+ case ps:
|
|
|
+ y(e, t, n, o)
|
|
|
+ break
|
|
|
+ case ds:
|
|
|
+ v(e, t, n, o)
|
|
|
+ break
|
|
|
+ case fs:
|
|
|
+ null == e ? x(t, n, o, i) : S(e, t, n, i)
|
|
|
+ break
|
|
|
+ case us:
|
|
|
+ M(e, t, n, o, r, s, i, c, l)
|
|
|
+ break
|
|
|
+ default:
|
|
|
+ 1 & p
|
|
|
+ ? k(e, t, n, o, r, s, i, c, l)
|
|
|
+ : 6 & p
|
|
|
+ ? P(e, t, n, o, r, s, i, c, l)
|
|
|
+ : 64 & p || 128 & p
|
|
|
+ ? a.process(e, t, n, o, r, s, i, c, l, oe)
|
|
|
+ : Kt('Invalid VNode type:', a, `(${typeof a})`)
|
|
|
+ }
|
|
|
+ null != u && r && Dr(u, e && e.ref, s, t || e, !t)
|
|
|
+ },
|
|
|
+ y = (e, t, n, o) => {
|
|
|
+ if (null == e) r((t.el = l(t.children)), n, o)
|
|
|
+ else {
|
|
|
+ const n = (t.el = e.el)
|
|
|
+ t.children !== e.children && u(n, t.children)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ v = (e, t, n, o) => {
|
|
|
+ null == e ? r((t.el = a(t.children || '')), n, o) : (t.el = e.el)
|
|
|
+ },
|
|
|
+ x = (e, t, n, o) => {
|
|
|
+ ;[e.el, e.anchor] = m(e.children, t, n, o, e.el, e.anchor)
|
|
|
+ },
|
|
|
+ S = (e, t, n, o) => {
|
|
|
+ if (t.children !== e.children) {
|
|
|
+ const r = f(e.anchor)
|
|
|
+ C(e), ([t.el, t.anchor] = m(t.children, n, r, o))
|
|
|
+ } else (t.el = e.el), (t.anchor = e.anchor)
|
|
|
+ },
|
|
|
+ C = ({ el: e, anchor: t }) => {
|
|
|
+ let n
|
|
|
+ for (; e && e !== t; ) (n = f(e)), s(e), (e = n)
|
|
|
+ s(t)
|
|
|
+ },
|
|
|
+ k = (e, t, n, o, r, s, i, c, l) => {
|
|
|
+ ;(i = i || 'svg' === t.type), null == e ? $(t, n, o, r, s, i, c, l) : A(e, t, r, s, i, c, l)
|
|
|
+ },
|
|
|
+ $ = (e, t, n, o, s, l, a, u) => {
|
|
|
+ let d, f
|
|
|
+ const { type: h, props: m, shapeFlag: g, transition: y, dirs: v } = e
|
|
|
+ if (
|
|
|
+ ((d = e.el = c(e.type, l, m && m.is, m)),
|
|
|
+ 8 & g
|
|
|
+ ? p(d, e.children)
|
|
|
+ : 16 & g && O(e.children, d, null, o, s, l && 'foreignObject' !== h, a, u),
|
|
|
+ v && Xo(e, null, o, 'created'),
|
|
|
+ m)
|
|
|
+ ) {
|
|
|
+ for (const t in m) 'value' === t || z(t) || i(d, t, null, m[t], l, e.children, o, s, X)
|
|
|
+ 'value' in m && i(d, 'value', null, m.value), (f = m.onVnodeBeforeMount) && Vs(f, o, e)
|
|
|
+ }
|
|
|
+ E(d, e, e.scopeId, a, o),
|
|
|
+ Object.defineProperty(d, '__vnode', {
|
|
|
+ value: e,
|
|
|
+ enumerable: !1
|
|
|
+ }),
|
|
|
+ Object.defineProperty(d, '__vueParentComponent', {
|
|
|
+ value: o,
|
|
|
+ enumerable: !1
|
|
|
+ }),
|
|
|
+ v && Xo(e, null, o, 'beforeMount')
|
|
|
+ const b = (!s || (s && !s.pendingBranch)) && y && !y.persisted
|
|
|
+ b && y.beforeEnter(d),
|
|
|
+ r(d, t, n),
|
|
|
+ ((f = m && m.onVnodeMounted) || b || v) &&
|
|
|
+ Xr(() => {
|
|
|
+ f && Vs(f, o, e), b && y.enter(d), v && Xo(e, null, o, 'mounted')
|
|
|
+ }, s)
|
|
|
+ },
|
|
|
+ E = (e, t, n, o, r) => {
|
|
|
+ if ((n && h(e, n), o)) for (let t = 0; t < o.length; t++) h(e, o[t])
|
|
|
+ if (r) {
|
|
|
+ let n = r.subTree
|
|
|
+ if ((n.patchFlag > 0 && 2048 & n.patchFlag && (n = Jn(n.children) || n), t === n)) {
|
|
|
+ const t = r.vnode
|
|
|
+ E(e, t, t.scopeId, t.slotScopeIds, r.parent)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ O = (e, t, n, o, r, s, i, c, l = 0) => {
|
|
|
+ for (let a = l; a < e.length; a++) {
|
|
|
+ const l = (e[a] = c ? Ps(e[a]) : Ms(e[a]))
|
|
|
+ g(null, l, t, n, o, r, s, i, c)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ A = (e, t, n, o, r, s, c) => {
|
|
|
+ const l = (t.el = e.el)
|
|
|
+ let { patchFlag: a, dynamicChildren: u, dirs: d } = t
|
|
|
+ a |= 16 & e.patchFlag
|
|
|
+ const f = e.props || b,
|
|
|
+ h = t.props || b
|
|
|
+ let m
|
|
|
+ n && ns(n, !1),
|
|
|
+ (m = h.onVnodeBeforeUpdate) && Vs(m, n, t, e),
|
|
|
+ d && Xo(t, e, n, 'beforeUpdate'),
|
|
|
+ n && ns(n, !0),
|
|
|
+ bn && ((a = 0), (c = !1), (u = null))
|
|
|
+ const g = r && 'foreignObject' !== t.type
|
|
|
+ if (
|
|
|
+ (u
|
|
|
+ ? (I(e.dynamicChildren, u, l, n, o, g, s), n && n.type.__hmrId && os(e, t))
|
|
|
+ : c || U(e, t, l, null, n, o, g, s, !1),
|
|
|
+ a > 0)
|
|
|
+ ) {
|
|
|
+ if (16 & a) R(l, t, f, h, n, o, r)
|
|
|
+ else if (
|
|
|
+ (2 & a && f.class !== h.class && i(l, 'class', null, h.class, r),
|
|
|
+ 4 & a && i(l, 'style', f.style, h.style, r),
|
|
|
+ 8 & a)
|
|
|
+ ) {
|
|
|
+ const s = t.dynamicProps
|
|
|
+ for (let t = 0; t < s.length; t++) {
|
|
|
+ const c = s[t],
|
|
|
+ a = f[c],
|
|
|
+ u = h[c]
|
|
|
+ ;(u === a && 'value' !== c) || i(l, c, a, u, r, e.children, n, o, X)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 1 & a && e.children !== t.children && p(l, t.children)
|
|
|
+ } else c || null != u || R(l, t, f, h, n, o, r)
|
|
|
+ ;((m = h.onVnodeUpdated) || d) &&
|
|
|
+ Xr(() => {
|
|
|
+ m && Vs(m, n, t, e), d && Xo(t, e, n, 'updated')
|
|
|
+ }, o)
|
|
|
+ },
|
|
|
+ I = (e, t, n, o, r, s, i) => {
|
|
|
+ for (let c = 0; c < t.length; c++) {
|
|
|
+ const l = e[c],
|
|
|
+ a = t[c],
|
|
|
+ u = l.el && (l.type === us || !Cs(l, a) || 70 & l.shapeFlag) ? d(l.el) : n
|
|
|
+ g(l, a, u, null, o, r, s, i, !0)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ R = (e, t, n, o, r, s, c) => {
|
|
|
+ if (n !== o) {
|
|
|
+ if (n !== b)
|
|
|
+ for (const l in n) z(l) || l in o || i(e, l, n[l], null, c, t.children, r, s, X)
|
|
|
+ for (const l in o) {
|
|
|
+ if (z(l)) continue
|
|
|
+ const a = o[l],
|
|
|
+ u = n[l]
|
|
|
+ a !== u && 'value' !== l && i(e, l, u, a, c, t.children, r, s, X)
|
|
|
+ }
|
|
|
+ 'value' in o && i(e, 'value', n.value, o.value)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ M = (e, t, n, o, s, i, c, a, u) => {
|
|
|
+ const p = (t.el = e ? e.el : l('')),
|
|
|
+ d = (t.anchor = e ? e.anchor : l(''))
|
|
|
+ let { patchFlag: f, dynamicChildren: h, slotScopeIds: m } = t
|
|
|
+ ;(bn || 2048 & f) && ((f = 0), (u = !1), (h = null)),
|
|
|
+ m && (a = a ? a.concat(m) : m),
|
|
|
+ null == e
|
|
|
+ ? (r(p, n, o), r(d, n, o), O(t.children, n, d, s, i, c, a, u))
|
|
|
+ : f > 0 && 64 & f && h && e.dynamicChildren
|
|
|
+ ? (I(e.dynamicChildren, h, n, s, i, c, a),
|
|
|
+ s && s.type.__hmrId
|
|
|
+ ? os(e, t)
|
|
|
+ : (null != t.key || (s && t === s.subTree)) && os(e, t, !0))
|
|
|
+ : U(e, t, n, d, s, i, c, a, u)
|
|
|
+ },
|
|
|
+ P = (e, t, n, o, r, s, i, c, l) => {
|
|
|
+ ;(t.slotScopeIds = c),
|
|
|
+ null == e
|
|
|
+ ? 512 & t.shapeFlag
|
|
|
+ ? r.ctx.activate(t, n, o, i, l)
|
|
|
+ : F(t, n, o, r, s, i, l)
|
|
|
+ : j(e, t, l)
|
|
|
+ },
|
|
|
+ F = (e, t, n, o, r, s, i) => {
|
|
|
+ const c = (e.component = (function (e, t, n) {
|
|
|
+ const o = e.type,
|
|
|
+ r = (t ? t.appContext : e.appContext) || Ls,
|
|
|
+ s = {
|
|
|
+ uid: Bs++,
|
|
|
+ vnode: e,
|
|
|
+ type: o,
|
|
|
+ parent: t,
|
|
|
+ appContext: r,
|
|
|
+ root: null,
|
|
|
+ next: null,
|
|
|
+ subTree: null,
|
|
|
+ effect: null,
|
|
|
+ update: null,
|
|
|
+ scope: new ce(!0),
|
|
|
+ render: null,
|
|
|
+ proxy: null,
|
|
|
+ exposed: null,
|
|
|
+ exposeProxy: null,
|
|
|
+ withProxy: null,
|
|
|
+ provides: t ? t.provides : Object.create(r.provides),
|
|
|
+ accessCache: null,
|
|
|
+ renderCache: [],
|
|
|
+ components: null,
|
|
|
+ directives: null,
|
|
|
+ propsOptions: Sr(o, r),
|
|
|
+ emitsOptions: Vn(o, r),
|
|
|
+ emit: null,
|
|
|
+ emitted: null,
|
|
|
+ propsDefaults: b,
|
|
|
+ inheritAttrs: o.inheritAttrs,
|
|
|
+ ctx: b,
|
|
|
+ data: b,
|
|
|
+ props: b,
|
|
|
+ attrs: b,
|
|
|
+ slots: b,
|
|
|
+ refs: b,
|
|
|
+ setupState: b,
|
|
|
+ setupContext: null,
|
|
|
+ suspense: n,
|
|
|
+ suspenseId: n ? n.pendingId : 0,
|
|
|
+ asyncDep: null,
|
|
|
+ asyncResolved: !1,
|
|
|
+ isMounted: !1,
|
|
|
+ isUnmounted: !1,
|
|
|
+ isDeactivated: !1,
|
|
|
+ bc: null,
|
|
|
+ c: null,
|
|
|
+ bm: null,
|
|
|
+ m: null,
|
|
|
+ bu: null,
|
|
|
+ u: null,
|
|
|
+ um: null,
|
|
|
+ bum: null,
|
|
|
+ da: null,
|
|
|
+ a: null,
|
|
|
+ rtg: null,
|
|
|
+ rtc: null,
|
|
|
+ ec: null,
|
|
|
+ sp: null
|
|
|
+ }
|
|
|
+ ;(s.ctx = (function (e) {
|
|
|
+ const t = {}
|
|
|
+ return (
|
|
|
+ Object.defineProperty(t, '_', {
|
|
|
+ configurable: !0,
|
|
|
+ enumerable: !1,
|
|
|
+ get: () => e
|
|
|
+ }),
|
|
|
+ Object.keys(sr).forEach((n) => {
|
|
|
+ Object.defineProperty(t, n, {
|
|
|
+ configurable: !0,
|
|
|
+ enumerable: !1,
|
|
|
+ get: () => sr[n](e),
|
|
|
+ set: w
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ })(s)),
|
|
|
+ (s.root = t ? t.root : s),
|
|
|
+ (s.emit = jn.bind(null, s)),
|
|
|
+ e.ce && e.ce(s)
|
|
|
+ return s
|
|
|
+ })(e, o, r))
|
|
|
+ if (
|
|
|
+ (c.type.__hmrId &&
|
|
|
+ (function (e) {
|
|
|
+ const t = e.type.__hmrId
|
|
|
+ let n = wn.get(t)
|
|
|
+ n || (xn(t, e.type), (n = wn.get(t))), n.instances.add(e)
|
|
|
+ })(c),
|
|
|
+ zt(e),
|
|
|
+ qr(c, 'mount'),
|
|
|
+ Oo(e) && (c.ctx.renderer = oe),
|
|
|
+ qr(c, 'init'),
|
|
|
+ (function (e, t = !1) {
|
|
|
+ Ys = t
|
|
|
+ const { props: n, children: o } = e.vnode,
|
|
|
+ r = Gs(e)
|
|
|
+ ;(function (e, t, n, o = !1) {
|
|
|
+ const r = {},
|
|
|
+ s = {}
|
|
|
+ te(s, ks, 1), (e.propsDefaults = Object.create(null)), wr(e, t, r, s)
|
|
|
+ for (const t in e.propsOptions[0]) t in r || (r[t] = void 0)
|
|
|
+ Er(t || {}, r, e),
|
|
|
+ n ? (e.props = o ? r : yt(r)) : e.type.props ? (e.props = r) : (e.props = s),
|
|
|
+ (e.attrs = s)
|
|
|
+ })(e, n, r, t),
|
|
|
+ ((e, t) => {
|
|
|
+ if (32 & e.vnode.shapeFlag) {
|
|
|
+ const n = t._
|
|
|
+ n ? ((e.slots = kt(t)), te(t, '_', n)) : jr(t, (e.slots = {}))
|
|
|
+ } else (e.slots = {}), t && Vr(e, t)
|
|
|
+ te(e.slots, ks, 1)
|
|
|
+ })(e, o)
|
|
|
+ const s = r
|
|
|
+ ? (function (e, t) {
|
|
|
+ var n
|
|
|
+ const o = e.type
|
|
|
+ o.name && Ks(o.name, e.appContext.config)
|
|
|
+ if (o.components) {
|
|
|
+ const t = Object.keys(o.components)
|
|
|
+ for (let n = 0; n < t.length; n++) Ks(t[n], e.appContext.config)
|
|
|
+ }
|
|
|
+ if (o.directives) {
|
|
|
+ const e = Object.keys(o.directives)
|
|
|
+ for (let t = 0; t < e.length; t++) Zo(e[t])
|
|
|
+ }
|
|
|
+ o.compilerOptions &&
|
|
|
+ Qs() &&
|
|
|
+ Kt(
|
|
|
+ '"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.'
|
|
|
+ )
|
|
|
+ ;(e.accessCache = Object.create(null)),
|
|
|
+ (e.proxy = Tt(new Proxy(e.ctx, lr))),
|
|
|
+ (function (e) {
|
|
|
+ const {
|
|
|
+ ctx: t,
|
|
|
+ propsOptions: [n]
|
|
|
+ } = e
|
|
|
+ n &&
|
|
|
+ Object.keys(n).forEach((n) => {
|
|
|
+ Object.defineProperty(t, n, {
|
|
|
+ enumerable: !0,
|
|
|
+ configurable: !0,
|
|
|
+ get: () => e.props[n],
|
|
|
+ set: w
|
|
|
+ })
|
|
|
+ })
|
|
|
+ })(e)
|
|
|
+ const { setup: r } = o
|
|
|
+ if (r) {
|
|
|
+ const s = (e.setupContext = r.length > 1 ? ti(e) : null)
|
|
|
+ Hs(e), xe()
|
|
|
+ const i = Yt(r, e, 0, [bt(e.props), s])
|
|
|
+ if ((Se(), zs(), V(i))) {
|
|
|
+ if ((i.then(zs, zs), t))
|
|
|
+ return i
|
|
|
+ .then((n) => {
|
|
|
+ Zs(e, n, t)
|
|
|
+ })
|
|
|
+ .catch((t) => {
|
|
|
+ Xt(t, e, 0)
|
|
|
+ })
|
|
|
+ if (((e.asyncDep = i), !e.suspense)) {
|
|
|
+ Kt(
|
|
|
+ `Component <${
|
|
|
+ null !== (n = o.name) && void 0 !== n ? n : 'Anonymous'
|
|
|
+ }>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ } else Zs(e, i, t)
|
|
|
+ } else ei(e, t)
|
|
|
+ })(e, t)
|
|
|
+ : void 0
|
|
|
+ Ys = !1
|
|
|
+ })(c),
|
|
|
+ Yr(c, 'init'),
|
|
|
+ c.asyncDep)
|
|
|
+ ) {
|
|
|
+ if ((r && r.registerDep(c, L), !e.el)) {
|
|
|
+ const e = (c.subTree = Ns(ds))
|
|
|
+ v(null, e, t, n)
|
|
|
+ }
|
|
|
+ } else L(c, e, t, n, r, s, i), Wt(), Yr(c, 'mount')
|
|
|
+ },
|
|
|
+ j = (e, t, n) => {
|
|
|
+ const o = (t.component = e.component)
|
|
|
+ if (
|
|
|
+ (function (e, t, n) {
|
|
|
+ const { props: o, children: r, component: s } = e,
|
|
|
+ { props: i, children: c, patchFlag: l } = t,
|
|
|
+ a = s.emitsOptions
|
|
|
+ if ((r || c) && bn) return !0
|
|
|
+ if (t.dirs || t.transition) return !0
|
|
|
+ if (!(n && l >= 0))
|
|
|
+ return !((!r && !c) || (c && c.$stable)) || (o !== i && (o ? !i || Xn(o, i, a) : !!i))
|
|
|
+ if (1024 & l) return !0
|
|
|
+ if (16 & l) return o ? Xn(o, i, a) : !!i
|
|
|
+ if (8 & l) {
|
|
|
+ const e = t.dynamicProps
|
|
|
+ for (let t = 0; t < e.length; t++) {
|
|
|
+ const n = e[t]
|
|
|
+ if (i[n] !== o[n] && !Ln(a, n)) return !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ })(e, t, n)
|
|
|
+ ) {
|
|
|
+ if (o.asyncDep && !o.asyncResolved) return zt(t), B(o, t, n), void Wt()
|
|
|
+ ;(o.next = t),
|
|
|
+ (function (e) {
|
|
|
+ const t = tn.indexOf(e)
|
|
|
+ t > nn && tn.splice(t, 1)
|
|
|
+ })(o.update),
|
|
|
+ o.update()
|
|
|
+ } else (t.el = e.el), (o.vnode = t)
|
|
|
+ },
|
|
|
+ L = (e, t, n, o, r, s, i) => {
|
|
|
+ const c = (e.effect = new ve(
|
|
|
+ () => {
|
|
|
+ if (e.isMounted) {
|
|
|
+ let t,
|
|
|
+ { next: n, bu: o, u: c, parent: l, vnode: a } = e,
|
|
|
+ u = n
|
|
|
+ zt(n || e.vnode),
|
|
|
+ ns(e, !1),
|
|
|
+ n ? ((n.el = a.el), B(e, n, i)) : (n = a),
|
|
|
+ o && ee(o),
|
|
|
+ (t = n.props && n.props.onVnodeBeforeUpdate) && Vs(t, l, n, a),
|
|
|
+ ns(e, !0),
|
|
|
+ qr(e, 'render')
|
|
|
+ const p = Kn(e)
|
|
|
+ Yr(e, 'render')
|
|
|
+ const f = e.subTree
|
|
|
+ ;(e.subTree = p),
|
|
|
+ qr(e, 'patch'),
|
|
|
+ g(f, p, d(f.el), Q(f), e, r, s),
|
|
|
+ Yr(e, 'patch'),
|
|
|
+ (n.el = p.el),
|
|
|
+ null === u && Qn(e, p.el),
|
|
|
+ c && Xr(c, r),
|
|
|
+ (t = n.props && n.props.onVnodeUpdated) && Xr(() => Vs(t, l, n, a), r),
|
|
|
+ An(e),
|
|
|
+ Wt()
|
|
|
+ } else {
|
|
|
+ let i
|
|
|
+ const { el: c, props: l } = t,
|
|
|
+ { bm: a, m: u, parent: p } = e,
|
|
|
+ d = Eo(t)
|
|
|
+ if (
|
|
|
+ (ns(e, !1),
|
|
|
+ a && ee(a),
|
|
|
+ !d && (i = l && l.onVnodeBeforeMount) && Vs(i, p, t),
|
|
|
+ ns(e, !0),
|
|
|
+ c && ie)
|
|
|
+ ) {
|
|
|
+ const n = () => {
|
|
|
+ qr(e, 'render'),
|
|
|
+ (e.subTree = Kn(e)),
|
|
|
+ Yr(e, 'render'),
|
|
|
+ qr(e, 'hydrate'),
|
|
|
+ ie(c, e.subTree, e, r, null),
|
|
|
+ Yr(e, 'hydrate')
|
|
|
+ }
|
|
|
+ d ? t.type.__asyncLoader().then(() => !e.isUnmounted && n()) : n()
|
|
|
+ } else {
|
|
|
+ qr(e, 'render')
|
|
|
+ const i = (e.subTree = Kn(e))
|
|
|
+ Yr(e, 'render'),
|
|
|
+ qr(e, 'patch'),
|
|
|
+ g(null, i, n, o, e, r, s),
|
|
|
+ Yr(e, 'patch'),
|
|
|
+ (t.el = i.el)
|
|
|
+ }
|
|
|
+ if ((u && Xr(u, r), !d && (i = l && l.onVnodeMounted))) {
|
|
|
+ const e = t
|
|
|
+ Xr(() => Vs(i, p, e), r)
|
|
|
+ }
|
|
|
+ ;(256 & t.shapeFlag || (p && Eo(p.vnode) && 256 & p.vnode.shapeFlag)) &&
|
|
|
+ e.a &&
|
|
|
+ Xr(e.a, r),
|
|
|
+ (e.isMounted = !0),
|
|
|
+ On(e),
|
|
|
+ (t = n = o = null)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ () => un(l),
|
|
|
+ e.scope
|
|
|
+ )),
|
|
|
+ l = (e.update = () => c.run())
|
|
|
+ ;(l.id = e.uid),
|
|
|
+ ns(e, !0),
|
|
|
+ (c.onTrack = e.rtc ? (t) => ee(e.rtc, t) : void 0),
|
|
|
+ (c.onTrigger = e.rtg ? (t) => ee(e.rtg, t) : void 0),
|
|
|
+ (l.ownerInstance = e),
|
|
|
+ l()
|
|
|
+ },
|
|
|
+ B = (e, t, n) => {
|
|
|
+ t.component = e
|
|
|
+ const o = e.vnode.props
|
|
|
+ ;(e.vnode = t),
|
|
|
+ (e.next = null),
|
|
|
+ (function (e, t, n, o) {
|
|
|
+ const {
|
|
|
+ props: r,
|
|
|
+ attrs: s,
|
|
|
+ vnode: { patchFlag: i }
|
|
|
+ } = e,
|
|
|
+ c = kt(r),
|
|
|
+ [l] = e.propsOptions
|
|
|
+ let a = !1
|
|
|
+ if (
|
|
|
+ (function (e) {
|
|
|
+ for (; e; ) {
|
|
|
+ if (e.type.__hmrId) return !0
|
|
|
+ e = e.parent
|
|
|
+ }
|
|
|
+ })(e) ||
|
|
|
+ !(o || i > 0) ||
|
|
|
+ 16 & i
|
|
|
+ ) {
|
|
|
+ let o
|
|
|
+ wr(e, t, r, s) && (a = !0)
|
|
|
+ for (const s in c)
|
|
|
+ (t && (N(t, s) || ((o = Y(s)) !== s && N(t, o)))) ||
|
|
|
+ (l
|
|
|
+ ? !n ||
|
|
|
+ (void 0 === n[s] && void 0 === n[o]) ||
|
|
|
+ (r[s] = xr(l, c, s, void 0, e, !0))
|
|
|
+ : delete r[s])
|
|
|
+ if (s !== c) for (const e in s) (t && N(t, e)) || (delete s[e], (a = !0))
|
|
|
+ } else if (8 & i) {
|
|
|
+ const n = e.vnode.dynamicProps
|
|
|
+ for (let o = 0; o < n.length; o++) {
|
|
|
+ let i = n[o]
|
|
|
+ if (Ln(e.emitsOptions, i)) continue
|
|
|
+ const u = t[i]
|
|
|
+ if (l)
|
|
|
+ if (N(s, i)) u !== s[i] && ((s[i] = u), (a = !0))
|
|
|
+ else {
|
|
|
+ const t = J(i)
|
|
|
+ r[t] = xr(l, c, t, u, e, !1)
|
|
|
+ }
|
|
|
+ else u !== s[i] && ((s[i] = u), (a = !0))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ a && Te(e, 'set', '$attrs'), Er(t || {}, r, e)
|
|
|
+ })(e, t.props, o, n),
|
|
|
+ ((e, t, n) => {
|
|
|
+ const { vnode: o, slots: r } = e
|
|
|
+ let s = !0,
|
|
|
+ i = b
|
|
|
+ if (32 & o.shapeFlag) {
|
|
|
+ const e = t._
|
|
|
+ e
|
|
|
+ ? bn
|
|
|
+ ? T(r, t)
|
|
|
+ : n && 1 === e
|
|
|
+ ? (s = !1)
|
|
|
+ : (T(r, t), n || 1 !== e || delete r._)
|
|
|
+ : ((s = !t.$stable), jr(t, r)),
|
|
|
+ (i = t)
|
|
|
+ } else
|
|
|
+ t &&
|
|
|
+ (Vr(e, t),
|
|
|
+ (i = {
|
|
|
+ default: 1
|
|
|
+ }))
|
|
|
+ if (s) for (const e in r) Mr(e) || e in i || delete r[e]
|
|
|
+ })(e, t.children, n),
|
|
|
+ xe(),
|
|
|
+ fn(),
|
|
|
+ Se()
|
|
|
+ },
|
|
|
+ U = (e, t, n, o, r, s, i, c, l = !1) => {
|
|
|
+ const a = e && e.children,
|
|
|
+ u = e ? e.shapeFlag : 0,
|
|
|
+ d = t.children,
|
|
|
+ { patchFlag: f, shapeFlag: h } = t
|
|
|
+ if (f > 0) {
|
|
|
+ if (128 & f) return void H(a, d, n, o, r, s, i, c, l)
|
|
|
+ if (256 & f) return void D(a, d, n, o, r, s, i, c, l)
|
|
|
+ }
|
|
|
+ 8 & h
|
|
|
+ ? (16 & u && X(a, r, s), d !== a && p(n, d))
|
|
|
+ : 16 & u
|
|
|
+ ? 16 & h
|
|
|
+ ? H(a, d, n, o, r, s, i, c, l)
|
|
|
+ : X(a, r, s, !0)
|
|
|
+ : (8 & u && p(n, ''), 16 & h && O(d, n, o, r, s, i, c, l))
|
|
|
+ },
|
|
|
+ D = (e, t, n, o, r, s, i, c, l) => {
|
|
|
+ t = t || _
|
|
|
+ const a = (e = e || _).length,
|
|
|
+ u = t.length,
|
|
|
+ p = Math.min(a, u)
|
|
|
+ let d
|
|
|
+ for (d = 0; d < p; d++) {
|
|
|
+ const o = (t[d] = l ? Ps(t[d]) : Ms(t[d]))
|
|
|
+ g(e[d], o, n, null, r, s, i, c, l)
|
|
|
+ }
|
|
|
+ a > u ? X(e, r, s, !0, !1, p) : O(t, n, o, r, s, i, c, l, p)
|
|
|
+ },
|
|
|
+ H = (e, t, n, o, r, s, i, c, l) => {
|
|
|
+ let a = 0
|
|
|
+ const u = t.length
|
|
|
+ let p = e.length - 1,
|
|
|
+ d = u - 1
|
|
|
+ for (; a <= p && a <= d; ) {
|
|
|
+ const o = e[a],
|
|
|
+ u = (t[a] = l ? Ps(t[a]) : Ms(t[a]))
|
|
|
+ if (!Cs(o, u)) break
|
|
|
+ g(o, u, n, null, r, s, i, c, l), a++
|
|
|
+ }
|
|
|
+ for (; a <= p && a <= d; ) {
|
|
|
+ const o = e[p],
|
|
|
+ a = (t[d] = l ? Ps(t[d]) : Ms(t[d]))
|
|
|
+ if (!Cs(o, a)) break
|
|
|
+ g(o, a, n, null, r, s, i, c, l), p--, d--
|
|
|
+ }
|
|
|
+ if (a > p) {
|
|
|
+ if (a <= d) {
|
|
|
+ const e = d + 1,
|
|
|
+ p = e < u ? t[e].el : o
|
|
|
+ for (; a <= d; ) g(null, (t[a] = l ? Ps(t[a]) : Ms(t[a])), n, p, r, s, i, c, l), a++
|
|
|
+ }
|
|
|
+ } else if (a > d) for (; a <= p; ) K(e[a], r, s, !0), a++
|
|
|
+ else {
|
|
|
+ const f = a,
|
|
|
+ h = a,
|
|
|
+ m = new Map()
|
|
|
+ for (a = h; a <= d; a++) {
|
|
|
+ const e = (t[a] = l ? Ps(t[a]) : Ms(t[a]))
|
|
|
+ null != e.key &&
|
|
|
+ (m.has(e.key) &&
|
|
|
+ Kt(
|
|
|
+ 'Duplicate keys found during update:',
|
|
|
+ JSON.stringify(e.key),
|
|
|
+ 'Make sure keys are unique.'
|
|
|
+ ),
|
|
|
+ m.set(e.key, a))
|
|
|
+ }
|
|
|
+ let y,
|
|
|
+ v = 0
|
|
|
+ const b = d - h + 1
|
|
|
+ let w = !1,
|
|
|
+ x = 0
|
|
|
+ const S = new Array(b)
|
|
|
+ for (a = 0; a < b; a++) S[a] = 0
|
|
|
+ for (a = f; a <= p; a++) {
|
|
|
+ const o = e[a]
|
|
|
+ if (v >= b) {
|
|
|
+ K(o, r, s, !0)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ let u
|
|
|
+ if (null != o.key) u = m.get(o.key)
|
|
|
+ else
|
|
|
+ for (y = h; y <= d; y++)
|
|
|
+ if (0 === S[y - h] && Cs(o, t[y])) {
|
|
|
+ u = y
|
|
|
+ break
|
|
|
+ }
|
|
|
+ void 0 === u
|
|
|
+ ? K(o, r, s, !0)
|
|
|
+ : ((S[u - h] = a + 1),
|
|
|
+ u >= x ? (x = u) : (w = !0),
|
|
|
+ g(o, t[u], n, null, r, s, i, c, l),
|
|
|
+ v++)
|
|
|
+ }
|
|
|
+ const C = w
|
|
|
+ ? (function (e) {
|
|
|
+ const t = e.slice(),
|
|
|
+ n = [0]
|
|
|
+ let o, r, s, i, c
|
|
|
+ const l = e.length
|
|
|
+ for (o = 0; o < l; o++) {
|
|
|
+ const l = e[o]
|
|
|
+ if (0 !== l) {
|
|
|
+ if (((r = n[n.length - 1]), e[r] < l)) {
|
|
|
+ ;(t[o] = r), n.push(o)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ for (s = 0, i = n.length - 1; s < i; )
|
|
|
+ (c = (s + i) >> 1), e[n[c]] < l ? (s = c + 1) : (i = c)
|
|
|
+ l < e[n[s]] && (s > 0 && (t[o] = n[s - 1]), (n[s] = o))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ;(s = n.length), (i = n[s - 1])
|
|
|
+ for (; s-- > 0; ) (n[s] = i), (i = t[i])
|
|
|
+ return n
|
|
|
+ })(S)
|
|
|
+ : _
|
|
|
+ for (y = C.length - 1, a = b - 1; a >= 0; a--) {
|
|
|
+ const e = h + a,
|
|
|
+ p = t[e],
|
|
|
+ d = e + 1 < u ? t[e + 1].el : o
|
|
|
+ 0 === S[a]
|
|
|
+ ? g(null, p, n, d, r, s, i, c, l)
|
|
|
+ : w && (y < 0 || a !== C[y] ? W(p, n, d, 2) : y--)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ W = (e, t, n, o, s = null) => {
|
|
|
+ const { el: i, type: c, transition: l, children: a, shapeFlag: u } = e
|
|
|
+ if (6 & u) return void W(e.component.subTree, t, n, o)
|
|
|
+ if (128 & u) return void e.suspense.move(t, n, o)
|
|
|
+ if (64 & u) return void c.move(e, t, n, oe)
|
|
|
+ if (c === us) {
|
|
|
+ r(i, t, n)
|
|
|
+ for (let e = 0; e < a.length; e++) W(a[e], t, n, o)
|
|
|
+ return void r(e.anchor, t, n)
|
|
|
+ }
|
|
|
+ if (c === fs)
|
|
|
+ return void (({ el: e, anchor: t }, n, o) => {
|
|
|
+ let s
|
|
|
+ for (; e && e !== t; ) (s = f(e)), r(e, n, o), (e = s)
|
|
|
+ r(t, n, o)
|
|
|
+ })(e, t, n)
|
|
|
+ if (2 !== o && 1 & u && l)
|
|
|
+ if (0 === o) l.beforeEnter(i), r(i, t, n), Xr(() => l.enter(i), s)
|
|
|
+ else {
|
|
|
+ const { leave: e, delayLeave: o, afterLeave: s } = l,
|
|
|
+ c = () => r(i, t, n),
|
|
|
+ a = () => {
|
|
|
+ e(i, () => {
|
|
|
+ c(), s && s()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ o ? o(i, c, a) : a()
|
|
|
+ }
|
|
|
+ else r(i, t, n)
|
|
|
+ },
|
|
|
+ K = (e, t, n, o = !1, r = !1) => {
|
|
|
+ const {
|
|
|
+ type: s,
|
|
|
+ props: i,
|
|
|
+ ref: c,
|
|
|
+ children: l,
|
|
|
+ dynamicChildren: a,
|
|
|
+ shapeFlag: u,
|
|
|
+ patchFlag: p,
|
|
|
+ dirs: d
|
|
|
+ } = e
|
|
|
+ if ((null != c && Dr(c, null, n, e, !0), 256 & u)) return void t.ctx.deactivate(e)
|
|
|
+ const f = 1 & u && d,
|
|
|
+ h = !Eo(e)
|
|
|
+ let m
|
|
|
+ if ((h && (m = i && i.onVnodeBeforeUnmount) && Vs(m, t, e), 6 & u)) Z(e.component, n, o)
|
|
|
+ else {
|
|
|
+ if (128 & u) return void e.suspense.unmount(n, o)
|
|
|
+ f && Xo(e, null, t, 'beforeUnmount'),
|
|
|
+ 64 & u
|
|
|
+ ? e.type.remove(e, t, n, r, oe, o)
|
|
|
+ : a && (s !== us || (p > 0 && 64 & p))
|
|
|
+ ? X(a, t, n, !1, !0)
|
|
|
+ : ((s === us && 384 & p) || (!r && 16 & u)) && X(l, t, n),
|
|
|
+ o && G(e)
|
|
|
+ }
|
|
|
+ ;((h && (m = i && i.onVnodeUnmounted)) || f) &&
|
|
|
+ Xr(() => {
|
|
|
+ m && Vs(m, t, e), f && Xo(e, null, t, 'unmounted')
|
|
|
+ }, n)
|
|
|
+ },
|
|
|
+ G = (e) => {
|
|
|
+ const { type: t, el: n, anchor: o, transition: r } = e
|
|
|
+ if (t === us)
|
|
|
+ return void (e.patchFlag > 0 && 2048 & e.patchFlag && r && !r.persisted
|
|
|
+ ? e.children.forEach((e) => {
|
|
|
+ e.type === ds ? s(e.el) : G(e)
|
|
|
+ })
|
|
|
+ : q(n, o))
|
|
|
+ if (t === fs) return void C(e)
|
|
|
+ const i = () => {
|
|
|
+ s(n), r && !r.persisted && r.afterLeave && r.afterLeave()
|
|
|
+ }
|
|
|
+ if (1 & e.shapeFlag && r && !r.persisted) {
|
|
|
+ const { leave: t, delayLeave: o } = r,
|
|
|
+ s = () => t(n, i)
|
|
|
+ o ? o(e.el, i, s) : s()
|
|
|
+ } else i()
|
|
|
+ },
|
|
|
+ q = (e, t) => {
|
|
|
+ let n
|
|
|
+ for (; e !== t; ) (n = f(e)), s(e), (e = n)
|
|
|
+ s(t)
|
|
|
+ },
|
|
|
+ Z = (t, n, o) => {
|
|
|
+ t.type.__hmrId &&
|
|
|
+ (function (e) {
|
|
|
+ wn.get(e.type.__hmrId).instances.delete(e)
|
|
|
+ })(t)
|
|
|
+ const { bum: r, scope: s, update: i, subTree: c, um: l } = t
|
|
|
+ var a
|
|
|
+ r && ee(r),
|
|
|
+ s.stop(),
|
|
|
+ i && ((i.active = !1), K(c, t, n, o)),
|
|
|
+ l && Xr(l, n),
|
|
|
+ Xr(() => {
|
|
|
+ t.isUnmounted = !0
|
|
|
+ }, n),
|
|
|
+ n &&
|
|
|
+ n.pendingBranch &&
|
|
|
+ !n.isUnmounted &&
|
|
|
+ t.asyncDep &&
|
|
|
+ !t.asyncResolved &&
|
|
|
+ t.suspenseId === n.pendingId &&
|
|
|
+ (n.deps--, 0 === n.deps && n.resolve()),
|
|
|
+ (a = t),
|
|
|
+ e.devtools &&
|
|
|
+ 'function' == typeof e.devtools.cleanupBuffer &&
|
|
|
+ !e.devtools.cleanupBuffer(a) &&
|
|
|
+ In(a)
|
|
|
+ },
|
|
|
+ X = (e, t, n, o = !1, r = !1, s = 0) => {
|
|
|
+ for (let i = s; i < e.length; i++) K(e[i], t, n, o, r)
|
|
|
+ },
|
|
|
+ Q = (e) =>
|
|
|
+ 6 & e.shapeFlag
|
|
|
+ ? Q(e.component.subTree)
|
|
|
+ : 128 & e.shapeFlag
|
|
|
+ ? e.suspense.next()
|
|
|
+ : f(e.anchor || e.el),
|
|
|
+ ne = (e, t, n) => {
|
|
|
+ null == e
|
|
|
+ ? t._vnode && K(t._vnode, null, null, !0)
|
|
|
+ : g(t._vnode || null, e, t, null, null, null, n),
|
|
|
+ fn(),
|
|
|
+ hn(),
|
|
|
+ (t._vnode = e)
|
|
|
+ },
|
|
|
+ oe = {
|
|
|
+ p: g,
|
|
|
+ um: K,
|
|
|
+ m: W,
|
|
|
+ r: G,
|
|
|
+ mt: F,
|
|
|
+ mc: O,
|
|
|
+ pc: U,
|
|
|
+ pbc: I,
|
|
|
+ n: Q,
|
|
|
+ o: t
|
|
|
+ }
|
|
|
+ let se, ie
|
|
|
+ return (
|
|
|
+ n && ([se, ie] = n(oe)),
|
|
|
+ {
|
|
|
+ render: ne,
|
|
|
+ hydrate: se,
|
|
|
+ createApp: Ur(ne, se)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ns({ effect: e, update: t }, n) {
|
|
|
+ e.allowRecurse = t.allowRecurse = n
|
|
|
+ }
|
|
|
+ function os(e, t, n = !1) {
|
|
|
+ const o = e.children,
|
|
|
+ r = t.children
|
|
|
+ if (O(o) && O(r))
|
|
|
+ for (let e = 0; e < o.length; e++) {
|
|
|
+ const t = o[e]
|
|
|
+ let s = r[e]
|
|
|
+ 1 & s.shapeFlag &&
|
|
|
+ !s.dynamicChildren &&
|
|
|
+ ((s.patchFlag <= 0 || 32 === s.patchFlag) && ((s = r[e] = Ps(r[e])), (s.el = t.el)),
|
|
|
+ n || os(t, s)),
|
|
|
+ s.type === ps && (s.el = t.el),
|
|
|
+ s.type !== ds || s.el || (s.el = t.el)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const rs = (e) => e && (e.disabled || '' === e.disabled),
|
|
|
+ ss = (e) => 'undefined' != typeof SVGElement && e instanceof SVGElement,
|
|
|
+ is = (e, t) => {
|
|
|
+ const n = e && e.to
|
|
|
+ if (P(n)) {
|
|
|
+ if (t) {
|
|
|
+ const e = t(n)
|
|
|
+ return (
|
|
|
+ e ||
|
|
|
+ Kt(
|
|
|
+ `Failed to locate Teleport target with selector "${n}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`
|
|
|
+ ),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ Kt(
|
|
|
+ 'Current renderer does not support string target for Teleports. (missing querySelector renderer option)'
|
|
|
+ ),
|
|
|
+ null
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return n || rs(e) || Kt(`Invalid Teleport target: ${n}`), n
|
|
|
+ }
|
|
|
+ function cs(e, t, n, { o: { insert: o }, m: r }, s = 2) {
|
|
|
+ 0 === s && o(e.targetAnchor, t, n)
|
|
|
+ const { el: i, anchor: c, shapeFlag: l, children: a, props: u } = e,
|
|
|
+ p = 2 === s
|
|
|
+ if ((p && o(i, t, n), (!p || rs(u)) && 16 & l))
|
|
|
+ for (let e = 0; e < a.length; e++) r(a[e], t, n, 2)
|
|
|
+ p && o(c, t, n)
|
|
|
+ }
|
|
|
+ const ls = {
|
|
|
+ __isTeleport: !0,
|
|
|
+ process(e, t, n, o, r, s, i, c, l, a) {
|
|
|
+ const {
|
|
|
+ mc: u,
|
|
|
+ pc: p,
|
|
|
+ pbc: d,
|
|
|
+ o: { insert: f, querySelector: h, createText: m, createComment: g }
|
|
|
+ } = a,
|
|
|
+ y = rs(t.props)
|
|
|
+ let { shapeFlag: v, children: b, dynamicChildren: _ } = t
|
|
|
+ if ((bn && ((l = !1), (_ = null)), null == e)) {
|
|
|
+ const e = (t.el = g('teleport start')),
|
|
|
+ a = (t.anchor = g('teleport end'))
|
|
|
+ f(e, n, o), f(a, n, o)
|
|
|
+ const p = (t.target = is(t.props, h)),
|
|
|
+ d = (t.targetAnchor = m(''))
|
|
|
+ p
|
|
|
+ ? (f(d, p), (i = i || ss(p)))
|
|
|
+ : y || Kt('Invalid Teleport target on mount:', p, `(${typeof p})`)
|
|
|
+ const _ = (e, t) => {
|
|
|
+ 16 & v && u(b, e, t, r, s, i, c, l)
|
|
|
+ }
|
|
|
+ y ? _(n, a) : p && _(p, d)
|
|
|
+ } else {
|
|
|
+ t.el = e.el
|
|
|
+ const o = (t.anchor = e.anchor),
|
|
|
+ u = (t.target = e.target),
|
|
|
+ f = (t.targetAnchor = e.targetAnchor),
|
|
|
+ m = rs(e.props),
|
|
|
+ g = m ? n : u,
|
|
|
+ v = m ? o : f
|
|
|
+ if (
|
|
|
+ ((i = i || ss(u)),
|
|
|
+ _
|
|
|
+ ? (d(e.dynamicChildren, _, g, r, s, i, c), os(e, t, !0))
|
|
|
+ : l || p(e, t, g, v, r, s, i, c, !1),
|
|
|
+ y)
|
|
|
+ )
|
|
|
+ m || cs(t, n, o, a, 1)
|
|
|
+ else if ((t.props && t.props.to) !== (e.props && e.props.to)) {
|
|
|
+ const e = (t.target = is(t.props, h))
|
|
|
+ e ? cs(t, e, null, a, 0) : Kt('Invalid Teleport target on update:', u, `(${typeof u})`)
|
|
|
+ } else m && cs(t, u, f, a, 1)
|
|
|
+ }
|
|
|
+ as(t)
|
|
|
+ },
|
|
|
+ remove(e, t, n, o, { um: r, o: { remove: s } }, i) {
|
|
|
+ const { shapeFlag: c, children: l, anchor: a, targetAnchor: u, target: p, props: d } = e
|
|
|
+ if ((p && s(u), (i || !rs(d)) && (s(a), 16 & c)))
|
|
|
+ for (let e = 0; e < l.length; e++) {
|
|
|
+ const o = l[e]
|
|
|
+ r(o, t, n, !0, !!o.dynamicChildren)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ move: cs,
|
|
|
+ hydrate: function (
|
|
|
+ e,
|
|
|
+ t,
|
|
|
+ n,
|
|
|
+ o,
|
|
|
+ r,
|
|
|
+ s,
|
|
|
+ { o: { nextSibling: i, parentNode: c, querySelector: l } },
|
|
|
+ a
|
|
|
+ ) {
|
|
|
+ const u = (t.target = is(t.props, l))
|
|
|
+ if (u) {
|
|
|
+ const l = u._lpa || u.firstChild
|
|
|
+ if (16 & t.shapeFlag)
|
|
|
+ if (rs(t.props)) (t.anchor = a(i(e), t, c(e), n, o, r, s)), (t.targetAnchor = l)
|
|
|
+ else {
|
|
|
+ t.anchor = i(e)
|
|
|
+ let c = l
|
|
|
+ for (; c; )
|
|
|
+ if (((c = i(c)), c && 8 === c.nodeType && 'teleport anchor' === c.data)) {
|
|
|
+ ;(t.targetAnchor = c), (u._lpa = t.targetAnchor && i(t.targetAnchor))
|
|
|
+ break
|
|
|
+ }
|
|
|
+ a(l, t, u, n, o, r, s)
|
|
|
+ }
|
|
|
+ as(t)
|
|
|
+ }
|
|
|
+ return t.anchor && i(t.anchor)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function as(e) {
|
|
|
+ const t = e.ctx
|
|
|
+ if (t && t.ut) {
|
|
|
+ let n = e.children[0].el
|
|
|
+ for (; n !== e.targetAnchor; )
|
|
|
+ 1 === n.nodeType && n.setAttribute('data-v-owner', t.uid), (n = n.nextSibling)
|
|
|
+ t.ut()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const us = Symbol('Fragment'),
|
|
|
+ ps = Symbol('Text'),
|
|
|
+ ds = Symbol('Comment'),
|
|
|
+ fs = Symbol('Static'),
|
|
|
+ hs = []
|
|
|
+ let ms = null
|
|
|
+ function gs(e = !1) {
|
|
|
+ hs.push((ms = e ? null : []))
|
|
|
+ }
|
|
|
+ function ys() {
|
|
|
+ hs.pop(), (ms = hs[hs.length - 1] || null)
|
|
|
+ }
|
|
|
+ let vs,
|
|
|
+ bs = 1
|
|
|
+ function _s(e) {
|
|
|
+ bs += e
|
|
|
+ }
|
|
|
+ function ws(e) {
|
|
|
+ return (e.dynamicChildren = bs > 0 ? ms || _ : null), ys(), bs > 0 && ms && ms.push(e), e
|
|
|
+ }
|
|
|
+ function xs(e, t, n, o, r) {
|
|
|
+ return ws(Ns(e, t, n, o, r, !0))
|
|
|
+ }
|
|
|
+ function Ss(e) {
|
|
|
+ return !!e && !0 === e.__v_isVNode
|
|
|
+ }
|
|
|
+ function Cs(e, t) {
|
|
|
+ return 6 & t.shapeFlag && _n.has(t.type)
|
|
|
+ ? ((e.shapeFlag &= -257), (t.shapeFlag &= -513), !1)
|
|
|
+ : e.type === t.type && e.key === t.key
|
|
|
+ }
|
|
|
+ const ks = '__vInternal',
|
|
|
+ Ts = ({ key: e }) => (null != e ? e : null),
|
|
|
+ $s = ({ ref: e, ref_key: t, ref_for: n }) =>
|
|
|
+ null != e
|
|
|
+ ? P(e) || At(e) || M(e)
|
|
|
+ ? {
|
|
|
+ i: Bn,
|
|
|
+ r: e,
|
|
|
+ k: t,
|
|
|
+ f: !!n
|
|
|
+ }
|
|
|
+ : e
|
|
|
+ : null
|
|
|
+ function Es(e, t = null, n = null, o = 0, r = null, s = e === us ? 0 : 1, i = !1, c = !1) {
|
|
|
+ const l = {
|
|
|
+ __v_isVNode: !0,
|
|
|
+ __v_skip: !0,
|
|
|
+ type: e,
|
|
|
+ props: t,
|
|
|
+ key: t && Ts(t),
|
|
|
+ ref: t && $s(t),
|
|
|
+ scopeId: Un,
|
|
|
+ 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: o,
|
|
|
+ dynamicProps: r,
|
|
|
+ dynamicChildren: null,
|
|
|
+ appContext: null,
|
|
|
+ ctx: Bn
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ c ? (Fs(l, n), 128 & s && e.normalize(l)) : n && (l.shapeFlag |= P(n) ? 8 : 16),
|
|
|
+ l.key != l.key && Kt('VNode created with invalid key (NaN). VNode type:', l.type),
|
|
|
+ bs > 0 && !i && ms && (l.patchFlag > 0 || 6 & s) && 32 !== l.patchFlag && ms.push(l),
|
|
|
+ l
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Ns = (...e) =>
|
|
|
+ (function (e, t = null, n = null, o = 0, r = null, i = !1) {
|
|
|
+ ;(e && e !== er) || (e || Kt(`Invalid vnode type when creating vnode: ${e}.`), (e = ds))
|
|
|
+ if (Ss(e)) {
|
|
|
+ const o = As(e, t, !0)
|
|
|
+ return (
|
|
|
+ n && Fs(o, n),
|
|
|
+ bs > 0 && !i && ms && (6 & o.shapeFlag ? (ms[ms.indexOf(e)] = o) : ms.push(o)),
|
|
|
+ (o.patchFlag |= -2),
|
|
|
+ o
|
|
|
+ )
|
|
|
+ }
|
|
|
+ ii(e) && (e = e.__vccOpts)
|
|
|
+ if (t) {
|
|
|
+ t = Os(t)
|
|
|
+ let { class: e, style: n } = t
|
|
|
+ e && !P(e) && (t.class = u(e)), j(n) && (Ct(n) && !O(n) && (n = T({}, n)), (t.style = s(n)))
|
|
|
+ }
|
|
|
+ const c = P(e) ? 1 : eo(e) ? 128 : ((e) => e.__isTeleport)(e) ? 64 : j(e) ? 4 : M(e) ? 2 : 0
|
|
|
+ 4 & c &&
|
|
|
+ Ct(e) &&
|
|
|
+ Kt(
|
|
|
+ 'Vue received a Component which 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`.',
|
|
|
+ '\nComponent that was made reactive: ',
|
|
|
+ (e = kt(e))
|
|
|
+ )
|
|
|
+ return Es(e, t, n, o, r, c, i, !0)
|
|
|
+ })(...(vs ? vs(e, Bn) : e))
|
|
|
+ function Os(e) {
|
|
|
+ return e ? (Ct(e) || ks in e ? T({}, e) : e) : null
|
|
|
+ }
|
|
|
+ function As(e, t, n = !1) {
|
|
|
+ const { props: o, ref: r, patchFlag: s, children: i } = e,
|
|
|
+ c = t ? js(o || {}, t) : o
|
|
|
+ return {
|
|
|
+ __v_isVNode: !0,
|
|
|
+ __v_skip: !0,
|
|
|
+ type: e.type,
|
|
|
+ props: c,
|
|
|
+ key: c && Ts(c),
|
|
|
+ ref: t && t.ref ? (n && r ? (O(r) ? r.concat($s(t)) : [r, $s(t)]) : $s(t)) : r,
|
|
|
+ scopeId: e.scopeId,
|
|
|
+ slotScopeIds: e.slotScopeIds,
|
|
|
+ children: -1 === s && O(i) ? i.map(Is) : i,
|
|
|
+ target: e.target,
|
|
|
+ targetAnchor: e.targetAnchor,
|
|
|
+ staticCount: e.staticCount,
|
|
|
+ shapeFlag: e.shapeFlag,
|
|
|
+ patchFlag: t && e.type !== us ? (-1 === s ? 16 : 16 | s) : s,
|
|
|
+ dynamicProps: e.dynamicProps,
|
|
|
+ dynamicChildren: e.dynamicChildren,
|
|
|
+ appContext: e.appContext,
|
|
|
+ dirs: e.dirs,
|
|
|
+ transition: e.transition,
|
|
|
+ component: e.component,
|
|
|
+ suspense: e.suspense,
|
|
|
+ ssContent: e.ssContent && As(e.ssContent),
|
|
|
+ ssFallback: e.ssFallback && As(e.ssFallback),
|
|
|
+ el: e.el,
|
|
|
+ anchor: e.anchor,
|
|
|
+ ctx: e.ctx
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Is(e) {
|
|
|
+ const t = As(e)
|
|
|
+ return O(e.children) && (t.children = e.children.map(Is)), t
|
|
|
+ }
|
|
|
+ function Rs(e = ' ', t = 0) {
|
|
|
+ return Ns(ps, null, e, t)
|
|
|
+ }
|
|
|
+ function Ms(e) {
|
|
|
+ return null == e || 'boolean' == typeof e
|
|
|
+ ? Ns(ds)
|
|
|
+ : O(e)
|
|
|
+ ? Ns(us, null, e.slice())
|
|
|
+ : 'object' == typeof e
|
|
|
+ ? Ps(e)
|
|
|
+ : Ns(ps, null, String(e))
|
|
|
+ }
|
|
|
+ function Ps(e) {
|
|
|
+ return (null === e.el && -1 !== e.patchFlag) || e.memo ? e : As(e)
|
|
|
+ }
|
|
|
+ function Fs(e, t) {
|
|
|
+ let n = 0
|
|
|
+ const { shapeFlag: o } = e
|
|
|
+ if (null == t) t = null
|
|
|
+ else if (O(t)) n = 16
|
|
|
+ else if ('object' == typeof t) {
|
|
|
+ if (65 & o) {
|
|
|
+ const n = t.default
|
|
|
+ return void (n && (n._c && (n._d = !1), Fs(e, n()), n._c && (n._d = !0)))
|
|
|
+ }
|
|
|
+ {
|
|
|
+ n = 32
|
|
|
+ const o = t._
|
|
|
+ o || ks in t
|
|
|
+ ? 3 === o && Bn && (1 === Bn.slots._ ? (t._ = 1) : ((t._ = 2), (e.patchFlag |= 1024)))
|
|
|
+ : (t._ctx = Bn)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ M(t)
|
|
|
+ ? ((t = {
|
|
|
+ default: t,
|
|
|
+ _ctx: Bn
|
|
|
+ }),
|
|
|
+ (n = 32))
|
|
|
+ : ((t = String(t)), 64 & o ? ((n = 16), (t = [Rs(t)])) : (n = 8))
|
|
|
+ ;(e.children = t), (e.shapeFlag |= n)
|
|
|
+ }
|
|
|
+ function js(...e) {
|
|
|
+ const t = {}
|
|
|
+ for (let n = 0; n < e.length; n++) {
|
|
|
+ const o = e[n]
|
|
|
+ for (const e in o)
|
|
|
+ if ('class' === e) t.class !== o.class && (t.class = u([t.class, o.class]))
|
|
|
+ else if ('style' === e) t.style = s([t.style, o.style])
|
|
|
+ else if (C(e)) {
|
|
|
+ const n = t[e],
|
|
|
+ r = o[e]
|
|
|
+ !r || n === r || (O(n) && n.includes(r)) || (t[e] = n ? [].concat(n, r) : r)
|
|
|
+ } else '' !== e && (t[e] = o[e])
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function Vs(e, t, n, o = null) {
|
|
|
+ Zt(e, t, 7, [n, o])
|
|
|
+ }
|
|
|
+ const Ls = Lr()
|
|
|
+ let Bs = 0
|
|
|
+ let Us = null
|
|
|
+ const Ds = () => Us || Bn,
|
|
|
+ Hs = (e) => {
|
|
|
+ ;(Us = e), e.scope.on()
|
|
|
+ },
|
|
|
+ zs = () => {
|
|
|
+ Us && Us.scope.off(), (Us = null)
|
|
|
+ },
|
|
|
+ Ws = t('slot,component')
|
|
|
+ function Ks(e, t) {
|
|
|
+ const n = t.isNativeTag || x
|
|
|
+ ;(Ws(e) || n(e)) && Kt('Do not use built-in or reserved HTML elements as component id: ' + e)
|
|
|
+ }
|
|
|
+ function Gs(e) {
|
|
|
+ return 4 & e.vnode.shapeFlag
|
|
|
+ }
|
|
|
+ let Js,
|
|
|
+ qs,
|
|
|
+ Ys = !1
|
|
|
+ function Zs(e, t, n) {
|
|
|
+ M(t)
|
|
|
+ ? (e.render = t)
|
|
|
+ : j(t)
|
|
|
+ ? (Ss(t) &&
|
|
|
+ Kt('setup() should not return VNodes directly - return a render function instead.'),
|
|
|
+ (e.devtoolsRawSetupState = t),
|
|
|
+ (e.setupState = jt(t)),
|
|
|
+ (function (e) {
|
|
|
+ const { ctx: t, setupState: n } = e
|
|
|
+ Object.keys(kt(n)).forEach((e) => {
|
|
|
+ if (!n.__isScriptSetup) {
|
|
|
+ if (ir(e[0]))
|
|
|
+ return void Kt(
|
|
|
+ `setup() return property ${JSON.stringify(
|
|
|
+ e
|
|
|
+ )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
|
|
|
+ )
|
|
|
+ Object.defineProperty(t, e, {
|
|
|
+ enumerable: !0,
|
|
|
+ configurable: !0,
|
|
|
+ get: () => n[e],
|
|
|
+ set: w
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })(e))
|
|
|
+ : void 0 !== t &&
|
|
|
+ Kt('setup() should return an object. Received: ' + (null === t ? 'null' : typeof t)),
|
|
|
+ ei(e, n)
|
|
|
+ }
|
|
|
+ function Xs(e) {
|
|
|
+ ;(Js = e),
|
|
|
+ (qs = (e) => {
|
|
|
+ e.render._rc && (e.withProxy = new Proxy(e.ctx, ar))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ const Qs = () => !Js
|
|
|
+ function ei(e, t, n) {
|
|
|
+ const o = e.type
|
|
|
+ if (!e.render) {
|
|
|
+ if (!t && Js && !o.render) {
|
|
|
+ const t = o.template || hr(e).template
|
|
|
+ if (t) {
|
|
|
+ qr(e, 'compile')
|
|
|
+ const { isCustomElement: n, compilerOptions: r } = e.appContext.config,
|
|
|
+ { delimiters: s, compilerOptions: i } = o,
|
|
|
+ c = T(
|
|
|
+ T(
|
|
|
+ {
|
|
|
+ isCustomElement: n,
|
|
|
+ delimiters: s
|
|
|
+ },
|
|
|
+ r
|
|
|
+ ),
|
|
|
+ i
|
|
|
+ )
|
|
|
+ ;(o.render = Js(t, c)), Yr(e, 'compile')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ;(e.render = o.render || w), qs && qs(e)
|
|
|
+ }
|
|
|
+ Hs(e),
|
|
|
+ xe(),
|
|
|
+ pr(e),
|
|
|
+ Se(),
|
|
|
+ zs(),
|
|
|
+ o.render ||
|
|
|
+ e.render !== w ||
|
|
|
+ t ||
|
|
|
+ (!Js && o.template
|
|
|
+ ? Kt(
|
|
|
+ 'Component provided template option but runtime compilation is not supported in this build of Vue. Use "vue.global.js" instead.'
|
|
|
+ )
|
|
|
+ : Kt('Component is missing template or render function.'))
|
|
|
+ }
|
|
|
+ function ti(e) {
|
|
|
+ const t = (t) => {
|
|
|
+ e.exposed && Kt('expose() should be called only once per setup().'), (e.exposed = t || {})
|
|
|
+ }
|
|
|
+ let n
|
|
|
+ return Object.freeze({
|
|
|
+ get attrs() {
|
|
|
+ return (
|
|
|
+ n ||
|
|
|
+ (n = (function (e) {
|
|
|
+ return new Proxy(e.attrs, {
|
|
|
+ get: (t, n) => (Wn(), Ce(e, 'get', '$attrs'), t[n]),
|
|
|
+ set: () => (Kt('setupContext.attrs is readonly.'), !1),
|
|
|
+ deleteProperty: () => (Kt('setupContext.attrs is readonly.'), !1)
|
|
|
+ })
|
|
|
+ })(e))
|
|
|
+ )
|
|
|
+ },
|
|
|
+ get slots() {
|
|
|
+ return bt(e.slots)
|
|
|
+ },
|
|
|
+ get emit() {
|
|
|
+ return (t, ...n) => e.emit(t, ...n)
|
|
|
+ },
|
|
|
+ expose: t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function ni(e) {
|
|
|
+ if (e.exposed)
|
|
|
+ return (
|
|
|
+ e.exposeProxy ||
|
|
|
+ (e.exposeProxy = new Proxy(jt(Tt(e.exposed)), {
|
|
|
+ get: (t, n) => (n in t ? t[n] : n in sr ? sr[n](e) : void 0),
|
|
|
+ has: (e, t) => t in e || t in sr
|
|
|
+ }))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const oi = /(?:^|[-_])(\w)/g
|
|
|
+ function ri(e, t = !0) {
|
|
|
+ return M(e) ? e.displayName || e.name : e.name || (t && e.__name)
|
|
|
+ }
|
|
|
+ function si(e, t, n = !1) {
|
|
|
+ let o = ri(t)
|
|
|
+ if (!o && t.__file) {
|
|
|
+ const e = t.__file.match(/([^/\\]+)\.\w+$/)
|
|
|
+ e && (o = e[1])
|
|
|
+ }
|
|
|
+ if (!o && e && e.parent) {
|
|
|
+ const n = (e) => {
|
|
|
+ for (const n in e) if (e[n] === t) return n
|
|
|
+ }
|
|
|
+ o = n(e.components || e.parent.type.components) || n(e.appContext.components)
|
|
|
+ }
|
|
|
+ return o ? o.replace(oi, (e) => e.toUpperCase()).replace(/[-_]/g, '') : n ? 'App' : 'Anonymous'
|
|
|
+ }
|
|
|
+ function ii(e) {
|
|
|
+ return M(e) && '__vccOpts' in e
|
|
|
+ }
|
|
|
+ const ci = (e, t) =>
|
|
|
+ (function (e, t, n = !1) {
|
|
|
+ let o, r
|
|
|
+ const s = M(e)
|
|
|
+ s
|
|
|
+ ? ((o = e),
|
|
|
+ (r = () => {
|
|
|
+ console.warn('Write operation failed: computed value is readonly')
|
|
|
+ }))
|
|
|
+ : ((o = e.get), (r = e.set))
|
|
|
+ const i = new Dt(o, r, s || !r, n)
|
|
|
+ return t && !n && ((i.effect.onTrack = t.onTrack), (i.effect.onTrigger = t.onTrigger)), i
|
|
|
+ })(e, t, Ys),
|
|
|
+ li = (e) =>
|
|
|
+ Kt(
|
|
|
+ `${e}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
|
|
|
+ )
|
|
|
+ function ai() {
|
|
|
+ const e = Ds()
|
|
|
+ return (
|
|
|
+ e || Kt('useContext() called without active instance.'),
|
|
|
+ e.setupContext || (e.setupContext = ti(e))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ui(e, t, n) {
|
|
|
+ const o = arguments.length
|
|
|
+ return 2 === o
|
|
|
+ ? j(t) && !O(t)
|
|
|
+ ? Ss(t)
|
|
|
+ ? Ns(e, null, [t])
|
|
|
+ : Ns(e, t)
|
|
|
+ : Ns(e, null, t)
|
|
|
+ : (o > 3 ? (n = Array.prototype.slice.call(arguments, 2)) : 3 === o && Ss(n) && (n = [n]),
|
|
|
+ Ns(e, t, n))
|
|
|
+ }
|
|
|
+ const pi = Symbol('ssrContext')
|
|
|
+ function di() {
|
|
|
+ if ('undefined' == typeof window) return
|
|
|
+ const e = {
|
|
|
+ style: 'color:#3ba776'
|
|
|
+ },
|
|
|
+ t = {
|
|
|
+ style: 'color:#0b1bc9'
|
|
|
+ },
|
|
|
+ n = {
|
|
|
+ style: 'color:#b62e24'
|
|
|
+ },
|
|
|
+ o = {
|
|
|
+ style: 'color:#9d288c'
|
|
|
+ },
|
|
|
+ r = {
|
|
|
+ header: (t) =>
|
|
|
+ j(t)
|
|
|
+ ? t.__isVue
|
|
|
+ ? ['div', e, 'VueInstance']
|
|
|
+ : At(t)
|
|
|
+ ? ['div', {}, ['span', e, u(t)], '<', c(t.value), '>']
|
|
|
+ : wt(t)
|
|
|
+ ? [
|
|
|
+ 'div',
|
|
|
+ {},
|
|
|
+ ['span', e, St(t) ? 'ShallowReactive' : 'Reactive'],
|
|
|
+ '<',
|
|
|
+ c(t),
|
|
|
+ '>' + (xt(t) ? ' (readonly)' : '')
|
|
|
+ ]
|
|
|
+ : xt(t)
|
|
|
+ ? ['div', {}, ['span', e, St(t) ? 'ShallowReadonly' : 'Readonly'], '<', c(t), '>']
|
|
|
+ : null
|
|
|
+ : null,
|
|
|
+ hasBody: (e) => e && e.__isVue,
|
|
|
+ body(e) {
|
|
|
+ if (e && e.__isVue) return ['div', {}, ...s(e.$)]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function s(e) {
|
|
|
+ const t = []
|
|
|
+ e.type.props && e.props && t.push(i('props', kt(e.props))),
|
|
|
+ e.setupState !== b && t.push(i('setup', e.setupState)),
|
|
|
+ e.data !== b && t.push(i('data', kt(e.data)))
|
|
|
+ const n = l(e, 'computed')
|
|
|
+ n && t.push(i('computed', n))
|
|
|
+ const r = l(e, 'inject')
|
|
|
+ return (
|
|
|
+ r && t.push(i('injected', r)),
|
|
|
+ t.push([
|
|
|
+ 'div',
|
|
|
+ {},
|
|
|
+ [
|
|
|
+ 'span',
|
|
|
+ {
|
|
|
+ style: o.style + ';opacity:0.66'
|
|
|
+ },
|
|
|
+ '$ (internal): '
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ 'object',
|
|
|
+ {
|
|
|
+ object: e
|
|
|
+ }
|
|
|
+ ]
|
|
|
+ ]),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function i(e, t) {
|
|
|
+ return (
|
|
|
+ (t = T({}, t)),
|
|
|
+ Object.keys(t).length
|
|
|
+ ? [
|
|
|
+ 'div',
|
|
|
+ {
|
|
|
+ style: 'line-height:1.25em;margin-bottom:0.6em'
|
|
|
+ },
|
|
|
+ [
|
|
|
+ 'div',
|
|
|
+ {
|
|
|
+ style: 'color:#476582'
|
|
|
+ },
|
|
|
+ e
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ 'div',
|
|
|
+ {
|
|
|
+ style: 'padding-left:1.25em'
|
|
|
+ },
|
|
|
+ ...Object.keys(t).map((e) => ['div', {}, ['span', o, e + ': '], c(t[e], !1)])
|
|
|
+ ]
|
|
|
+ ]
|
|
|
+ : ['span', {}]
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function c(e, r = !0) {
|
|
|
+ return 'number' == typeof e
|
|
|
+ ? ['span', t, e]
|
|
|
+ : 'string' == typeof e
|
|
|
+ ? ['span', n, JSON.stringify(e)]
|
|
|
+ : 'boolean' == typeof e
|
|
|
+ ? ['span', o, e]
|
|
|
+ : j(e)
|
|
|
+ ? [
|
|
|
+ 'object',
|
|
|
+ {
|
|
|
+ object: r ? kt(e) : e
|
|
|
+ }
|
|
|
+ ]
|
|
|
+ : ['span', n, String(e)]
|
|
|
+ }
|
|
|
+ function l(e, t) {
|
|
|
+ const n = e.type
|
|
|
+ if (M(n)) return
|
|
|
+ const o = {}
|
|
|
+ for (const r in e.ctx) a(n, r, t) && (o[r] = e.ctx[r])
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function a(e, t, n) {
|
|
|
+ const o = e[n]
|
|
|
+ return (
|
|
|
+ !!((O(o) && o.includes(t)) || (j(o) && t in o)) ||
|
|
|
+ !(!e.extends || !a(e.extends, t, n)) ||
|
|
|
+ !(!e.mixins || !e.mixins.some((e) => a(e, t, n))) ||
|
|
|
+ void 0
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function u(e) {
|
|
|
+ return St(e) ? 'ShallowRef' : e.effect ? 'ComputedRef' : 'Ref'
|
|
|
+ }
|
|
|
+ window.devtoolsFormatters
|
|
|
+ ? window.devtoolsFormatters.push(r)
|
|
|
+ : (window.devtoolsFormatters = [r])
|
|
|
+ }
|
|
|
+ function fi(e, t) {
|
|
|
+ const n = e.memo
|
|
|
+ if (n.length != t.length) return !1
|
|
|
+ for (let e = 0; e < n.length; e++) if (Q(n[e], t[e])) return !1
|
|
|
+ return bs > 0 && ms && ms.push(e), !0
|
|
|
+ }
|
|
|
+ const hi = '3.2.45',
|
|
|
+ mi = 'undefined' != typeof document ? document : null,
|
|
|
+ gi = mi && mi.createElement('template'),
|
|
|
+ yi = {
|
|
|
+ insert: (e, t, n) => {
|
|
|
+ t.insertBefore(e, n || null)
|
|
|
+ },
|
|
|
+ remove: (e) => {
|
|
|
+ const t = e.parentNode
|
|
|
+ t && t.removeChild(e)
|
|
|
+ },
|
|
|
+ createElement: (e, t, n, o) => {
|
|
|
+ const r = t
|
|
|
+ ? mi.createElementNS('http://www.w3.org/2000/svg', e)
|
|
|
+ : mi.createElement(
|
|
|
+ e,
|
|
|
+ n
|
|
|
+ ? {
|
|
|
+ is: n
|
|
|
+ }
|
|
|
+ : void 0
|
|
|
+ )
|
|
|
+ return (
|
|
|
+ 'select' === e && o && null != o.multiple && r.setAttribute('multiple', o.multiple), r
|
|
|
+ )
|
|
|
+ },
|
|
|
+ createText: (e) => mi.createTextNode(e),
|
|
|
+ createComment: (e) => mi.createComment(e),
|
|
|
+ setText: (e, t) => {
|
|
|
+ e.nodeValue = t
|
|
|
+ },
|
|
|
+ setElementText: (e, t) => {
|
|
|
+ e.textContent = t
|
|
|
+ },
|
|
|
+ parentNode: (e) => e.parentNode,
|
|
|
+ nextSibling: (e) => e.nextSibling,
|
|
|
+ querySelector: (e) => mi.querySelector(e),
|
|
|
+ setScopeId(e, t) {
|
|
|
+ e.setAttribute(t, '')
|
|
|
+ },
|
|
|
+ insertStaticContent(e, t, n, o, r, s) {
|
|
|
+ const i = n ? n.previousSibling : t.lastChild
|
|
|
+ if (r && (r === s || r.nextSibling))
|
|
|
+ for (; t.insertBefore(r.cloneNode(!0), n), r !== s && (r = r.nextSibling); );
|
|
|
+ else {
|
|
|
+ gi.innerHTML = o ? `<svg>${e}</svg>` : e
|
|
|
+ const r = gi.content
|
|
|
+ if (o) {
|
|
|
+ const e = r.firstChild
|
|
|
+ for (; e.firstChild; ) r.appendChild(e.firstChild)
|
|
|
+ r.removeChild(e)
|
|
|
+ }
|
|
|
+ t.insertBefore(r, n)
|
|
|
+ }
|
|
|
+ return [i ? i.nextSibling : t.firstChild, n ? n.previousSibling : t.lastChild]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const vi = /[^\\];\s*$/,
|
|
|
+ bi = /\s*!important$/
|
|
|
+ function _i(e, t, n) {
|
|
|
+ if (O(n)) n.forEach((n) => _i(e, t, n))
|
|
|
+ else if (
|
|
|
+ (null == n && (n = ''),
|
|
|
+ vi.test(n) && Kt(`Unexpected semicolon at the end of '${t}' style value: '${n}'`),
|
|
|
+ t.startsWith('--'))
|
|
|
+ )
|
|
|
+ e.setProperty(t, n)
|
|
|
+ else {
|
|
|
+ const o = (function (e, t) {
|
|
|
+ const n = xi[t]
|
|
|
+ if (n) return n
|
|
|
+ let o = J(t)
|
|
|
+ if ('filter' !== o && o in e) return (xi[t] = o)
|
|
|
+ o = Z(o)
|
|
|
+ for (let n = 0; n < wi.length; n++) {
|
|
|
+ const r = wi[n] + o
|
|
|
+ if (r in e) return (xi[t] = r)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ })(e, t)
|
|
|
+ bi.test(n) ? e.setProperty(Y(o), n.replace(bi, ''), 'important') : (e[o] = n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const wi = ['Webkit', 'Moz', 'ms'],
|
|
|
+ xi = {}
|
|
|
+ const Si = 'http://www.w3.org/1999/xlink'
|
|
|
+ function Ci(e, t, n, o) {
|
|
|
+ e.addEventListener(t, n, o)
|
|
|
+ }
|
|
|
+ function ki(e, t, n, o, r = null) {
|
|
|
+ const s = e._vei || (e._vei = {}),
|
|
|
+ i = s[t]
|
|
|
+ if (o && i) i.value = o
|
|
|
+ else {
|
|
|
+ const [n, c] = (function (e) {
|
|
|
+ let t
|
|
|
+ if (Ti.test(e)) {
|
|
|
+ let n
|
|
|
+ for (t = {}; (n = e.match(Ti)); )
|
|
|
+ (e = e.slice(0, e.length - n[0].length)), (t[n[0].toLowerCase()] = !0)
|
|
|
+ }
|
|
|
+ return [':' === e[2] ? e.slice(3) : Y(e.slice(2)), t]
|
|
|
+ })(t)
|
|
|
+ if (o) {
|
|
|
+ const i = (s[t] = (function (e, t) {
|
|
|
+ const n = (e) => {
|
|
|
+ if (e._vts) {
|
|
|
+ if (e._vts <= n.attached) return
|
|
|
+ } else e._vts = Date.now()
|
|
|
+ Zt(
|
|
|
+ (function (e, t) {
|
|
|
+ if (O(t)) {
|
|
|
+ const n = e.stopImmediatePropagation
|
|
|
+ return (
|
|
|
+ (e.stopImmediatePropagation = () => {
|
|
|
+ n.call(e), (e._stopped = !0)
|
|
|
+ }),
|
|
|
+ t.map((e) => (t) => !t._stopped && e && e(t))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ })(e, n.value),
|
|
|
+ t,
|
|
|
+ 5,
|
|
|
+ [e]
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ (n.value = e),
|
|
|
+ (n.attached = (() => $i || (Ei.then(() => ($i = 0)), ($i = Date.now())))()),
|
|
|
+ n
|
|
|
+ )
|
|
|
+ })(o, r))
|
|
|
+ Ci(e, n, i, c)
|
|
|
+ } else
|
|
|
+ i &&
|
|
|
+ (!(function (e, t, n, o) {
|
|
|
+ e.removeEventListener(t, n, o)
|
|
|
+ })(e, n, i, c),
|
|
|
+ (s[t] = void 0))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Ti = /(?:Once|Passive|Capture)$/
|
|
|
+ let $i = 0
|
|
|
+ const Ei = Promise.resolve()
|
|
|
+ const Ni = /^on[a-z]/
|
|
|
+ function Oi(e, t) {
|
|
|
+ const n = $o(e)
|
|
|
+ class o extends Ii {
|
|
|
+ constructor(e) {
|
|
|
+ super(n, e, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return (o.def = n), o
|
|
|
+ }
|
|
|
+ const Ai = 'undefined' != typeof HTMLElement ? HTMLElement : class {}
|
|
|
+ class Ii extends Ai {
|
|
|
+ constructor(e, t = {}, n) {
|
|
|
+ super(),
|
|
|
+ (this._def = e),
|
|
|
+ (this._props = t),
|
|
|
+ (this._instance = null),
|
|
|
+ (this._connected = !1),
|
|
|
+ (this._resolved = !1),
|
|
|
+ (this._numberProps = null),
|
|
|
+ this.shadowRoot && n
|
|
|
+ ? n(this._createVNode(), this.shadowRoot)
|
|
|
+ : (this.shadowRoot &&
|
|
|
+ Kt(
|
|
|
+ 'Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use `defineSSRCustomElement`.'
|
|
|
+ ),
|
|
|
+ this.attachShadow({
|
|
|
+ mode: 'open'
|
|
|
+ }),
|
|
|
+ this._def.__asyncLoader || this._resolveProps(this._def))
|
|
|
+ }
|
|
|
+ connectedCallback() {
|
|
|
+ ;(this._connected = !0),
|
|
|
+ this._instance || (this._resolved ? this._update() : this._resolveDef())
|
|
|
+ }
|
|
|
+ disconnectedCallback() {
|
|
|
+ ;(this._connected = !1),
|
|
|
+ an(() => {
|
|
|
+ this._connected || (Ec(null, this.shadowRoot), (this._instance = null))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ _resolveDef() {
|
|
|
+ this._resolved = !0
|
|
|
+ for (let e = 0; e < this.attributes.length; e++) this._setAttr(this.attributes[e].name)
|
|
|
+ new MutationObserver((e) => {
|
|
|
+ for (const t of e) this._setAttr(t.attributeName)
|
|
|
+ }).observe(this, {
|
|
|
+ attributes: !0
|
|
|
+ })
|
|
|
+ const e = (e, t = !1) => {
|
|
|
+ const { props: n, styles: o } = e
|
|
|
+ let r
|
|
|
+ if (n && !O(n))
|
|
|
+ for (const e in n) {
|
|
|
+ const t = n[e]
|
|
|
+ ;(t === Number || (t && t.type === Number)) &&
|
|
|
+ (e in this._props && (this._props[e] = ne(this._props[e])),
|
|
|
+ ((r || (r = Object.create(null)))[J(e)] = !0))
|
|
|
+ }
|
|
|
+ ;(this._numberProps = r), t && this._resolveProps(e), this._applyStyles(o), this._update()
|
|
|
+ },
|
|
|
+ t = this._def.__asyncLoader
|
|
|
+ t ? t().then((t) => e(t, !0)) : e(this._def)
|
|
|
+ }
|
|
|
+ _resolveProps(e) {
|
|
|
+ const { props: t } = e,
|
|
|
+ n = O(t) ? t : Object.keys(t || {})
|
|
|
+ for (const e of Object.keys(this))
|
|
|
+ '_' !== e[0] && n.includes(e) && this._setProp(e, this[e], !0, !1)
|
|
|
+ for (const e of n.map(J))
|
|
|
+ Object.defineProperty(this, e, {
|
|
|
+ get() {
|
|
|
+ return this._getProp(e)
|
|
|
+ },
|
|
|
+ set(t) {
|
|
|
+ this._setProp(e, t)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ _setAttr(e) {
|
|
|
+ let t = this.getAttribute(e)
|
|
|
+ const n = J(e)
|
|
|
+ this._numberProps && this._numberProps[n] && (t = ne(t)), this._setProp(n, t, !1)
|
|
|
+ }
|
|
|
+ _getProp(e) {
|
|
|
+ return this._props[e]
|
|
|
+ }
|
|
|
+ _setProp(e, t, n = !0, o = !0) {
|
|
|
+ t !== this._props[e] &&
|
|
|
+ ((this._props[e] = t),
|
|
|
+ o && this._instance && this._update(),
|
|
|
+ n &&
|
|
|
+ (!0 === t
|
|
|
+ ? this.setAttribute(Y(e), '')
|
|
|
+ : 'string' == typeof t || 'number' == typeof t
|
|
|
+ ? this.setAttribute(Y(e), t + '')
|
|
|
+ : t || this.removeAttribute(Y(e))))
|
|
|
+ }
|
|
|
+ _update() {
|
|
|
+ Ec(this._createVNode(), this.shadowRoot)
|
|
|
+ }
|
|
|
+ _createVNode() {
|
|
|
+ const e = Ns(this._def, T({}, this._props))
|
|
|
+ return (
|
|
|
+ this._instance ||
|
|
|
+ (e.ce = (e) => {
|
|
|
+ ;(this._instance = e),
|
|
|
+ (e.isCE = !0),
|
|
|
+ (e.ceReload = (e) => {
|
|
|
+ this._styles &&
|
|
|
+ (this._styles.forEach((e) => this.shadowRoot.removeChild(e)),
|
|
|
+ (this._styles.length = 0)),
|
|
|
+ this._applyStyles(e),
|
|
|
+ (this._instance = null),
|
|
|
+ this._update()
|
|
|
+ })
|
|
|
+ const t = (e, t) => {
|
|
|
+ this.dispatchEvent(
|
|
|
+ new CustomEvent(e, {
|
|
|
+ detail: t
|
|
|
+ })
|
|
|
+ )
|
|
|
+ }
|
|
|
+ e.emit = (e, ...n) => {
|
|
|
+ t(e, n), Y(e) !== e && t(Y(e), n)
|
|
|
+ }
|
|
|
+ let n = this
|
|
|
+ for (; (n = n && (n.parentNode || n.host)); )
|
|
|
+ if (n instanceof Ii) {
|
|
|
+ ;(e.parent = n._instance), (e.provides = n._instance.provides)
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ _applyStyles(e) {
|
|
|
+ e &&
|
|
|
+ e.forEach((e) => {
|
|
|
+ const t = document.createElement('style')
|
|
|
+ ;(t.textContent = e),
|
|
|
+ this.shadowRoot.appendChild(t),
|
|
|
+ (this._styles || (this._styles = [])).push(t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ri(e, t) {
|
|
|
+ if (128 & e.shapeFlag) {
|
|
|
+ const n = e.suspense
|
|
|
+ ;(e = n.activeBranch),
|
|
|
+ n.pendingBranch &&
|
|
|
+ !n.isHydrating &&
|
|
|
+ n.effects.push(() => {
|
|
|
+ Ri(n.activeBranch, t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ for (; e.component; ) e = e.component.subTree
|
|
|
+ if (1 & e.shapeFlag && e.el) Mi(e.el, t)
|
|
|
+ else if (e.type === us) e.children.forEach((e) => Ri(e, t))
|
|
|
+ else if (e.type === fs) {
|
|
|
+ let { el: n, anchor: o } = e
|
|
|
+ for (; n && (Mi(n, t), n !== o); ) n = n.nextSibling
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Mi(e, t) {
|
|
|
+ if (1 === e.nodeType) {
|
|
|
+ const n = e.style
|
|
|
+ for (const e in t) n.setProperty(`--${e}`, t[e])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Pi = 'transition',
|
|
|
+ Fi = 'animation',
|
|
|
+ ji = (e, { slots: t }) => ui(_o, Di(e), t)
|
|
|
+ ji.displayName = 'Transition'
|
|
|
+ const Vi = {
|
|
|
+ name: String,
|
|
|
+ type: String,
|
|
|
+ css: {
|
|
|
+ type: Boolean,
|
|
|
+ default: !0
|
|
|
+ },
|
|
|
+ duration: [String, Number, Object],
|
|
|
+ enterFromClass: String,
|
|
|
+ enterActiveClass: String,
|
|
|
+ enterToClass: String,
|
|
|
+ appearFromClass: String,
|
|
|
+ appearActiveClass: String,
|
|
|
+ appearToClass: String,
|
|
|
+ leaveFromClass: String,
|
|
|
+ leaveActiveClass: String,
|
|
|
+ leaveToClass: String
|
|
|
+ },
|
|
|
+ Li = (ji.props = T({}, _o.props, Vi)),
|
|
|
+ Bi = (e, t = []) => {
|
|
|
+ O(e) ? e.forEach((e) => e(...t)) : e && e(...t)
|
|
|
+ },
|
|
|
+ Ui = (e) => !!e && (O(e) ? e.some((e) => e.length > 1) : e.length > 1)
|
|
|
+ function Di(e) {
|
|
|
+ const t = {}
|
|
|
+ for (const n in e) n in Vi || (t[n] = e[n])
|
|
|
+ if (!1 === e.css) return t
|
|
|
+ const {
|
|
|
+ name: n = 'v',
|
|
|
+ type: o,
|
|
|
+ duration: r,
|
|
|
+ enterFromClass: s = `${n}-enter-from`,
|
|
|
+ enterActiveClass: i = `${n}-enter-active`,
|
|
|
+ enterToClass: c = `${n}-enter-to`,
|
|
|
+ appearFromClass: l = s,
|
|
|
+ appearActiveClass: a = i,
|
|
|
+ appearToClass: u = c,
|
|
|
+ leaveFromClass: p = `${n}-leave-from`,
|
|
|
+ leaveActiveClass: d = `${n}-leave-active`,
|
|
|
+ leaveToClass: f = `${n}-leave-to`
|
|
|
+ } = e,
|
|
|
+ h = (function (e) {
|
|
|
+ if (null == e) return null
|
|
|
+ if (j(e)) return [Hi(e.enter), Hi(e.leave)]
|
|
|
+ {
|
|
|
+ const t = Hi(e)
|
|
|
+ return [t, t]
|
|
|
+ }
|
|
|
+ })(r),
|
|
|
+ m = h && h[0],
|
|
|
+ g = h && h[1],
|
|
|
+ {
|
|
|
+ onBeforeEnter: y,
|
|
|
+ onEnter: v,
|
|
|
+ onEnterCancelled: b,
|
|
|
+ onLeave: _,
|
|
|
+ onLeaveCancelled: w,
|
|
|
+ onBeforeAppear: x = y,
|
|
|
+ onAppear: S = v,
|
|
|
+ onAppearCancelled: C = b
|
|
|
+ } = t,
|
|
|
+ k = (e, t, n) => {
|
|
|
+ Wi(e, t ? u : c), Wi(e, t ? a : i), n && n()
|
|
|
+ },
|
|
|
+ $ = (e, t) => {
|
|
|
+ ;(e._isLeaving = !1), Wi(e, p), Wi(e, f), Wi(e, d), t && t()
|
|
|
+ },
|
|
|
+ E = (e) => (t, n) => {
|
|
|
+ const r = e ? S : v,
|
|
|
+ i = () => k(t, e, n)
|
|
|
+ Bi(r, [t, i]),
|
|
|
+ Ki(() => {
|
|
|
+ Wi(t, e ? l : s), zi(t, e ? u : c), Ui(r) || Ji(t, o, m, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return T(t, {
|
|
|
+ onBeforeEnter(e) {
|
|
|
+ Bi(y, [e]), zi(e, s), zi(e, i)
|
|
|
+ },
|
|
|
+ onBeforeAppear(e) {
|
|
|
+ Bi(x, [e]), zi(e, l), zi(e, a)
|
|
|
+ },
|
|
|
+ onEnter: E(!1),
|
|
|
+ onAppear: E(!0),
|
|
|
+ onLeave(e, t) {
|
|
|
+ e._isLeaving = !0
|
|
|
+ const n = () => $(e, t)
|
|
|
+ zi(e, p),
|
|
|
+ Xi(),
|
|
|
+ zi(e, d),
|
|
|
+ Ki(() => {
|
|
|
+ e._isLeaving && (Wi(e, p), zi(e, f), Ui(_) || Ji(e, o, g, n))
|
|
|
+ }),
|
|
|
+ Bi(_, [e, n])
|
|
|
+ },
|
|
|
+ onEnterCancelled(e) {
|
|
|
+ k(e, !1), Bi(b, [e])
|
|
|
+ },
|
|
|
+ onAppearCancelled(e) {
|
|
|
+ k(e, !0), Bi(C, [e])
|
|
|
+ },
|
|
|
+ onLeaveCancelled(e) {
|
|
|
+ $(e), Bi(w, [e])
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Hi(e) {
|
|
|
+ const t = ne(e)
|
|
|
+ return (
|
|
|
+ (function (e) {
|
|
|
+ 'number' != typeof e
|
|
|
+ ? Kt(`<transition> explicit duration is not a valid number - got ${JSON.stringify(e)}.`)
|
|
|
+ : isNaN(e) &&
|
|
|
+ Kt(
|
|
|
+ '<transition> explicit duration is NaN - the duration expression might be incorrect.'
|
|
|
+ )
|
|
|
+ })(t),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function zi(e, t) {
|
|
|
+ t.split(/\s+/).forEach((t) => t && e.classList.add(t)), (e._vtc || (e._vtc = new Set())).add(t)
|
|
|
+ }
|
|
|
+ function Wi(e, t) {
|
|
|
+ t.split(/\s+/).forEach((t) => t && e.classList.remove(t))
|
|
|
+ const { _vtc: n } = e
|
|
|
+ n && (n.delete(t), n.size || (e._vtc = void 0))
|
|
|
+ }
|
|
|
+ function Ki(e) {
|
|
|
+ requestAnimationFrame(() => {
|
|
|
+ requestAnimationFrame(e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ let Gi = 0
|
|
|
+ function Ji(e, t, n, o) {
|
|
|
+ const r = (e._endId = ++Gi),
|
|
|
+ s = () => {
|
|
|
+ r === e._endId && o()
|
|
|
+ }
|
|
|
+ if (n) return setTimeout(s, n)
|
|
|
+ const { type: i, timeout: c, propCount: l } = qi(e, t)
|
|
|
+ if (!i) return o()
|
|
|
+ const a = i + 'end'
|
|
|
+ let u = 0
|
|
|
+ const p = () => {
|
|
|
+ e.removeEventListener(a, d), s()
|
|
|
+ },
|
|
|
+ d = (t) => {
|
|
|
+ t.target === e && ++u >= l && p()
|
|
|
+ }
|
|
|
+ setTimeout(() => {
|
|
|
+ u < l && p()
|
|
|
+ }, c + 1),
|
|
|
+ e.addEventListener(a, d)
|
|
|
+ }
|
|
|
+ function qi(e, t) {
|
|
|
+ const n = window.getComputedStyle(e),
|
|
|
+ o = (e) => (n[e] || '').split(', '),
|
|
|
+ r = o('transitionDelay'),
|
|
|
+ s = o('transitionDuration'),
|
|
|
+ i = Yi(r, s),
|
|
|
+ c = o('animationDelay'),
|
|
|
+ l = o('animationDuration'),
|
|
|
+ a = Yi(c, l)
|
|
|
+ let u = null,
|
|
|
+ p = 0,
|
|
|
+ d = 0
|
|
|
+ t === Pi
|
|
|
+ ? i > 0 && ((u = Pi), (p = i), (d = s.length))
|
|
|
+ : t === Fi
|
|
|
+ ? a > 0 && ((u = Fi), (p = a), (d = l.length))
|
|
|
+ : ((p = Math.max(i, a)),
|
|
|
+ (u = p > 0 ? (i > a ? Pi : Fi) : null),
|
|
|
+ (d = u ? (u === Pi ? s.length : l.length) : 0))
|
|
|
+ return {
|
|
|
+ type: u,
|
|
|
+ timeout: p,
|
|
|
+ propCount: d,
|
|
|
+ hasTransform: u === Pi && /\b(transform|all)(,|$)/.test(o('transitionProperty').toString())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Yi(e, t) {
|
|
|
+ for (; e.length < t.length; ) e = e.concat(e)
|
|
|
+ return Math.max(...t.map((t, n) => Zi(t) + Zi(e[n])))
|
|
|
+ }
|
|
|
+ function Zi(e) {
|
|
|
+ return 1e3 * Number(e.slice(0, -1).replace(',', '.'))
|
|
|
+ }
|
|
|
+ function Xi() {
|
|
|
+ return document.body.offsetHeight
|
|
|
+ }
|
|
|
+ const Qi = new WeakMap(),
|
|
|
+ ec = new WeakMap(),
|
|
|
+ tc = {
|
|
|
+ name: 'TransitionGroup',
|
|
|
+ props: T({}, Li, {
|
|
|
+ tag: String,
|
|
|
+ moveClass: String
|
|
|
+ }),
|
|
|
+ setup(e, { slots: t }) {
|
|
|
+ const n = Ds(),
|
|
|
+ o = vo()
|
|
|
+ let r, s
|
|
|
+ return (
|
|
|
+ zo(() => {
|
|
|
+ if (!r.length) return
|
|
|
+ const t = e.moveClass || `${e.name || 'v'}-move`
|
|
|
+ if (
|
|
|
+ !(function (e, t, n) {
|
|
|
+ const o = e.cloneNode()
|
|
|
+ e._vtc &&
|
|
|
+ e._vtc.forEach((e) => {
|
|
|
+ e.split(/\s+/).forEach((e) => e && o.classList.remove(e))
|
|
|
+ })
|
|
|
+ n.split(/\s+/).forEach((e) => e && o.classList.add(e)), (o.style.display = 'none')
|
|
|
+ const r = 1 === t.nodeType ? t : t.parentNode
|
|
|
+ r.appendChild(o)
|
|
|
+ const { hasTransform: s } = qi(o)
|
|
|
+ return r.removeChild(o), s
|
|
|
+ })(r[0].el, n.vnode.el, t)
|
|
|
+ )
|
|
|
+ return
|
|
|
+ r.forEach(nc), r.forEach(oc)
|
|
|
+ const o = r.filter(rc)
|
|
|
+ Xi(),
|
|
|
+ o.forEach((e) => {
|
|
|
+ const n = e.el,
|
|
|
+ o = n.style
|
|
|
+ zi(n, t), (o.transform = o.webkitTransform = o.transitionDuration = '')
|
|
|
+ const r = (n._moveCb = (e) => {
|
|
|
+ ;(e && e.target !== n) ||
|
|
|
+ (e && !/transform$/.test(e.propertyName)) ||
|
|
|
+ (n.removeEventListener('transitionend', r), (n._moveCb = null), Wi(n, t))
|
|
|
+ })
|
|
|
+ n.addEventListener('transitionend', r)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ () => {
|
|
|
+ const i = kt(e),
|
|
|
+ c = Di(i)
|
|
|
+ let l = i.tag || us
|
|
|
+ ;(r = s), (s = t.default ? To(t.default()) : [])
|
|
|
+ for (let e = 0; e < s.length; e++) {
|
|
|
+ const t = s[e]
|
|
|
+ null != t.key
|
|
|
+ ? ko(t, xo(t, c, o, n))
|
|
|
+ : Kt('<TransitionGroup> children must be keyed.')
|
|
|
+ }
|
|
|
+ if (r)
|
|
|
+ for (let e = 0; e < r.length; e++) {
|
|
|
+ const t = r[e]
|
|
|
+ ko(t, xo(t, c, o, n)), Qi.set(t, t.el.getBoundingClientRect())
|
|
|
+ }
|
|
|
+ return Ns(l, null, s)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function nc(e) {
|
|
|
+ const t = e.el
|
|
|
+ t._moveCb && t._moveCb(), t._enterCb && t._enterCb()
|
|
|
+ }
|
|
|
+ function oc(e) {
|
|
|
+ ec.set(e, e.el.getBoundingClientRect())
|
|
|
+ }
|
|
|
+ function rc(e) {
|
|
|
+ const t = Qi.get(e),
|
|
|
+ n = ec.get(e),
|
|
|
+ o = t.left - n.left,
|
|
|
+ r = t.top - n.top
|
|
|
+ if (o || r) {
|
|
|
+ const t = e.el.style
|
|
|
+ return (
|
|
|
+ (t.transform = t.webkitTransform = `translate(${o}px,${r}px)`),
|
|
|
+ (t.transitionDuration = '0s'),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const sc = (e) => {
|
|
|
+ const t = e.props['onUpdate:modelValue'] || !1
|
|
|
+ return O(t) ? (e) => ee(t, e) : t
|
|
|
+ }
|
|
|
+ function ic(e) {
|
|
|
+ e.target.composing = !0
|
|
|
+ }
|
|
|
+ function cc(e) {
|
|
|
+ const t = e.target
|
|
|
+ t.composing && ((t.composing = !1), t.dispatchEvent(new Event('input')))
|
|
|
+ }
|
|
|
+ const lc = {
|
|
|
+ created(e, { modifiers: { lazy: t, trim: n, number: o } }, r) {
|
|
|
+ e._assign = sc(r)
|
|
|
+ const s = o || (r.props && 'number' === r.props.type)
|
|
|
+ Ci(e, t ? 'change' : 'input', (t) => {
|
|
|
+ if (t.target.composing) return
|
|
|
+ let o = e.value
|
|
|
+ n && (o = o.trim()), s && (o = ne(o)), e._assign(o)
|
|
|
+ }),
|
|
|
+ n &&
|
|
|
+ Ci(e, 'change', () => {
|
|
|
+ e.value = e.value.trim()
|
|
|
+ }),
|
|
|
+ t || (Ci(e, 'compositionstart', ic), Ci(e, 'compositionend', cc), Ci(e, 'change', cc))
|
|
|
+ },
|
|
|
+ mounted(e, { value: t }) {
|
|
|
+ e.value = null == t ? '' : t
|
|
|
+ },
|
|
|
+ beforeUpdate(e, { value: t, modifiers: { lazy: n, trim: o, number: r } }, s) {
|
|
|
+ if (((e._assign = sc(s)), e.composing)) return
|
|
|
+ if (document.activeElement === e && 'range' !== e.type) {
|
|
|
+ if (n) return
|
|
|
+ if (o && e.value.trim() === t) return
|
|
|
+ if ((r || 'number' === e.type) && ne(e.value) === t) return
|
|
|
+ }
|
|
|
+ const i = null == t ? '' : t
|
|
|
+ e.value !== i && (e.value = i)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ac = {
|
|
|
+ deep: !0,
|
|
|
+ created(e, t, n) {
|
|
|
+ ;(e._assign = sc(n)),
|
|
|
+ Ci(e, 'change', () => {
|
|
|
+ const t = e._modelValue,
|
|
|
+ n = hc(e),
|
|
|
+ o = e.checked,
|
|
|
+ r = e._assign
|
|
|
+ if (O(t)) {
|
|
|
+ const e = y(t, n),
|
|
|
+ s = -1 !== e
|
|
|
+ if (o && !s) r(t.concat(n))
|
|
|
+ else if (!o && s) {
|
|
|
+ const n = [...t]
|
|
|
+ n.splice(e, 1), r(n)
|
|
|
+ }
|
|
|
+ } else if (I(t)) {
|
|
|
+ const e = new Set(t)
|
|
|
+ o ? e.add(n) : e.delete(n), r(e)
|
|
|
+ } else r(mc(e, o))
|
|
|
+ })
|
|
|
+ },
|
|
|
+ mounted: uc,
|
|
|
+ beforeUpdate(e, t, n) {
|
|
|
+ ;(e._assign = sc(n)), uc(e, t, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function uc(e, { value: t, oldValue: n }, o) {
|
|
|
+ ;(e._modelValue = t),
|
|
|
+ O(t)
|
|
|
+ ? (e.checked = y(t, o.props.value) > -1)
|
|
|
+ : I(t)
|
|
|
+ ? (e.checked = t.has(o.props.value))
|
|
|
+ : t !== n && (e.checked = g(t, mc(e, !0)))
|
|
|
+ }
|
|
|
+ const pc = {
|
|
|
+ created(e, { value: t }, n) {
|
|
|
+ ;(e.checked = g(t, n.props.value)),
|
|
|
+ (e._assign = sc(n)),
|
|
|
+ Ci(e, 'change', () => {
|
|
|
+ e._assign(hc(e))
|
|
|
+ })
|
|
|
+ },
|
|
|
+ beforeUpdate(e, { value: t, oldValue: n }, o) {
|
|
|
+ ;(e._assign = sc(o)), t !== n && (e.checked = g(t, o.props.value))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dc = {
|
|
|
+ deep: !0,
|
|
|
+ created(e, { value: t, modifiers: { number: n } }, o) {
|
|
|
+ const r = I(t)
|
|
|
+ Ci(e, 'change', () => {
|
|
|
+ const t = Array.prototype.filter
|
|
|
+ .call(e.options, (e) => e.selected)
|
|
|
+ .map((e) => (n ? ne(hc(e)) : hc(e)))
|
|
|
+ e._assign(e.multiple ? (r ? new Set(t) : t) : t[0])
|
|
|
+ }),
|
|
|
+ (e._assign = sc(o))
|
|
|
+ },
|
|
|
+ mounted(e, { value: t }) {
|
|
|
+ fc(e, t)
|
|
|
+ },
|
|
|
+ beforeUpdate(e, t, n) {
|
|
|
+ e._assign = sc(n)
|
|
|
+ },
|
|
|
+ updated(e, { value: t }) {
|
|
|
+ fc(e, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function fc(e, t) {
|
|
|
+ const n = e.multiple
|
|
|
+ if (!n || O(t) || I(t)) {
|
|
|
+ for (let o = 0, r = e.options.length; o < r; o++) {
|
|
|
+ const r = e.options[o],
|
|
|
+ s = hc(r)
|
|
|
+ if (n) O(t) ? (r.selected = y(t, s) > -1) : (r.selected = t.has(s))
|
|
|
+ else if (g(hc(r), t)) return void (e.selectedIndex !== o && (e.selectedIndex = o))
|
|
|
+ }
|
|
|
+ n || -1 === e.selectedIndex || (e.selectedIndex = -1)
|
|
|
+ } else
|
|
|
+ Kt(
|
|
|
+ `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString
|
|
|
+ .call(t)
|
|
|
+ .slice(8, -1)}.`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function hc(e) {
|
|
|
+ return '_value' in e ? e._value : e.value
|
|
|
+ }
|
|
|
+ function mc(e, t) {
|
|
|
+ const n = t ? '_trueValue' : '_falseValue'
|
|
|
+ return n in e ? e[n] : t
|
|
|
+ }
|
|
|
+ const gc = {
|
|
|
+ created(e, t, n) {
|
|
|
+ yc(e, t, n, null, 'created')
|
|
|
+ },
|
|
|
+ mounted(e, t, n) {
|
|
|
+ yc(e, t, n, null, 'mounted')
|
|
|
+ },
|
|
|
+ beforeUpdate(e, t, n, o) {
|
|
|
+ yc(e, t, n, o, 'beforeUpdate')
|
|
|
+ },
|
|
|
+ updated(e, t, n, o) {
|
|
|
+ yc(e, t, n, o, 'updated')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yc(e, t, n, o, r) {
|
|
|
+ const s = (function (e, t) {
|
|
|
+ switch (e) {
|
|
|
+ case 'SELECT':
|
|
|
+ return dc
|
|
|
+ case 'TEXTAREA':
|
|
|
+ return lc
|
|
|
+ default:
|
|
|
+ switch (t) {
|
|
|
+ case 'checkbox':
|
|
|
+ return ac
|
|
|
+ case 'radio':
|
|
|
+ return pc
|
|
|
+ default:
|
|
|
+ return lc
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })(e.tagName, n.props && n.props.type)[r]
|
|
|
+ s && s(e, t, n, o)
|
|
|
+ }
|
|
|
+ const vc = ['ctrl', 'shift', 'alt', 'meta'],
|
|
|
+ bc = {
|
|
|
+ stop: (e) => e.stopPropagation(),
|
|
|
+ prevent: (e) => e.preventDefault(),
|
|
|
+ self: (e) => e.target !== e.currentTarget,
|
|
|
+ ctrl: (e) => !e.ctrlKey,
|
|
|
+ shift: (e) => !e.shiftKey,
|
|
|
+ alt: (e) => !e.altKey,
|
|
|
+ meta: (e) => !e.metaKey,
|
|
|
+ left: (e) => 'button' in e && 0 !== e.button,
|
|
|
+ middle: (e) => 'button' in e && 1 !== e.button,
|
|
|
+ right: (e) => 'button' in e && 2 !== e.button,
|
|
|
+ exact: (e, t) => vc.some((n) => e[`${n}Key`] && !t.includes(n))
|
|
|
+ },
|
|
|
+ _c = {
|
|
|
+ esc: 'escape',
|
|
|
+ space: ' ',
|
|
|
+ up: 'arrow-up',
|
|
|
+ left: 'arrow-left',
|
|
|
+ right: 'arrow-right',
|
|
|
+ down: 'arrow-down',
|
|
|
+ delete: 'backspace'
|
|
|
+ },
|
|
|
+ wc = {
|
|
|
+ beforeMount(e, { value: t }, { transition: n }) {
|
|
|
+ ;(e._vod = 'none' === e.style.display ? '' : e.style.display),
|
|
|
+ n && t ? n.beforeEnter(e) : xc(e, t)
|
|
|
+ },
|
|
|
+ mounted(e, { value: t }, { transition: n }) {
|
|
|
+ n && t && n.enter(e)
|
|
|
+ },
|
|
|
+ updated(e, { value: t, oldValue: n }, { transition: o }) {
|
|
|
+ !t != !n &&
|
|
|
+ (o
|
|
|
+ ? t
|
|
|
+ ? (o.beforeEnter(e), xc(e, !0), o.enter(e))
|
|
|
+ : o.leave(e, () => {
|
|
|
+ xc(e, !1)
|
|
|
+ })
|
|
|
+ : xc(e, t))
|
|
|
+ },
|
|
|
+ beforeUnmount(e, { value: t }) {
|
|
|
+ xc(e, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function xc(e, t) {
|
|
|
+ e.style.display = t ? e._vod : 'none'
|
|
|
+ }
|
|
|
+ const Sc = T(
|
|
|
+ {
|
|
|
+ patchProp: (e, t, n, o, r = !1, s, i, c, l) => {
|
|
|
+ 'class' === t
|
|
|
+ ? (function (e, t, n) {
|
|
|
+ const o = e._vtc
|
|
|
+ o && (t = (t ? [t, ...o] : [...o]).join(' ')),
|
|
|
+ null == t
|
|
|
+ ? e.removeAttribute('class')
|
|
|
+ : n
|
|
|
+ ? e.setAttribute('class', t)
|
|
|
+ : (e.className = t)
|
|
|
+ })(e, o, r)
|
|
|
+ : 'style' === t
|
|
|
+ ? (function (e, t, n) {
|
|
|
+ const o = e.style,
|
|
|
+ r = P(n)
|
|
|
+ if (n && !r) {
|
|
|
+ for (const e in n) _i(o, e, n[e])
|
|
|
+ if (t && !P(t)) for (const e in t) null == n[e] && _i(o, e, '')
|
|
|
+ } else {
|
|
|
+ const s = o.display
|
|
|
+ r ? t !== n && (o.cssText = n) : t && e.removeAttribute('style'),
|
|
|
+ '_vod' in e && (o.display = s)
|
|
|
+ }
|
|
|
+ })(e, n, o)
|
|
|
+ : C(t)
|
|
|
+ ? k(t) || ki(e, t, 0, o, i)
|
|
|
+ : (
|
|
|
+ '.' === t[0]
|
|
|
+ ? ((t = t.slice(1)), 1)
|
|
|
+ : '^' === t[0]
|
|
|
+ ? ((t = t.slice(1)), 0)
|
|
|
+ : (function (e, t, n, o) {
|
|
|
+ if (o)
|
|
|
+ return (
|
|
|
+ 'innerHTML' === t || 'textContent' === t || !!(t in e && Ni.test(t) && M(n))
|
|
|
+ )
|
|
|
+ if ('spellcheck' === t || 'draggable' === t || 'translate' === t) return !1
|
|
|
+ if ('form' === t) return !1
|
|
|
+ if ('list' === t && 'INPUT' === e.tagName) return !1
|
|
|
+ if ('type' === t && 'TEXTAREA' === e.tagName) return !1
|
|
|
+ if (Ni.test(t) && P(n)) return !1
|
|
|
+ return t in e
|
|
|
+ })(e, t, o, r)
|
|
|
+ )
|
|
|
+ ? (function (e, t, n, o, r, s, i) {
|
|
|
+ if ('innerHTML' === t || 'textContent' === t)
|
|
|
+ return o && i(o, r, s), void (e[t] = null == n ? '' : n)
|
|
|
+ if ('value' === t && 'PROGRESS' !== e.tagName && !e.tagName.includes('-')) {
|
|
|
+ e._value = n
|
|
|
+ const o = null == n ? '' : n
|
|
|
+ return (
|
|
|
+ (e.value === o && 'OPTION' !== e.tagName) || (e.value = o),
|
|
|
+ void (null == n && e.removeAttribute(t))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ let c = !1
|
|
|
+ if ('' === n || null == n) {
|
|
|
+ const o = typeof e[t]
|
|
|
+ 'boolean' === o
|
|
|
+ ? (n = m(n))
|
|
|
+ : null == n && 'string' === o
|
|
|
+ ? ((n = ''), (c = !0))
|
|
|
+ : 'number' === o && ((n = 0), (c = !0))
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ e[t] = n
|
|
|
+ } catch (o) {
|
|
|
+ c ||
|
|
|
+ Kt(
|
|
|
+ `Failed setting prop "${t}" on <${e.tagName.toLowerCase()}>: value ${n} is invalid.`,
|
|
|
+ o
|
|
|
+ )
|
|
|
+ }
|
|
|
+ c && e.removeAttribute(t)
|
|
|
+ })(e, t, o, s, i, c, l)
|
|
|
+ : ('true-value' === t ? (e._trueValue = o) : 'false-value' === t && (e._falseValue = o),
|
|
|
+ (function (e, t, n, o, r) {
|
|
|
+ if (o && t.startsWith('xlink:'))
|
|
|
+ null == n
|
|
|
+ ? e.removeAttributeNS(Si, t.slice(6, t.length))
|
|
|
+ : e.setAttributeNS(Si, t, n)
|
|
|
+ else {
|
|
|
+ const o = h(t)
|
|
|
+ null == n || (o && !m(n)) ? e.removeAttribute(t) : e.setAttribute(t, o ? '' : n)
|
|
|
+ }
|
|
|
+ })(e, t, o, r))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ yi
|
|
|
+ )
|
|
|
+ let Cc,
|
|
|
+ kc = !1
|
|
|
+ function Tc() {
|
|
|
+ return Cc || (Cc = Qr(Sc))
|
|
|
+ }
|
|
|
+ function $c() {
|
|
|
+ return (Cc = kc ? Cc : es(Sc)), (kc = !0), Cc
|
|
|
+ }
|
|
|
+ const Ec = (...e) => {
|
|
|
+ Tc().render(...e)
|
|
|
+ },
|
|
|
+ Nc = (...e) => {
|
|
|
+ $c().hydrate(...e)
|
|
|
+ }
|
|
|
+ function Oc(e) {
|
|
|
+ Object.defineProperty(e.config, 'isNativeTag', {
|
|
|
+ value: (e) => p(e) || d(e),
|
|
|
+ writable: !1
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ac(e) {
|
|
|
+ if (Qs()) {
|
|
|
+ const t = e.config.isCustomElement
|
|
|
+ Object.defineProperty(e.config, 'isCustomElement', {
|
|
|
+ get: () => t,
|
|
|
+ set() {
|
|
|
+ Kt(
|
|
|
+ 'The `isCustomElement` config option is deprecated. Use `compilerOptions.isCustomElement` instead.'
|
|
|
+ )
|
|
|
+ }
|
|
|
+ })
|
|
|
+ const n = e.config.compilerOptions,
|
|
|
+ o =
|
|
|
+ 'The `compilerOptions` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, `compilerOptions` must be passed to `@vue/compiler-dom` in the build setup instead.\n- For vue-loader: pass it via vue-loader\'s `compilerOptions` loader option.\n- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader\n- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-dom'
|
|
|
+ Object.defineProperty(e.config, 'compilerOptions', {
|
|
|
+ get: () => (Kt(o), n),
|
|
|
+ set() {
|
|
|
+ Kt(o)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ic(e) {
|
|
|
+ if (P(e)) {
|
|
|
+ const t = document.querySelector(e)
|
|
|
+ return t || Kt(`Failed to mount app: mount target selector "${e}" returned null.`), t
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ window.ShadowRoot &&
|
|
|
+ e instanceof window.ShadowRoot &&
|
|
|
+ 'closed' === e.mode &&
|
|
|
+ Kt('mounting on a ShadowRoot with `{mode: "closed"}` may lead to unpredictable bugs'),
|
|
|
+ e
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Rc = w
|
|
|
+ function Mc(e) {
|
|
|
+ throw e
|
|
|
+ }
|
|
|
+ function Pc(e) {
|
|
|
+ console.warn(`[Vue warn] ${e.message}`)
|
|
|
+ }
|
|
|
+ function Fc(e, t, n, o) {
|
|
|
+ const r = (n || jc)[e] + (o || ''),
|
|
|
+ s = new SyntaxError(String(r))
|
|
|
+ return (s.code = e), (s.loc = t), s
|
|
|
+ }
|
|
|
+ const jc = {
|
|
|
+ 0: 'Illegal comment.',
|
|
|
+ 1: 'CDATA section is allowed only in XML context.',
|
|
|
+ 2: 'Duplicate attribute.',
|
|
|
+ 3: 'End tag cannot have attributes.',
|
|
|
+ 4: "Illegal '/' in tags.",
|
|
|
+ 5: 'Unexpected EOF in tag.',
|
|
|
+ 6: 'Unexpected EOF in CDATA section.',
|
|
|
+ 7: 'Unexpected EOF in comment.',
|
|
|
+ 8: 'Unexpected EOF in script.',
|
|
|
+ 9: 'Unexpected EOF in tag.',
|
|
|
+ 10: 'Incorrectly closed comment.',
|
|
|
+ 11: 'Incorrectly opened comment.',
|
|
|
+ 12: "Illegal tag name. Use '<' to print '<'.",
|
|
|
+ 13: 'Attribute value was expected.',
|
|
|
+ 14: 'End tag name was expected.',
|
|
|
+ 15: 'Whitespace was expected.',
|
|
|
+ 16: "Unexpected '\x3c!--' in comment.",
|
|
|
+ 17: 'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).',
|
|
|
+ 18: 'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).',
|
|
|
+ 19: "Attribute name cannot start with '='.",
|
|
|
+ 21: "'<?' is allowed only in XML context.",
|
|
|
+ 20: 'Unexpected null character.',
|
|
|
+ 22: "Illegal '/' in tags.",
|
|
|
+ 23: 'Invalid end tag.',
|
|
|
+ 24: 'Element is missing end tag.',
|
|
|
+ 25: 'Interpolation end sign was not found.',
|
|
|
+ 27: 'End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.',
|
|
|
+ 26: 'Legal directive name was expected.',
|
|
|
+ 28: 'v-if/v-else-if is missing expression.',
|
|
|
+ 29: 'v-if/else branches must use unique keys.',
|
|
|
+ 30: 'v-else/v-else-if has no adjacent v-if or v-else-if.',
|
|
|
+ 31: 'v-for is missing expression.',
|
|
|
+ 32: 'v-for has invalid expression.',
|
|
|
+ 33: '<template v-for> key should be placed on the <template> tag.',
|
|
|
+ 34: 'v-bind is missing expression.',
|
|
|
+ 35: 'v-on is missing expression.',
|
|
|
+ 36: 'Unexpected custom directive on <slot> outlet.',
|
|
|
+ 37: 'Mixed v-slot usage on both the component and nested <template>.When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.',
|
|
|
+ 38: 'Duplicate slot names found. ',
|
|
|
+ 39: 'Extraneous children found when component already has explicitly named default slot. These children will be ignored.',
|
|
|
+ 40: 'v-slot can only be used on components or <template> tags.',
|
|
|
+ 41: 'v-model is missing expression.',
|
|
|
+ 42: 'v-model value must be a valid JavaScript member expression.',
|
|
|
+ 43: 'v-model cannot be used on v-for or v-slot scope variables because they are not writable.',
|
|
|
+ 44: 'v-model cannot be used on a prop, because local prop bindings are not writable.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.',
|
|
|
+ 45: 'Error parsing JavaScript expression: ',
|
|
|
+ 46: '<KeepAlive> expects exactly one child component.',
|
|
|
+ 47: '"prefixIdentifiers" option is not supported in this build of compiler.',
|
|
|
+ 48: 'ES module mode is not supported in this build of compiler.',
|
|
|
+ 49: '"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.',
|
|
|
+ 50: '"scopeId" option is only supported in module mode.',
|
|
|
+ 51: ''
|
|
|
+ },
|
|
|
+ Vc = Symbol('Fragment'),
|
|
|
+ Lc = Symbol('Teleport'),
|
|
|
+ Bc = Symbol('Suspense'),
|
|
|
+ Uc = Symbol('KeepAlive'),
|
|
|
+ Dc = Symbol('BaseTransition'),
|
|
|
+ Hc = Symbol('openBlock'),
|
|
|
+ zc = Symbol('createBlock'),
|
|
|
+ Wc = Symbol('createElementBlock'),
|
|
|
+ Kc = Symbol('createVNode'),
|
|
|
+ Gc = Symbol('createElementVNode'),
|
|
|
+ Jc = Symbol('createCommentVNode'),
|
|
|
+ qc = Symbol('createTextVNode'),
|
|
|
+ Yc = Symbol('createStaticVNode'),
|
|
|
+ Zc = Symbol('resolveComponent'),
|
|
|
+ Xc = Symbol('resolveDynamicComponent'),
|
|
|
+ Qc = Symbol('resolveDirective'),
|
|
|
+ el = Symbol('resolveFilter'),
|
|
|
+ tl = Symbol('withDirectives'),
|
|
|
+ nl = Symbol('renderList'),
|
|
|
+ ol = Symbol('renderSlot'),
|
|
|
+ rl = Symbol('createSlots'),
|
|
|
+ sl = Symbol('toDisplayString'),
|
|
|
+ il = Symbol('mergeProps'),
|
|
|
+ cl = Symbol('normalizeClass'),
|
|
|
+ ll = Symbol('normalizeStyle'),
|
|
|
+ al = Symbol('normalizeProps'),
|
|
|
+ ul = Symbol('guardReactiveProps'),
|
|
|
+ pl = Symbol('toHandlers'),
|
|
|
+ dl = Symbol('camelize'),
|
|
|
+ fl = Symbol('capitalize'),
|
|
|
+ hl = Symbol('toHandlerKey'),
|
|
|
+ ml = Symbol('setBlockTracking'),
|
|
|
+ gl = Symbol('pushScopeId'),
|
|
|
+ yl = Symbol('popScopeId'),
|
|
|
+ vl = Symbol('withCtx'),
|
|
|
+ bl = Symbol('unref'),
|
|
|
+ _l = Symbol('isRef'),
|
|
|
+ wl = Symbol('withMemo'),
|
|
|
+ xl = Symbol('isMemoSame'),
|
|
|
+ Sl = {
|
|
|
+ [Vc]: 'Fragment',
|
|
|
+ [Lc]: 'Teleport',
|
|
|
+ [Bc]: 'Suspense',
|
|
|
+ [Uc]: 'KeepAlive',
|
|
|
+ [Dc]: 'BaseTransition',
|
|
|
+ [Hc]: 'openBlock',
|
|
|
+ [zc]: 'createBlock',
|
|
|
+ [Wc]: 'createElementBlock',
|
|
|
+ [Kc]: 'createVNode',
|
|
|
+ [Gc]: 'createElementVNode',
|
|
|
+ [Jc]: 'createCommentVNode',
|
|
|
+ [qc]: 'createTextVNode',
|
|
|
+ [Yc]: 'createStaticVNode',
|
|
|
+ [Zc]: 'resolveComponent',
|
|
|
+ [Xc]: 'resolveDynamicComponent',
|
|
|
+ [Qc]: 'resolveDirective',
|
|
|
+ [el]: 'resolveFilter',
|
|
|
+ [tl]: 'withDirectives',
|
|
|
+ [nl]: 'renderList',
|
|
|
+ [ol]: 'renderSlot',
|
|
|
+ [rl]: 'createSlots',
|
|
|
+ [sl]: 'toDisplayString',
|
|
|
+ [il]: 'mergeProps',
|
|
|
+ [cl]: 'normalizeClass',
|
|
|
+ [ll]: 'normalizeStyle',
|
|
|
+ [al]: 'normalizeProps',
|
|
|
+ [ul]: 'guardReactiveProps',
|
|
|
+ [pl]: 'toHandlers',
|
|
|
+ [dl]: 'camelize',
|
|
|
+ [fl]: 'capitalize',
|
|
|
+ [hl]: 'toHandlerKey',
|
|
|
+ [ml]: 'setBlockTracking',
|
|
|
+ [gl]: 'pushScopeId',
|
|
|
+ [yl]: 'popScopeId',
|
|
|
+ [vl]: 'withCtx',
|
|
|
+ [bl]: 'unref',
|
|
|
+ [_l]: 'isRef',
|
|
|
+ [wl]: 'withMemo',
|
|
|
+ [xl]: 'isMemoSame'
|
|
|
+ }
|
|
|
+ const Cl = {
|
|
|
+ source: '',
|
|
|
+ start: {
|
|
|
+ line: 1,
|
|
|
+ column: 1,
|
|
|
+ offset: 0
|
|
|
+ },
|
|
|
+ end: {
|
|
|
+ line: 1,
|
|
|
+ column: 1,
|
|
|
+ offset: 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function kl(e, t, n, o, r, s, i, c = !1, l = !1, a = !1, u = Cl) {
|
|
|
+ return (
|
|
|
+ e &&
|
|
|
+ (c ? (e.helper(Hc), e.helper(ta(e.inSSR, a))) : e.helper(ea(e.inSSR, a)),
|
|
|
+ i && e.helper(tl)),
|
|
|
+ {
|
|
|
+ type: 13,
|
|
|
+ tag: t,
|
|
|
+ props: n,
|
|
|
+ children: o,
|
|
|
+ patchFlag: r,
|
|
|
+ dynamicProps: s,
|
|
|
+ directives: i,
|
|
|
+ isBlock: c,
|
|
|
+ disableTracking: l,
|
|
|
+ isComponent: a,
|
|
|
+ loc: u
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Tl(e, t = Cl) {
|
|
|
+ return {
|
|
|
+ type: 17,
|
|
|
+ loc: t,
|
|
|
+ elements: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function $l(e, t = Cl) {
|
|
|
+ return {
|
|
|
+ type: 15,
|
|
|
+ loc: t,
|
|
|
+ properties: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function El(e, t) {
|
|
|
+ return {
|
|
|
+ type: 16,
|
|
|
+ loc: Cl,
|
|
|
+ key: P(e) ? Nl(e, !0) : e,
|
|
|
+ value: t
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Nl(e, t = !1, n = Cl, o = 0) {
|
|
|
+ return {
|
|
|
+ type: 4,
|
|
|
+ loc: n,
|
|
|
+ content: e,
|
|
|
+ isStatic: t,
|
|
|
+ constType: t ? 3 : o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ol(e, t = Cl) {
|
|
|
+ return {
|
|
|
+ type: 8,
|
|
|
+ loc: t,
|
|
|
+ children: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Al(e, t = [], n = Cl) {
|
|
|
+ return {
|
|
|
+ type: 14,
|
|
|
+ loc: n,
|
|
|
+ callee: e,
|
|
|
+ arguments: t
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Il(e, t, n = !1, o = !1, r = Cl) {
|
|
|
+ return {
|
|
|
+ type: 18,
|
|
|
+ params: e,
|
|
|
+ returns: t,
|
|
|
+ newline: n,
|
|
|
+ isSlot: o,
|
|
|
+ loc: r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Rl(e, t, n, o = !0) {
|
|
|
+ return {
|
|
|
+ type: 19,
|
|
|
+ test: e,
|
|
|
+ consequent: t,
|
|
|
+ alternate: n,
|
|
|
+ newline: o,
|
|
|
+ loc: Cl
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Ml = (e) => 4 === e.type && e.isStatic,
|
|
|
+ Pl = (e, t) => e === t || e === Y(t)
|
|
|
+ function Fl(e) {
|
|
|
+ return Pl(e, 'Teleport')
|
|
|
+ ? Lc
|
|
|
+ : Pl(e, 'Suspense')
|
|
|
+ ? Bc
|
|
|
+ : Pl(e, 'KeepAlive')
|
|
|
+ ? Uc
|
|
|
+ : Pl(e, 'BaseTransition')
|
|
|
+ ? Dc
|
|
|
+ : void 0
|
|
|
+ }
|
|
|
+ const jl = /^\d|[^\$\w]/,
|
|
|
+ Vl = (e) => !jl.test(e),
|
|
|
+ Ll = /[A-Za-z_$\xA0-\uFFFF]/,
|
|
|
+ Bl = /[\.\?\w$\xA0-\uFFFF]/,
|
|
|
+ Ul = /\s+[.[]\s*|\s*[.[]\s+/g,
|
|
|
+ Dl = (e) => {
|
|
|
+ e = e.trim().replace(Ul, (e) => e.trim())
|
|
|
+ let t = 0,
|
|
|
+ n = [],
|
|
|
+ o = 0,
|
|
|
+ r = 0,
|
|
|
+ s = null
|
|
|
+ for (let i = 0; i < e.length; i++) {
|
|
|
+ const c = e.charAt(i)
|
|
|
+ switch (t) {
|
|
|
+ case 0:
|
|
|
+ if ('[' === c) n.push(t), (t = 1), o++
|
|
|
+ else if ('(' === c) n.push(t), (t = 2), r++
|
|
|
+ else if (!(0 === i ? Ll : Bl).test(c)) return !1
|
|
|
+ break
|
|
|
+ case 1:
|
|
|
+ "'" === c || '"' === c || '`' === c
|
|
|
+ ? (n.push(t), (t = 3), (s = c))
|
|
|
+ : '[' === c
|
|
|
+ ? o++
|
|
|
+ : ']' === c && (--o || (t = n.pop()))
|
|
|
+ break
|
|
|
+ case 2:
|
|
|
+ if ("'" === c || '"' === c || '`' === c) n.push(t), (t = 3), (s = c)
|
|
|
+ else if ('(' === c) r++
|
|
|
+ else if (')' === c) {
|
|
|
+ if (i === e.length - 1) return !1
|
|
|
+ --r || (t = n.pop())
|
|
|
+ }
|
|
|
+ break
|
|
|
+ case 3:
|
|
|
+ c === s && ((t = n.pop()), (s = null))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return !o && !r
|
|
|
+ }
|
|
|
+ function Hl(e, t, n) {
|
|
|
+ const o = {
|
|
|
+ source: e.source.slice(t, t + n),
|
|
|
+ start: zl(e.start, e.source, t),
|
|
|
+ end: e.end
|
|
|
+ }
|
|
|
+ return null != n && (o.end = zl(e.start, e.source, t + n)), o
|
|
|
+ }
|
|
|
+ function zl(e, t, n = t.length) {
|
|
|
+ return Wl(T({}, e), t, n)
|
|
|
+ }
|
|
|
+ function Wl(e, t, n = t.length) {
|
|
|
+ let o = 0,
|
|
|
+ r = -1
|
|
|
+ for (let e = 0; e < n; e++) 10 === t.charCodeAt(e) && (o++, (r = e))
|
|
|
+ return (e.offset += n), (e.line += o), (e.column = -1 === r ? e.column + n : n - r), e
|
|
|
+ }
|
|
|
+ function Kl(e, t) {
|
|
|
+ if (!e) throw new Error(t || 'unexpected compiler condition')
|
|
|
+ }
|
|
|
+ function Gl(e, t, n = !1) {
|
|
|
+ for (let o = 0; o < e.props.length; o++) {
|
|
|
+ const r = e.props[o]
|
|
|
+ if (7 === r.type && (n || r.exp) && (P(t) ? r.name === t : t.test(r.name))) return r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Jl(e, t, n = !1, o = !1) {
|
|
|
+ for (let r = 0; r < e.props.length; r++) {
|
|
|
+ const s = e.props[r]
|
|
|
+ if (6 === s.type) {
|
|
|
+ if (n) continue
|
|
|
+ if (s.name === t && (s.value || o)) return s
|
|
|
+ } else if ('bind' === s.name && (s.exp || o) && ql(s.arg, t)) return s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ql(e, t) {
|
|
|
+ return !(!e || !Ml(e) || e.content !== t)
|
|
|
+ }
|
|
|
+ function Yl(e) {
|
|
|
+ return 5 === e.type || 2 === e.type
|
|
|
+ }
|
|
|
+ function Zl(e) {
|
|
|
+ return 7 === e.type && 'slot' === e.name
|
|
|
+ }
|
|
|
+ function Xl(e) {
|
|
|
+ return 1 === e.type && 3 === e.tagType
|
|
|
+ }
|
|
|
+ function Ql(e) {
|
|
|
+ return 1 === e.type && 2 === e.tagType
|
|
|
+ }
|
|
|
+ function ea(e, t) {
|
|
|
+ return e || t ? Kc : Gc
|
|
|
+ }
|
|
|
+ function ta(e, t) {
|
|
|
+ return e || t ? zc : Wc
|
|
|
+ }
|
|
|
+ const na = new Set([al, ul])
|
|
|
+ function oa(e, t = []) {
|
|
|
+ if (e && !P(e) && 14 === e.type) {
|
|
|
+ const n = e.callee
|
|
|
+ if (!P(n) && na.has(n)) return oa(e.arguments[0], t.concat(e))
|
|
|
+ }
|
|
|
+ return [e, t]
|
|
|
+ }
|
|
|
+ function ra(e, t, n) {
|
|
|
+ let o,
|
|
|
+ r,
|
|
|
+ s = 13 === e.type ? e.props : e.arguments[2],
|
|
|
+ i = []
|
|
|
+ if (s && !P(s) && 14 === s.type) {
|
|
|
+ const e = oa(s)
|
|
|
+ ;(s = e[0]), (i = e[1]), (r = i[i.length - 1])
|
|
|
+ }
|
|
|
+ if (null == s || P(s)) o = $l([t])
|
|
|
+ else if (14 === s.type) {
|
|
|
+ const e = s.arguments[0]
|
|
|
+ P(e) || 15 !== e.type
|
|
|
+ ? s.callee === pl
|
|
|
+ ? (o = Al(n.helper(il), [$l([t]), s]))
|
|
|
+ : s.arguments.unshift($l([t]))
|
|
|
+ : sa(t, e) || e.properties.unshift(t),
|
|
|
+ !o && (o = s)
|
|
|
+ } else
|
|
|
+ 15 === s.type
|
|
|
+ ? (sa(t, s) || s.properties.unshift(t), (o = s))
|
|
|
+ : ((o = Al(n.helper(il), [$l([t]), s])), r && r.callee === ul && (r = i[i.length - 2]))
|
|
|
+ 13 === e.type
|
|
|
+ ? r
|
|
|
+ ? (r.arguments[0] = o)
|
|
|
+ : (e.props = o)
|
|
|
+ : r
|
|
|
+ ? (r.arguments[0] = o)
|
|
|
+ : (e.arguments[2] = o)
|
|
|
+ }
|
|
|
+ function sa(e, t) {
|
|
|
+ let n = !1
|
|
|
+ if (4 === e.key.type) {
|
|
|
+ const o = e.key.content
|
|
|
+ n = t.properties.some((e) => 4 === e.key.type && e.key.content === o)
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function ia(e, t) {
|
|
|
+ return `_${t}_${e.replace(/[^\w]/g, (t, n) => ('-' === t ? '_' : e.charCodeAt(n).toString()))}`
|
|
|
+ }
|
|
|
+ function ca(e, { helper: t, removeHelper: n, inSSR: o }) {
|
|
|
+ e.isBlock || ((e.isBlock = !0), n(ea(o, e.isComponent)), t(Hc), t(ta(o, e.isComponent)))
|
|
|
+ }
|
|
|
+ const la = /&(gt|lt|amp|apos|quot);/g,
|
|
|
+ aa = {
|
|
|
+ gt: '>',
|
|
|
+ lt: '<',
|
|
|
+ amp: '&',
|
|
|
+ apos: "'",
|
|
|
+ quot: '"'
|
|
|
+ },
|
|
|
+ ua = {
|
|
|
+ delimiters: ['{{', '}}'],
|
|
|
+ getNamespace: () => 0,
|
|
|
+ getTextMode: () => 0,
|
|
|
+ isVoidTag: x,
|
|
|
+ isPreTag: x,
|
|
|
+ isCustomElement: x,
|
|
|
+ decodeEntities: (e) => e.replace(la, (e, t) => aa[t]),
|
|
|
+ onError: Mc,
|
|
|
+ onWarn: Pc,
|
|
|
+ comments: !0
|
|
|
+ }
|
|
|
+ function pa(e, t = {}) {
|
|
|
+ const n = (function (e, t) {
|
|
|
+ const n = T({}, ua)
|
|
|
+ let o
|
|
|
+ for (o in t) n[o] = void 0 === t[o] ? ua[o] : t[o]
|
|
|
+ return {
|
|
|
+ options: n,
|
|
|
+ column: 1,
|
|
|
+ line: 1,
|
|
|
+ offset: 0,
|
|
|
+ originalSource: e,
|
|
|
+ source: e,
|
|
|
+ inPre: !1,
|
|
|
+ inVPre: !1,
|
|
|
+ onWarn: n.onWarn
|
|
|
+ }
|
|
|
+ })(e, t),
|
|
|
+ o = ka(n)
|
|
|
+ return (function (e, t = Cl) {
|
|
|
+ return {
|
|
|
+ type: 0,
|
|
|
+ children: e,
|
|
|
+ helpers: [],
|
|
|
+ components: [],
|
|
|
+ directives: [],
|
|
|
+ hoists: [],
|
|
|
+ imports: [],
|
|
|
+ cached: 0,
|
|
|
+ temps: 0,
|
|
|
+ codegenNode: void 0,
|
|
|
+ loc: t
|
|
|
+ }
|
|
|
+ })(da(n, 0, []), Ta(n, o))
|
|
|
+ }
|
|
|
+ function da(e, t, n) {
|
|
|
+ const o = $a(n),
|
|
|
+ r = o ? o.ns : 0,
|
|
|
+ s = []
|
|
|
+ for (; !Ra(e, t, n); ) {
|
|
|
+ const i = e.source
|
|
|
+ let c
|
|
|
+ if (0 === t || 1 === t)
|
|
|
+ if (!e.inVPre && Ea(i, e.options.delimiters[0])) c = xa(e, t)
|
|
|
+ else if (0 === t && '<' === i[0])
|
|
|
+ if (1 === i.length) Ia(e, 5, 1)
|
|
|
+ else if ('!' === i[1])
|
|
|
+ Ea(i, '\x3c!--')
|
|
|
+ ? (c = ma(e))
|
|
|
+ : Ea(i, '<!DOCTYPE')
|
|
|
+ ? (c = ga(e))
|
|
|
+ : Ea(i, '<![CDATA[')
|
|
|
+ ? 0 !== r
|
|
|
+ ? (c = ha(e, n))
|
|
|
+ : (Ia(e, 1), (c = ga(e)))
|
|
|
+ : (Ia(e, 11), (c = ga(e)))
|
|
|
+ else if ('/' === i[1])
|
|
|
+ if (2 === i.length) Ia(e, 5, 2)
|
|
|
+ else {
|
|
|
+ if ('>' === i[2]) {
|
|
|
+ Ia(e, 14, 2), Na(e, 3)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ if (/[a-z]/i.test(i[2])) {
|
|
|
+ Ia(e, 23), ba(e, 1, o)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ Ia(e, 12, 2), (c = ga(e))
|
|
|
+ }
|
|
|
+ else
|
|
|
+ /[a-z]/i.test(i[1])
|
|
|
+ ? (c = ya(e, n))
|
|
|
+ : '?' === i[1]
|
|
|
+ ? (Ia(e, 21, 1), (c = ga(e)))
|
|
|
+ : Ia(e, 12, 1)
|
|
|
+ if ((c || (c = Sa(e, t)), O(c))) for (let e = 0; e < c.length; e++) fa(s, c[e])
|
|
|
+ else fa(s, c)
|
|
|
+ }
|
|
|
+ let i = !1
|
|
|
+ if (2 !== t && 1 !== t) {
|
|
|
+ const t = 'preserve' !== e.options.whitespace
|
|
|
+ for (let n = 0; n < s.length; n++) {
|
|
|
+ const o = s[n]
|
|
|
+ if (2 === o.type)
|
|
|
+ if (e.inPre) o.content = o.content.replace(/\r\n/g, '\n')
|
|
|
+ else if (/[^\t\r\n\f ]/.test(o.content))
|
|
|
+ t && (o.content = o.content.replace(/[\t\r\n\f ]+/g, ' '))
|
|
|
+ else {
|
|
|
+ const e = s[n - 1],
|
|
|
+ r = s[n + 1]
|
|
|
+ !e ||
|
|
|
+ !r ||
|
|
|
+ (t &&
|
|
|
+ ((3 === e.type && 3 === r.type) ||
|
|
|
+ (3 === e.type && 1 === r.type) ||
|
|
|
+ (1 === e.type && 3 === r.type) ||
|
|
|
+ (1 === e.type && 1 === r.type && /[\r\n]/.test(o.content))))
|
|
|
+ ? ((i = !0), (s[n] = null))
|
|
|
+ : (o.content = ' ')
|
|
|
+ }
|
|
|
+ else 3 !== o.type || e.options.comments || ((i = !0), (s[n] = null))
|
|
|
+ }
|
|
|
+ if (e.inPre && o && e.options.isPreTag(o.tag)) {
|
|
|
+ const e = s[0]
|
|
|
+ e && 2 === e.type && (e.content = e.content.replace(/^\r?\n/, ''))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i ? s.filter(Boolean) : s
|
|
|
+ }
|
|
|
+ function fa(e, t) {
|
|
|
+ if (2 === t.type) {
|
|
|
+ const n = $a(e)
|
|
|
+ if (n && 2 === n.type && n.loc.end.offset === t.loc.start.offset)
|
|
|
+ return (
|
|
|
+ (n.content += t.content), (n.loc.end = t.loc.end), void (n.loc.source += t.loc.source)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ e.push(t)
|
|
|
+ }
|
|
|
+ function ha(e, t) {
|
|
|
+ Na(e, 9)
|
|
|
+ const n = da(e, 3, t)
|
|
|
+ return 0 === e.source.length ? Ia(e, 6) : Na(e, 3), n
|
|
|
+ }
|
|
|
+ function ma(e) {
|
|
|
+ const t = ka(e)
|
|
|
+ let n
|
|
|
+ const o = /--(\!)?>/.exec(e.source)
|
|
|
+ if (o) {
|
|
|
+ o.index <= 3 && Ia(e, 0), o[1] && Ia(e, 10), (n = e.source.slice(4, o.index))
|
|
|
+ const t = e.source.slice(0, o.index)
|
|
|
+ let r = 1,
|
|
|
+ s = 0
|
|
|
+ for (; -1 !== (s = t.indexOf('\x3c!--', r)); )
|
|
|
+ Na(e, s - r + 1), s + 4 < t.length && Ia(e, 16), (r = s + 1)
|
|
|
+ Na(e, o.index + o[0].length - r + 1)
|
|
|
+ } else (n = e.source.slice(4)), Na(e, e.source.length), Ia(e, 7)
|
|
|
+ return {
|
|
|
+ type: 3,
|
|
|
+ content: n,
|
|
|
+ loc: Ta(e, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ga(e) {
|
|
|
+ const t = ka(e),
|
|
|
+ n = '?' === e.source[1] ? 1 : 2
|
|
|
+ let o
|
|
|
+ const r = e.source.indexOf('>')
|
|
|
+ return (
|
|
|
+ -1 === r
|
|
|
+ ? ((o = e.source.slice(n)), Na(e, e.source.length))
|
|
|
+ : ((o = e.source.slice(n, r)), Na(e, r + 1)),
|
|
|
+ {
|
|
|
+ type: 3,
|
|
|
+ content: o,
|
|
|
+ loc: Ta(e, t)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ya(e, t) {
|
|
|
+ const n = e.inPre,
|
|
|
+ o = e.inVPre,
|
|
|
+ r = $a(t),
|
|
|
+ s = ba(e, 0, r),
|
|
|
+ i = e.inPre && !n,
|
|
|
+ c = e.inVPre && !o
|
|
|
+ if (s.isSelfClosing || e.options.isVoidTag(s.tag))
|
|
|
+ return i && (e.inPre = !1), c && (e.inVPre = !1), s
|
|
|
+ t.push(s)
|
|
|
+ const l = e.options.getTextMode(s, r),
|
|
|
+ a = da(e, l, t)
|
|
|
+ if ((t.pop(), (s.children = a), Ma(e.source, s.tag))) ba(e, 1, r)
|
|
|
+ else if (
|
|
|
+ (Ia(e, 24, 0, s.loc.start), 0 === e.source.length && 'script' === s.tag.toLowerCase())
|
|
|
+ ) {
|
|
|
+ const t = a[0]
|
|
|
+ t && Ea(t.loc.source, '\x3c!--') && Ia(e, 8)
|
|
|
+ }
|
|
|
+ return (s.loc = Ta(e, s.loc.start)), i && (e.inPre = !1), c && (e.inVPre = !1), s
|
|
|
+ }
|
|
|
+ const va = t('if,else,else-if,for,slot')
|
|
|
+ function ba(e, t, n) {
|
|
|
+ const o = ka(e),
|
|
|
+ r = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(e.source),
|
|
|
+ s = r[1],
|
|
|
+ i = e.options.getNamespace(s, n)
|
|
|
+ Na(e, r[0].length), Oa(e)
|
|
|
+ const c = ka(e),
|
|
|
+ l = e.source
|
|
|
+ e.options.isPreTag(s) && (e.inPre = !0)
|
|
|
+ let a = _a(e, t)
|
|
|
+ 0 === t &&
|
|
|
+ !e.inVPre &&
|
|
|
+ a.some((e) => 7 === e.type && 'pre' === e.name) &&
|
|
|
+ ((e.inVPre = !0), T(e, c), (e.source = l), (a = _a(e, t).filter((e) => 'v-pre' !== e.name)))
|
|
|
+ let u = !1
|
|
|
+ if (
|
|
|
+ (0 === e.source.length
|
|
|
+ ? Ia(e, 9)
|
|
|
+ : ((u = Ea(e.source, '/>')), 1 === t && u && Ia(e, 4), Na(e, u ? 2 : 1)),
|
|
|
+ 1 === t)
|
|
|
+ )
|
|
|
+ return
|
|
|
+ let p = 0
|
|
|
+ return (
|
|
|
+ e.inVPre ||
|
|
|
+ ('slot' === s
|
|
|
+ ? (p = 2)
|
|
|
+ : 'template' === s
|
|
|
+ ? a.some((e) => 7 === e.type && va(e.name)) && (p = 3)
|
|
|
+ : (function (e, t, n) {
|
|
|
+ const o = n.options
|
|
|
+ if (o.isCustomElement(e)) return !1
|
|
|
+ if (
|
|
|
+ 'component' === e ||
|
|
|
+ /^[A-Z]/.test(e) ||
|
|
|
+ Fl(e) ||
|
|
|
+ (o.isBuiltInComponent && o.isBuiltInComponent(e)) ||
|
|
|
+ (o.isNativeTag && !o.isNativeTag(e))
|
|
|
+ )
|
|
|
+ return !0
|
|
|
+ for (let e = 0; e < t.length; e++) {
|
|
|
+ const n = t[e]
|
|
|
+ if (6 === n.type) {
|
|
|
+ if ('is' === n.name && n.value && n.value.content.startsWith('vue:')) return !0
|
|
|
+ } else {
|
|
|
+ if ('is' === n.name) return !0
|
|
|
+ 'bind' === n.name && ql(n.arg, 'is')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })(s, a, e) && (p = 1)),
|
|
|
+ {
|
|
|
+ type: 1,
|
|
|
+ ns: i,
|
|
|
+ tag: s,
|
|
|
+ tagType: p,
|
|
|
+ props: a,
|
|
|
+ isSelfClosing: u,
|
|
|
+ children: [],
|
|
|
+ loc: Ta(e, o),
|
|
|
+ codegenNode: void 0
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function _a(e, t) {
|
|
|
+ const n = [],
|
|
|
+ o = new Set()
|
|
|
+ for (; e.source.length > 0 && !Ea(e.source, '>') && !Ea(e.source, '/>'); ) {
|
|
|
+ if (Ea(e.source, '/')) {
|
|
|
+ Ia(e, 22), Na(e, 1), Oa(e)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ 1 === t && Ia(e, 3)
|
|
|
+ const r = wa(e, o)
|
|
|
+ 6 === r.type &&
|
|
|
+ r.value &&
|
|
|
+ 'class' === r.name &&
|
|
|
+ (r.value.content = r.value.content.replace(/\s+/g, ' ').trim()),
|
|
|
+ 0 === t && n.push(r),
|
|
|
+ /^[^\t\r\n\f />]/.test(e.source) && Ia(e, 15),
|
|
|
+ Oa(e)
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function wa(e, t) {
|
|
|
+ const n = ka(e),
|
|
|
+ o = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(e.source)[0]
|
|
|
+ t.has(o) && Ia(e, 2), t.add(o), '=' === o[0] && Ia(e, 19)
|
|
|
+ {
|
|
|
+ const t = /["'<]/g
|
|
|
+ let n
|
|
|
+ for (; (n = t.exec(o)); ) Ia(e, 17, n.index)
|
|
|
+ }
|
|
|
+ let r
|
|
|
+ Na(e, o.length),
|
|
|
+ /^[\t\r\n\f ]*=/.test(e.source) &&
|
|
|
+ (Oa(e),
|
|
|
+ Na(e, 1),
|
|
|
+ Oa(e),
|
|
|
+ (r = (function (e) {
|
|
|
+ const t = ka(e)
|
|
|
+ let n
|
|
|
+ const o = e.source[0],
|
|
|
+ r = '"' === o || "'" === o
|
|
|
+ if (r) {
|
|
|
+ Na(e, 1)
|
|
|
+ const t = e.source.indexOf(o)
|
|
|
+ ;-1 === t ? (n = Ca(e, e.source.length, 4)) : ((n = Ca(e, t, 4)), Na(e, 1))
|
|
|
+ } else {
|
|
|
+ const t = /^[^\t\r\n\f >]+/.exec(e.source)
|
|
|
+ if (!t) return
|
|
|
+ const o = /["'<=`]/g
|
|
|
+ let r
|
|
|
+ for (; (r = o.exec(t[0])); ) Ia(e, 18, r.index)
|
|
|
+ n = Ca(e, t[0].length, 4)
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ content: n,
|
|
|
+ isQuoted: r,
|
|
|
+ loc: Ta(e, t)
|
|
|
+ }
|
|
|
+ })(e)),
|
|
|
+ r || Ia(e, 13))
|
|
|
+ const s = Ta(e, n)
|
|
|
+ if (!e.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(o)) {
|
|
|
+ const t = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(o)
|
|
|
+ let i,
|
|
|
+ c = Ea(o, '.'),
|
|
|
+ l = t[1] || (c || Ea(o, ':') ? 'bind' : Ea(o, '@') ? 'on' : 'slot')
|
|
|
+ if (t[2]) {
|
|
|
+ const r = 'slot' === l,
|
|
|
+ s = o.lastIndexOf(t[2]),
|
|
|
+ c = Ta(e, Aa(e, n, s), Aa(e, n, s + t[2].length + ((r && t[3]) || '').length))
|
|
|
+ let a = t[2],
|
|
|
+ u = !0
|
|
|
+ a.startsWith('[')
|
|
|
+ ? ((u = !1),
|
|
|
+ a.endsWith(']') ? (a = a.slice(1, a.length - 1)) : (Ia(e, 27), (a = a.slice(1))))
|
|
|
+ : r && (a += t[3] || ''),
|
|
|
+ (i = {
|
|
|
+ type: 4,
|
|
|
+ content: a,
|
|
|
+ isStatic: u,
|
|
|
+ constType: u ? 3 : 0,
|
|
|
+ loc: c
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if (r && r.isQuoted) {
|
|
|
+ const e = r.loc
|
|
|
+ e.start.offset++,
|
|
|
+ e.start.column++,
|
|
|
+ (e.end = zl(e.start, r.content)),
|
|
|
+ (e.source = e.source.slice(1, -1))
|
|
|
+ }
|
|
|
+ const a = t[3] ? t[3].slice(1).split('.') : []
|
|
|
+ return (
|
|
|
+ c && a.push('prop'),
|
|
|
+ {
|
|
|
+ type: 7,
|
|
|
+ name: l,
|
|
|
+ exp: r && {
|
|
|
+ type: 4,
|
|
|
+ content: r.content,
|
|
|
+ isStatic: !1,
|
|
|
+ constType: 0,
|
|
|
+ loc: r.loc
|
|
|
+ },
|
|
|
+ arg: i,
|
|
|
+ modifiers: a,
|
|
|
+ loc: s
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ !e.inVPre && Ea(o, 'v-') && Ia(e, 26),
|
|
|
+ {
|
|
|
+ type: 6,
|
|
|
+ name: o,
|
|
|
+ value: r && {
|
|
|
+ type: 2,
|
|
|
+ content: r.content,
|
|
|
+ loc: r.loc
|
|
|
+ },
|
|
|
+ loc: s
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function xa(e, t) {
|
|
|
+ const [n, o] = e.options.delimiters,
|
|
|
+ r = e.source.indexOf(o, n.length)
|
|
|
+ if (-1 === r) return void Ia(e, 25)
|
|
|
+ const s = ka(e)
|
|
|
+ Na(e, n.length)
|
|
|
+ const i = ka(e),
|
|
|
+ c = ka(e),
|
|
|
+ l = r - n.length,
|
|
|
+ a = e.source.slice(0, l),
|
|
|
+ u = Ca(e, l, t),
|
|
|
+ p = u.trim(),
|
|
|
+ d = u.indexOf(p)
|
|
|
+ d > 0 && Wl(i, a, d)
|
|
|
+ return (
|
|
|
+ Wl(c, a, l - (u.length - p.length - d)),
|
|
|
+ Na(e, o.length),
|
|
|
+ {
|
|
|
+ type: 5,
|
|
|
+ content: {
|
|
|
+ type: 4,
|
|
|
+ isStatic: !1,
|
|
|
+ constType: 0,
|
|
|
+ content: p,
|
|
|
+ loc: Ta(e, i, c)
|
|
|
+ },
|
|
|
+ loc: Ta(e, s)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Sa(e, t) {
|
|
|
+ const n = 3 === t ? [']]>'] : ['<', e.options.delimiters[0]]
|
|
|
+ let o = e.source.length
|
|
|
+ for (let t = 0; t < n.length; t++) {
|
|
|
+ const r = e.source.indexOf(n[t], 1)
|
|
|
+ ;-1 !== r && o > r && (o = r)
|
|
|
+ }
|
|
|
+ const r = ka(e)
|
|
|
+ return {
|
|
|
+ type: 2,
|
|
|
+ content: Ca(e, o, t),
|
|
|
+ loc: Ta(e, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ca(e, t, n) {
|
|
|
+ const o = e.source.slice(0, t)
|
|
|
+ return (
|
|
|
+ Na(e, t), 2 !== n && 3 !== n && o.includes('&') ? e.options.decodeEntities(o, 4 === n) : o
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ka(e) {
|
|
|
+ const { column: t, line: n, offset: o } = e
|
|
|
+ return {
|
|
|
+ column: t,
|
|
|
+ line: n,
|
|
|
+ offset: o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ta(e, t, n) {
|
|
|
+ return {
|
|
|
+ start: t,
|
|
|
+ end: (n = n || ka(e)),
|
|
|
+ source: e.originalSource.slice(t.offset, n.offset)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function $a(e) {
|
|
|
+ return e[e.length - 1]
|
|
|
+ }
|
|
|
+ function Ea(e, t) {
|
|
|
+ return e.startsWith(t)
|
|
|
+ }
|
|
|
+ function Na(e, t) {
|
|
|
+ const { source: n } = e
|
|
|
+ Wl(e, n, t), (e.source = n.slice(t))
|
|
|
+ }
|
|
|
+ function Oa(e) {
|
|
|
+ const t = /^[\t\r\n\f ]+/.exec(e.source)
|
|
|
+ t && Na(e, t[0].length)
|
|
|
+ }
|
|
|
+ function Aa(e, t, n) {
|
|
|
+ return zl(t, e.originalSource.slice(t.offset, n), n)
|
|
|
+ }
|
|
|
+ function Ia(e, t, n, o = ka(e)) {
|
|
|
+ n && ((o.offset += n), (o.column += n)),
|
|
|
+ e.options.onError(
|
|
|
+ Fc(t, {
|
|
|
+ start: o,
|
|
|
+ end: o,
|
|
|
+ source: ''
|
|
|
+ })
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Ra(e, t, n) {
|
|
|
+ const o = e.source
|
|
|
+ switch (t) {
|
|
|
+ case 0:
|
|
|
+ if (Ea(o, '</')) for (let e = n.length - 1; e >= 0; --e) if (Ma(o, n[e].tag)) return !0
|
|
|
+ break
|
|
|
+ case 1:
|
|
|
+ case 2: {
|
|
|
+ const e = $a(n)
|
|
|
+ if (e && Ma(o, e.tag)) return !0
|
|
|
+ break
|
|
|
+ }
|
|
|
+ case 3:
|
|
|
+ if (Ea(o, ']]>')) return !0
|
|
|
+ }
|
|
|
+ return !o
|
|
|
+ }
|
|
|
+ function Ma(e, t) {
|
|
|
+ return (
|
|
|
+ Ea(e, '</') &&
|
|
|
+ e.slice(2, 2 + t.length).toLowerCase() === t.toLowerCase() &&
|
|
|
+ /[\t\r\n\f />]/.test(e[2 + t.length] || '>')
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Pa(e, t) {
|
|
|
+ ja(e, t, Fa(e, e.children[0]))
|
|
|
+ }
|
|
|
+ function Fa(e, t) {
|
|
|
+ const { children: n } = e
|
|
|
+ return 1 === n.length && 1 === t.type && !Ql(t)
|
|
|
+ }
|
|
|
+ function ja(e, t, n = !1) {
|
|
|
+ const { children: o } = e,
|
|
|
+ r = o.length
|
|
|
+ let s = 0
|
|
|
+ for (let e = 0; e < o.length; e++) {
|
|
|
+ const r = o[e]
|
|
|
+ if (1 === r.type && 0 === r.tagType) {
|
|
|
+ const e = n ? 0 : Va(r, t)
|
|
|
+ if (e > 0) {
|
|
|
+ if (e >= 2) {
|
|
|
+ ;(r.codegenNode.patchFlag = '-1 /* HOISTED */'),
|
|
|
+ (r.codegenNode = t.hoist(r.codegenNode)),
|
|
|
+ s++
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ const e = r.codegenNode
|
|
|
+ if (13 === e.type) {
|
|
|
+ const n = Ha(e)
|
|
|
+ if ((!n || 512 === n || 1 === n) && Ua(r, t) >= 2) {
|
|
|
+ const n = Da(r)
|
|
|
+ n && (e.props = t.hoist(n))
|
|
|
+ }
|
|
|
+ e.dynamicProps && (e.dynamicProps = t.hoist(e.dynamicProps))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (1 === r.type) {
|
|
|
+ const e = 1 === r.tagType
|
|
|
+ e && t.scopes.vSlot++, ja(r, t), e && t.scopes.vSlot--
|
|
|
+ } else if (11 === r.type) ja(r, t, 1 === r.children.length)
|
|
|
+ else if (9 === r.type)
|
|
|
+ for (let e = 0; e < r.branches.length; e++)
|
|
|
+ ja(r.branches[e], t, 1 === r.branches[e].children.length)
|
|
|
+ }
|
|
|
+ s && t.transformHoist && t.transformHoist(o, t, e),
|
|
|
+ s &&
|
|
|
+ s === r &&
|
|
|
+ 1 === e.type &&
|
|
|
+ 0 === e.tagType &&
|
|
|
+ e.codegenNode &&
|
|
|
+ 13 === e.codegenNode.type &&
|
|
|
+ O(e.codegenNode.children) &&
|
|
|
+ (e.codegenNode.children = t.hoist(Tl(e.codegenNode.children)))
|
|
|
+ }
|
|
|
+ function Va(e, t) {
|
|
|
+ const { constantCache: n } = t
|
|
|
+ switch (e.type) {
|
|
|
+ case 1:
|
|
|
+ if (0 !== e.tagType) return 0
|
|
|
+ const o = n.get(e)
|
|
|
+ if (void 0 !== o) return o
|
|
|
+ const r = e.codegenNode
|
|
|
+ if (13 !== r.type) return 0
|
|
|
+ if (r.isBlock && 'svg' !== e.tag && 'foreignObject' !== e.tag) return 0
|
|
|
+ if (Ha(r)) return n.set(e, 0), 0
|
|
|
+ {
|
|
|
+ let o = 3
|
|
|
+ const s = Ua(e, t)
|
|
|
+ if (0 === s) return n.set(e, 0), 0
|
|
|
+ s < o && (o = s)
|
|
|
+ for (let r = 0; r < e.children.length; r++) {
|
|
|
+ const s = Va(e.children[r], t)
|
|
|
+ if (0 === s) return n.set(e, 0), 0
|
|
|
+ s < o && (o = s)
|
|
|
+ }
|
|
|
+ if (o > 1)
|
|
|
+ for (let r = 0; r < e.props.length; r++) {
|
|
|
+ const s = e.props[r]
|
|
|
+ if (7 === s.type && 'bind' === s.name && s.exp) {
|
|
|
+ const r = Va(s.exp, t)
|
|
|
+ if (0 === r) return n.set(e, 0), 0
|
|
|
+ r < o && (o = r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (r.isBlock) {
|
|
|
+ for (let t = 0; t < e.props.length; t++) {
|
|
|
+ if (7 === e.props[t].type) return n.set(e, 0), 0
|
|
|
+ }
|
|
|
+ t.removeHelper(Hc),
|
|
|
+ t.removeHelper(ta(t.inSSR, r.isComponent)),
|
|
|
+ (r.isBlock = !1),
|
|
|
+ t.helper(ea(t.inSSR, r.isComponent))
|
|
|
+ }
|
|
|
+ return n.set(e, o), o
|
|
|
+ }
|
|
|
+ case 2:
|
|
|
+ case 3:
|
|
|
+ return 3
|
|
|
+ case 9:
|
|
|
+ case 11:
|
|
|
+ case 10:
|
|
|
+ default:
|
|
|
+ return 0
|
|
|
+ case 5:
|
|
|
+ case 12:
|
|
|
+ return Va(e.content, t)
|
|
|
+ case 4:
|
|
|
+ return e.constType
|
|
|
+ case 8:
|
|
|
+ let s = 3
|
|
|
+ for (let n = 0; n < e.children.length; n++) {
|
|
|
+ const o = e.children[n]
|
|
|
+ if (P(o) || F(o)) continue
|
|
|
+ const r = Va(o, t)
|
|
|
+ if (0 === r) return 0
|
|
|
+ r < s && (s = r)
|
|
|
+ }
|
|
|
+ return s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const La = new Set([cl, ll, al, ul])
|
|
|
+ function Ba(e, t) {
|
|
|
+ if (14 === e.type && !P(e.callee) && La.has(e.callee)) {
|
|
|
+ const n = e.arguments[0]
|
|
|
+ if (4 === n.type) return Va(n, t)
|
|
|
+ if (14 === n.type) return Ba(n, t)
|
|
|
+ }
|
|
|
+ return 0
|
|
|
+ }
|
|
|
+ function Ua(e, t) {
|
|
|
+ let n = 3
|
|
|
+ const o = Da(e)
|
|
|
+ if (o && 15 === o.type) {
|
|
|
+ const { properties: e } = o
|
|
|
+ for (let o = 0; o < e.length; o++) {
|
|
|
+ const { key: r, value: s } = e[o],
|
|
|
+ i = Va(r, t)
|
|
|
+ if (0 === i) return i
|
|
|
+ let c
|
|
|
+ if (
|
|
|
+ (i < n && (n = i), (c = 4 === s.type ? Va(s, t) : 14 === s.type ? Ba(s, t) : 0), 0 === c)
|
|
|
+ )
|
|
|
+ return c
|
|
|
+ c < n && (n = c)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function Da(e) {
|
|
|
+ const t = e.codegenNode
|
|
|
+ if (13 === t.type) return t.props
|
|
|
+ }
|
|
|
+ function Ha(e) {
|
|
|
+ const t = e.patchFlag
|
|
|
+ return t ? parseInt(t, 10) : void 0
|
|
|
+ }
|
|
|
+ function za(
|
|
|
+ e,
|
|
|
+ {
|
|
|
+ filename: t = '',
|
|
|
+ prefixIdentifiers: n = !1,
|
|
|
+ hoistStatic: o = !1,
|
|
|
+ cacheHandlers: r = !1,
|
|
|
+ nodeTransforms: s = [],
|
|
|
+ directiveTransforms: i = {},
|
|
|
+ transformHoist: c = null,
|
|
|
+ isBuiltInComponent: l = w,
|
|
|
+ isCustomElement: a = w,
|
|
|
+ expressionPlugins: u = [],
|
|
|
+ scopeId: p = null,
|
|
|
+ slotted: d = !0,
|
|
|
+ ssr: f = !1,
|
|
|
+ inSSR: h = !1,
|
|
|
+ ssrCssVars: m = '',
|
|
|
+ bindingMetadata: g = b,
|
|
|
+ inline: y = !1,
|
|
|
+ isTS: v = !1,
|
|
|
+ onError: _ = Mc,
|
|
|
+ onWarn: x = Pc,
|
|
|
+ compatConfig: S
|
|
|
+ }
|
|
|
+ ) {
|
|
|
+ const C = t.replace(/\?.*$/, '').match(/([^/\\]+)\.\w+$/),
|
|
|
+ k = {
|
|
|
+ selfName: C && Z(J(C[1])),
|
|
|
+ prefixIdentifiers: n,
|
|
|
+ hoistStatic: o,
|
|
|
+ cacheHandlers: r,
|
|
|
+ nodeTransforms: s,
|
|
|
+ directiveTransforms: i,
|
|
|
+ transformHoist: c,
|
|
|
+ isBuiltInComponent: l,
|
|
|
+ isCustomElement: a,
|
|
|
+ expressionPlugins: u,
|
|
|
+ scopeId: p,
|
|
|
+ slotted: d,
|
|
|
+ ssr: f,
|
|
|
+ inSSR: h,
|
|
|
+ ssrCssVars: m,
|
|
|
+ bindingMetadata: g,
|
|
|
+ inline: y,
|
|
|
+ isTS: v,
|
|
|
+ onError: _,
|
|
|
+ onWarn: x,
|
|
|
+ compatConfig: S,
|
|
|
+ root: e,
|
|
|
+ helpers: new Map(),
|
|
|
+ components: new Set(),
|
|
|
+ directives: new Set(),
|
|
|
+ hoists: [],
|
|
|
+ imports: [],
|
|
|
+ constantCache: new Map(),
|
|
|
+ temps: 0,
|
|
|
+ cached: 0,
|
|
|
+ identifiers: Object.create(null),
|
|
|
+ scopes: {
|
|
|
+ vFor: 0,
|
|
|
+ vSlot: 0,
|
|
|
+ vPre: 0,
|
|
|
+ vOnce: 0
|
|
|
+ },
|
|
|
+ parent: null,
|
|
|
+ currentNode: e,
|
|
|
+ childIndex: 0,
|
|
|
+ inVOnce: !1,
|
|
|
+ helper(e) {
|
|
|
+ const t = k.helpers.get(e) || 0
|
|
|
+ return k.helpers.set(e, t + 1), e
|
|
|
+ },
|
|
|
+ removeHelper(e) {
|
|
|
+ const t = k.helpers.get(e)
|
|
|
+ if (t) {
|
|
|
+ const n = t - 1
|
|
|
+ n ? k.helpers.set(e, n) : k.helpers.delete(e)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ helperString: (e) => `_${Sl[k.helper(e)]}`,
|
|
|
+ replaceNode(e) {
|
|
|
+ if (!k.currentNode) throw new Error('Node being replaced is already removed.')
|
|
|
+ if (!k.parent) throw new Error('Cannot replace root node.')
|
|
|
+ k.parent.children[k.childIndex] = k.currentNode = e
|
|
|
+ },
|
|
|
+ removeNode(e) {
|
|
|
+ if (!k.parent) throw new Error('Cannot remove root node.')
|
|
|
+ const t = k.parent.children,
|
|
|
+ n = e ? t.indexOf(e) : k.currentNode ? k.childIndex : -1
|
|
|
+ if (n < 0) throw new Error('node being removed is not a child of current parent')
|
|
|
+ e && e !== k.currentNode
|
|
|
+ ? k.childIndex > n && (k.childIndex--, k.onNodeRemoved())
|
|
|
+ : ((k.currentNode = null), k.onNodeRemoved()),
|
|
|
+ k.parent.children.splice(n, 1)
|
|
|
+ },
|
|
|
+ onNodeRemoved: () => {},
|
|
|
+ addIdentifiers(e) {},
|
|
|
+ removeIdentifiers(e) {},
|
|
|
+ hoist(e) {
|
|
|
+ P(e) && (e = Nl(e)), k.hoists.push(e)
|
|
|
+ const t = Nl(`_hoisted_${k.hoists.length}`, !1, e.loc, 2)
|
|
|
+ return (t.hoisted = e), t
|
|
|
+ },
|
|
|
+ cache: (e, t = !1) =>
|
|
|
+ (function (e, t, n = !1) {
|
|
|
+ return {
|
|
|
+ type: 20,
|
|
|
+ index: e,
|
|
|
+ value: t,
|
|
|
+ isVNode: n,
|
|
|
+ loc: Cl
|
|
|
+ }
|
|
|
+ })(k.cached++, e, t)
|
|
|
+ }
|
|
|
+ return k
|
|
|
+ }
|
|
|
+ function Wa(e, t) {
|
|
|
+ const o = za(e, t)
|
|
|
+ Ka(e, o),
|
|
|
+ t.hoistStatic && Pa(e, o),
|
|
|
+ t.ssr ||
|
|
|
+ (function (e, t) {
|
|
|
+ const { helper: o } = t,
|
|
|
+ { children: r } = e
|
|
|
+ if (1 === r.length) {
|
|
|
+ const n = r[0]
|
|
|
+ if (Fa(e, n) && n.codegenNode) {
|
|
|
+ const o = n.codegenNode
|
|
|
+ 13 === o.type && ca(o, t), (e.codegenNode = o)
|
|
|
+ } else e.codegenNode = n
|
|
|
+ } else if (r.length > 1) {
|
|
|
+ let s = 64,
|
|
|
+ i = n[64]
|
|
|
+ 1 === r.filter((e) => 3 !== e.type).length && ((s |= 2048), (i += `, ${n[2048]}`)),
|
|
|
+ (e.codegenNode = kl(
|
|
|
+ t,
|
|
|
+ o(Vc),
|
|
|
+ void 0,
|
|
|
+ e.children,
|
|
|
+ s + ` /* ${i} */`,
|
|
|
+ void 0,
|
|
|
+ void 0,
|
|
|
+ !0,
|
|
|
+ void 0,
|
|
|
+ !1
|
|
|
+ ))
|
|
|
+ }
|
|
|
+ })(e, o),
|
|
|
+ (e.helpers = [...o.helpers.keys()]),
|
|
|
+ (e.components = [...o.components]),
|
|
|
+ (e.directives = [...o.directives]),
|
|
|
+ (e.imports = o.imports),
|
|
|
+ (e.hoists = o.hoists),
|
|
|
+ (e.temps = o.temps),
|
|
|
+ (e.cached = o.cached)
|
|
|
+ }
|
|
|
+ function Ka(e, t) {
|
|
|
+ t.currentNode = e
|
|
|
+ const { nodeTransforms: n } = t,
|
|
|
+ o = []
|
|
|
+ for (let r = 0; r < n.length; r++) {
|
|
|
+ const s = n[r](e, t)
|
|
|
+ if ((s && (O(s) ? o.push(...s) : o.push(s)), !t.currentNode)) return
|
|
|
+ e = t.currentNode
|
|
|
+ }
|
|
|
+ switch (e.type) {
|
|
|
+ case 3:
|
|
|
+ t.ssr || t.helper(Jc)
|
|
|
+ break
|
|
|
+ case 5:
|
|
|
+ t.ssr || t.helper(sl)
|
|
|
+ break
|
|
|
+ case 9:
|
|
|
+ for (let n = 0; n < e.branches.length; n++) Ka(e.branches[n], t)
|
|
|
+ break
|
|
|
+ case 10:
|
|
|
+ case 11:
|
|
|
+ case 1:
|
|
|
+ case 0:
|
|
|
+ !(function (e, t) {
|
|
|
+ let n = 0
|
|
|
+ const o = () => {
|
|
|
+ n--
|
|
|
+ }
|
|
|
+ for (; n < e.children.length; n++) {
|
|
|
+ const r = e.children[n]
|
|
|
+ P(r) || ((t.parent = e), (t.childIndex = n), (t.onNodeRemoved = o), Ka(r, t))
|
|
|
+ }
|
|
|
+ })(e, t)
|
|
|
+ }
|
|
|
+ t.currentNode = e
|
|
|
+ let r = o.length
|
|
|
+ for (; r--; ) o[r]()
|
|
|
+ }
|
|
|
+ function Ga(e, t) {
|
|
|
+ const n = P(e) ? (t) => t === e : (t) => e.test(t)
|
|
|
+ return (e, o) => {
|
|
|
+ if (1 === e.type) {
|
|
|
+ const { props: r } = e
|
|
|
+ if (3 === e.tagType && r.some(Zl)) return
|
|
|
+ const s = []
|
|
|
+ for (let i = 0; i < r.length; i++) {
|
|
|
+ const c = r[i]
|
|
|
+ if (7 === c.type && n(c.name)) {
|
|
|
+ r.splice(i, 1), i--
|
|
|
+ const n = t(e, c, o)
|
|
|
+ n && s.push(n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Ja = '/*#__PURE__*/',
|
|
|
+ qa = (e) => `${Sl[e]}: _${Sl[e]}`
|
|
|
+ function Ya(e, t = {}) {
|
|
|
+ const n = (function (
|
|
|
+ e,
|
|
|
+ {
|
|
|
+ mode: t = 'function',
|
|
|
+ prefixIdentifiers: n = 'module' === t,
|
|
|
+ sourceMap: o = !1,
|
|
|
+ filename: r = 'template.vue.html',
|
|
|
+ scopeId: s = null,
|
|
|
+ optimizeImports: i = !1,
|
|
|
+ runtimeGlobalName: c = 'Vue',
|
|
|
+ runtimeModuleName: l = 'vue',
|
|
|
+ ssrRuntimeModuleName: a = 'vue/server-renderer',
|
|
|
+ ssr: u = !1,
|
|
|
+ isTS: p = !1,
|
|
|
+ inSSR: d = !1
|
|
|
+ }
|
|
|
+ ) {
|
|
|
+ const f = {
|
|
|
+ mode: t,
|
|
|
+ prefixIdentifiers: n,
|
|
|
+ sourceMap: o,
|
|
|
+ filename: r,
|
|
|
+ scopeId: s,
|
|
|
+ optimizeImports: i,
|
|
|
+ runtimeGlobalName: c,
|
|
|
+ runtimeModuleName: l,
|
|
|
+ ssrRuntimeModuleName: a,
|
|
|
+ ssr: u,
|
|
|
+ isTS: p,
|
|
|
+ inSSR: d,
|
|
|
+ source: e.loc.source,
|
|
|
+ code: '',
|
|
|
+ column: 1,
|
|
|
+ line: 1,
|
|
|
+ offset: 0,
|
|
|
+ indentLevel: 0,
|
|
|
+ pure: !1,
|
|
|
+ map: void 0,
|
|
|
+ helper: (e) => `_${Sl[e]}`,
|
|
|
+ push(e, t) {
|
|
|
+ f.code += e
|
|
|
+ },
|
|
|
+ indent() {
|
|
|
+ h(++f.indentLevel)
|
|
|
+ },
|
|
|
+ deindent(e = !1) {
|
|
|
+ e ? --f.indentLevel : h(--f.indentLevel)
|
|
|
+ },
|
|
|
+ newline() {
|
|
|
+ h(f.indentLevel)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function h(e) {
|
|
|
+ f.push('\n' + ' '.repeat(e))
|
|
|
+ }
|
|
|
+ return f
|
|
|
+ })(e, t)
|
|
|
+ t.onContextCreated && t.onContextCreated(n)
|
|
|
+ const {
|
|
|
+ mode: o,
|
|
|
+ push: r,
|
|
|
+ prefixIdentifiers: s,
|
|
|
+ indent: i,
|
|
|
+ deindent: c,
|
|
|
+ newline: l,
|
|
|
+ scopeId: a,
|
|
|
+ ssr: u
|
|
|
+ } = n,
|
|
|
+ p = e.helpers.length > 0,
|
|
|
+ d = !s && 'module' !== o
|
|
|
+ !(function (e, t) {
|
|
|
+ const {
|
|
|
+ ssr: n,
|
|
|
+ prefixIdentifiers: o,
|
|
|
+ push: r,
|
|
|
+ newline: s,
|
|
|
+ runtimeModuleName: i,
|
|
|
+ runtimeGlobalName: c,
|
|
|
+ ssrRuntimeModuleName: l
|
|
|
+ } = t,
|
|
|
+ a = c
|
|
|
+ if (e.helpers.length > 0 && (r(`const _Vue = ${a}\n`), e.hoists.length)) {
|
|
|
+ r(
|
|
|
+ `const { ${[Kc, Gc, Jc, qc, Yc]
|
|
|
+ .filter((t) => e.helpers.includes(t))
|
|
|
+ .map(qa)
|
|
|
+ .join(', ')} } = _Vue\n`
|
|
|
+ )
|
|
|
+ }
|
|
|
+ ;(function (e, t) {
|
|
|
+ if (!e.length) return
|
|
|
+ t.pure = !0
|
|
|
+ const { push: n, newline: o, helper: r, scopeId: s, mode: i } = t
|
|
|
+ o()
|
|
|
+ for (let r = 0; r < e.length; r++) {
|
|
|
+ const s = e[r]
|
|
|
+ s && (n(`const _hoisted_${r + 1} = `), eu(s, t), o())
|
|
|
+ }
|
|
|
+ t.pure = !1
|
|
|
+ })(e.hoists, t),
|
|
|
+ s(),
|
|
|
+ r('return ')
|
|
|
+ })(e, n)
|
|
|
+ if (
|
|
|
+ (r(
|
|
|
+ `function ${u ? 'ssrRender' : 'render'}(${(u
|
|
|
+ ? ['_ctx', '_push', '_parent', '_attrs']
|
|
|
+ : ['_ctx', '_cache']
|
|
|
+ ).join(', ')}) {`
|
|
|
+ ),
|
|
|
+ i(),
|
|
|
+ d &&
|
|
|
+ (r('with (_ctx) {'),
|
|
|
+ i(),
|
|
|
+ p && (r(`const { ${e.helpers.map(qa).join(', ')} } = _Vue`), r('\n'), l())),
|
|
|
+ e.components.length &&
|
|
|
+ (Za(e.components, 'component', n), (e.directives.length || e.temps > 0) && l()),
|
|
|
+ e.directives.length && (Za(e.directives, 'directive', n), e.temps > 0 && l()),
|
|
|
+ e.temps > 0)
|
|
|
+ ) {
|
|
|
+ r('let ')
|
|
|
+ for (let t = 0; t < e.temps; t++) r(`${t > 0 ? ', ' : ''}_temp${t}`)
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ (e.components.length || e.directives.length || e.temps) && (r('\n'), l()),
|
|
|
+ u || r('return '),
|
|
|
+ e.codegenNode ? eu(e.codegenNode, n) : r('null'),
|
|
|
+ d && (c(), r('}')),
|
|
|
+ c(),
|
|
|
+ r('}'),
|
|
|
+ {
|
|
|
+ ast: e,
|
|
|
+ code: n.code,
|
|
|
+ preamble: '',
|
|
|
+ map: n.map ? n.map.toJSON() : void 0
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function Za(e, t, { helper: n, push: o, newline: r, isTS: s }) {
|
|
|
+ const i = n('component' === t ? Zc : Qc)
|
|
|
+ for (let n = 0; n < e.length; n++) {
|
|
|
+ let c = e[n]
|
|
|
+ const l = c.endsWith('__self')
|
|
|
+ l && (c = c.slice(0, -6)),
|
|
|
+ o(`const ${ia(c, t)} = ${i}(${JSON.stringify(c)}${l ? ', true' : ''})${s ? '!' : ''}`),
|
|
|
+ n < e.length - 1 && r()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Xa(e, t) {
|
|
|
+ const n =
|
|
|
+ e.length > 3 ||
|
|
|
+ e.some(
|
|
|
+ (e) =>
|
|
|
+ O(e) ||
|
|
|
+ !(function (e) {
|
|
|
+ return P(e) || 4 === e.type || 2 === e.type || 5 === e.type || 8 === e.type
|
|
|
+ })(e)
|
|
|
+ )
|
|
|
+ t.push('['), n && t.indent(), Qa(e, t, n), n && t.deindent(), t.push(']')
|
|
|
+ }
|
|
|
+ function Qa(e, t, n = !1, o = !0) {
|
|
|
+ const { push: r, newline: s } = t
|
|
|
+ for (let i = 0; i < e.length; i++) {
|
|
|
+ const c = e[i]
|
|
|
+ P(c) ? r(c) : O(c) ? Xa(c, t) : eu(c, t),
|
|
|
+ i < e.length - 1 && (n ? (o && r(','), s()) : o && r(', '))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function eu(e, t) {
|
|
|
+ if (P(e)) t.push(e)
|
|
|
+ else if (F(e)) t.push(t.helper(e))
|
|
|
+ else
|
|
|
+ switch (e.type) {
|
|
|
+ case 1:
|
|
|
+ case 9:
|
|
|
+ case 11:
|
|
|
+ Kl(
|
|
|
+ null != e.codegenNode,
|
|
|
+ 'Codegen node is missing for element/if/for node. Apply appropriate transforms first.'
|
|
|
+ ),
|
|
|
+ eu(e.codegenNode, t)
|
|
|
+ break
|
|
|
+ case 2:
|
|
|
+ !(function (e, t) {
|
|
|
+ t.push(JSON.stringify(e.content), e)
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 4:
|
|
|
+ tu(e, t)
|
|
|
+ break
|
|
|
+ case 5:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, helper: o, pure: r } = t
|
|
|
+ r && n(Ja)
|
|
|
+ n(`${o(sl)}(`), eu(e.content, t), n(')')
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 12:
|
|
|
+ eu(e.codegenNode, t)
|
|
|
+ break
|
|
|
+ case 8:
|
|
|
+ nu(e, t)
|
|
|
+ break
|
|
|
+ case 3:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, helper: o, pure: r } = t
|
|
|
+ r && n(Ja)
|
|
|
+ n(`${o(Jc)}(${JSON.stringify(e.content)})`, e)
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 13:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, helper: o, pure: r } = t,
|
|
|
+ {
|
|
|
+ tag: s,
|
|
|
+ props: i,
|
|
|
+ children: c,
|
|
|
+ patchFlag: l,
|
|
|
+ dynamicProps: a,
|
|
|
+ directives: u,
|
|
|
+ isBlock: p,
|
|
|
+ disableTracking: d,
|
|
|
+ isComponent: f
|
|
|
+ } = e
|
|
|
+ u && n(o(tl) + '(')
|
|
|
+ p && n(`(${o(Hc)}(${d ? 'true' : ''}), `)
|
|
|
+ r && n(Ja)
|
|
|
+ const h = p ? ta(t.inSSR, f) : ea(t.inSSR, f)
|
|
|
+ n(o(h) + '(', e),
|
|
|
+ Qa(
|
|
|
+ (function (e) {
|
|
|
+ let t = e.length
|
|
|
+ for (; t-- && null == e[t]; );
|
|
|
+ return e.slice(0, t + 1).map((e) => e || 'null')
|
|
|
+ })([s, i, c, l, a]),
|
|
|
+ t
|
|
|
+ ),
|
|
|
+ n(')'),
|
|
|
+ p && n(')')
|
|
|
+ u && (n(', '), eu(u, t), n(')'))
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 14:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, helper: o, pure: r } = t,
|
|
|
+ s = P(e.callee) ? e.callee : o(e.callee)
|
|
|
+ r && n(Ja)
|
|
|
+ n(s + '(', e), Qa(e.arguments, t), n(')')
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 15:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, indent: o, deindent: r, newline: s } = t,
|
|
|
+ { properties: i } = e
|
|
|
+ if (!i.length) return void n('{}', e)
|
|
|
+ const c = i.length > 1 || i.some((e) => 4 !== e.value.type)
|
|
|
+ n(c ? '{' : '{ '), c && o()
|
|
|
+ for (let e = 0; e < i.length; e++) {
|
|
|
+ const { key: o, value: r } = i[e]
|
|
|
+ ou(o, t), n(': '), eu(r, t), e < i.length - 1 && (n(','), s())
|
|
|
+ }
|
|
|
+ c && r(), n(c ? '}' : ' }')
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 17:
|
|
|
+ !(function (e, t) {
|
|
|
+ Xa(e.elements, t)
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 18:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, indent: o, deindent: r } = t,
|
|
|
+ { params: s, returns: i, body: c, newline: l, isSlot: a } = e
|
|
|
+ a && n(`_${Sl[vl]}(`)
|
|
|
+ n('(', e), O(s) ? Qa(s, t) : s && eu(s, t)
|
|
|
+ n(') => '), (l || c) && (n('{'), o())
|
|
|
+ i ? (l && n('return '), O(i) ? Xa(i, t) : eu(i, t)) : c && eu(c, t)
|
|
|
+ ;(l || c) && (r(), n('}'))
|
|
|
+ a && n(')')
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 19:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { test: n, consequent: o, alternate: r, newline: s } = e,
|
|
|
+ { push: i, indent: c, deindent: l, newline: a } = t
|
|
|
+ if (4 === n.type) {
|
|
|
+ const e = !Vl(n.content)
|
|
|
+ e && i('('), tu(n, t), e && i(')')
|
|
|
+ } else i('('), eu(n, t), i(')')
|
|
|
+ s && c(),
|
|
|
+ t.indentLevel++,
|
|
|
+ s || i(' '),
|
|
|
+ i('? '),
|
|
|
+ eu(o, t),
|
|
|
+ t.indentLevel--,
|
|
|
+ s && a(),
|
|
|
+ s || i(' '),
|
|
|
+ i(': ')
|
|
|
+ const u = 19 === r.type
|
|
|
+ u || t.indentLevel++
|
|
|
+ eu(r, t), u || t.indentLevel--
|
|
|
+ s && l(!0)
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 20:
|
|
|
+ !(function (e, t) {
|
|
|
+ const { push: n, helper: o, indent: r, deindent: s, newline: i } = t
|
|
|
+ n(`_cache[${e.index}] || (`), e.isVNode && (r(), n(`${o(ml)}(-1),`), i())
|
|
|
+ n(`_cache[${e.index}] = `),
|
|
|
+ eu(e.value, t),
|
|
|
+ e.isVNode && (n(','), i(), n(`${o(ml)}(1),`), i(), n(`_cache[${e.index}]`), s())
|
|
|
+ n(')')
|
|
|
+ })(e, t)
|
|
|
+ break
|
|
|
+ case 21:
|
|
|
+ Qa(e.body, t, !0, !1)
|
|
|
+ break
|
|
|
+ case 22:
|
|
|
+ case 23:
|
|
|
+ case 24:
|
|
|
+ case 25:
|
|
|
+ case 26:
|
|
|
+ case 10:
|
|
|
+ break
|
|
|
+ default:
|
|
|
+ Kl(!1, `unhandled codegen node type: ${e.type}`)
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function tu(e, t) {
|
|
|
+ const { content: n, isStatic: o } = e
|
|
|
+ t.push(o ? JSON.stringify(n) : n, e)
|
|
|
+ }
|
|
|
+ function nu(e, t) {
|
|
|
+ for (let n = 0; n < e.children.length; n++) {
|
|
|
+ const o = e.children[n]
|
|
|
+ P(o) ? t.push(o) : eu(o, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ou(e, t) {
|
|
|
+ const { push: n } = t
|
|
|
+ if (8 === e.type) n('['), nu(e, t), n(']')
|
|
|
+ else if (e.isStatic) {
|
|
|
+ n(Vl(e.content) ? e.content : JSON.stringify(e.content), e)
|
|
|
+ } else n(`[${e.content}]`, e)
|
|
|
+ }
|
|
|
+ const ru = new RegExp(
|
|
|
+ '\\b' +
|
|
|
+ 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments,typeof,void'
|
|
|
+ .split(',')
|
|
|
+ .join('\\b|\\b') +
|
|
|
+ '\\b'
|
|
|
+ ),
|
|
|
+ su =
|
|
|
+ /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
|
|
|
+ function iu(e, t, n = !1, o = !1) {
|
|
|
+ const r = e.content
|
|
|
+ if (r.trim())
|
|
|
+ try {
|
|
|
+ new Function(o ? ` ${r} ` : 'return ' + (n ? `(${r}) => {}` : `(${r})`))
|
|
|
+ } catch (n) {
|
|
|
+ let o = n.message
|
|
|
+ const s = r.replace(su, '').match(ru)
|
|
|
+ s && (o = `avoid using JavaScript keyword as property name: "${s[0]}"`),
|
|
|
+ t.onError(Fc(45, e.loc, void 0, o))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const cu = (e, t) => {
|
|
|
+ if (5 === e.type) e.content = lu(e.content, t)
|
|
|
+ else if (1 === e.type)
|
|
|
+ for (let n = 0; n < e.props.length; n++) {
|
|
|
+ const o = e.props[n]
|
|
|
+ if (7 === o.type && 'for' !== o.name) {
|
|
|
+ const e = o.exp,
|
|
|
+ n = o.arg
|
|
|
+ !e || 4 !== e.type || ('on' === o.name && n) || (o.exp = lu(e, t, 'slot' === o.name)),
|
|
|
+ n && 4 === n.type && !n.isStatic && (o.arg = lu(n, t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function lu(e, t, n = !1, o = !1, r = Object.create(t.identifiers)) {
|
|
|
+ return iu(e, t, n, o), e
|
|
|
+ }
|
|
|
+ const au = Ga(/^(if|else|else-if)$/, (e, t, n) =>
|
|
|
+ (function (e, t, n, o) {
|
|
|
+ if (!('else' === t.name || (t.exp && t.exp.content.trim()))) {
|
|
|
+ const o = t.exp ? t.exp.loc : e.loc
|
|
|
+ n.onError(Fc(28, t.loc)), (t.exp = Nl('true', !1, o))
|
|
|
+ }
|
|
|
+ t.exp && iu(t.exp, n)
|
|
|
+ if ('if' === t.name) {
|
|
|
+ const r = uu(e, t),
|
|
|
+ s = {
|
|
|
+ type: 9,
|
|
|
+ loc: e.loc,
|
|
|
+ branches: [r]
|
|
|
+ }
|
|
|
+ if ((n.replaceNode(s), o)) return o(s, r, !0)
|
|
|
+ } else {
|
|
|
+ const r = n.parent.children,
|
|
|
+ s = []
|
|
|
+ let i = r.indexOf(e)
|
|
|
+ for (; i-- >= -1; ) {
|
|
|
+ const c = r[i]
|
|
|
+ if (c && 3 === c.type) n.removeNode(c), s.unshift(c)
|
|
|
+ else {
|
|
|
+ if (!c || 2 !== c.type || c.content.trim().length) {
|
|
|
+ if (c && 9 === c.type) {
|
|
|
+ 'else-if' === t.name &&
|
|
|
+ void 0 === c.branches[c.branches.length - 1].condition &&
|
|
|
+ n.onError(Fc(30, e.loc)),
|
|
|
+ n.removeNode()
|
|
|
+ const r = uu(e, t)
|
|
|
+ !s.length ||
|
|
|
+ (n.parent && 1 === n.parent.type && Pl(n.parent.tag, 'transition')) ||
|
|
|
+ (r.children = [...s, ...r.children])
|
|
|
+ {
|
|
|
+ const e = r.userKey
|
|
|
+ e &&
|
|
|
+ c.branches.forEach(({ userKey: t }) => {
|
|
|
+ fu(t, e) && n.onError(Fc(29, r.userKey.loc))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ c.branches.push(r)
|
|
|
+ const i = o && o(c, r, !1)
|
|
|
+ Ka(r, n), i && i(), (n.currentNode = null)
|
|
|
+ } else n.onError(Fc(30, e.loc))
|
|
|
+ break
|
|
|
+ }
|
|
|
+ n.removeNode(c)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })(e, t, n, (e, t, o) => {
|
|
|
+ const r = n.parent.children
|
|
|
+ let s = r.indexOf(e),
|
|
|
+ i = 0
|
|
|
+ for (; s-- >= 0; ) {
|
|
|
+ const e = r[s]
|
|
|
+ e && 9 === e.type && (i += e.branches.length)
|
|
|
+ }
|
|
|
+ return () => {
|
|
|
+ if (o) e.codegenNode = pu(t, i, n)
|
|
|
+ else {
|
|
|
+ const o = (function (e) {
|
|
|
+ for (;;)
|
|
|
+ if (19 === e.type) {
|
|
|
+ if (19 !== e.alternate.type) return e
|
|
|
+ e = e.alternate
|
|
|
+ } else 20 === e.type && (e = e.value)
|
|
|
+ })(e.codegenNode)
|
|
|
+ o.alternate = pu(t, i + e.branches.length - 1, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ )
|
|
|
+ function uu(e, t) {
|
|
|
+ const n = 3 === e.tagType
|
|
|
+ return {
|
|
|
+ type: 10,
|
|
|
+ loc: e.loc,
|
|
|
+ condition: 'else' === t.name ? void 0 : t.exp,
|
|
|
+ children: n && !Gl(e, 'for') ? e.children : [e],
|
|
|
+ userKey: Jl(e, 'key'),
|
|
|
+ isTemplateIf: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function pu(e, t, n) {
|
|
|
+ return e.condition
|
|
|
+ ? Rl(e.condition, du(e, t, n), Al(n.helper(Jc), ['"v-if"', 'true']))
|
|
|
+ : du(e, t, n)
|
|
|
+ }
|
|
|
+ function du(e, t, o) {
|
|
|
+ const { helper: r } = o,
|
|
|
+ s = El('key', Nl(`${t}`, !1, Cl, 2)),
|
|
|
+ { children: i } = e,
|
|
|
+ c = i[0]
|
|
|
+ if (1 !== i.length || 1 !== c.type) {
|
|
|
+ if (1 === i.length && 11 === c.type) {
|
|
|
+ const e = c.codegenNode
|
|
|
+ return ra(e, s, o), e
|
|
|
+ }
|
|
|
+ {
|
|
|
+ let t = 64,
|
|
|
+ c = n[64]
|
|
|
+ return (
|
|
|
+ e.isTemplateIf ||
|
|
|
+ 1 !== i.filter((e) => 3 !== e.type).length ||
|
|
|
+ ((t |= 2048), (c += `, ${n[2048]}`)),
|
|
|
+ kl(o, r(Vc), $l([s]), i, t + ` /* ${c} */`, void 0, void 0, !0, !1, !1, e.loc)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ {
|
|
|
+ const e = c.codegenNode,
|
|
|
+ t = 14 === (l = e).type && l.callee === wl ? l.arguments[1].returns : l
|
|
|
+ return 13 === t.type && ca(t, o), ra(t, s, o), e
|
|
|
+ }
|
|
|
+ var l
|
|
|
+ }
|
|
|
+ function fu(e, t) {
|
|
|
+ if (!e || e.type !== t.type) return !1
|
|
|
+ if (6 === e.type) {
|
|
|
+ if (e.value.content !== t.value.content) return !1
|
|
|
+ } else {
|
|
|
+ const n = e.exp,
|
|
|
+ o = t.exp
|
|
|
+ if (n.type !== o.type) return !1
|
|
|
+ if (4 !== n.type || n.isStatic !== o.isStatic || n.content !== o.content) return !1
|
|
|
+ }
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ const hu = Ga('for', (e, t, o) => {
|
|
|
+ const { helper: r, removeHelper: s } = o
|
|
|
+ return (function (e, t, n, o) {
|
|
|
+ if (!t.exp) return void n.onError(Fc(31, t.loc))
|
|
|
+ const r = vu(t.exp, n)
|
|
|
+ if (!r) return void n.onError(Fc(32, t.loc))
|
|
|
+ const { addIdentifiers: s, removeIdentifiers: i, scopes: c } = n,
|
|
|
+ { source: l, value: a, key: u, index: p } = r,
|
|
|
+ d = {
|
|
|
+ type: 11,
|
|
|
+ loc: t.loc,
|
|
|
+ source: l,
|
|
|
+ valueAlias: a,
|
|
|
+ keyAlias: u,
|
|
|
+ objectIndexAlias: p,
|
|
|
+ parseResult: r,
|
|
|
+ children: Xl(e) ? e.children : [e]
|
|
|
+ }
|
|
|
+ n.replaceNode(d), c.vFor++
|
|
|
+ const f = o && o(d)
|
|
|
+ return () => {
|
|
|
+ c.vFor--, f && f()
|
|
|
+ }
|
|
|
+ })(e, t, o, (t) => {
|
|
|
+ const i = Al(r(nl), [t.source]),
|
|
|
+ c = Xl(e),
|
|
|
+ l = Gl(e, 'memo'),
|
|
|
+ a = Jl(e, 'key'),
|
|
|
+ u = a && (6 === a.type ? Nl(a.value.content, !0) : a.exp),
|
|
|
+ p = a ? El('key', u) : null,
|
|
|
+ d = 4 === t.source.type && t.source.constType > 0,
|
|
|
+ f = d ? 64 : a ? 128 : 256
|
|
|
+ return (
|
|
|
+ (t.codegenNode = kl(
|
|
|
+ o,
|
|
|
+ r(Vc),
|
|
|
+ void 0,
|
|
|
+ i,
|
|
|
+ f + ` /* ${n[f]} */`,
|
|
|
+ void 0,
|
|
|
+ void 0,
|
|
|
+ !0,
|
|
|
+ !d,
|
|
|
+ !1,
|
|
|
+ e.loc
|
|
|
+ )),
|
|
|
+ () => {
|
|
|
+ let a
|
|
|
+ const { children: f } = t
|
|
|
+ c &&
|
|
|
+ e.children.some((e) => {
|
|
|
+ if (1 === e.type) {
|
|
|
+ const t = Jl(e, 'key')
|
|
|
+ if (t) return o.onError(Fc(33, t.loc)), !0
|
|
|
+ }
|
|
|
+ })
|
|
|
+ const h = 1 !== f.length || 1 !== f[0].type,
|
|
|
+ m = Ql(e) ? e : c && 1 === e.children.length && Ql(e.children[0]) ? e.children[0] : null
|
|
|
+ if (
|
|
|
+ (m
|
|
|
+ ? ((a = m.codegenNode), c && p && ra(a, p, o))
|
|
|
+ : h
|
|
|
+ ? (a = kl(
|
|
|
+ o,
|
|
|
+ r(Vc),
|
|
|
+ p ? $l([p]) : void 0,
|
|
|
+ e.children,
|
|
|
+ `64 /* ${n[64]} */`,
|
|
|
+ void 0,
|
|
|
+ void 0,
|
|
|
+ !0,
|
|
|
+ void 0,
|
|
|
+ !1
|
|
|
+ ))
|
|
|
+ : ((a = f[0].codegenNode),
|
|
|
+ c && p && ra(a, p, o),
|
|
|
+ a.isBlock !== !d &&
|
|
|
+ (a.isBlock
|
|
|
+ ? (s(Hc), s(ta(o.inSSR, a.isComponent)))
|
|
|
+ : s(ea(o.inSSR, a.isComponent))),
|
|
|
+ (a.isBlock = !d),
|
|
|
+ a.isBlock ? (r(Hc), r(ta(o.inSSR, a.isComponent))) : r(ea(o.inSSR, a.isComponent))),
|
|
|
+ l)
|
|
|
+ ) {
|
|
|
+ const e = Il(_u(t.parseResult, [Nl('_cached')]))
|
|
|
+ ;(e.body = {
|
|
|
+ type: 21,
|
|
|
+ body: [
|
|
|
+ Ol(['const _memo = (', l.exp, ')']),
|
|
|
+ Ol([
|
|
|
+ 'if (_cached',
|
|
|
+ ...(u ? [' && _cached.key === ', u] : []),
|
|
|
+ ` && ${o.helperString(xl)}(_cached, _memo)) return _cached`
|
|
|
+ ]),
|
|
|
+ Ol(['const _item = ', a]),
|
|
|
+ Nl('_item.memo = _memo'),
|
|
|
+ Nl('return _item')
|
|
|
+ ],
|
|
|
+ loc: Cl
|
|
|
+ }),
|
|
|
+ i.arguments.push(e, Nl('_cache'), Nl(String(o.cached++)))
|
|
|
+ } else i.arguments.push(Il(_u(t.parseResult), a, !0))
|
|
|
+ }
|
|
|
+ )
|
|
|
+ })
|
|
|
+ })
|
|
|
+ const mu = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,
|
|
|
+ gu = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/,
|
|
|
+ yu = /^\(|\)$/g
|
|
|
+ function vu(e, t) {
|
|
|
+ const n = e.loc,
|
|
|
+ o = e.content,
|
|
|
+ r = o.match(mu)
|
|
|
+ if (!r) return
|
|
|
+ const [, s, i] = r,
|
|
|
+ c = {
|
|
|
+ source: bu(n, i.trim(), o.indexOf(i, s.length)),
|
|
|
+ value: void 0,
|
|
|
+ key: void 0,
|
|
|
+ index: void 0
|
|
|
+ }
|
|
|
+ iu(c.source, t)
|
|
|
+ let l = s.trim().replace(yu, '').trim()
|
|
|
+ const a = s.indexOf(l),
|
|
|
+ u = l.match(gu)
|
|
|
+ if (u) {
|
|
|
+ l = l.replace(gu, '').trim()
|
|
|
+ const e = u[1].trim()
|
|
|
+ let r
|
|
|
+ if (
|
|
|
+ (e && ((r = o.indexOf(e, a + l.length)), (c.key = bu(n, e, r)), iu(c.key, t, !0)), u[2])
|
|
|
+ ) {
|
|
|
+ const s = u[2].trim()
|
|
|
+ s &&
|
|
|
+ ((c.index = bu(n, s, o.indexOf(s, c.key ? r + e.length : a + l.length))),
|
|
|
+ iu(c.index, t, !0))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return l && ((c.value = bu(n, l, a)), iu(c.value, t, !0)), c
|
|
|
+ }
|
|
|
+ function bu(e, t, n) {
|
|
|
+ return Nl(t, !1, Hl(e, n, t.length))
|
|
|
+ }
|
|
|
+ function _u({ value: e, key: t, index: n }, o = []) {
|
|
|
+ return (function (e) {
|
|
|
+ let t = e.length
|
|
|
+ for (; t-- && !e[t]; );
|
|
|
+ return e.slice(0, t + 1).map((e, t) => e || Nl('_'.repeat(t + 1), !1))
|
|
|
+ })([e, t, n, ...o])
|
|
|
+ }
|
|
|
+ const wu = Nl('undefined', !1),
|
|
|
+ xu = (e, t) => {
|
|
|
+ if (1 === e.type && (1 === e.tagType || 3 === e.tagType)) {
|
|
|
+ const n = Gl(e, 'slot')
|
|
|
+ if (n)
|
|
|
+ return (
|
|
|
+ n.exp,
|
|
|
+ t.scopes.vSlot++,
|
|
|
+ () => {
|
|
|
+ t.scopes.vSlot--
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Su = (e, t, n) => Il(e, t, !1, !0, t.length ? t[0].loc : n)
|
|
|
+ function Cu(e, t, n = Su) {
|
|
|
+ t.helper(vl)
|
|
|
+ const { children: r, loc: s } = e,
|
|
|
+ i = [],
|
|
|
+ c = []
|
|
|
+ let l = t.scopes.vSlot > 0 || t.scopes.vFor > 0
|
|
|
+ const a = Gl(e, 'slot', !0)
|
|
|
+ if (a) {
|
|
|
+ const { arg: e, exp: t } = a
|
|
|
+ e && !Ml(e) && (l = !0), i.push(El(e || Nl('default', !0), n(t, r, s)))
|
|
|
+ }
|
|
|
+ let u = !1,
|
|
|
+ p = !1
|
|
|
+ const d = [],
|
|
|
+ f = new Set()
|
|
|
+ let h = 0
|
|
|
+ for (let e = 0; e < r.length; e++) {
|
|
|
+ const o = r[e]
|
|
|
+ let s
|
|
|
+ if (!Xl(o) || !(s = Gl(o, 'slot', !0))) {
|
|
|
+ 3 !== o.type && d.push(o)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ if (a) {
|
|
|
+ t.onError(Fc(37, s.loc))
|
|
|
+ break
|
|
|
+ }
|
|
|
+ u = !0
|
|
|
+ const { children: m, loc: g } = o,
|
|
|
+ { arg: y = Nl('default', !0), exp: v, loc: b } = s
|
|
|
+ let _
|
|
|
+ Ml(y) ? (_ = y ? y.content : 'default') : (l = !0)
|
|
|
+ const w = n(v, m, g)
|
|
|
+ let x, S, C
|
|
|
+ if ((x = Gl(o, 'if'))) (l = !0), c.push(Rl(x.exp, ku(y, w, h++), wu))
|
|
|
+ else if ((S = Gl(o, /^else(-if)?$/, !0))) {
|
|
|
+ let n,
|
|
|
+ o = e
|
|
|
+ for (; o-- && ((n = r[o]), 3 === n.type); );
|
|
|
+ if (n && Xl(n) && Gl(n, 'if')) {
|
|
|
+ r.splice(e, 1), e--
|
|
|
+ let t = c[c.length - 1]
|
|
|
+ for (; 19 === t.alternate.type; ) t = t.alternate
|
|
|
+ t.alternate = S.exp ? Rl(S.exp, ku(y, w, h++), wu) : ku(y, w, h++)
|
|
|
+ } else t.onError(Fc(30, S.loc))
|
|
|
+ } else if ((C = Gl(o, 'for'))) {
|
|
|
+ l = !0
|
|
|
+ const e = C.parseResult || vu(C.exp, t)
|
|
|
+ e ? c.push(Al(t.helper(nl), [e.source, Il(_u(e), ku(y, w), !0)])) : t.onError(Fc(32, C.loc))
|
|
|
+ } else {
|
|
|
+ if (_) {
|
|
|
+ if (f.has(_)) {
|
|
|
+ t.onError(Fc(38, b))
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ f.add(_), 'default' === _ && (p = !0)
|
|
|
+ }
|
|
|
+ i.push(El(y, w))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!a) {
|
|
|
+ const e = (e, t) => El('default', n(e, t, s))
|
|
|
+ u
|
|
|
+ ? d.length &&
|
|
|
+ d.some((e) => $u(e)) &&
|
|
|
+ (p ? t.onError(Fc(39, d[0].loc)) : i.push(e(void 0, d)))
|
|
|
+ : i.push(e(void 0, r))
|
|
|
+ }
|
|
|
+ const m = l ? 2 : Tu(e.children) ? 3 : 1
|
|
|
+ let g = $l(i.concat(El('_', Nl(m + ` /* ${o[m]} */`, !1))), s)
|
|
|
+ return (
|
|
|
+ c.length && (g = Al(t.helper(rl), [g, Tl(c)])),
|
|
|
+ {
|
|
|
+ slots: g,
|
|
|
+ hasDynamicSlots: l
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ function ku(e, t, n) {
|
|
|
+ const o = [El('name', e), El('fn', t)]
|
|
|
+ return null != n && o.push(El('key', Nl(String(n), !0))), $l(o)
|
|
|
+ }
|
|
|
+ function Tu(e) {
|
|
|
+ for (let t = 0; t < e.length; t++) {
|
|
|
+ const n = e[t]
|
|
|
+ switch (n.type) {
|
|
|
+ case 1:
|
|
|
+ if (2 === n.tagType || Tu(n.children)) return !0
|
|
|
+ break
|
|
|
+ case 9:
|
|
|
+ if (Tu(n.branches)) return !0
|
|
|
+ break
|
|
|
+ case 10:
|
|
|
+ case 11:
|
|
|
+ if (Tu(n.children)) return !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ function $u(e) {
|
|
|
+ return (2 !== e.type && 12 !== e.type) || (2 === e.type ? !!e.content.trim() : $u(e.content))
|
|
|
+ }
|
|
|
+ const Eu = new WeakMap(),
|
|
|
+ Nu = (e, t) =>
|
|
|
+ function () {
|
|
|
+ if (1 !== (e = t.currentNode).type || (0 !== e.tagType && 1 !== e.tagType)) return
|
|
|
+ const { tag: o, props: r } = e,
|
|
|
+ s = 1 === e.tagType
|
|
|
+ let i = s
|
|
|
+ ? (function (e, t, n = !1) {
|
|
|
+ let { tag: o } = e
|
|
|
+ const r = Ru(o),
|
|
|
+ s = Jl(e, 'is')
|
|
|
+ if (s)
|
|
|
+ if (r) {
|
|
|
+ const e = 6 === s.type ? s.value && Nl(s.value.content, !0) : s.exp
|
|
|
+ if (e) return Al(t.helper(Xc), [e])
|
|
|
+ } else
|
|
|
+ 6 === s.type &&
|
|
|
+ s.value.content.startsWith('vue:') &&
|
|
|
+ (o = s.value.content.slice(4))
|
|
|
+ const i = !r && Gl(e, 'is')
|
|
|
+ if (i && i.exp) return Al(t.helper(Xc), [i.exp])
|
|
|
+ const c = Fl(o) || t.isBuiltInComponent(o)
|
|
|
+ if (c) return n || t.helper(c), c
|
|
|
+ return t.helper(Zc), t.components.add(o), ia(o, 'component')
|
|
|
+ })(e, t)
|
|
|
+ : `"${o}"`
|
|
|
+ const c = j(i) && i.callee === Xc
|
|
|
+ let l,
|
|
|
+ a,
|
|
|
+ u,
|
|
|
+ p,
|
|
|
+ d,
|
|
|
+ f,
|
|
|
+ h = 0,
|
|
|
+ m = c || i === Lc || i === Bc || (!s && ('svg' === o || 'foreignObject' === o))
|
|
|
+ if (r.length > 0) {
|
|
|
+ const n = Ou(e, t, void 0, s, c)
|
|
|
+ ;(l = n.props), (h = n.patchFlag), (d = n.dynamicPropNames)
|
|
|
+ const o = n.directives
|
|
|
+ ;(f =
|
|
|
+ o && o.length
|
|
|
+ ? Tl(
|
|
|
+ o.map((e) =>
|
|
|
+ (function (e, t) {
|
|
|
+ const n = [],
|
|
|
+ o = Eu.get(e)
|
|
|
+ o
|
|
|
+ ? n.push(t.helperString(o))
|
|
|
+ : (t.helper(Qc), t.directives.add(e.name), n.push(ia(e.name, 'directive')))
|
|
|
+ const { loc: r } = e
|
|
|
+ e.exp && n.push(e.exp)
|
|
|
+ e.arg && (e.exp || n.push('void 0'), n.push(e.arg))
|
|
|
+ if (Object.keys(e.modifiers).length) {
|
|
|
+ e.arg || (e.exp || n.push('void 0'), n.push('void 0'))
|
|
|
+ const t = Nl('true', !1, r)
|
|
|
+ n.push(
|
|
|
+ $l(
|
|
|
+ e.modifiers.map((e) => El(e, t)),
|
|
|
+ r
|
|
|
+ )
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return Tl(n, e.loc)
|
|
|
+ })(e, t)
|
|
|
+ )
|
|
|
+ )
|
|
|
+ : void 0),
|
|
|
+ n.shouldUseBlock && (m = !0)
|
|
|
+ }
|
|
|
+ if (e.children.length > 0) {
|
|
|
+ i === Uc &&
|
|
|
+ ((m = !0),
|
|
|
+ (h |= 1024),
|
|
|
+ e.children.length > 1 &&
|
|
|
+ t.onError(
|
|
|
+ Fc(46, {
|
|
|
+ start: e.children[0].loc.start,
|
|
|
+ end: e.children[e.children.length - 1].loc.end,
|
|
|
+ source: ''
|
|
|
+ })
|
|
|
+ ))
|
|
|
+ if (s && i !== Lc && i !== Uc) {
|
|
|
+ const { slots: n, hasDynamicSlots: o } = Cu(e, t)
|
|
|
+ ;(a = n), o && (h |= 1024)
|
|
|
+ } else if (1 === e.children.length && i !== Lc) {
|
|
|
+ const n = e.children[0],
|
|
|
+ o = n.type,
|
|
|
+ r = 5 === o || 8 === o
|
|
|
+ r && 0 === Va(n, t) && (h |= 1), (a = r || 2 === o ? n : e.children)
|
|
|
+ } else a = e.children
|
|
|
+ }
|
|
|
+ if (0 !== h) {
|
|
|
+ if (h < 0) u = h + ` /* ${n[h]} */`
|
|
|
+ else {
|
|
|
+ const e = Object.keys(n)
|
|
|
+ .map(Number)
|
|
|
+ .filter((e) => e > 0 && h & e)
|
|
|
+ .map((e) => n[e])
|
|
|
+ .join(', ')
|
|
|
+ u = h + ` /* ${e} */`
|
|
|
+ }
|
|
|
+ d &&
|
|
|
+ d.length &&
|
|
|
+ (p = (function (e) {
|
|
|
+ let t = '['
|
|
|
+ for (let n = 0, o = e.length; n < o; n++)
|
|
|
+ (t += JSON.stringify(e[n])), n < o - 1 && (t += ', ')
|
|
|
+ return t + ']'
|
|
|
+ })(d))
|
|
|
+ }
|
|
|
+ e.codegenNode = kl(t, i, l, a, u, p, f, !!m, !1, s, e.loc)
|
|
|
+ }
|
|
|
+ function Ou(e, t, n = e.props, o, r, s = !1) {
|
|
|
+ const { tag: i, loc: c, children: l } = e
|
|
|
+ let a = []
|
|
|
+ const u = [],
|
|
|
+ p = [],
|
|
|
+ d = l.length > 0
|
|
|
+ let f = !1,
|
|
|
+ h = 0,
|
|
|
+ m = !1,
|
|
|
+ g = !1,
|
|
|
+ y = !1,
|
|
|
+ v = !1,
|
|
|
+ b = !1,
|
|
|
+ _ = !1
|
|
|
+ const w = [],
|
|
|
+ x = (e) => {
|
|
|
+ a.length && (u.push($l(Au(a), c)), (a = [])), e && u.push(e)
|
|
|
+ },
|
|
|
+ S = ({ key: e, value: n }) => {
|
|
|
+ if (Ml(e)) {
|
|
|
+ const s = e.content,
|
|
|
+ i = C(s)
|
|
|
+ if (
|
|
|
+ (!i ||
|
|
|
+ (o && !r) ||
|
|
|
+ 'onclick' === s.toLowerCase() ||
|
|
|
+ 'onUpdate:modelValue' === s ||
|
|
|
+ z(s) ||
|
|
|
+ (v = !0),
|
|
|
+ i && z(s) && (_ = !0),
|
|
|
+ 20 === n.type || ((4 === n.type || 8 === n.type) && Va(n, t) > 0))
|
|
|
+ )
|
|
|
+ return
|
|
|
+ 'ref' === s
|
|
|
+ ? (m = !0)
|
|
|
+ : 'class' === s
|
|
|
+ ? (g = !0)
|
|
|
+ : 'style' === s
|
|
|
+ ? (y = !0)
|
|
|
+ : 'key' === s || w.includes(s) || w.push(s),
|
|
|
+ !o || ('class' !== s && 'style' !== s) || w.includes(s) || w.push(s)
|
|
|
+ } else b = !0
|
|
|
+ }
|
|
|
+ for (let r = 0; r < n.length; r++) {
|
|
|
+ const l = n[r]
|
|
|
+ if (6 === l.type) {
|
|
|
+ const { loc: e, name: n, value: o } = l
|
|
|
+ let r = !0
|
|
|
+ if (
|
|
|
+ ('ref' === n &&
|
|
|
+ ((m = !0), t.scopes.vFor > 0 && a.push(El(Nl('ref_for', !0), Nl('true')))),
|
|
|
+ 'is' === n && (Ru(i) || (o && o.content.startsWith('vue:'))))
|
|
|
+ )
|
|
|
+ continue
|
|
|
+ a.push(El(Nl(n, !0, Hl(e, 0, n.length)), Nl(o ? o.content : '', r, o ? o.loc : e)))
|
|
|
+ } else {
|
|
|
+ const { name: n, arg: r, exp: h, loc: m } = l,
|
|
|
+ g = 'bind' === n,
|
|
|
+ y = 'on' === n
|
|
|
+ if ('slot' === n) {
|
|
|
+ o || t.onError(Fc(40, m))
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ if ('once' === n || 'memo' === n) continue
|
|
|
+ if ('is' === n || (g && ql(r, 'is') && Ru(i))) continue
|
|
|
+ if (y && s) continue
|
|
|
+ if (
|
|
|
+ (((g && ql(r, 'key')) || (y && d && ql(r, 'vue:before-update'))) && (f = !0),
|
|
|
+ g && ql(r, 'ref') && t.scopes.vFor > 0 && a.push(El(Nl('ref_for', !0), Nl('true'))),
|
|
|
+ !r && (g || y))
|
|
|
+ ) {
|
|
|
+ ;(b = !0),
|
|
|
+ h
|
|
|
+ ? g
|
|
|
+ ? (x(), u.push(h))
|
|
|
+ : x({
|
|
|
+ type: 14,
|
|
|
+ loc: m,
|
|
|
+ callee: t.helper(pl),
|
|
|
+ arguments: o ? [h] : [h, 'true']
|
|
|
+ })
|
|
|
+ : t.onError(Fc(g ? 34 : 35, m))
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ const v = t.directiveTransforms[n]
|
|
|
+ if (v) {
|
|
|
+ const { props: n, needRuntime: o } = v(l, e, t)
|
|
|
+ !s && n.forEach(S),
|
|
|
+ y && r && !Ml(r) ? x($l(n, c)) : a.push(...n),
|
|
|
+ o && (p.push(l), F(o) && Eu.set(l, o))
|
|
|
+ } else W(n) || (p.push(l), d && (f = !0))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ let k
|
|
|
+ if (
|
|
|
+ (u.length
|
|
|
+ ? (x(), (k = u.length > 1 ? Al(t.helper(il), u, c) : u[0]))
|
|
|
+ : a.length && (k = $l(Au(a), c)),
|
|
|
+ b
|
|
|
+ ? (h |= 16)
|
|
|
+ : (g && !o && (h |= 2), y && !o && (h |= 4), w.length && (h |= 8), v && (h |= 32)),
|
|
|
+ f || (0 !== h && 32 !== h) || !(m || _ || p.length > 0) || (h |= 512),
|
|
|
+ !t.inSSR && k)
|
|
|
+ )
|
|
|
+ switch (k.type) {
|
|
|
+ case 15:
|
|
|
+ let e = -1,
|
|
|
+ n = -1,
|
|
|
+ o = !1
|
|
|
+ for (let t = 0; t < k.properties.length; t++) {
|
|
|
+ const r = k.properties[t].key
|
|
|
+ Ml(r)
|
|
|
+ ? 'class' === r.content
|
|
|
+ ? (e = t)
|
|
|
+ : 'style' === r.content && (n = t)
|
|
|
+ : r.isHandlerKey || (o = !0)
|
|
|
+ }
|
|
|
+ const r = k.properties[e],
|
|
|
+ s = k.properties[n]
|
|
|
+ o
|
|
|
+ ? (k = Al(t.helper(al), [k]))
|
|
|
+ : (r && !Ml(r.value) && (r.value = Al(t.helper(cl), [r.value])),
|
|
|
+ s &&
|
|
|
+ (y ||
|
|
|
+ (4 === s.value.type && '[' === s.value.content.trim()[0]) ||
|
|
|
+ 17 === s.value.type) &&
|
|
|
+ (s.value = Al(t.helper(ll), [s.value])))
|
|
|
+ break
|
|
|
+ case 14:
|
|
|
+ break
|
|
|
+ default:
|
|
|
+ k = Al(t.helper(al), [Al(t.helper(ul), [k])])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ props: k,
|
|
|
+ directives: p,
|
|
|
+ patchFlag: h,
|
|
|
+ dynamicPropNames: w,
|
|
|
+ shouldUseBlock: f
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Au(e) {
|
|
|
+ const t = new Map(),
|
|
|
+ n = []
|
|
|
+ for (let o = 0; o < e.length; o++) {
|
|
|
+ const r = e[o]
|
|
|
+ if (8 === r.key.type || !r.key.isStatic) {
|
|
|
+ n.push(r)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ const s = r.key.content,
|
|
|
+ i = t.get(s)
|
|
|
+ i ? ('style' === s || 'class' === s || C(s)) && Iu(i, r) : (t.set(s, r), n.push(r))
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function Iu(e, t) {
|
|
|
+ 17 === e.value.type ? e.value.elements.push(t.value) : (e.value = Tl([e.value, t.value], e.loc))
|
|
|
+ }
|
|
|
+ function Ru(e) {
|
|
|
+ return 'component' === e || 'Component' === e
|
|
|
+ }
|
|
|
+ const Mu = (e, t) => {
|
|
|
+ if (Ql(e)) {
|
|
|
+ const { children: n, loc: o } = e,
|
|
|
+ { slotName: r, slotProps: s } = (function (e, t) {
|
|
|
+ let n,
|
|
|
+ o = '"default"'
|
|
|
+ const r = []
|
|
|
+ for (let t = 0; t < e.props.length; t++) {
|
|
|
+ const n = e.props[t]
|
|
|
+ 6 === n.type
|
|
|
+ ? n.value &&
|
|
|
+ ('name' === n.name
|
|
|
+ ? (o = JSON.stringify(n.value.content))
|
|
|
+ : ((n.name = J(n.name)), r.push(n)))
|
|
|
+ : 'bind' === n.name && ql(n.arg, 'name')
|
|
|
+ ? n.exp && (o = n.exp)
|
|
|
+ : ('bind' === n.name && n.arg && Ml(n.arg) && (n.arg.content = J(n.arg.content)),
|
|
|
+ r.push(n))
|
|
|
+ }
|
|
|
+ if (r.length > 0) {
|
|
|
+ const { props: o, directives: s } = Ou(e, t, r, !1, !1)
|
|
|
+ ;(n = o), s.length && t.onError(Fc(36, s[0].loc))
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ slotName: o,
|
|
|
+ slotProps: n
|
|
|
+ }
|
|
|
+ })(e, t),
|
|
|
+ i = [t.prefixIdentifiers ? '_ctx.$slots' : '$slots', r, '{}', 'undefined', 'true']
|
|
|
+ let c = 2
|
|
|
+ s && ((i[2] = s), (c = 3)),
|
|
|
+ n.length && ((i[3] = Il([], n, !1, !1, o)), (c = 4)),
|
|
|
+ t.scopeId && !t.slotted && (c = 5),
|
|
|
+ i.splice(c),
|
|
|
+ (e.codegenNode = Al(t.helper(ol), i, o))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const Pu =
|
|
|
+ /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/,
|
|
|
+ Fu = (e, t, n, o) => {
|
|
|
+ const { loc: r, modifiers: s, arg: i } = e
|
|
|
+ let c
|
|
|
+ if ((e.exp || s.length || n.onError(Fc(35, r)), 4 === i.type))
|
|
|
+ if (i.isStatic) {
|
|
|
+ let e = i.content
|
|
|
+ e.startsWith('vue:') && (e = `vnode-${e.slice(4)}`)
|
|
|
+ c = Nl(
|
|
|
+ 0 !== t.tagType || e.startsWith('vnode') || !/[A-Z]/.test(e) ? X(J(e)) : `on:${e}`,
|
|
|
+ !0,
|
|
|
+ i.loc
|
|
|
+ )
|
|
|
+ } else c = Ol([`${n.helperString(hl)}(`, i, ')'])
|
|
|
+ else (c = i), c.children.unshift(`${n.helperString(hl)}(`), c.children.push(')')
|
|
|
+ let l = e.exp
|
|
|
+ l && !l.content.trim() && (l = void 0)
|
|
|
+ let a = n.cacheHandlers && !l && !n.inVOnce
|
|
|
+ if (l) {
|
|
|
+ const e = Dl(l.content),
|
|
|
+ t = !(e || Pu.test(l.content)),
|
|
|
+ o = l.content.includes(';')
|
|
|
+ iu(l, n, !1, o),
|
|
|
+ (t || (a && e)) &&
|
|
|
+ (l = Ol([`${t ? '$event' : '(...args)'} => ${o ? '{' : '('}`, l, o ? '}' : ')']))
|
|
|
+ }
|
|
|
+ let u = {
|
|
|
+ props: [El(c, l || Nl('() => {}', !1, r))]
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ o && (u = o(u)),
|
|
|
+ a && (u.props[0].value = n.cache(u.props[0].value)),
|
|
|
+ u.props.forEach((e) => (e.key.isHandlerKey = !0)),
|
|
|
+ u
|
|
|
+ )
|
|
|
+ },
|
|
|
+ ju = (e, t, n) => {
|
|
|
+ const { exp: o, modifiers: r, loc: s } = e,
|
|
|
+ i = e.arg
|
|
|
+ return (
|
|
|
+ 4 !== i.type
|
|
|
+ ? (i.children.unshift('('), i.children.push(') || ""'))
|
|
|
+ : i.isStatic || (i.content = `${i.content} || ""`),
|
|
|
+ r.includes('camel') &&
|
|
|
+ (4 === i.type
|
|
|
+ ? i.isStatic
|
|
|
+ ? (i.content = J(i.content))
|
|
|
+ : (i.content = `${n.helperString(dl)}(${i.content})`)
|
|
|
+ : (i.children.unshift(`${n.helperString(dl)}(`), i.children.push(')'))),
|
|
|
+ n.inSSR || (r.includes('prop') && Vu(i, '.'), r.includes('attr') && Vu(i, '^')),
|
|
|
+ !o || (4 === o.type && !o.content.trim())
|
|
|
+ ? (n.onError(Fc(34, s)),
|
|
|
+ {
|
|
|
+ props: [El(i, Nl('', !0, s))]
|
|
|
+ })
|
|
|
+ : {
|
|
|
+ props: [El(i, o)]
|
|
|
+ }
|
|
|
+ )
|
|
|
+ },
|
|
|
+ Vu = (e, t) => {
|
|
|
+ 4 === e.type
|
|
|
+ ? e.isStatic
|
|
|
+ ? (e.content = t + e.content)
|
|
|
+ : (e.content = `\`${t}\${${e.content}}\``)
|
|
|
+ : (e.children.unshift(`'${t}' + (`), e.children.push(')'))
|
|
|
+ },
|
|
|
+ Lu = (e, t) => {
|
|
|
+ if (0 === e.type || 1 === e.type || 11 === e.type || 10 === e.type)
|
|
|
+ return () => {
|
|
|
+ const o = e.children
|
|
|
+ let r,
|
|
|
+ s = !1
|
|
|
+ for (let e = 0; e < o.length; e++) {
|
|
|
+ const t = o[e]
|
|
|
+ if (Yl(t)) {
|
|
|
+ s = !0
|
|
|
+ for (let n = e + 1; n < o.length; n++) {
|
|
|
+ const s = o[n]
|
|
|
+ if (!Yl(s)) {
|
|
|
+ r = void 0
|
|
|
+ break
|
|
|
+ }
|
|
|
+ r || (r = o[e] = Ol([t], t.loc)), r.children.push(' + ', s), o.splice(n, 1), n--
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (
|
|
|
+ s &&
|
|
|
+ (1 !== o.length ||
|
|
|
+ (0 !== e.type &&
|
|
|
+ (1 !== e.type ||
|
|
|
+ 0 !== e.tagType ||
|
|
|
+ e.props.find((e) => 7 === e.type && !t.directiveTransforms[e.name]))))
|
|
|
+ )
|
|
|
+ for (let e = 0; e < o.length; e++) {
|
|
|
+ const r = o[e]
|
|
|
+ if (Yl(r) || 8 === r.type) {
|
|
|
+ const s = []
|
|
|
+ ;(2 === r.type && ' ' === r.content) || s.push(r),
|
|
|
+ t.ssr || 0 !== Va(r, t) || s.push(`1 /* ${n[1]} */`),
|
|
|
+ (o[e] = {
|
|
|
+ type: 12,
|
|
|
+ content: r,
|
|
|
+ loc: r.loc,
|
|
|
+ codegenNode: Al(t.helper(qc), s)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Bu = new WeakSet(),
|
|
|
+ Uu = (e, t) => {
|
|
|
+ if (1 === e.type && Gl(e, 'once', !0)) {
|
|
|
+ if (Bu.has(e) || t.inVOnce) return
|
|
|
+ return (
|
|
|
+ Bu.add(e),
|
|
|
+ (t.inVOnce = !0),
|
|
|
+ t.helper(ml),
|
|
|
+ () => {
|
|
|
+ t.inVOnce = !1
|
|
|
+ const e = t.currentNode
|
|
|
+ e.codegenNode && (e.codegenNode = t.cache(e.codegenNode, !0))
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Du = (e, t, n) => {
|
|
|
+ const { exp: o, arg: r } = e
|
|
|
+ if (!o) return n.onError(Fc(41, e.loc)), Hu()
|
|
|
+ const s = o.loc.source,
|
|
|
+ i = 4 === o.type ? o.content : s,
|
|
|
+ c = n.bindingMetadata[s]
|
|
|
+ if ('props' === c || 'props-aliased' === c) return n.onError(Fc(44, o.loc)), Hu()
|
|
|
+ if (!i.trim() || !Dl(i)) return n.onError(Fc(42, o.loc)), Hu()
|
|
|
+ const l = r || Nl('modelValue', !0),
|
|
|
+ a = r
|
|
|
+ ? Ml(r)
|
|
|
+ ? `onUpdate:${r.content}`
|
|
|
+ : Ol(['"onUpdate:" + ', r])
|
|
|
+ : 'onUpdate:modelValue'
|
|
|
+ let u
|
|
|
+ u = Ol([`${n.isTS ? '($event: any)' : '$event'} => ((`, o, ') = $event)'])
|
|
|
+ const p = [El(l, e.exp), El(a, u)]
|
|
|
+ if (e.modifiers.length && 1 === t.tagType) {
|
|
|
+ const t = e.modifiers.map((e) => (Vl(e) ? e : JSON.stringify(e)) + ': true').join(', '),
|
|
|
+ n = r ? (Ml(r) ? `${r.content}Modifiers` : Ol([r, ' + "Modifiers"'])) : 'modelModifiers'
|
|
|
+ p.push(El(n, Nl(`{ ${t} }`, !1, e.loc, 2)))
|
|
|
+ }
|
|
|
+ return Hu(p)
|
|
|
+ }
|
|
|
+ function Hu(e = []) {
|
|
|
+ return {
|
|
|
+ props: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const zu = new WeakSet(),
|
|
|
+ Wu = (e, t) => {
|
|
|
+ if (1 === e.type) {
|
|
|
+ const n = Gl(e, 'memo')
|
|
|
+ if (!n || zu.has(e)) return
|
|
|
+ return (
|
|
|
+ zu.add(e),
|
|
|
+ () => {
|
|
|
+ const o = e.codegenNode || t.currentNode.codegenNode
|
|
|
+ o &&
|
|
|
+ 13 === o.type &&
|
|
|
+ (1 !== e.tagType && ca(o, t),
|
|
|
+ (e.codegenNode = Al(t.helper(wl), [
|
|
|
+ n.exp,
|
|
|
+ Il(void 0, o),
|
|
|
+ '_cache',
|
|
|
+ String(t.cached++)
|
|
|
+ ])))
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ku(e, t = {}) {
|
|
|
+ const n = t.onError || Mc,
|
|
|
+ o = 'module' === t.mode
|
|
|
+ !0 === t.prefixIdentifiers ? n(Fc(47)) : o && n(Fc(48))
|
|
|
+ t.cacheHandlers && n(Fc(49)), t.scopeId && !o && n(Fc(50))
|
|
|
+ const r = P(e) ? pa(e, t) : e,
|
|
|
+ [s, i] = [
|
|
|
+ [Uu, au, Wu, hu, cu, Mu, Nu, xu, Lu],
|
|
|
+ {
|
|
|
+ on: Fu,
|
|
|
+ bind: ju,
|
|
|
+ model: Du
|
|
|
+ }
|
|
|
+ ]
|
|
|
+ return (
|
|
|
+ Wa(
|
|
|
+ r,
|
|
|
+ T({}, t, {
|
|
|
+ prefixIdentifiers: false,
|
|
|
+ nodeTransforms: [...s, ...(t.nodeTransforms || [])],
|
|
|
+ directiveTransforms: T({}, i, t.directiveTransforms || {})
|
|
|
+ })
|
|
|
+ ),
|
|
|
+ Ya(
|
|
|
+ r,
|
|
|
+ T({}, t, {
|
|
|
+ prefixIdentifiers: false
|
|
|
+ })
|
|
|
+ )
|
|
|
+ )
|
|
|
+ }
|
|
|
+ const Gu = Symbol('vModelRadio'),
|
|
|
+ Ju = Symbol('vModelCheckbox'),
|
|
|
+ qu = Symbol('vModelText'),
|
|
|
+ Yu = Symbol('vModelSelect'),
|
|
|
+ Zu = Symbol('vModelDynamic'),
|
|
|
+ Xu = Symbol('vOnModifiersGuard'),
|
|
|
+ Qu = Symbol('vOnKeysGuard'),
|
|
|
+ ep = Symbol('vShow'),
|
|
|
+ tp = Symbol('Transition'),
|
|
|
+ np = Symbol('TransitionGroup')
|
|
|
+ var op
|
|
|
+ let rp
|
|
|
+ ;(op = {
|
|
|
+ [Gu]: 'vModelRadio',
|
|
|
+ [Ju]: 'vModelCheckbox',
|
|
|
+ [qu]: 'vModelText',
|
|
|
+ [Yu]: 'vModelSelect',
|
|
|
+ [Zu]: 'vModelDynamic',
|
|
|
+ [Xu]: 'withModifiers',
|
|
|
+ [Qu]: 'withKeys',
|
|
|
+ [ep]: 'vShow',
|
|
|
+ [tp]: 'Transition',
|
|
|
+ [np]: 'TransitionGroup'
|
|
|
+ }),
|
|
|
+ Object.getOwnPropertySymbols(op).forEach((e) => {
|
|
|
+ Sl[e] = op[e]
|
|
|
+ })
|
|
|
+ const sp = t('style,iframe,script,noscript', !0),
|
|
|
+ ip = {
|
|
|
+ isVoidTag: f,
|
|
|
+ isNativeTag: (e) => p(e) || d(e),
|
|
|
+ isPreTag: (e) => 'pre' === e,
|
|
|
+ decodeEntities: function (e, t = !1) {
|
|
|
+ return (
|
|
|
+ rp || (rp = document.createElement('div')),
|
|
|
+ t
|
|
|
+ ? ((rp.innerHTML = `<div foo="${e.replace(/"/g, '"')}">`),
|
|
|
+ rp.children[0].getAttribute('foo'))
|
|
|
+ : ((rp.innerHTML = e), rp.textContent)
|
|
|
+ )
|
|
|
+ },
|
|
|
+ isBuiltInComponent: (e) =>
|
|
|
+ Pl(e, 'Transition') ? tp : Pl(e, 'TransitionGroup') ? np : void 0,
|
|
|
+ getNamespace(e, t) {
|
|
|
+ let n = t ? t.ns : 0
|
|
|
+ if (t && 2 === n)
|
|
|
+ if ('annotation-xml' === t.tag) {
|
|
|
+ if ('svg' === e) return 1
|
|
|
+ t.props.some(
|
|
|
+ (e) =>
|
|
|
+ 6 === e.type &&
|
|
|
+ 'encoding' === e.name &&
|
|
|
+ null != e.value &&
|
|
|
+ ('text/html' === e.value.content || 'application/xhtml+xml' === e.value.content)
|
|
|
+ ) && (n = 0)
|
|
|
+ } else /^m(?:[ions]|text)$/.test(t.tag) && 'mglyph' !== e && 'malignmark' !== e && (n = 0)
|
|
|
+ else
|
|
|
+ t &&
|
|
|
+ 1 === n &&
|
|
|
+ (('foreignObject' !== t.tag && 'desc' !== t.tag && 'title' !== t.tag) || (n = 0))
|
|
|
+ if (0 === n) {
|
|
|
+ if ('svg' === e) return 1
|
|
|
+ if ('math' === e) return 2
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ },
|
|
|
+ getTextMode({ tag: e, ns: t }) {
|
|
|
+ if (0 === t) {
|
|
|
+ if ('textarea' === e || 'title' === e) return 1
|
|
|
+ if (sp(e)) return 2
|
|
|
+ }
|
|
|
+ return 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ cp = (e, t) => {
|
|
|
+ const n = a(e)
|
|
|
+ return Nl(JSON.stringify(n), !1, t, 3)
|
|
|
+ }
|
|
|
+ function lp(e, t) {
|
|
|
+ return Fc(e, t, ap)
|
|
|
+ }
|
|
|
+ const ap = {
|
|
|
+ 51: 'v-html is missing expression.',
|
|
|
+ 52: 'v-html will override element children.',
|
|
|
+ 53: 'v-text is missing expression.',
|
|
|
+ 54: 'v-text will override element children.',
|
|
|
+ 55: 'v-model can only be used on <input>, <textarea> and <select> elements.',
|
|
|
+ 56: 'v-model argument is not supported on plain elements.',
|
|
|
+ 57: 'v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.',
|
|
|
+ 58: "Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.",
|
|
|
+ 59: 'v-show is missing expression.',
|
|
|
+ 60: '<Transition> expects exactly one child element or component.',
|
|
|
+ 61: 'Tags with side effect (<script> and <style>) are ignored in client component templates.'
|
|
|
+ },
|
|
|
+ up = t('passive,once,capture'),
|
|
|
+ pp = t('stop,prevent,self,ctrl,shift,alt,meta,exact,middle'),
|
|
|
+ dp = t('left,right'),
|
|
|
+ fp = t('onkeyup,onkeydown,onkeypress', !0),
|
|
|
+ hp = (e, t) =>
|
|
|
+ Ml(e) && 'onclick' === e.content.toLowerCase()
|
|
|
+ ? Nl(t, !0)
|
|
|
+ : 4 !== e.type
|
|
|
+ ? Ol(['(', e, `) === "onClick" ? "${t}" : (`, e, ')'])
|
|
|
+ : e
|
|
|
+ function mp(e) {
|
|
|
+ const t = (e.children = e.children.filter(
|
|
|
+ (e) => 3 !== e.type && !(2 === e.type && !e.content.trim())
|
|
|
+ )),
|
|
|
+ n = t[0]
|
|
|
+ return 1 !== t.length || 11 === n.type || (9 === n.type && n.branches.some(mp))
|
|
|
+ }
|
|
|
+ const gp = (e, t) => {
|
|
|
+ 1 !== e.type ||
|
|
|
+ 0 !== e.tagType ||
|
|
|
+ ('script' !== e.tag && 'style' !== e.tag) ||
|
|
|
+ (t.onError(lp(61, e.loc)), t.removeNode())
|
|
|
+ },
|
|
|
+ yp = [
|
|
|
+ (e) => {
|
|
|
+ 1 === e.type &&
|
|
|
+ e.props.forEach((t, n) => {
|
|
|
+ 6 === t.type &&
|
|
|
+ 'style' === t.name &&
|
|
|
+ t.value &&
|
|
|
+ (e.props[n] = {
|
|
|
+ type: 7,
|
|
|
+ name: 'bind',
|
|
|
+ arg: Nl('style', !0, t.loc),
|
|
|
+ exp: cp(t.value.content, t.loc),
|
|
|
+ modifiers: [],
|
|
|
+ loc: t.loc
|
|
|
+ })
|
|
|
+ })
|
|
|
+ },
|
|
|
+ (e, t) => {
|
|
|
+ if (1 === e.type && 1 === e.tagType) {
|
|
|
+ if (t.isBuiltInComponent(e.tag) === tp)
|
|
|
+ return () => {
|
|
|
+ if (!e.children.length) return
|
|
|
+ mp(e) &&
|
|
|
+ t.onError(
|
|
|
+ lp(60, {
|
|
|
+ start: e.children[0].loc.start,
|
|
|
+ end: e.children[e.children.length - 1].loc.end,
|
|
|
+ source: ''
|
|
|
+ })
|
|
|
+ )
|
|
|
+ const n = e.children[0]
|
|
|
+ if (1 === n.type)
|
|
|
+ for (const t of n.props)
|
|
|
+ 7 === t.type &&
|
|
|
+ 'show' === t.name &&
|
|
|
+ e.props.push({
|
|
|
+ type: 6,
|
|
|
+ name: 'persisted',
|
|
|
+ value: void 0,
|
|
|
+ loc: e.loc
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ],
|
|
|
+ vp = {
|
|
|
+ cloak: () => ({
|
|
|
+ props: []
|
|
|
+ }),
|
|
|
+ html: (e, t, n) => {
|
|
|
+ const { exp: o, loc: r } = e
|
|
|
+ return (
|
|
|
+ o || n.onError(lp(51, r)),
|
|
|
+ t.children.length && (n.onError(lp(52, r)), (t.children.length = 0)),
|
|
|
+ {
|
|
|
+ props: [El(Nl('innerHTML', !0, r), o || Nl('', !0))]
|
|
|
+ }
|
|
|
+ )
|
|
|
+ },
|
|
|
+ text: (e, t, n) => {
|
|
|
+ const { exp: o, loc: r } = e
|
|
|
+ return (
|
|
|
+ o || n.onError(lp(53, r)),
|
|
|
+ t.children.length && (n.onError(lp(54, r)), (t.children.length = 0)),
|
|
|
+ {
|
|
|
+ props: [
|
|
|
+ El(
|
|
|
+ Nl('textContent', !0),
|
|
|
+ o ? (Va(o, n) > 0 ? o : Al(n.helperString(sl), [o], r)) : Nl('', !0)
|
|
|
+ )
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ )
|
|
|
+ },
|
|
|
+ model: (e, t, n) => {
|
|
|
+ const o = Du(e, t, n)
|
|
|
+ if (!o.props.length || 1 === t.tagType) return o
|
|
|
+ function r() {
|
|
|
+ const e = Jl(t, 'value')
|
|
|
+ e && n.onError(lp(58, e.loc))
|
|
|
+ }
|
|
|
+ e.arg && n.onError(lp(56, e.arg.loc))
|
|
|
+ const { tag: s } = t,
|
|
|
+ i = n.isCustomElement(s)
|
|
|
+ if ('input' === s || 'textarea' === s || 'select' === s || i) {
|
|
|
+ let c = qu,
|
|
|
+ l = !1
|
|
|
+ if ('input' === s || i) {
|
|
|
+ const o = Jl(t, 'type')
|
|
|
+ if (o) {
|
|
|
+ if (7 === o.type) c = Zu
|
|
|
+ else if (o.value)
|
|
|
+ switch (o.value.content) {
|
|
|
+ case 'radio':
|
|
|
+ c = Gu
|
|
|
+ break
|
|
|
+ case 'checkbox':
|
|
|
+ c = Ju
|
|
|
+ break
|
|
|
+ case 'file':
|
|
|
+ ;(l = !0), n.onError(lp(57, e.loc))
|
|
|
+ break
|
|
|
+ default:
|
|
|
+ r()
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ !(function (e) {
|
|
|
+ return e.props.some(
|
|
|
+ (e) =>
|
|
|
+ !(
|
|
|
+ 7 !== e.type ||
|
|
|
+ 'bind' !== e.name ||
|
|
|
+ (e.arg && 4 === e.arg.type && e.arg.isStatic)
|
|
|
+ )
|
|
|
+ )
|
|
|
+ })(t)
|
|
|
+ ? r()
|
|
|
+ : (c = Zu)
|
|
|
+ } else 'select' === s ? (c = Yu) : r()
|
|
|
+ l || (o.needRuntime = n.helper(c))
|
|
|
+ } else n.onError(lp(55, e.loc))
|
|
|
+ return (
|
|
|
+ (o.props = o.props.filter((e) => !(4 === e.key.type && 'modelValue' === e.key.content))),
|
|
|
+ o
|
|
|
+ )
|
|
|
+ },
|
|
|
+ on: (e, t, n) =>
|
|
|
+ Fu(e, t, n, (t) => {
|
|
|
+ const { modifiers: o } = e
|
|
|
+ if (!o.length) return t
|
|
|
+ let { key: r, value: s } = t.props[0]
|
|
|
+ const {
|
|
|
+ keyModifiers: i,
|
|
|
+ nonKeyModifiers: c,
|
|
|
+ eventOptionModifiers: l
|
|
|
+ } = ((e, t, n, o) => {
|
|
|
+ const r = [],
|
|
|
+ s = [],
|
|
|
+ i = []
|
|
|
+ for (let n = 0; n < t.length; n++) {
|
|
|
+ const o = t[n]
|
|
|
+ up(o)
|
|
|
+ ? i.push(o)
|
|
|
+ : dp(o)
|
|
|
+ ? Ml(e)
|
|
|
+ ? fp(e.content)
|
|
|
+ ? r.push(o)
|
|
|
+ : s.push(o)
|
|
|
+ : (r.push(o), s.push(o))
|
|
|
+ : pp(o)
|
|
|
+ ? s.push(o)
|
|
|
+ : r.push(o)
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ keyModifiers: r,
|
|
|
+ nonKeyModifiers: s,
|
|
|
+ eventOptionModifiers: i
|
|
|
+ }
|
|
|
+ })(r, o, 0, e.loc)
|
|
|
+ if (
|
|
|
+ (c.includes('right') && (r = hp(r, 'onContextmenu')),
|
|
|
+ c.includes('middle') && (r = hp(r, 'onMouseup')),
|
|
|
+ c.length && (s = Al(n.helper(Xu), [s, JSON.stringify(c)])),
|
|
|
+ !i.length ||
|
|
|
+ (Ml(r) && !fp(r.content)) ||
|
|
|
+ (s = Al(n.helper(Qu), [s, JSON.stringify(i)])),
|
|
|
+ l.length)
|
|
|
+ ) {
|
|
|
+ const e = l.map(Z).join('')
|
|
|
+ r = Ml(r) ? Nl(`${r.content}${e}`, !0) : Ol(['(', r, `) + "${e}"`])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ props: [El(r, s)]
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ show: (e, t, n) => {
|
|
|
+ const { exp: o, loc: r } = e
|
|
|
+ return (
|
|
|
+ o || n.onError(lp(59, r)),
|
|
|
+ {
|
|
|
+ props: [],
|
|
|
+ needRuntime: n.helper(ep)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ console.info(
|
|
|
+ 'You are running a development build of Vue.\nMake sure to use the production build (*.prod.js) when deploying for production.'
|
|
|
+ ),
|
|
|
+ di()
|
|
|
+ const bp = Object.create(null)
|
|
|
+ function _p(e, t) {
|
|
|
+ if (!P(e)) {
|
|
|
+ if (!e.nodeType) return Kt('invalid template option: ', e), w
|
|
|
+ e = e.innerHTML
|
|
|
+ }
|
|
|
+ const n = e,
|
|
|
+ o = bp[n]
|
|
|
+ if (o) return o
|
|
|
+ if ('#' === e[0]) {
|
|
|
+ const t = document.querySelector(e)
|
|
|
+ t || Kt(`Template element not found or is empty: ${e}`), (e = t ? t.innerHTML : '')
|
|
|
+ }
|
|
|
+ const r = T(
|
|
|
+ {
|
|
|
+ hoistStatic: !0,
|
|
|
+ onError: i,
|
|
|
+ onWarn: (e) => i(e, !0)
|
|
|
+ },
|
|
|
+ t
|
|
|
+ )
|
|
|
+ r.isCustomElement ||
|
|
|
+ 'undefined' == typeof customElements ||
|
|
|
+ (r.isCustomElement = (e) => !!customElements.get(e))
|
|
|
+ const { code: s } = (function (e, t = {}) {
|
|
|
+ return Ku(
|
|
|
+ e,
|
|
|
+ T({}, ip, t, {
|
|
|
+ nodeTransforms: [gp, ...yp, ...(t.nodeTransforms || [])],
|
|
|
+ directiveTransforms: T({}, vp, t.directiveTransforms || {}),
|
|
|
+ transformHoist: null
|
|
|
+ })
|
|
|
+ )
|
|
|
+ })(e, r)
|
|
|
+ function i(t, n = !1) {
|
|
|
+ const o = n ? t.message : `Template compilation error: ${t.message}`,
|
|
|
+ r =
|
|
|
+ t.loc &&
|
|
|
+ (function (e, t = 0, n = e.length) {
|
|
|
+ let o = e.split(/(\r?\n)/)
|
|
|
+ const r = o.filter((e, t) => t % 2 == 1)
|
|
|
+ o = o.filter((e, t) => t % 2 == 0)
|
|
|
+ let s = 0
|
|
|
+ const i = []
|
|
|
+ for (let e = 0; e < o.length; e++)
|
|
|
+ if (((s += o[e].length + ((r[e] && r[e].length) || 0)), s >= t)) {
|
|
|
+ for (let c = e - 2; c <= e + 2 || n > s; c++) {
|
|
|
+ if (c < 0 || c >= o.length) continue
|
|
|
+ const l = c + 1
|
|
|
+ i.push(`${l}${' '.repeat(Math.max(3 - String(l).length, 0))}| ${o[c]}`)
|
|
|
+ const a = o[c].length,
|
|
|
+ u = (r[c] && r[c].length) || 0
|
|
|
+ if (c === e) {
|
|
|
+ const e = t - (s - (a + u)),
|
|
|
+ o = Math.max(1, n > s ? a - e : n - t)
|
|
|
+ i.push(' | ' + ' '.repeat(e) + '^'.repeat(o))
|
|
|
+ } else if (c > e) {
|
|
|
+ if (n > s) {
|
|
|
+ const e = Math.max(Math.min(n - s, a), 1)
|
|
|
+ i.push(' | ' + '^'.repeat(e))
|
|
|
+ }
|
|
|
+ s += a + u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break
|
|
|
+ }
|
|
|
+ return i.join('\n')
|
|
|
+ })(e, t.loc.start.offset, t.loc.end.offset)
|
|
|
+ Kt(r ? `${o}\n${r}` : o)
|
|
|
+ }
|
|
|
+ const c = new Function(s)()
|
|
|
+ return (c._rc = !0), (bp[n] = c)
|
|
|
+ }
|
|
|
+ return (
|
|
|
+ Xs(_p),
|
|
|
+ (e.BaseTransition = _o),
|
|
|
+ (e.Comment = ds),
|
|
|
+ (e.EffectScope = ce),
|
|
|
+ (e.Fragment = us),
|
|
|
+ (e.KeepAlive = Ao),
|
|
|
+ (e.ReactiveEffect = ve),
|
|
|
+ (e.Static = fs),
|
|
|
+ (e.Suspense = to),
|
|
|
+ (e.Teleport = ls),
|
|
|
+ (e.Text = ps),
|
|
|
+ (e.Transition = ji),
|
|
|
+ (e.TransitionGroup = tc),
|
|
|
+ (e.VueElement = Ii),
|
|
|
+ (e.callWithAsyncErrorHandling = Zt),
|
|
|
+ (e.callWithErrorHandling = Yt),
|
|
|
+ (e.camelize = J),
|
|
|
+ (e.capitalize = Z),
|
|
|
+ (e.cloneVNode = As),
|
|
|
+ (e.compatUtils = null),
|
|
|
+ (e.compile = _p),
|
|
|
+ (e.computed = ci),
|
|
|
+ (e.createApp = (...e) => {
|
|
|
+ const t = Tc().createApp(...e)
|
|
|
+ Oc(t), Ac(t)
|
|
|
+ const { mount: n } = t
|
|
|
+ return (
|
|
|
+ (t.mount = (e) => {
|
|
|
+ const o = Ic(e)
|
|
|
+ if (!o) return
|
|
|
+ const r = t._component
|
|
|
+ M(r) || r.render || r.template || (r.template = o.innerHTML), (o.innerHTML = '')
|
|
|
+ const s = n(o, !1, o instanceof SVGElement)
|
|
|
+ return (
|
|
|
+ o instanceof Element &&
|
|
|
+ (o.removeAttribute('v-cloak'), o.setAttribute('data-v-app', '')),
|
|
|
+ s
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ (e.createBlock = xs),
|
|
|
+ (e.createCommentVNode = function (e = '', t = !1) {
|
|
|
+ return t ? (gs(), xs(ds, null, e)) : Ns(ds, null, e)
|
|
|
+ }),
|
|
|
+ (e.createElementBlock = function (e, t, n, o, r, s) {
|
|
|
+ return ws(Es(e, t, n, o, r, s, !0))
|
|
|
+ }),
|
|
|
+ (e.createElementVNode = Es),
|
|
|
+ (e.createHydrationRenderer = es),
|
|
|
+ (e.createPropsRestProxy = function (e, t) {
|
|
|
+ const n = {}
|
|
|
+ for (const o in e)
|
|
|
+ t.includes(o) ||
|
|
|
+ Object.defineProperty(n, o, {
|
|
|
+ enumerable: !0,
|
|
|
+ get: () => e[o]
|
|
|
+ })
|
|
|
+ return n
|
|
|
+ }),
|
|
|
+ (e.createRenderer = Qr),
|
|
|
+ (e.createSSRApp = (...e) => {
|
|
|
+ const t = $c().createApp(...e)
|
|
|
+ Oc(t), Ac(t)
|
|
|
+ const { mount: n } = t
|
|
|
+ return (
|
|
|
+ (t.mount = (e) => {
|
|
|
+ const t = Ic(e)
|
|
|
+ if (t) return n(t, !0, t instanceof SVGElement)
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ (e.createSlots = function (e, t) {
|
|
|
+ for (let n = 0; n < t.length; n++) {
|
|
|
+ const o = t[n]
|
|
|
+ if (O(o)) for (let t = 0; t < o.length; t++) e[o[t].name] = o[t].fn
|
|
|
+ else
|
|
|
+ o &&
|
|
|
+ (e[o.name] = o.key
|
|
|
+ ? (...e) => {
|
|
|
+ const t = o.fn(...e)
|
|
|
+ return t && (t.key = o.key), t
|
|
|
+ }
|
|
|
+ : o.fn)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }),
|
|
|
+ (e.createStaticVNode = function (e, t) {
|
|
|
+ const n = Ns(fs, null, e)
|
|
|
+ return (n.staticCount = t), n
|
|
|
+ }),
|
|
|
+ (e.createTextVNode = Rs),
|
|
|
+ (e.createVNode = Ns),
|
|
|
+ (e.customRef = function (e) {
|
|
|
+ return new Vt(e)
|
|
|
+ }),
|
|
|
+ (e.defineAsyncComponent = function (e) {
|
|
|
+ M(e) &&
|
|
|
+ (e = {
|
|
|
+ loader: e
|
|
|
+ })
|
|
|
+ const {
|
|
|
+ loader: t,
|
|
|
+ loadingComponent: n,
|
|
|
+ errorComponent: o,
|
|
|
+ delay: r = 200,
|
|
|
+ timeout: s,
|
|
|
+ suspensible: i = !0,
|
|
|
+ onError: c
|
|
|
+ } = e
|
|
|
+ let l,
|
|
|
+ a = null,
|
|
|
+ u = 0
|
|
|
+ const p = () => {
|
|
|
+ let e
|
|
|
+ return (
|
|
|
+ a ||
|
|
|
+ (e = a =
|
|
|
+ t()
|
|
|
+ .catch((e) => {
|
|
|
+ if (((e = e instanceof Error ? e : new Error(String(e))), c))
|
|
|
+ return new Promise((t, n) => {
|
|
|
+ c(
|
|
|
+ e,
|
|
|
+ () => t((u++, (a = null), p())),
|
|
|
+ () => n(e),
|
|
|
+ u + 1
|
|
|
+ )
|
|
|
+ })
|
|
|
+ throw e
|
|
|
+ })
|
|
|
+ .then((t) => {
|
|
|
+ if (e !== a && a) return a
|
|
|
+ if (
|
|
|
+ (t ||
|
|
|
+ Kt(
|
|
|
+ 'Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.'
|
|
|
+ ),
|
|
|
+ t && (t.__esModule || 'Module' === t[Symbol.toStringTag]) && (t = t.default),
|
|
|
+ t && !j(t) && !M(t))
|
|
|
+ )
|
|
|
+ throw new Error(`Invalid async component load result: ${t}`)
|
|
|
+ return (l = t), t
|
|
|
+ }))
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return $o({
|
|
|
+ name: 'AsyncComponentWrapper',
|
|
|
+ __asyncLoader: p,
|
|
|
+ get __asyncResolved() {
|
|
|
+ return l
|
|
|
+ },
|
|
|
+ setup() {
|
|
|
+ const e = Us
|
|
|
+ if (l) return () => No(l, e)
|
|
|
+ const t = (t) => {
|
|
|
+ ;(a = null), Xt(t, e, 13, !o)
|
|
|
+ }
|
|
|
+ if (i && e.suspense)
|
|
|
+ return p()
|
|
|
+ .then((t) => () => No(t, e))
|
|
|
+ .catch(
|
|
|
+ (e) => (
|
|
|
+ t(e),
|
|
|
+ () =>
|
|
|
+ o
|
|
|
+ ? Ns(o, {
|
|
|
+ error: e
|
|
|
+ })
|
|
|
+ : null
|
|
|
+ )
|
|
|
+ )
|
|
|
+ const c = It(!1),
|
|
|
+ u = It(),
|
|
|
+ d = It(!!r)
|
|
|
+ return (
|
|
|
+ r &&
|
|
|
+ setTimeout(() => {
|
|
|
+ d.value = !1
|
|
|
+ }, r),
|
|
|
+ null != s &&
|
|
|
+ setTimeout(() => {
|
|
|
+ if (!c.value && !u.value) {
|
|
|
+ const e = new Error(`Async component timed out after ${s}ms.`)
|
|
|
+ t(e), (u.value = e)
|
|
|
+ }
|
|
|
+ }, s),
|
|
|
+ p()
|
|
|
+ .then(() => {
|
|
|
+ ;(c.value = !0), e.parent && Oo(e.parent.vnode) && un(e.parent.update)
|
|
|
+ })
|
|
|
+ .catch((e) => {
|
|
|
+ t(e), (u.value = e)
|
|
|
+ }),
|
|
|
+ () =>
|
|
|
+ c.value && l
|
|
|
+ ? No(l, e)
|
|
|
+ : u.value && o
|
|
|
+ ? Ns(o, {
|
|
|
+ error: u.value
|
|
|
+ })
|
|
|
+ : n && !d.value
|
|
|
+ ? Ns(n)
|
|
|
+ : void 0
|
|
|
+ )
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ (e.defineComponent = $o),
|
|
|
+ (e.defineCustomElement = Oi),
|
|
|
+ (e.defineEmits = function () {
|
|
|
+ return li('defineEmits'), null
|
|
|
+ }),
|
|
|
+ (e.defineExpose = function (e) {
|
|
|
+ li('defineExpose')
|
|
|
+ }),
|
|
|
+ (e.defineProps = function () {
|
|
|
+ return li('defineProps'), null
|
|
|
+ }),
|
|
|
+ (e.defineSSRCustomElement = (e) => Oi(e, Nc)),
|
|
|
+ (e.effect = function (e, t) {
|
|
|
+ e.effect && (e = e.effect.fn)
|
|
|
+ const n = new ve(e)
|
|
|
+ t && (T(n, t), t.scope && le(n, t.scope)), (t && t.lazy) || n.run()
|
|
|
+ const o = n.run.bind(n)
|
|
|
+ return (o.effect = n), o
|
|
|
+ }),
|
|
|
+ (e.effectScope = function (e) {
|
|
|
+ return new ce(e)
|
|
|
+ }),
|
|
|
+ (e.getCurrentInstance = Ds),
|
|
|
+ (e.getCurrentScope = function () {
|
|
|
+ return ie
|
|
|
+ }),
|
|
|
+ (e.getTransitionRawChildren = To),
|
|
|
+ (e.guardReactiveProps = Os),
|
|
|
+ (e.h = ui),
|
|
|
+ (e.handleError = Xt),
|
|
|
+ (e.hydrate = Nc),
|
|
|
+ (e.initCustomFormatter = di),
|
|
|
+ (e.initDirectivesForSSR = Rc),
|
|
|
+ (e.inject = ao),
|
|
|
+ (e.isMemoSame = fi),
|
|
|
+ (e.isProxy = Ct),
|
|
|
+ (e.isReactive = wt),
|
|
|
+ (e.isReadonly = xt),
|
|
|
+ (e.isRef = At),
|
|
|
+ (e.isRuntimeOnly = Qs),
|
|
|
+ (e.isShallow = St),
|
|
|
+ (e.isVNode = Ss),
|
|
|
+ (e.markRaw = Tt),
|
|
|
+ (e.mergeDefaults = function (e, t) {
|
|
|
+ const n = O(e) ? e.reduce((e, t) => ((e[t] = {}), e), {}) : e
|
|
|
+ for (const e in t) {
|
|
|
+ const o = n[e]
|
|
|
+ o
|
|
|
+ ? O(o) || M(o)
|
|
|
+ ? (n[e] = {
|
|
|
+ type: o,
|
|
|
+ default: t[e]
|
|
|
+ })
|
|
|
+ : (o.default = t[e])
|
|
|
+ : null === o
|
|
|
+ ? (n[e] = {
|
|
|
+ default: t[e]
|
|
|
+ })
|
|
|
+ : Kt(`props default key "${e}" has no corresponding declaration.`)
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }),
|
|
|
+ (e.mergeProps = js),
|
|
|
+ (e.nextTick = an),
|
|
|
+ (e.normalizeClass = u),
|
|
|
+ (e.normalizeProps = function (e) {
|
|
|
+ if (!e) return null
|
|
|
+ let { class: t, style: n } = e
|
|
|
+ return t && !P(t) && (e.class = u(t)), n && (e.style = s(n)), e
|
|
|
+ }),
|
|
|
+ (e.normalizeStyle = s),
|
|
|
+ (e.onActivated = Ro),
|
|
|
+ (e.onBeforeMount = Uo),
|
|
|
+ (e.onBeforeUnmount = Wo),
|
|
|
+ (e.onBeforeUpdate = Ho),
|
|
|
+ (e.onDeactivated = Mo),
|
|
|
+ (e.onErrorCaptured = Yo),
|
|
|
+ (e.onMounted = Do),
|
|
|
+ (e.onRenderTracked = qo),
|
|
|
+ (e.onRenderTriggered = Jo),
|
|
|
+ (e.onScopeDispose = function (e) {
|
|
|
+ ie
|
|
|
+ ? ie.cleanups.push(e)
|
|
|
+ : se(
|
|
|
+ 'onScopeDispose() is called when there is no active effect scope to be associated with.'
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ (e.onServerPrefetch = Go),
|
|
|
+ (e.onUnmounted = Ko),
|
|
|
+ (e.onUpdated = zo),
|
|
|
+ (e.openBlock = gs),
|
|
|
+ (e.popScopeId = function () {
|
|
|
+ Un = null
|
|
|
+ }),
|
|
|
+ (e.provide = lo),
|
|
|
+ (e.proxyRefs = jt),
|
|
|
+ (e.pushScopeId = function (e) {
|
|
|
+ Un = e
|
|
|
+ }),
|
|
|
+ (e.queuePostFlushCb = dn),
|
|
|
+ (e.reactive = gt),
|
|
|
+ (e.readonly = vt),
|
|
|
+ (e.ref = It),
|
|
|
+ (e.registerRuntimeCompiler = Xs),
|
|
|
+ (e.render = Ec),
|
|
|
+ (e.renderList = function (e, t, n, o) {
|
|
|
+ let r
|
|
|
+ const s = n && n[o]
|
|
|
+ if (O(e) || P(e)) {
|
|
|
+ r = new Array(e.length)
|
|
|
+ for (let n = 0, o = e.length; n < o; n++) r[n] = t(e[n], n, void 0, s && s[n])
|
|
|
+ } else if ('number' == typeof e) {
|
|
|
+ Number.isInteger(e) || Kt(`The v-for range expect an integer value but got ${e}.`),
|
|
|
+ (r = new Array(e))
|
|
|
+ for (let n = 0; n < e; n++) r[n] = t(n + 1, n, void 0, s && s[n])
|
|
|
+ } else if (j(e))
|
|
|
+ if (e[Symbol.iterator]) r = Array.from(e, (e, n) => t(e, n, void 0, s && s[n]))
|
|
|
+ else {
|
|
|
+ const n = Object.keys(e)
|
|
|
+ r = new Array(n.length)
|
|
|
+ for (let o = 0, i = n.length; o < i; o++) {
|
|
|
+ const i = n[o]
|
|
|
+ r[o] = t(e[i], i, o, s && s[o])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else r = []
|
|
|
+ return n && (n[o] = r), r
|
|
|
+ }),
|
|
|
+ (e.renderSlot = function (e, t, n = {}, o, r) {
|
|
|
+ if (Bn.isCE || (Bn.parent && Eo(Bn.parent) && Bn.parent.isCE))
|
|
|
+ return 'default' !== t && (n.name = t), Ns('slot', n, o && o())
|
|
|
+ let s = e[t]
|
|
|
+ s &&
|
|
|
+ s.length > 1 &&
|
|
|
+ (Kt(
|
|
|
+ 'SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.'
|
|
|
+ ),
|
|
|
+ (s = () => [])),
|
|
|
+ s && s._c && (s._d = !1),
|
|
|
+ gs()
|
|
|
+ const i = s && or(s(n)),
|
|
|
+ c = xs(
|
|
|
+ us,
|
|
|
+ {
|
|
|
+ key: n.key || (i && i.key) || `_${t}`
|
|
|
+ },
|
|
|
+ i || (o ? o() : []),
|
|
|
+ i && 1 === e._ ? 64 : -2
|
|
|
+ )
|
|
|
+ return !r && c.scopeId && (c.slotScopeIds = [c.scopeId + '-s']), s && s._c && (s._d = !0), c
|
|
|
+ }),
|
|
|
+ (e.resolveComponent = function (e, t) {
|
|
|
+ return tr(Qo, e, !0, t) || e
|
|
|
+ }),
|
|
|
+ (e.resolveDirective = function (e) {
|
|
|
+ return tr('directives', e)
|
|
|
+ }),
|
|
|
+ (e.resolveDynamicComponent = function (e) {
|
|
|
+ return P(e) ? tr(Qo, e, !1) || e : e || er
|
|
|
+ }),
|
|
|
+ (e.resolveFilter = null),
|
|
|
+ (e.resolveTransitionHooks = xo),
|
|
|
+ (e.setBlockTracking = _s),
|
|
|
+ (e.setDevtoolsHook = Nn),
|
|
|
+ (e.setTransitionHooks = ko),
|
|
|
+ (e.shallowReactive = yt),
|
|
|
+ (e.shallowReadonly = bt),
|
|
|
+ (e.shallowRef = function (e) {
|
|
|
+ return Rt(e, !0)
|
|
|
+ }),
|
|
|
+ (e.ssrContextKey = pi),
|
|
|
+ (e.ssrUtils = null),
|
|
|
+ (e.stop = function (e) {
|
|
|
+ e.effect.stop()
|
|
|
+ }),
|
|
|
+ (e.toDisplayString = (e) =>
|
|
|
+ P(e)
|
|
|
+ ? e
|
|
|
+ : null == e
|
|
|
+ ? ''
|
|
|
+ : O(e) || (j(e) && (e.toString === L || !M(e.toString)))
|
|
|
+ ? JSON.stringify(e, v, 2)
|
|
|
+ : String(e)),
|
|
|
+ (e.toHandlerKey = X),
|
|
|
+ (e.toHandlers = function (e, t) {
|
|
|
+ const n = {}
|
|
|
+ if (!j(e)) return Kt('v-on with no argument expects an object value.'), n
|
|
|
+ for (const o in e) n[t && /[A-Z]/.test(o) ? `on:${o}` : X(o)] = e[o]
|
|
|
+ return n
|
|
|
+ }),
|
|
|
+ (e.toRaw = kt),
|
|
|
+ (e.toRef = Bt),
|
|
|
+ (e.toRefs = function (e) {
|
|
|
+ Ct(e) || console.warn('toRefs() expects a reactive object but received a plain one.')
|
|
|
+ const t = O(e) ? new Array(e.length) : {}
|
|
|
+ for (const n in e) t[n] = Bt(e, n)
|
|
|
+ return t
|
|
|
+ }),
|
|
|
+ (e.transformVNodeArgs = function (e) {
|
|
|
+ vs = e
|
|
|
+ }),
|
|
|
+ (e.triggerRef = function (e) {
|
|
|
+ Ot(e, e.value)
|
|
|
+ }),
|
|
|
+ (e.unref = Pt),
|
|
|
+ (e.useAttrs = function () {
|
|
|
+ return ai().attrs
|
|
|
+ }),
|
|
|
+ (e.useCssModule = function (e = '$style') {
|
|
|
+ return Kt('useCssModule() is not supported in the global build.'), b
|
|
|
+ }),
|
|
|
+ (e.useCssVars = function (e) {
|
|
|
+ const t = Ds()
|
|
|
+ if (!t) return void Kt('useCssVars is called without current active component instance.')
|
|
|
+ const n = (t.ut = (n = e(t.proxy)) => {
|
|
|
+ Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach((e) =>
|
|
|
+ Mi(e, n)
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ o = () => {
|
|
|
+ const o = e(t.proxy)
|
|
|
+ Ri(t.subTree, o), n(o)
|
|
|
+ }
|
|
|
+ uo(o),
|
|
|
+ Do(() => {
|
|
|
+ const e = new MutationObserver(o)
|
|
|
+ e.observe(t.subTree.el.parentNode, {
|
|
|
+ childList: !0
|
|
|
+ }),
|
|
|
+ Ko(() => e.disconnect())
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ (e.useSSRContext = () => {
|
|
|
+ Kt('useSSRContext() is not supported in the global build.')
|
|
|
+ }),
|
|
|
+ (e.useSlots = function () {
|
|
|
+ return ai().slots
|
|
|
+ }),
|
|
|
+ (e.useTransitionState = vo),
|
|
|
+ (e.vModelCheckbox = ac),
|
|
|
+ (e.vModelDynamic = gc),
|
|
|
+ (e.vModelRadio = pc),
|
|
|
+ (e.vModelSelect = dc),
|
|
|
+ (e.vModelText = lc),
|
|
|
+ (e.vShow = wc),
|
|
|
+ (e.version = hi),
|
|
|
+ (e.warn = Kt),
|
|
|
+ (e.watch = fo),
|
|
|
+ (e.watchEffect = function (e, t) {
|
|
|
+ return ho(e, null, t)
|
|
|
+ }),
|
|
|
+ (e.watchPostEffect = uo),
|
|
|
+ (e.watchSyncEffect = function (e, t) {
|
|
|
+ return ho(
|
|
|
+ e,
|
|
|
+ null,
|
|
|
+ Object.assign(Object.assign({}, t), {
|
|
|
+ flush: 'sync'
|
|
|
+ })
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ (e.withAsyncContext = function (e) {
|
|
|
+ const t = Ds()
|
|
|
+ t || Kt('withAsyncContext called without active current instance. This is likely a bug.')
|
|
|
+ let n = e()
|
|
|
+ return (
|
|
|
+ zs(),
|
|
|
+ V(n) &&
|
|
|
+ (n = n.catch((e) => {
|
|
|
+ throw (Hs(t), e)
|
|
|
+ })),
|
|
|
+ [n, () => Hs(t)]
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ (e.withCtx = Hn),
|
|
|
+ (e.withDefaults = function (e, t) {
|
|
|
+ return li('withDefaults'), null
|
|
|
+ }),
|
|
|
+ (e.withDirectives = function (e, t) {
|
|
|
+ const n = Bn
|
|
|
+ if (null === n) return Kt('withDirectives can only be used inside render functions.'), e
|
|
|
+ const o = ni(n) || n.proxy,
|
|
|
+ r = e.dirs || (e.dirs = [])
|
|
|
+ for (let e = 0; e < t.length; e++) {
|
|
|
+ let [n, s, i, c = b] = t[e]
|
|
|
+ n &&
|
|
|
+ (M(n) &&
|
|
|
+ (n = {
|
|
|
+ mounted: n,
|
|
|
+ updated: n
|
|
|
+ }),
|
|
|
+ n.deep && yo(s),
|
|
|
+ r.push({
|
|
|
+ dir: n,
|
|
|
+ instance: o,
|
|
|
+ value: s,
|
|
|
+ oldValue: void 0,
|
|
|
+ arg: i,
|
|
|
+ modifiers: c
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }),
|
|
|
+ (e.withKeys = (e, t) => (n) => {
|
|
|
+ if (!('key' in n)) return
|
|
|
+ const o = Y(n.key)
|
|
|
+ return t.some((e) => e === o || _c[e] === o) ? e(n) : void 0
|
|
|
+ }),
|
|
|
+ (e.withMemo = function (e, t, n, o) {
|
|
|
+ const r = n[o]
|
|
|
+ if (r && fi(r, e)) return r
|
|
|
+ const s = t()
|
|
|
+ return (s.memo = e.slice()), (n[o] = s)
|
|
|
+ }),
|
|
|
+ (e.withModifiers =
|
|
|
+ (e, t) =>
|
|
|
+ (n, ...o) => {
|
|
|
+ for (let e = 0; e < t.length; e++) {
|
|
|
+ const o = bc[t[e]]
|
|
|
+ if (o && o(n, t)) return
|
|
|
+ }
|
|
|
+ return e(n, ...o)
|
|
|
+ }),
|
|
|
+ (e.withScopeId = (e) => Hn),
|
|
|
+ Object.defineProperty(e, '__esModule', {
|
|
|
+ value: !0
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ )
|
|
|
+})({})
|
|
|
+//# sourceMappingURL=/sm/1edd312f49c8475fe9bc2a5e5b45ea0cd371cb0508566390840340f473ac1ff0.map
|
