diff --git a/bundle/lux.dist.mjs b/bundle/lux.dist.mjs index 3a0c3f55..14dc8378 100644 --- a/bundle/lux.dist.mjs +++ b/bundle/lux.dist.mjs @@ -1,805 +1,432 @@ -var __defProp = Object.defineProperty; -var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; -var __publicField = (obj, key, value) => { - __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); - return value; -}; -function _mergeNamespaces(n, m) { - for (var i = 0; i < m.length; i++) { - const e = m[i]; - if (typeof e !== "string" && !Array.isArray(e)) { - for (const k in e) { - if (k !== "default" && !(k in n)) { - const d = Object.getOwnPropertyDescriptor(e, k); - if (d) { - Object.defineProperty(n, k, d.get ? d : { - enumerable: true, - get: () => e[k] - }); - } - } - } - } - } - return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" })); -} -function makeMap(str, expectsLowerCase) { - const map2 = /* @__PURE__ */ Object.create(null); - const list = str.split(","); - for (let i = 0; i < list.length; i++) { - map2[list[i]] = true; - } - return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val]; -} -function normalizeStyle(value) { - if (isArray(value)) { - const res = {}; - for (let i = 0; i < value.length; i++) { - const item = value[i]; - const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); - if (normalized) { - for (const key in normalized) { - res[key] = normalized[key]; +var CP = Object.defineProperty; +var IP = (t, e, r) => e in t ? CP(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r; +var ei = (t, e, r) => (IP(t, typeof e != "symbol" ? e + "" : e, r), r); +function PP(t, e) { + for (var r = 0; r < e.length; r++) { + const n = e[r]; + if (typeof n != "string" && !Array.isArray(n)) { + for (const i in n) + if (i !== "default" && !(i in t)) { + const l = Object.getOwnPropertyDescriptor(n, i); + l && Object.defineProperty(t, i, l.get ? l : { + enumerable: !0, + get: () => n[i] + }); } - } } - return res; - } else if (isString(value)) { - return value; - } else if (isObject(value)) { - return value; } + return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" })); } -const listDelimiterRE = /;(?![^(]*\))/g; -const propertyDelimiterRE = /:([^]+)/; -const styleCommentRE = /\/\*.*?\*\//gs; -function parseStringStyle(cssText) { - const ret = {}; - cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => { - if (item) { - const tmp = item.split(propertyDelimiterRE); - tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); - } - }); - return ret; +function Hl(t, e) { + const r = /* @__PURE__ */ Object.create(null), n = t.split(","); + for (let i = 0; i < n.length; i++) + r[n[i]] = !0; + return e ? (i) => !!r[i.toLowerCase()] : (i) => !!r[i]; } -function normalizeClass(value) { - let res = ""; - if (isString(value)) { - res = value; - } else if (isArray(value)) { - for (let i = 0; i < value.length; i++) { - const normalized = normalizeClass(value[i]); - if (normalized) { - res += normalized + " "; - } +function Uh(t) { + if (Zt(t)) { + const e = {}; + for (let r = 0; r < t.length; r++) { + const n = t[r], i = Nn(n) ? LP(n) : Uh(n); + if (i) + for (const l in i) + e[l] = i[l]; } - } else if (isObject(value)) { - for (const name in value) { - if (value[name]) { - res += name + " "; - } - } - } - return res.trim(); -} -const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,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"; -const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,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"; -const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS); -const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS); -const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; -const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs); -function includeBooleanAttr(value) { - return !!value || value === ""; -} -const toDisplayString = (val) => { - return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val); -}; -const replacer = (_key, val) => { - if (val && val.__v_isRef) { - return replacer(_key, val.value); - } else if (isMap(val)) { - return { - [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => { - entries[`${key} =>`] = val2; - return entries; - }, {}) - }; - } else if (isSet(val)) { - return { - [`Set(${val.size})`]: [...val.values()] - }; - } else if (isObject(val) && !isArray(val) && !isPlainObject$1(val)) { - return String(val); - } - return val; -}; -const EMPTY_OBJ = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {}; -const EMPTY_ARR = process.env.NODE_ENV !== "production" ? Object.freeze([]) : []; -const NOOP = () => { -}; -const NO = () => false; -const onRE = /^on[^a-z]/; -const isOn = (key) => onRE.test(key); -const isModelListener = (key) => key.startsWith("onUpdate:"); -const extend$4 = Object.assign; -const remove = (arr2, el) => { - const i = arr2.indexOf(el); - if (i > -1) { - arr2.splice(i, 1); - } -}; -const hasOwnProperty$2 = Object.prototype.hasOwnProperty; -const hasOwn = (val, key) => hasOwnProperty$2.call(val, key); -const isArray = Array.isArray; -const isMap = (val) => toTypeString(val) === "[object Map]"; -const isSet = (val) => toTypeString(val) === "[object Set]"; -const isFunction = (val) => typeof val === "function"; -const isString = (val) => typeof val === "string"; -const isSymbol = (val) => typeof val === "symbol"; -const isObject = (val) => val !== null && typeof val === "object"; -const isPromise$1 = (val) => { - return isObject(val) && isFunction(val.then) && isFunction(val.catch); -}; -const objectToString = Object.prototype.toString; -const toTypeString = (value) => objectToString.call(value); -const toRawType = (value) => { - return toTypeString(value).slice(8, -1); -}; -const isPlainObject$1 = (val) => toTypeString(val) === "[object Object]"; -const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; -const isReservedProp = /* @__PURE__ */ makeMap( + return e; + } else { + if (Nn(t)) + return t; + if (rn(t)) + return t; + } +} +const AP = /;(?![^(]*\))/g, OP = /:([^]+)/, RP = /\/\*.*?\*\//gs; +function LP(t) { + const e = {}; + return t.replace(RP, "").split(AP).forEach((r) => { + if (r) { + const n = r.split(OP); + n.length > 1 && (e[n[0].trim()] = n[1].trim()); + } + }), e; +} +function Or(t) { + let e = ""; + if (Nn(t)) + e = t; + else if (Zt(t)) + for (let r = 0; r < t.length; r++) { + const n = Or(t[r]); + n && (e += n + " "); + } + else if (rn(t)) + for (const r in t) + t[r] && (e += r + " "); + return e.trim(); +} +const DP = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,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", kP = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,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", NP = /* @__PURE__ */ Hl(DP), FP = /* @__PURE__ */ Hl(kP), zP = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", BP = /* @__PURE__ */ Hl(zP); +function vT(t) { + return !!t || t === ""; +} +const Vt = (t) => Nn(t) ? t : t == null ? "" : Zt(t) || rn(t) && (t.toString === ET || !ar(t.toString)) ? JSON.stringify(t, xT, 2) : String(t), xT = (t, e) => e && e.__v_isRef ? xT(t, e.value) : Zc(e) ? { + [`Map(${e.size})`]: [...e.entries()].reduce((r, [n, i]) => (r[`${n} =>`] = i, r), {}) +} : wT(e) ? { + [`Set(${e.size})`]: [...e.values()] +} : rn(e) && !Zt(e) && !TT(e) ? String(e) : e, dn = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {}, vh = process.env.NODE_ENV !== "production" ? Object.freeze([]) : [], Ui = () => { +}, bT = () => !1, UP = /^on[^a-z]/, $d = (t) => UP.test(t), vg = (t) => t.startsWith("onUpdate:"), kn = Object.assign, H0 = (t, e) => { + const r = t.indexOf(e); + r > -1 && t.splice(r, 1); +}, $P = Object.prototype.hasOwnProperty, Ar = (t, e) => $P.call(t, e), Zt = Array.isArray, Zc = (t) => py(t) === "[object Map]", wT = (t) => py(t) === "[object Set]", ar = (t) => typeof t == "function", Nn = (t) => typeof t == "string", K0 = (t) => typeof t == "symbol", rn = (t) => t !== null && typeof t == "object", Y0 = (t) => rn(t) && ar(t.then) && ar(t.catch), ET = Object.prototype.toString, py = (t) => ET.call(t), J0 = (t) => py(t).slice(8, -1), TT = (t) => py(t) === "[object Object]", Q0 = (t) => Nn(t) && t !== "NaN" && t[0] !== "-" && "" + parseInt(t, 10) === t, Qm = /* @__PURE__ */ Hl( ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" -); -const isBuiltInDirective = /* @__PURE__ */ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"); -const cacheStringFunction = (fn) => { - const cache2 = /* @__PURE__ */ Object.create(null); - return (str) => { - const hit = cache2[str]; - return hit || (cache2[str] = fn(str)); - }; -}; -const camelizeRE = /-(\w)/g; -const camelize = cacheStringFunction((str) => { - return str.replace(camelizeRE, (_23, c2) => c2 ? c2.toUpperCase() : ""); -}); -const hyphenateRE = /\B([A-Z])/g; -const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); -const capitalize$1 = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); -const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize$1(str)}` : ``); -const hasChanged = (value, oldValue) => !Object.is(value, oldValue); -const invokeArrayFns = (fns, arg) => { - for (let i = 0; i < fns.length; i++) { - fns[i](arg); - } -}; -const def = (obj, key, value) => { - Object.defineProperty(obj, key, { - configurable: true, - enumerable: false, - value +), VP = /* @__PURE__ */ Hl("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"), my = (t) => { + const e = /* @__PURE__ */ Object.create(null); + return (r) => e[r] || (e[r] = t(r)); +}, jP = /-(\w)/g, Go = my((t) => t.replace(jP, (e, r) => r ? r.toUpperCase() : "")), GP = /\B([A-Z])/g, Mo = my((t) => t.replace(GP, "-$1").toLowerCase()), ru = my((t) => t.charAt(0).toUpperCase() + t.slice(1)), Bc = my((t) => t ? `on${ru(t)}` : ""), Td = (t, e) => !Object.is(t, e), Wf = (t, e) => { + for (let r = 0; r < t.length; r++) + t[r](e); +}, xg = (t, e, r) => { + Object.defineProperty(t, e, { + configurable: !0, + enumerable: !1, + value: r }); -}; -const looseToNumber = (val) => { - const n = parseFloat(val); - return isNaN(n) ? val : n; -}; -const toNumber = (val) => { - const n = isString(val) ? Number(val) : NaN; - return isNaN(n) ? val : n; -}; -let _globalThis; -const getGlobalThis = () => { - return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}); -}; -function warn$1(msg, ...args) { - console.warn(`[Vue warn] ${msg}`, ...args); -} -let activeEffectScope; -class EffectScope { - constructor(detached = false) { - this.detached = detached; - this._active = true; - this.effects = []; - this.cleanups = []; - this.parent = activeEffectScope; - if (!detached && activeEffectScope) { - this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; - } +}, qP = (t) => { + const e = parseFloat(t); + return isNaN(e) ? t : e; +}, Wv = (t) => { + const e = Nn(t) ? Number(t) : NaN; + return isNaN(e) ? t : e; +}; +let Eb; +const ST = () => Eb || (Eb = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {}); +function bg(t, ...e) { + console.warn(`[Vue warn] ${t}`, ...e); +} +let Uo; +class MT { + constructor(e = !1) { + this.detached = e, this._active = !0, this.effects = [], this.cleanups = [], this.parent = Uo, !e && Uo && (this.index = (Uo.scopes || (Uo.scopes = [])).push(this) - 1); } get active() { return this._active; } - run(fn) { + run(e) { if (this._active) { - const currentEffectScope = activeEffectScope; + const r = Uo; try { - activeEffectScope = this; - return fn(); + return Uo = this, e(); } finally { - activeEffectScope = currentEffectScope; + Uo = r; } - } else if (process.env.NODE_ENV !== "production") { - warn$1(`cannot run an inactive effect scope.`); - } + } else + process.env.NODE_ENV !== "production" && bg("cannot run an inactive effect scope."); } on() { - activeEffectScope = this; + Uo = this; } off() { - activeEffectScope = this.parent; + Uo = this.parent; } - stop(fromParent) { + stop(e) { if (this._active) { - let i, l; - for (i = 0, l = this.effects.length; i < l; i++) { - this.effects[i].stop(); - } - for (i = 0, l = this.cleanups.length; i < l; i++) { - this.cleanups[i](); - } - if (this.scopes) { - for (i = 0, l = this.scopes.length; i < l; i++) { - this.scopes[i].stop(true); - } - } - if (!this.detached && this.parent && !fromParent) { - const last = this.parent.scopes.pop(); - if (last && last !== this) { - this.parent.scopes[this.index] = last; - last.index = this.index; - } - } - this.parent = void 0; - this._active = false; - } - } -} -function effectScope(detached) { - return new EffectScope(detached); -} -function recordEffectScope(effect, scope = activeEffectScope) { - if (scope && scope.active) { - scope.effects.push(effect); - } -} -function getCurrentScope() { - return activeEffectScope; -} -function onScopeDispose(fn) { - if (activeEffectScope) { - activeEffectScope.cleanups.push(fn); - } else if (process.env.NODE_ENV !== "production") { - warn$1(`onScopeDispose() is called when there is no active effect scope to be associated with.`); - } -} -const createDep = (effects) => { - const dep = new Set(effects); - dep.w = 0; - dep.n = 0; - return dep; -}; -const wasTracked = (dep) => (dep.w & trackOpBit) > 0; -const newTracked = (dep) => (dep.n & trackOpBit) > 0; -const initDepMarkers = ({ deps }) => { - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].w |= trackOpBit; - } - } -}; -const finalizeDepMarkers = (effect) => { - const { deps } = effect; - if (deps.length) { - let ptr = 0; - for (let i = 0; i < deps.length; i++) { - const dep = deps[i]; - if (wasTracked(dep) && !newTracked(dep)) { - dep.delete(effect); - } else { - deps[ptr++] = dep; - } - dep.w &= ~trackOpBit; - dep.n &= ~trackOpBit; - } - deps.length = ptr; - } -}; -const targetMap = /* @__PURE__ */ new WeakMap(); -let effectTrackDepth = 0; -let trackOpBit = 1; -const maxMarkerBits = 30; -let activeEffect; -const ITERATE_KEY = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""); -const MAP_KEY_ITERATE_KEY = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : ""); -class ReactiveEffect { - constructor(fn, scheduler = null, scope) { - this.fn = fn; - this.scheduler = scheduler; - this.active = true; - this.deps = []; - this.parent = void 0; - recordEffectScope(this, scope); + let r, n; + for (r = 0, n = this.effects.length; r < n; r++) + this.effects[r].stop(); + for (r = 0, n = this.cleanups.length; r < n; r++) + this.cleanups[r](); + if (this.scopes) + for (r = 0, n = this.scopes.length; r < n; r++) + this.scopes[r].stop(!0); + if (!this.detached && this.parent && !e) { + const i = this.parent.scopes.pop(); + i && i !== this && (this.parent.scopes[this.index] = i, i.index = this.index); + } + this.parent = void 0, this._active = !1; + } + } +} +function CT(t) { + return new MT(t); +} +function WP(t, e = Uo) { + e && e.active && e.effects.push(t); +} +function IT() { + return Uo; +} +function XP(t) { + Uo ? Uo.cleanups.push(t) : process.env.NODE_ENV !== "production" && bg("onScopeDispose() is called when there is no active effect scope to be associated with."); +} +const Sd = (t) => { + const e = new Set(t); + return e.w = 0, e.n = 0, e; +}, PT = (t) => (t.w & Vl) > 0, AT = (t) => (t.n & Vl) > 0, ZP = ({ deps: t }) => { + if (t.length) + for (let e = 0; e < t.length; e++) + t[e].w |= Vl; +}, HP = (t) => { + const { deps: e } = t; + if (e.length) { + let r = 0; + for (let n = 0; n < e.length; n++) { + const i = e[n]; + PT(i) && !AT(i) ? i.delete(t) : e[r++] = i, i.w &= ~Vl, i.n &= ~Vl; + } + e.length = r; + } +}, wg = /* @__PURE__ */ new WeakMap(); +let Qf = 0, Vl = 1; +const Xv = 30; +let fo; +const Hc = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""), Zv = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : ""); +class ex { + constructor(e, r = null, n) { + this.fn = e, this.scheduler = r, this.active = !0, this.deps = [], this.parent = void 0, WP(this, n); } run() { - if (!this.active) { + if (!this.active) return this.fn(); - } - let parent = activeEffect; - let lastShouldTrack = shouldTrack; - while (parent) { - if (parent === this) { + let e = fo, r = Nl; + for (; e; ) { + if (e === this) return; - } - parent = parent.parent; + e = e.parent; } try { - this.parent = activeEffect; - activeEffect = this; - shouldTrack = true; - trackOpBit = 1 << ++effectTrackDepth; - if (effectTrackDepth <= maxMarkerBits) { - initDepMarkers(this); - } else { - cleanupEffect(this); - } - return this.fn(); + return this.parent = fo, fo = this, Nl = !0, Vl = 1 << ++Qf, Qf <= Xv ? ZP(this) : Tb(this), this.fn(); } finally { - if (effectTrackDepth <= maxMarkerBits) { - finalizeDepMarkers(this); - } - trackOpBit = 1 << --effectTrackDepth; - activeEffect = this.parent; - shouldTrack = lastShouldTrack; - this.parent = void 0; - if (this.deferStop) { - this.stop(); - } + Qf <= Xv && HP(this), Vl = 1 << --Qf, fo = this.parent, Nl = r, this.parent = void 0, this.deferStop && this.stop(); } } stop() { - if (activeEffect === this) { - this.deferStop = true; - } else if (this.active) { - cleanupEffect(this); - if (this.onStop) { - this.onStop(); - } - this.active = false; - } + fo === this ? this.deferStop = !0 : this.active && (Tb(this), this.onStop && this.onStop(), this.active = !1); } } -function cleanupEffect(effect) { - const { deps } = effect; - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } - deps.length = 0; +function Tb(t) { + const { deps: e } = t; + if (e.length) { + for (let r = 0; r < e.length; r++) + e[r].delete(t); + e.length = 0; } } -let shouldTrack = true; -const trackStack = []; -function pauseTracking() { - trackStack.push(shouldTrack); - shouldTrack = false; +let Nl = !0; +const OT = []; +function uu() { + OT.push(Nl), Nl = !1; } -function resetTracking() { - const last = trackStack.pop(); - shouldTrack = last === void 0 ? true : last; +function hu() { + const t = OT.pop(); + Nl = t === void 0 ? !0 : t; } -function track(target, type, key) { - if (shouldTrack && activeEffect) { - let depsMap = targetMap.get(target); - if (!depsMap) { - targetMap.set(target, depsMap = /* @__PURE__ */ new Map()); - } - let dep = depsMap.get(key); - if (!dep) { - depsMap.set(key, dep = createDep()); - } - const eventInfo = process.env.NODE_ENV !== "production" ? { effect: activeEffect, target, type, key } : void 0; - trackEffects(dep, eventInfo); +function mo(t, e, r) { + if (Nl && fo) { + let n = wg.get(t); + n || wg.set(t, n = /* @__PURE__ */ new Map()); + let i = n.get(r); + i || n.set(r, i = Sd()); + const l = process.env.NODE_ENV !== "production" ? { effect: fo, target: t, type: e, key: r } : void 0; + Hv(i, l); } } -function trackEffects(dep, debuggerEventExtraInfo) { - let shouldTrack2 = false; - if (effectTrackDepth <= maxMarkerBits) { - if (!newTracked(dep)) { - dep.n |= trackOpBit; - shouldTrack2 = !wasTracked(dep); - } - } else { - shouldTrack2 = !dep.has(activeEffect); - } - if (shouldTrack2) { - dep.add(activeEffect); - activeEffect.deps.push(dep); - if (process.env.NODE_ENV !== "production" && activeEffect.onTrack) { - activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo)); - } - } +function Hv(t, e) { + let r = !1; + Qf <= Xv ? AT(t) || (t.n |= Vl, r = !PT(t)) : r = !t.has(fo), r && (t.add(fo), fo.deps.push(t), process.env.NODE_ENV !== "production" && fo.onTrack && fo.onTrack(Object.assign({ effect: fo }, e))); } -function trigger(target, type, key, newValue, oldValue, oldTarget) { - const depsMap = targetMap.get(target); - if (!depsMap) { +function Vs(t, e, r, n, i, l) { + const h = wg.get(t); + if (!h) return; - } - let deps = []; - if (type === "clear") { - deps = [...depsMap.values()]; - } else if (key === "length" && isArray(target)) { - const newLength = Number(newValue); - depsMap.forEach((dep, key2) => { - if (key2 === "length" || key2 >= newLength) { - deps.push(dep); - } + let s = []; + if (e === "clear") + s = [...h.values()]; + else if (r === "length" && Zt(t)) { + const v = Number(n); + h.forEach((E, T) => { + (T === "length" || T >= v) && s.push(E); }); - } else { - if (key !== void 0) { - deps.push(depsMap.get(key)); - } - switch (type) { + } else + switch (r !== void 0 && s.push(h.get(r)), e) { case "add": - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } else if (isIntegerKey(key)) { - deps.push(depsMap.get("length")); - } + Zt(t) ? Q0(r) && s.push(h.get("length")) : (s.push(h.get(Hc)), Zc(t) && s.push(h.get(Zv))); break; case "delete": - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } + Zt(t) || (s.push(h.get(Hc)), Zc(t) && s.push(h.get(Zv))); break; case "set": - if (isMap(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - } + Zc(t) && s.push(h.get(Hc)); break; } - } - const eventInfo = process.env.NODE_ENV !== "production" ? { target, type, key, newValue, oldValue, oldTarget } : void 0; - if (deps.length === 1) { - if (deps[0]) { - if (process.env.NODE_ENV !== "production") { - triggerEffects(deps[0], eventInfo); - } else { - triggerEffects(deps[0]); - } - } - } else { - const effects = []; - for (const dep of deps) { - if (dep) { - effects.push(...dep); - } - } - if (process.env.NODE_ENV !== "production") { - triggerEffects(createDep(effects), eventInfo); - } else { - triggerEffects(createDep(effects)); - } - } -} -function triggerEffects(dep, debuggerEventExtraInfo) { - const effects = isArray(dep) ? dep : [...dep]; - for (const effect of effects) { - if (effect.computed) { - triggerEffect(effect, debuggerEventExtraInfo); - } - } - for (const effect of effects) { - if (!effect.computed) { - triggerEffect(effect, debuggerEventExtraInfo); - } - } -} -function triggerEffect(effect, debuggerEventExtraInfo) { - if (effect !== activeEffect || effect.allowRecurse) { - if (process.env.NODE_ENV !== "production" && effect.onTrigger) { - effect.onTrigger(extend$4({ effect }, debuggerEventExtraInfo)); - } - if (effect.scheduler) { - effect.scheduler(); - } else { - effect.run(); - } - } -} -function getDepFromReactive(object, key) { - var _a; - return (_a = targetMap.get(object)) === null || _a === void 0 ? void 0 : _a.get(key); -} -const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); -const builtInSymbols = new Set( - /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol) -); -const get$1$1 = /* @__PURE__ */ createGetter(); -const shallowGet = /* @__PURE__ */ createGetter(false, true); -const readonlyGet = /* @__PURE__ */ createGetter(true); -const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); -const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations(); -function createArrayInstrumentations() { - const instrumentations = {}; - ["includes", "indexOf", "lastIndexOf"].forEach((key) => { - instrumentations[key] = function(...args) { - const arr2 = toRaw(this); - for (let i = 0, l = this.length; i < l; i++) { - track(arr2, "get", i + ""); - } - const res = arr2[key](...args); - if (res === -1 || res === false) { - return arr2[key](...args.map(toRaw)); - } else { - return res; - } + const m = process.env.NODE_ENV !== "production" ? { target: t, type: e, key: r, newValue: n, oldValue: i, oldTarget: l } : void 0; + if (s.length === 1) + s[0] && (process.env.NODE_ENV !== "production" ? ch(s[0], m) : ch(s[0])); + else { + const v = []; + for (const E of s) + E && v.push(...E); + process.env.NODE_ENV !== "production" ? ch(Sd(v), m) : ch(Sd(v)); + } +} +function ch(t, e) { + const r = Zt(t) ? t : [...t]; + for (const n of r) + n.computed && Sb(n, e); + for (const n of r) + n.computed || Sb(n, e); +} +function Sb(t, e) { + (t !== fo || t.allowRecurse) && (process.env.NODE_ENV !== "production" && t.onTrigger && t.onTrigger(kn({ effect: t }, e)), t.scheduler ? t.scheduler() : t.run()); +} +function KP(t, e) { + var r; + return (r = wg.get(t)) === null || r === void 0 ? void 0 : r.get(e); +} +const YP = /* @__PURE__ */ Hl("__proto__,__v_isRef,__isVue"), RT = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((t) => t !== "arguments" && t !== "caller").map((t) => Symbol[t]).filter(K0) +), JP = /* @__PURE__ */ gy(), QP = /* @__PURE__ */ gy(!1, !0), eA = /* @__PURE__ */ gy(!0), tA = /* @__PURE__ */ gy(!0, !0), Mb = /* @__PURE__ */ rA(); +function rA() { + const t = {}; + return ["includes", "indexOf", "lastIndexOf"].forEach((e) => { + t[e] = function(...r) { + const n = ir(this); + for (let l = 0, h = this.length; l < h; l++) + mo(n, "get", l + ""); + const i = n[e](...r); + return i === -1 || i === !1 ? n[e](...r.map(ir)) : i; }; - }); - ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { - instrumentations[key] = function(...args) { - pauseTracking(); - const res = toRaw(this)[key].apply(this, args); - resetTracking(); - return res; + }), ["push", "pop", "shift", "unshift", "splice"].forEach((e) => { + t[e] = function(...r) { + uu(); + const n = ir(this)[e].apply(this, r); + return hu(), n; }; - }); - return instrumentations; -} -function hasOwnProperty$1(key) { - const obj = toRaw(this); - track(obj, "has", key); - return obj.hasOwnProperty(key); -} -function createGetter(isReadonly2 = false, shallow = false) { - return function get2(target, key, receiver) { - if (key === "__v_isReactive") { - return !isReadonly2; - } else if (key === "__v_isReadonly") { - return isReadonly2; - } else if (key === "__v_isShallow") { - return shallow; - } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { - return target; - } - const targetIsArray = isArray(target); - if (!isReadonly2) { - if (targetIsArray && hasOwn(arrayInstrumentations, key)) { - return Reflect.get(arrayInstrumentations, key, receiver); - } - if (key === "hasOwnProperty") { - return hasOwnProperty$1; - } - } - const res = Reflect.get(target, key, receiver); - if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { - return res; - } - if (!isReadonly2) { - track(target, "get", key); - } - if (shallow) { - return res; - } - if (isRef(res)) { - return targetIsArray && isIntegerKey(key) ? res : res.value; - } - if (isObject(res)) { - return isReadonly2 ? readonly(res) : reactive(res); - } - return res; - }; -} -const set$1 = /* @__PURE__ */ createSetter(); -const shallowSet = /* @__PURE__ */ createSetter(true); -function createSetter(shallow = false) { - return function set2(target, key, value, receiver) { - let oldValue = target[key]; - if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) { - return false; - } - if (!shallow) { - if (!isShallow$1(value) && !isReadonly(value)) { - oldValue = toRaw(oldValue); - value = toRaw(value); - } - if (!isArray(target) && isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } - } - const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); - const result = Reflect.set(target, key, value, receiver); - if (target === toRaw(receiver)) { - if (!hadKey) { - trigger(target, "add", key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set", key, value, oldValue); - } - } - return result; - }; -} -function deleteProperty(target, key) { - const hadKey = hasOwn(target, key); - const oldValue = target[key]; - const result = Reflect.deleteProperty(target, key); - if (result && hadKey) { - trigger(target, "delete", key, void 0, oldValue); - } - return result; -} -function has$1(target, key) { - const result = Reflect.has(target, key); - if (!isSymbol(key) || !builtInSymbols.has(key)) { - track(target, "has", key); - } - return result; -} -function ownKeys$8(target) { - track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY); - return Reflect.ownKeys(target); -} -const mutableHandlers = { - get: get$1$1, - set: set$1, - deleteProperty, - has: has$1, - ownKeys: ownKeys$8 -}; -const readonlyHandlers = { - get: readonlyGet, - set(target, key) { - if (process.env.NODE_ENV !== "production") { - warn$1(`Set operation on key "${String(key)}" failed: target is readonly.`, target); - } - return true; + }), t; +} +function nA(t) { + const e = ir(this); + return mo(e, "has", t), e.hasOwnProperty(t); +} +function gy(t = !1, e = !1) { + return function(n, i, l) { + if (i === "__v_isReactive") + return !t; + if (i === "__v_isReadonly") + return t; + if (i === "__v_isShallow") + return e; + if (i === "__v_raw" && l === (t ? e ? UT : BT : e ? zT : FT).get(n)) + return n; + const h = Zt(n); + if (!t) { + if (h && Ar(Mb, i)) + return Reflect.get(Mb, i, l); + if (i === "hasOwnProperty") + return nA; + } + const s = Reflect.get(n, i, l); + return (K0(i) ? RT.has(i) : YP(i)) || (t || mo(n, "get", i), e) ? s : tn(s) ? h && Q0(i) ? s : s.value : rn(s) ? t ? $T(s) : vy(s) : s; + }; +} +const iA = /* @__PURE__ */ LT(), oA = /* @__PURE__ */ LT(!0); +function LT(t = !1) { + return function(r, n, i, l) { + let h = r[n]; + if (jl(h) && tn(h) && !tn(i)) + return !1; + if (!t && (!Eg(i) && !jl(i) && (h = ir(h), i = ir(i)), !Zt(r) && tn(h) && !tn(i))) + return h.value = i, !0; + const s = Zt(r) && Q0(n) ? Number(n) < r.length : Ar(r, n), m = Reflect.set(r, n, i, l); + return r === ir(l) && (s ? Td(i, h) && Vs(r, "set", n, i, h) : Vs(r, "add", n, i)), m; + }; +} +function aA(t, e) { + const r = Ar(t, e), n = t[e], i = Reflect.deleteProperty(t, e); + return i && r && Vs(t, "delete", e, void 0, n), i; +} +function sA(t, e) { + const r = Reflect.has(t, e); + return (!K0(e) || !RT.has(e)) && mo(t, "has", e), r; +} +function lA(t) { + return mo(t, "iterate", Zt(t) ? "length" : Hc), Reflect.ownKeys(t); +} +const DT = { + get: JP, + set: iA, + deleteProperty: aA, + has: sA, + ownKeys: lA +}, kT = { + get: eA, + set(t, e) { + return process.env.NODE_ENV !== "production" && bg(`Set operation on key "${String(e)}" failed: target is readonly.`, t), !0; }, - deleteProperty(target, key) { - if (process.env.NODE_ENV !== "production") { - warn$1(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); - } - return true; - } -}; -const shallowReactiveHandlers = /* @__PURE__ */ extend$4({}, mutableHandlers, { - get: shallowGet, - set: shallowSet -}); -const shallowReadonlyHandlers = /* @__PURE__ */ extend$4({}, readonlyHandlers, { - get: shallowReadonlyGet -}); -const toShallow = (value) => value; -const getProto = (v2) => Reflect.getPrototypeOf(v2); -function get$5(target, key, isReadonly2 = false, isShallow2 = false) { - target = target["__v_raw"]; - const rawTarget = toRaw(target); - const rawKey = toRaw(key); - if (!isReadonly2) { - if (key !== rawKey) { - track(rawTarget, "get", key); - } - track(rawTarget, "get", rawKey); - } - const { has: has2 } = getProto(rawTarget); - const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; - if (has2.call(rawTarget, key)) { - return wrap(target.get(key)); - } else if (has2.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } else if (target !== rawTarget) { - target.get(key); - } -} -function has(key, isReadonly2 = false) { - const target = this["__v_raw"]; - const rawTarget = toRaw(target); - const rawKey = toRaw(key); - if (!isReadonly2) { - if (key !== rawKey) { - track(rawTarget, "has", key); - } - track(rawTarget, "has", rawKey); - } - return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); -} -function size(target, isReadonly2 = false) { - target = target["__v_raw"]; - !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY); - return Reflect.get(target, "size", target); -} -function add$4(value) { - value = toRaw(value); - const target = toRaw(this); - const proto = getProto(target); - const hadKey = proto.has.call(target, value); - if (!hadKey) { - target.add(value); - trigger(target, "add", value, value); - } - return this; -} -function set$2(key, value) { - value = toRaw(value); - const target = toRaw(this); - const { has: has2, get: get2 } = getProto(target); - let hadKey = has2.call(target, key); - if (!hadKey) { - key = toRaw(key); - hadKey = has2.call(target, key); - } else if (process.env.NODE_ENV !== "production") { - checkIdentityKeys(target, has2, key); - } - const oldValue = get2.call(target, key); - target.set(key, value); - if (!hadKey) { - trigger(target, "add", key, value); - } else if (hasChanged(value, oldValue)) { - trigger(target, "set", key, value, oldValue); - } - return this; -} -function deleteEntry(key) { - const target = toRaw(this); - const { has: has2, get: get2 } = getProto(target); - let hadKey = has2.call(target, key); - if (!hadKey) { - key = toRaw(key); - hadKey = has2.call(target, key); - } else if (process.env.NODE_ENV !== "production") { - checkIdentityKeys(target, has2, key); - } - const oldValue = get2 ? get2.call(target, key) : void 0; - const result = target.delete(key); - if (hadKey) { - trigger(target, "delete", key, void 0, oldValue); - } - return result; -} -function clear$1() { - const target = toRaw(this); - const hadItems = target.size !== 0; - const oldTarget = process.env.NODE_ENV !== "production" ? isMap(target) ? new Map(target) : new Set(target) : void 0; - const result = target.clear(); - if (hadItems) { - trigger(target, "clear", void 0, void 0, oldTarget); - } - return result; -} -function createForEach(isReadonly2, isShallow2) { - return function forEach2(callback, thisArg) { - const observed = this; - const target = observed["__v_raw"]; - const rawTarget = toRaw(target); - const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; - !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY); - return target.forEach((value, key) => { - return callback.call(thisArg, wrap(value), wrap(key), observed); - }); - }; -} -function createIterableMethod(method, isReadonly2, isShallow2) { - return function(...args) { - const target = this["__v_raw"]; - const rawTarget = toRaw(target); - const targetIsMap = isMap(rawTarget); - const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; - const isKeyOnly = method === "keys" && targetIsMap; - const innerIterator = target[method](...args); - const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; - !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); - return { + deleteProperty(t, e) { + return process.env.NODE_ENV !== "production" && bg(`Delete operation on key "${String(e)}" failed: target is readonly.`, t), !0; + } +}, cA = /* @__PURE__ */ kn({}, DT, { + get: QP, + set: oA +}), uA = /* @__PURE__ */ kn({}, kT, { + get: tA +}), tx = (t) => t, yy = (t) => Reflect.getPrototypeOf(t); +function vm(t, e, r = !1, n = !1) { + t = t.__v_raw; + const i = ir(t), l = ir(e); + r || (e !== l && mo(i, "get", e), mo(i, "get", l)); + const { has: h } = yy(i), s = n ? tx : r ? rx : Md; + if (h.call(i, e)) + return s(t.get(e)); + if (h.call(i, l)) + return s(t.get(l)); + t !== i && t.get(e); +} +function xm(t, e = !1) { + const r = this.__v_raw, n = ir(r), i = ir(t); + return e || (t !== i && mo(n, "has", t), mo(n, "has", i)), t === i ? r.has(t) : r.has(t) || r.has(i); +} +function bm(t, e = !1) { + return t = t.__v_raw, !e && mo(ir(t), "iterate", Hc), Reflect.get(t, "size", t); +} +function Cb(t) { + t = ir(t); + const e = ir(this); + return yy(e).has.call(e, t) || (e.add(t), Vs(e, "add", t, t)), this; +} +function Ib(t, e) { + e = ir(e); + const r = ir(this), { has: n, get: i } = yy(r); + let l = n.call(r, t); + l ? process.env.NODE_ENV !== "production" && NT(r, n, t) : (t = ir(t), l = n.call(r, t)); + const h = i.call(r, t); + return r.set(t, e), l ? Td(e, h) && Vs(r, "set", t, e, h) : Vs(r, "add", t, e), this; +} +function Pb(t) { + const e = ir(this), { has: r, get: n } = yy(e); + let i = r.call(e, t); + i ? process.env.NODE_ENV !== "production" && NT(e, r, t) : (t = ir(t), i = r.call(e, t)); + const l = n ? n.call(e, t) : void 0, h = e.delete(t); + return i && Vs(e, "delete", t, void 0, l), h; +} +function Ab() { + const t = ir(this), e = t.size !== 0, r = process.env.NODE_ENV !== "production" ? Zc(t) ? new Map(t) : new Set(t) : void 0, n = t.clear(); + return e && Vs(t, "clear", void 0, void 0, r), n; +} +function wm(t, e) { + return function(n, i) { + const l = this, h = l.__v_raw, s = ir(h), m = e ? tx : t ? rx : Md; + return !t && mo(s, "iterate", Hc), h.forEach((v, E) => n.call(i, m(v), m(E), l)); + }; +} +function Em(t, e, r) { + return function(...n) { + const i = this.__v_raw, l = ir(i), h = Zc(l), s = t === "entries" || t === Symbol.iterator && h, m = t === "keys" && h, v = i[t](...n), E = r ? tx : e ? rx : Md; + return !e && mo(l, "iterate", m ? Zv : Hc), { next() { - const { value, done } = innerIterator.next(); - return done ? { value, done } : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done + const { value: T, done: S } = v.next(); + return S ? { value: T, done: S } : { + value: s ? [E(T[0]), E(T[1])] : E(T), + done: S }; }, [Symbol.iterator]() { @@ -808,129 +435,106 @@ function createIterableMethod(method, isReadonly2, isShallow2) { }; }; } -function createReadonlyMethod(type) { - return function(...args) { +function pl(t) { + return function(...e) { if (process.env.NODE_ENV !== "production") { - const key = args[0] ? `on key "${args[0]}" ` : ``; - console.warn(`${capitalize$1(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + const r = e[0] ? `on key "${e[0]}" ` : ""; + console.warn(`${ru(t)} operation ${r}failed: target is readonly.`, ir(this)); } - return type === "delete" ? false : this; + return t === "delete" ? !1 : this; }; } -function createInstrumentations() { - const mutableInstrumentations2 = { - get(key) { - return get$5(this, key); +function hA() { + const t = { + get(l) { + return vm(this, l); }, get size() { - return size(this); + return bm(this); }, - has, - add: add$4, - set: set$2, - delete: deleteEntry, - clear: clear$1, - forEach: createForEach(false, false) - }; - const shallowInstrumentations2 = { - get(key) { - return get$5(this, key, false, true); + has: xm, + add: Cb, + set: Ib, + delete: Pb, + clear: Ab, + forEach: wm(!1, !1) + }, e = { + get(l) { + return vm(this, l, !1, !0); }, get size() { - return size(this); + return bm(this); }, - has, - add: add$4, - set: set$2, - delete: deleteEntry, - clear: clear$1, - forEach: createForEach(false, true) - }; - const readonlyInstrumentations2 = { - get(key) { - return get$5(this, key, true); + has: xm, + add: Cb, + set: Ib, + delete: Pb, + clear: Ab, + forEach: wm(!1, !0) + }, r = { + get(l) { + return vm(this, l, !0); }, get size() { - return size(this, true); + return bm(this, !0); }, - has(key) { - return has.call(this, key, true); + has(l) { + return xm.call(this, l, !0); }, - add: createReadonlyMethod("add"), - set: createReadonlyMethod("set"), - delete: createReadonlyMethod("delete"), - clear: createReadonlyMethod("clear"), - forEach: createForEach(true, false) - }; - const shallowReadonlyInstrumentations2 = { - get(key) { - return get$5(this, key, true, true); + add: pl("add"), + set: pl("set"), + delete: pl("delete"), + clear: pl("clear"), + forEach: wm(!0, !1) + }, n = { + get(l) { + return vm(this, l, !0, !0); }, get size() { - return size(this, true); + return bm(this, !0); }, - has(key) { - return has.call(this, key, true); + has(l) { + return xm.call(this, l, !0); }, - add: createReadonlyMethod("add"), - set: createReadonlyMethod("set"), - delete: createReadonlyMethod("delete"), - clear: createReadonlyMethod("clear"), - forEach: createForEach(true, true) - }; - const iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; - iteratorMethods.forEach((method) => { - mutableInstrumentations2[method] = createIterableMethod(method, false, false); - readonlyInstrumentations2[method] = createIterableMethod(method, true, false); - shallowInstrumentations2[method] = createIterableMethod(method, false, true); - shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true); - }); - return [ - mutableInstrumentations2, - readonlyInstrumentations2, - shallowInstrumentations2, - shallowReadonlyInstrumentations2 + add: pl("add"), + set: pl("set"), + delete: pl("delete"), + clear: pl("clear"), + forEach: wm(!0, !0) + }; + return ["keys", "values", "entries", Symbol.iterator].forEach((l) => { + t[l] = Em(l, !1, !1), r[l] = Em(l, !0, !1), e[l] = Em(l, !1, !0), n[l] = Em(l, !0, !0); + }), [ + t, + r, + e, + n ]; } -const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations(); -function createInstrumentationGetter(isReadonly2, shallow) { - const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations; - return (target, key, receiver) => { - if (key === "__v_isReactive") { - return !isReadonly2; - } else if (key === "__v_isReadonly") { - return isReadonly2; - } else if (key === "__v_raw") { - return target; - } - return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); - }; -} -const mutableCollectionHandlers = { - get: /* @__PURE__ */ createInstrumentationGetter(false, false) -}; -const shallowCollectionHandlers = { - get: /* @__PURE__ */ createInstrumentationGetter(false, true) -}; -const readonlyCollectionHandlers = { - get: /* @__PURE__ */ createInstrumentationGetter(true, false) -}; -const shallowReadonlyCollectionHandlers = { - get: /* @__PURE__ */ createInstrumentationGetter(true, true) -}; -function checkIdentityKeys(target, has2, key) { - const rawKey = toRaw(key); - if (rawKey !== key && has2.call(target, rawKey)) { - const type = toRawType(target); - console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`); - } -} -const reactiveMap = /* @__PURE__ */ new WeakMap(); -const shallowReactiveMap = /* @__PURE__ */ new WeakMap(); -const readonlyMap = /* @__PURE__ */ new WeakMap(); -const shallowReadonlyMap = /* @__PURE__ */ new WeakMap(); -function targetTypeMap(rawType) { - switch (rawType) { +const [fA, dA, pA, mA] = /* @__PURE__ */ hA(); +function _y(t, e) { + const r = e ? t ? mA : pA : t ? dA : fA; + return (n, i, l) => i === "__v_isReactive" ? !t : i === "__v_isReadonly" ? t : i === "__v_raw" ? n : Reflect.get(Ar(r, i) && i in n ? r : n, i, l); +} +const gA = { + get: /* @__PURE__ */ _y(!1, !1) +}, yA = { + get: /* @__PURE__ */ _y(!1, !0) +}, _A = { + get: /* @__PURE__ */ _y(!0, !1) +}, vA = { + get: /* @__PURE__ */ _y(!0, !0) +}; +function NT(t, e, r) { + const n = ir(r); + if (n !== r && e.call(t, n)) { + const i = J0(t); + console.warn(`Reactive ${i} contains both the raw and reactive versions of the same object${i === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`); + } +} +const FT = /* @__PURE__ */ new WeakMap(), zT = /* @__PURE__ */ new WeakMap(), BT = /* @__PURE__ */ new WeakMap(), UT = /* @__PURE__ */ new WeakMap(); +function xA(t) { + switch (t) { case "Object": case "Array": return 1; @@ -943,360 +547,241 @@ function targetTypeMap(rawType) { return 0; } } -function getTargetType(value) { - return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value)); +function bA(t) { + return t.__v_skip || !Object.isExtensible(t) ? 0 : xA(J0(t)); } -function reactive(target) { - if (isReadonly(target)) { - return target; - } - return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); +function vy(t) { + return jl(t) ? t : xy(t, !1, DT, gA, FT); } -function shallowReactive(target) { - return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); +function wA(t) { + return xy(t, !1, cA, yA, zT); } -function readonly(target) { - return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); +function $T(t) { + return xy(t, !0, kT, _A, BT); } -function shallowReadonly(target) { - return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); +function uh(t) { + return xy(t, !0, uA, vA, UT); } -function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { - if (!isObject(target)) { - if (process.env.NODE_ENV !== "production") { - console.warn(`value cannot be made reactive: ${String(target)}`); - } - return target; - } - if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) { - return target; - } - const existingProxy = proxyMap.get(target); - if (existingProxy) { - return existingProxy; - } - const targetType = getTargetType(target); - if (targetType === 0) { - return target; - } - const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers); - proxyMap.set(target, proxy); - return proxy; +function xy(t, e, r, n, i) { + if (!rn(t)) + return process.env.NODE_ENV !== "production" && console.warn(`value cannot be made reactive: ${String(t)}`), t; + if (t.__v_raw && !(e && t.__v_isReactive)) + return t; + const l = i.get(t); + if (l) + return l; + const h = bA(t); + if (h === 0) + return t; + const s = new Proxy(t, h === 2 ? n : r); + return i.set(t, s), s; } -function isReactive(value) { - if (isReadonly(value)) { - return isReactive(value["__v_raw"]); - } - return !!(value && value["__v_isReactive"]); +function Aa(t) { + return jl(t) ? Aa(t.__v_raw) : !!(t && t.__v_isReactive); } -function isReadonly(value) { - return !!(value && value["__v_isReadonly"]); +function jl(t) { + return !!(t && t.__v_isReadonly); } -function isShallow$1(value) { - return !!(value && value["__v_isShallow"]); +function Eg(t) { + return !!(t && t.__v_isShallow); } -function isProxy(value) { - return isReactive(value) || isReadonly(value); +function Tg(t) { + return Aa(t) || jl(t); } -function toRaw(observed) { - const raw = observed && observed["__v_raw"]; - return raw ? toRaw(raw) : observed; +function ir(t) { + const e = t && t.__v_raw; + return e ? ir(e) : t; } -function markRaw(value) { - def(value, "__v_skip", true); - return value; +function Ta(t) { + return xg(t, "__v_skip", !0), t; } -const toReactive = (value) => isObject(value) ? reactive(value) : value; -const toReadonly = (value) => isObject(value) ? readonly(value) : value; -function trackRefValue(ref2) { - if (shouldTrack && activeEffect) { - ref2 = toRaw(ref2); - if (process.env.NODE_ENV !== "production") { - trackEffects(ref2.dep || (ref2.dep = createDep()), { - target: ref2, - type: "get", - key: "value" - }); - } else { - trackEffects(ref2.dep || (ref2.dep = createDep())); - } - } +const Md = (t) => rn(t) ? vy(t) : t, rx = (t) => rn(t) ? $T(t) : t; +function VT(t) { + Nl && fo && (t = ir(t), process.env.NODE_ENV !== "production" ? Hv(t.dep || (t.dep = Sd()), { + target: t, + type: "get", + key: "value" + }) : Hv(t.dep || (t.dep = Sd()))); } -function triggerRefValue(ref2, newVal) { - ref2 = toRaw(ref2); - const dep = ref2.dep; - if (dep) { - if (process.env.NODE_ENV !== "production") { - triggerEffects(dep, { - target: ref2, - type: "set", - key: "value", - newValue: newVal - }); - } else { - triggerEffects(dep); - } - } +function jT(t, e) { + t = ir(t); + const r = t.dep; + r && (process.env.NODE_ENV !== "production" ? ch(r, { + target: t, + type: "set", + key: "value", + newValue: e + }) : ch(r)); } -function isRef(r) { - return !!(r && r.__v_isRef === true); +function tn(t) { + return !!(t && t.__v_isRef === !0); } -function ref(value) { - return createRef(value, false); +function Kr(t) { + return GT(t, !1); } -function shallowRef(value) { - return createRef(value, true); +function yi(t) { + return GT(t, !0); } -function createRef(rawValue, shallow) { - if (isRef(rawValue)) { - return rawValue; - } - return new RefImpl(rawValue, shallow); +function GT(t, e) { + return tn(t) ? t : new EA(t, e); } -class RefImpl { - constructor(value, __v_isShallow) { - this.__v_isShallow = __v_isShallow; - this.dep = void 0; - this.__v_isRef = true; - this._rawValue = __v_isShallow ? value : toRaw(value); - this._value = __v_isShallow ? value : toReactive(value); +class EA { + constructor(e, r) { + this.__v_isShallow = r, this.dep = void 0, this.__v_isRef = !0, this._rawValue = r ? e : ir(e), this._value = r ? e : Md(e); } get value() { - trackRefValue(this); - return this._value; + return VT(this), this._value; } - set value(newVal) { - const useDirectValue = this.__v_isShallow || isShallow$1(newVal) || isReadonly(newVal); - newVal = useDirectValue ? newVal : toRaw(newVal); - if (hasChanged(newVal, this._rawValue)) { - this._rawValue = newVal; - this._value = useDirectValue ? newVal : toReactive(newVal); - triggerRefValue(this, newVal); - } + set value(e) { + const r = this.__v_isShallow || Eg(e) || jl(e); + e = r ? e : ir(e), Td(e, this._rawValue) && (this._rawValue = e, this._value = r ? e : Md(e), jT(this, e)); } } -function unref(ref2) { - return isRef(ref2) ? ref2.value : ref2; +function _e(t) { + return tn(t) ? t.value : t; } -const shallowUnwrapHandlers = { - get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), - set: (target, key, value, receiver) => { - const oldValue = target[key]; - if (isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } else { - return Reflect.set(target, key, value, receiver); - } +const TA = { + get: (t, e, r) => _e(Reflect.get(t, e, r)), + set: (t, e, r, n) => { + const i = t[e]; + return tn(i) && !tn(r) ? (i.value = r, !0) : Reflect.set(t, e, r, n); } }; -function proxyRefs(objectWithRefs) { - return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); +function qT(t) { + return Aa(t) ? t : new Proxy(t, TA); } -function toRefs(object) { - if (process.env.NODE_ENV !== "production" && !isProxy(object)) { - console.warn(`toRefs() expects a reactive object but received a plain one.`); - } - const ret = isArray(object) ? new Array(object.length) : {}; - for (const key in object) { - ret[key] = toRef(object, key); - } - return ret; +function Ob(t) { + process.env.NODE_ENV !== "production" && !Tg(t) && console.warn("toRefs() expects a reactive object but received a plain one."); + const e = Zt(t) ? new Array(t.length) : {}; + for (const r in t) + e[r] = cd(t, r); + return e; } -class ObjectRefImpl { - constructor(_object, _key, _defaultValue) { - this._object = _object; - this._key = _key; - this._defaultValue = _defaultValue; - this.__v_isRef = true; +class SA { + constructor(e, r, n) { + this._object = e, this._key = r, this._defaultValue = n, this.__v_isRef = !0; } get value() { - const val = this._object[this._key]; - return val === void 0 ? this._defaultValue : val; + const e = this._object[this._key]; + return e === void 0 ? this._defaultValue : e; } - set value(newVal) { - this._object[this._key] = newVal; + set value(e) { + this._object[this._key] = e; } get dep() { - return getDepFromReactive(toRaw(this._object), this._key); - } -} -function toRef(object, key, defaultValue) { - const val = object[key]; - return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue); -} -var _a$1; -class ComputedRefImpl { - constructor(getter, _setter, isReadonly2, isSSR) { - this._setter = _setter; - this.dep = void 0; - this.__v_isRef = true; - this[_a$1] = false; - this._dirty = true; - this.effect = new ReactiveEffect(getter, () => { - if (!this._dirty) { - this._dirty = true; - triggerRefValue(this); - } - }); - this.effect.computed = this; - this.effect.active = this._cacheable = !isSSR; - this["__v_isReadonly"] = isReadonly2; + return KP(ir(this._object), this._key); + } +} +function cd(t, e, r) { + const n = t[e]; + return tn(n) ? n : new SA(t, e, r); +} +var WT; +class MA { + constructor(e, r, n, i) { + this._setter = r, this.dep = void 0, this.__v_isRef = !0, this[WT] = !1, this._dirty = !0, this.effect = new ex(e, () => { + this._dirty || (this._dirty = !0, jT(this)); + }), this.effect.computed = this, this.effect.active = this._cacheable = !i, this.__v_isReadonly = n; } get value() { - const self2 = toRaw(this); - trackRefValue(self2); - if (self2._dirty || !self2._cacheable) { - self2._dirty = false; - self2._value = self2.effect.run(); - } - return self2._value; - } - set value(newValue) { - this._setter(newValue); - } -} -_a$1 = "__v_isReadonly"; -function computed$1(getterOrOptions, debugOptions, isSSR = false) { - let getter; - let setter; - const onlyGetter = isFunction(getterOrOptions); - if (onlyGetter) { - getter = getterOrOptions; - setter = process.env.NODE_ENV !== "production" ? () => { - console.warn("Write operation failed: computed value is readonly"); - } : NOOP; - } else { - getter = getterOrOptions.get; - setter = getterOrOptions.set; + const e = ir(this); + return VT(e), (e._dirty || !e._cacheable) && (e._dirty = !1, e._value = e.effect.run()), e._value; } - const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); - if (process.env.NODE_ENV !== "production" && debugOptions && !isSSR) { - cRef.effect.onTrack = debugOptions.onTrack; - cRef.effect.onTrigger = debugOptions.onTrigger; + set value(e) { + this._setter(e); } - return cRef; } -const stack = []; -function pushWarningContext(vnode) { - stack.push(vnode); +WT = "__v_isReadonly"; +function CA(t, e, r = !1) { + let n, i; + const l = ar(t); + l ? (n = t, i = process.env.NODE_ENV !== "production" ? () => { + console.warn("Write operation failed: computed value is readonly"); + } : Ui) : (n = t.get, i = t.set); + const h = new MA(n, i, l || !i, r); + return process.env.NODE_ENV !== "production" && e && !r && (h.effect.onTrack = e.onTrack, h.effect.onTrigger = e.onTrigger), h; +} +const Kc = []; +function eg(t) { + Kc.push(t); } -function popWarningContext() { - stack.pop(); +function tg() { + Kc.pop(); } -function warn(msg, ...args) { - if (!(process.env.NODE_ENV !== "production")) +function st(t, ...e) { + if (process.env.NODE_ENV === "production") return; - pauseTracking(); - const instance2 = stack.length ? stack[stack.length - 1].component : null; - const appWarnHandler = instance2 && instance2.appContext.config.warnHandler; - const trace = getComponentTrace(); - if (appWarnHandler) { - callWithErrorHandling(appWarnHandler, instance2, 11, [ - msg + args.join(""), - instance2 && instance2.proxy, - trace.map(({ vnode }) => `at <${formatComponentName(instance2, vnode.type)}>`).join("\n"), - trace + uu(); + const r = Kc.length ? Kc[Kc.length - 1].component : null, n = r && r.appContext.config.warnHandler, i = IA(); + if (n) + Ns(n, r, 11, [ + t + e.join(""), + r && r.proxy, + i.map(({ vnode: l }) => `at <${Iy(r, l.type)}>`).join(` +`), + i ]); - } else { - const warnArgs = [`[Vue warn]: ${msg}`, ...args]; - if (trace.length && true) { - warnArgs.push(` -`, ...formatTrace(trace)); - } - console.warn(...warnArgs); + else { + const l = [`[Vue warn]: ${t}`, ...e]; + i.length && l.push(` +`, ...PA(i)), console.warn(...l); } - resetTracking(); + hu(); } -function getComponentTrace() { - let currentVNode = stack[stack.length - 1]; - if (!currentVNode) { +function IA() { + let t = Kc[Kc.length - 1]; + if (!t) return []; - } - const normalizedStack = []; - while (currentVNode) { - const last = normalizedStack[0]; - if (last && last.vnode === currentVNode) { - last.recurseCount++; - } else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }); - } - const parentInstance = currentVNode.component && currentVNode.component.parent; - currentVNode = parentInstance && parentInstance.vnode; - } - return normalizedStack; -} -function formatTrace(trace) { - const logs = []; - trace.forEach((entry, i) => { - logs.push(...i === 0 ? [] : [` -`], ...formatTraceEntry(entry)); - }); - return logs; -} -function formatTraceEntry({ vnode, recurseCount }) { - const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; - const isRoot = vnode.component ? vnode.component.parent == null : false; - const open2 = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; - const close = `>` + postfix; - return vnode.props ? [open2, ...formatProps(vnode.props), close] : [open2 + close]; -} -function formatProps(props) { - const res = []; - const keys = Object.keys(props); - keys.slice(0, 3).forEach((key) => { - res.push(...formatProp(key, props[key])); - }); - if (keys.length > 3) { - res.push(` ...`); - } - return res; -} -function formatProp(key, value, raw) { - if (isString(value)) { - value = JSON.stringify(value); - return raw ? value : [`${key}=${value}`]; - } else if (typeof value === "number" || typeof value === "boolean" || value == null) { - return raw ? value : [`${key}=${value}`]; - } else if (isRef(value)) { - value = formatProp(key, toRaw(value.value), true); - return raw ? value : [`${key}=Ref<`, value, `>`]; - } else if (isFunction(value)) { - return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; - } else { - value = toRaw(value); - return raw ? value : [`${key}=`, value]; - } -} -function assertNumber(val, type) { - if (!(process.env.NODE_ENV !== "production")) - return; - if (val === void 0) { - return; - } else if (typeof val !== "number") { - warn(`${type} is not a valid number - got ${JSON.stringify(val)}.`); - } else if (isNaN(val)) { - warn(`${type} is NaN - the duration expression might be incorrect.`); - } -} -const ErrorTypeStrings = { - ["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", + const e = []; + for (; t; ) { + const r = e[0]; + r && r.vnode === t ? r.recurseCount++ : e.push({ + vnode: t, + recurseCount: 0 + }); + const n = t.component && t.component.parent; + t = n && n.vnode; + } + return e; +} +function PA(t) { + const e = []; + return t.forEach((r, n) => { + e.push(...n === 0 ? [] : [` +`], ...AA(r)); + }), e; +} +function AA({ vnode: t, recurseCount: e }) { + const r = e > 0 ? `... (${e} recursive calls)` : "", n = t.component ? t.component.parent == null : !1, i = ` at <${Iy(t.component, t.type, n)}`, l = ">" + r; + return t.props ? [i, ...OA(t.props), l] : [i + l]; +} +function OA(t) { + const e = [], r = Object.keys(t); + return r.slice(0, 3).forEach((n) => { + e.push(...XT(n, t[n])); + }), r.length > 3 && e.push(" ..."), e; +} +function XT(t, e, r) { + return Nn(e) ? (e = JSON.stringify(e), r ? e : [`${t}=${e}`]) : typeof e == "number" || typeof e == "boolean" || e == null ? r ? e : [`${t}=${e}`] : tn(e) ? (e = XT(t, ir(e.value), !0), r ? e : [`${t}=Ref<`, e, ">"]) : ar(e) ? [`${t}=fn${e.name ? `<${e.name}>` : ""}`] : (e = ir(e), r ? e : [`${t}=`, e]); +} +function RA(t, e) { + process.env.NODE_ENV !== "production" && t !== void 0 && (typeof t != "number" ? st(`${e} is not a valid number - got ${JSON.stringify(t)}.`) : isNaN(t) && st(`${e} is NaN - the duration expression might be incorrect.`)); +} +const nx = { + 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", @@ -1313,26571 +798,14800 @@ const ErrorTypeStrings = { [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 callWithErrorHandling(fn, instance2, type, args) { - let res; +function Ns(t, e, r, n) { + let i; try { - res = args ? fn(...args) : fn(); - } catch (err) { - handleError(err, instance2, type); - } - return res; -} -function callWithAsyncErrorHandling(fn, instance2, type, args) { - if (isFunction(fn)) { - const res = callWithErrorHandling(fn, instance2, type, args); - if (res && isPromise$1(res)) { - res.catch((err) => { - handleError(err, instance2, type); - }); - } - return res; - } - const values = []; - for (let i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling(fn[i], instance2, type, args)); - } - return values; -} -function handleError(err, instance2, type, throwInDev = true) { - const contextVNode = instance2 ? instance2.vnode : null; - if (instance2) { - let cur = instance2.parent; - const exposedInstance = instance2.proxy; - const errorInfo = process.env.NODE_ENV !== "production" ? ErrorTypeStrings[type] : type; - while (cur) { - const errorCapturedHooks = cur.ec; - if (errorCapturedHooks) { - for (let i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + i = n ? t(...n) : t(); + } catch (l) { + by(l, e, r); + } + return i; +} +function na(t, e, r, n) { + if (ar(t)) { + const l = Ns(t, e, r, n); + return l && Y0(l) && l.catch((h) => { + by(h, e, r); + }), l; + } + const i = []; + for (let l = 0; l < t.length; l++) + i.push(na(t[l], e, r, n)); + return i; +} +function by(t, e, r, n = !0) { + const i = e ? e.vnode : null; + if (e) { + let l = e.parent; + const h = e.proxy, s = process.env.NODE_ENV !== "production" ? nx[r] : r; + for (; l; ) { + const v = l.ec; + if (v) { + for (let E = 0; E < v.length; E++) + if (v[E](t, h, s) === !1) return; - } - } } - cur = cur.parent; + l = l.parent; } - const appErrorHandler = instance2.appContext.config.errorHandler; - if (appErrorHandler) { - callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]); + const m = e.appContext.config.errorHandler; + if (m) { + Ns(m, null, 10, [t, h, s]); return; } } - logError(err, type, contextVNode, throwInDev); + LA(t, r, i, n); } -function logError(err, type, contextVNode, throwInDev = true) { +function LA(t, e, r, n = !0) { if (process.env.NODE_ENV !== "production") { - const info = ErrorTypeStrings[type]; - if (contextVNode) { - pushWarningContext(contextVNode); - } - warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); - if (contextVNode) { - popWarningContext(); - } - if (throwInDev) { - throw err; - } else { - console.error(err); - } - } else { - console.error(err); - } -} -let isFlushing = false; -let isFlushPending = false; -const queue = []; -let flushIndex = 0; -const pendingPostFlushCbs = []; -let activePostFlushCbs = null; -let postFlushIndex = 0; -const resolvedPromise = /* @__PURE__ */ Promise.resolve(); -let currentFlushPromise = null; -const RECURSION_LIMIT = 100; -function nextTick(fn) { - const p2 = currentFlushPromise || resolvedPromise; - return fn ? p2.then(this ? fn.bind(this) : fn) : p2; -} -function findInsertionIndex(id) { - let start2 = flushIndex + 1; - let end = queue.length; - while (start2 < end) { - const middle = start2 + end >>> 1; - const middleJobId = getId(queue[middle]); - middleJobId < id ? start2 = middle + 1 : end = middle; - } - return start2; -} -function queueJob(job) { - if (!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) { - if (job.id == null) { - queue.push(job); - } else { - queue.splice(findInsertionIndex(job.id), 0, job); + const i = nx[e]; + if (r && eg(r), st(`Unhandled error${i ? ` during execution of ${i}` : ""}`), r && tg(), n) + throw t; + console.error(t); + } else + console.error(t); +} +let Cd = !1, Kv = !1; +const Ki = []; +let Ka = 0; +const xh = []; +let Za = null, El = 0; +const ZT = /* @__PURE__ */ Promise.resolve(); +let ix = null; +const DA = 100; +function Sg(t) { + const e = ix || ZT; + return t ? e.then(this ? t.bind(this) : t) : e; +} +function kA(t) { + let e = Ka + 1, r = Ki.length; + for (; e < r; ) { + const n = e + r >>> 1; + Id(Ki[n]) < t ? e = n + 1 : r = n; + } + return e; +} +function wy(t) { + (!Ki.length || !Ki.includes(t, Cd && t.allowRecurse ? Ka + 1 : Ka)) && (t.id == null ? Ki.push(t) : Ki.splice(kA(t.id), 0, t), HT()); +} +function HT() { + !Cd && !Kv && (Kv = !0, ix = ZT.then(JT)); +} +function NA(t) { + const e = Ki.indexOf(t); + e > Ka && Ki.splice(e, 1); +} +function KT(t) { + Zt(t) ? xh.push(...t) : (!Za || !Za.includes(t, t.allowRecurse ? El + 1 : El)) && xh.push(t), HT(); +} +function Rb(t, e = Cd ? Ka + 1 : 0) { + for (process.env.NODE_ENV !== "production" && (t = t || /* @__PURE__ */ new Map()); e < Ki.length; e++) { + const r = Ki[e]; + if (r && r.pre) { + if (process.env.NODE_ENV !== "production" && ox(t, r)) + continue; + Ki.splice(e, 1), e--, r(); } - queueFlush(); - } -} -function queueFlush() { - if (!isFlushing && !isFlushPending) { - isFlushPending = true; - currentFlushPromise = resolvedPromise.then(flushJobs); - } -} -function invalidateJob(job) { - const i = queue.indexOf(job); - if (i > flushIndex) { - queue.splice(i, 1); } } -function queuePostFlushCb(cb) { - if (!isArray(cb)) { - if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) { - pendingPostFlushCbs.push(cb); +function YT(t) { + if (xh.length) { + const e = [...new Set(xh)]; + if (xh.length = 0, Za) { + Za.push(...e); + return; } - } else { - pendingPostFlushCbs.push(...cb); + for (Za = e, process.env.NODE_ENV !== "production" && (t = t || /* @__PURE__ */ new Map()), Za.sort((r, n) => Id(r) - Id(n)), El = 0; El < Za.length; El++) + process.env.NODE_ENV !== "production" && ox(t, Za[El]) || Za[El](); + Za = null, El = 0; } - queueFlush(); } -function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) { - if (process.env.NODE_ENV !== "production") { - seen = seen || /* @__PURE__ */ new Map(); +const Id = (t) => t.id == null ? 1 / 0 : t.id, FA = (t, e) => { + const r = Id(t) - Id(e); + if (r === 0) { + if (t.pre && !e.pre) + return -1; + if (e.pre && !t.pre) + return 1; } - for (; i < queue.length; i++) { - const cb = queue[i]; - if (cb && cb.pre) { - if (process.env.NODE_ENV !== "production" && checkRecursiveUpdates(seen, cb)) { - continue; - } - queue.splice(i, 1); - i--; - cb(); - } - } -} -function flushPostFlushCbs(seen) { - if (pendingPostFlushCbs.length) { - const deduped = [...new Set(pendingPostFlushCbs)]; - pendingPostFlushCbs.length = 0; - if (activePostFlushCbs) { - activePostFlushCbs.push(...deduped); - return; - } - activePostFlushCbs = deduped; - if (process.env.NODE_ENV !== "production") { - seen = seen || /* @__PURE__ */ new Map(); - } - activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); - for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { - if (process.env.NODE_ENV !== "production" && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { - continue; - } - activePostFlushCbs[postFlushIndex](); - } - activePostFlushCbs = null; - postFlushIndex = 0; - } -} -const getId = (job) => job.id == null ? Infinity : job.id; -const comparator = (a, b) => { - const diff = getId(a) - getId(b); - if (diff === 0) { - if (a.pre && !b.pre) - return -1; - if (b.pre && !a.pre) - return 1; - } - return diff; -}; -function flushJobs(seen) { - isFlushPending = false; - isFlushing = true; - if (process.env.NODE_ENV !== "production") { - seen = seen || /* @__PURE__ */ new Map(); - } - queue.sort(comparator); - const check = process.env.NODE_ENV !== "production" ? (job) => checkRecursiveUpdates(seen, job) : NOOP; - try { - for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { - const job = queue[flushIndex]; - if (job && job.active !== false) { - if (process.env.NODE_ENV !== "production" && check(job)) { - continue; - } - callWithErrorHandling(job, null, 14); + return r; +}; +function JT(t) { + Kv = !1, Cd = !0, process.env.NODE_ENV !== "production" && (t = t || /* @__PURE__ */ new Map()), Ki.sort(FA); + const e = process.env.NODE_ENV !== "production" ? (r) => ox(t, r) : Ui; + try { + for (Ka = 0; Ka < Ki.length; Ka++) { + const r = Ki[Ka]; + if (r && r.active !== !1) { + if (process.env.NODE_ENV !== "production" && e(r)) + continue; + Ns(r, null, 14); } } } finally { - flushIndex = 0; - queue.length = 0; - flushPostFlushCbs(seen); - isFlushing = false; - currentFlushPromise = null; - if (queue.length || pendingPostFlushCbs.length) { - flushJobs(seen); - } - } -} -function checkRecursiveUpdates(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1); - } else { - const count = seen.get(fn); - if (count > RECURSION_LIMIT) { - const instance2 = fn.ownerInstance; - const componentName = instance2 && getComponentName(instance2.type); - warn(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. 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.`); - return true; - } else { - seen.set(fn, count + 1); - } - } -} -let isHmrUpdating = false; -const hmrDirtyComponents = /* @__PURE__ */ new Set(); -if (process.env.NODE_ENV !== "production") { - getGlobalThis().__VUE_HMR_RUNTIME__ = { - createRecord: tryWrap(createRecord), - rerender: tryWrap(rerender), - reload: tryWrap(reload) - }; -} -const map$1 = /* @__PURE__ */ new Map(); -function registerHMR(instance2) { - const id = instance2.type.__hmrId; - let record = map$1.get(id); - if (!record) { - createRecord(id, instance2.type); - record = map$1.get(id); - } - record.instances.add(instance2); -} -function unregisterHMR(instance2) { - map$1.get(instance2.type.__hmrId).instances.delete(instance2); -} -function createRecord(id, initialDef) { - if (map$1.has(id)) { - return false; - } - map$1.set(id, { - initialDef: normalizeClassComponent(initialDef), + Ka = 0, Ki.length = 0, YT(t), Cd = !1, ix = null, (Ki.length || xh.length) && JT(t); + } +} +function ox(t, e) { + if (!t.has(e)) + t.set(e, 1); + else { + const r = t.get(e); + if (r > DA) { + const n = e.ownerInstance, i = n && fx(n.type); + return st(`Maximum recursive updates exceeded${i ? ` in component <${i}>` : ""}. 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; + } else + t.set(e, r + 1); + } +} +let Fl = !1; +const nh = /* @__PURE__ */ new Set(); +process.env.NODE_ENV !== "production" && (ST().__VUE_HMR_RUNTIME__ = { + createRecord: J_(QT), + rerender: J_(UA), + reload: J_($A) +}); +const nu = /* @__PURE__ */ new Map(); +function zA(t) { + const e = t.type.__hmrId; + let r = nu.get(e); + r || (QT(e, t.type), r = nu.get(e)), r.instances.add(t); +} +function BA(t) { + nu.get(t.type.__hmrId).instances.delete(t); +} +function QT(t, e) { + return nu.has(t) ? !1 : (nu.set(t, { + initialDef: ud(e), instances: /* @__PURE__ */ new Set() - }); - return true; + }), !0); } -function normalizeClassComponent(component) { - return isClassComponent(component) ? component.__vccOpts : component; +function ud(t) { + return LS(t) ? t.__vccOpts : t; } -function rerender(id, newRender) { - const record = map$1.get(id); - if (!record) { - return; - } - record.initialDef.render = newRender; - [...record.instances].forEach((instance2) => { - if (newRender) { - instance2.render = newRender; - normalizeClassComponent(instance2.type).render = newRender; - } - instance2.renderCache = []; - isHmrUpdating = true; - instance2.update(); - isHmrUpdating = false; - }); +function UA(t, e) { + const r = nu.get(t); + !r || (r.initialDef.render = e, [...r.instances].forEach((n) => { + e && (n.render = e, ud(n.type).render = e), n.renderCache = [], Fl = !0, n.update(), Fl = !1; + })); } -function reload(id, newComp) { - const record = map$1.get(id); - if (!record) +function $A(t, e) { + const r = nu.get(t); + if (!r) return; - newComp = normalizeClassComponent(newComp); - updateComponentDef(record.initialDef, newComp); - const instances = [...record.instances]; - for (const instance2 of instances) { - const oldComp = normalizeClassComponent(instance2.type); - if (!hmrDirtyComponents.has(oldComp)) { - if (oldComp !== record.initialDef) { - updateComponentDef(oldComp, newComp); - } - hmrDirtyComponents.add(oldComp); - } - instance2.appContext.optionsCache.delete(instance2.type); - if (instance2.ceReload) { - hmrDirtyComponents.add(oldComp); - instance2.ceReload(newComp.styles); - hmrDirtyComponents.delete(oldComp); - } else if (instance2.parent) { - queueJob(instance2.parent.update); - } else if (instance2.appContext.reload) { - instance2.appContext.reload(); - } else if (typeof window !== "undefined") { - window.location.reload(); - } else { - console.warn("[HMR] Root or manually mounted instance modified. Full reload required."); - } - } - queuePostFlushCb(() => { - for (const instance2 of instances) { - hmrDirtyComponents.delete(normalizeClassComponent(instance2.type)); - } + e = ud(e), Lb(r.initialDef, e); + const n = [...r.instances]; + for (const i of n) { + const l = ud(i.type); + nh.has(l) || (l !== r.initialDef && Lb(l, e), nh.add(l)), i.appContext.optionsCache.delete(i.type), i.ceReload ? (nh.add(l), i.ceReload(e.styles), nh.delete(l)) : i.parent ? wy(i.parent.update) : i.appContext.reload ? i.appContext.reload() : typeof window < "u" ? window.location.reload() : console.warn("[HMR] Root or manually mounted instance modified. Full reload required."); + } + KT(() => { + for (const i of n) + nh.delete(ud(i.type)); }); } -function updateComponentDef(oldComp, newComp) { - extend$4(oldComp, newComp); - for (const key in oldComp) { - if (key !== "__file" && !(key in newComp)) { - delete oldComp[key]; - } - } +function Lb(t, e) { + kn(t, e); + for (const r in t) + r !== "__file" && !(r in e) && delete t[r]; } -function tryWrap(fn) { - return (id, arg) => { +function J_(t) { + return (e, r) => { try { - return fn(id, arg); - } catch (e) { - console.error(e); - console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`); - } - }; -} -let devtools; -let buffer = []; -let devtoolsNotInstalled = false; -function emit$1(event, ...args) { - if (devtools) { - devtools.emit(event, ...args); - } else if (!devtoolsNotInstalled) { - buffer.push({ event, args }); - } -} -function setDevtoolsHook(hook, target) { - var _a, _b; - devtools = hook; - if (devtools) { - devtools.enabled = true; - buffer.forEach(({ event, args }) => devtools.emit(event, ...args)); - buffer = []; - } else if (typeof window !== "undefined" && window.HTMLElement && !((_b = (_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) === null || _b === void 0 ? void 0 : _b.includes("jsdom"))) { - const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; - replay.push((newHook) => { - setDevtoolsHook(newHook, target); - }); - setTimeout(() => { - if (!devtools) { - target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; - devtoolsNotInstalled = true; - buffer = []; - } - }, 3e3); - } else { - devtoolsNotInstalled = true; - buffer = []; - } -} -function devtoolsInitApp(app2, version2) { - emit$1("app:init", app2, version2, { - Fragment, - Text, - Comment, - Static + return t(e, r); + } catch (n) { + console.error(n), console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required."); + } + }; +} +let Ya, ed = [], Yv = !1; +function Vd(t, ...e) { + Ya ? Ya.emit(t, ...e) : Yv || ed.push({ event: t, args: e }); +} +function eS(t, e) { + var r, n; + Ya = t, Ya ? (Ya.enabled = !0, ed.forEach(({ event: i, args: l }) => Ya.emit(i, ...l)), ed = []) : typeof window < "u" && window.HTMLElement && !(!((n = (r = window.navigator) === null || r === void 0 ? void 0 : r.userAgent) === null || n === void 0) && n.includes("jsdom")) ? ((e.__VUE_DEVTOOLS_HOOK_REPLAY__ = e.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((l) => { + eS(l, e); + }), setTimeout(() => { + Ya || (e.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, Yv = !0, ed = []); + }, 3e3)) : (Yv = !0, ed = []); +} +function VA(t, e) { + Vd("app:init", t, e, { + Fragment: pn, + Text: qd, + Comment: Ii, + Static: rg }); } -function devtoolsUnmountApp(app2) { - emit$1("app:unmount", app2); +function jA(t) { + Vd("app:unmount", t); } -const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook("component:added"); -const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated"); -const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook("component:removed"); -const devtoolsComponentRemoved = (component) => { - if (devtools && typeof devtools.cleanupBuffer === "function" && !devtools.cleanupBuffer(component)) { - _devtoolsComponentRemoved(component); - } +const GA = /* @__PURE__ */ ax("component:added"), tS = /* @__PURE__ */ ax("component:updated"), qA = /* @__PURE__ */ ax("component:removed"), WA = (t) => { + Ya && typeof Ya.cleanupBuffer == "function" && !Ya.cleanupBuffer(t) && qA(t); }; -function createDevtoolsComponentHook(hook) { - return (component) => { - emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component); +function ax(t) { + return (e) => { + Vd(t, e.appContext.app, e.uid, e.parent ? e.parent.uid : void 0, e); }; } -const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:start"); -const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:end"); -function createDevtoolsPerformanceHook(hook) { - return (component, type, time) => { - emit$1(hook, component.appContext.app, component.uid, component, type, time); +const XA = /* @__PURE__ */ rS("perf:start"), ZA = /* @__PURE__ */ rS("perf:end"); +function rS(t) { + return (e, r, n) => { + Vd(t, e.appContext.app, e.uid, e, r, n); }; } -function devtoolsComponentEmit(component, event, params2) { - emit$1("component:emit", component.appContext.app, component, event, params2); +function HA(t, e, r) { + Vd("component:emit", t.appContext.app, t, e, r); } -function emit(instance2, event, ...rawArgs) { - if (instance2.isUnmounted) +function KA(t, e, ...r) { + if (t.isUnmounted) return; - const props = instance2.vnode.props || EMPTY_OBJ; - if (process.env.NODE_ENV !== "production") { - const { emitsOptions, propsOptions: [propsOptions] } = instance2; - if (emitsOptions) { - if (!(event in emitsOptions) && true) { - if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { - warn(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`); - } - } else { - const validator = emitsOptions[event]; - if (isFunction(validator)) { - const isValid = validator(...rawArgs); - if (!isValid) { - warn(`Invalid event arguments: event validation failed for event "${event}".`); - } - } - } - } - } - let args = rawArgs; - const isModelListener2 = event.startsWith("update:"); - const modelArg = isModelListener2 && event.slice(7); - if (modelArg && modelArg in props) { - const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`; - const { number, trim } = props[modifiersKey] || EMPTY_OBJ; - if (trim) { - args = rawArgs.map((a) => isString(a) ? a.trim() : a); - } - if (number) { - args = rawArgs.map(looseToNumber); - } - } - if (process.env.NODE_ENV !== "production" || false) { - devtoolsComponentEmit(instance2, event, args); - } + const n = t.vnode.props || dn; if (process.env.NODE_ENV !== "production") { - const lowerCaseEvent = event.toLowerCase(); - if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { - warn(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance2, instance2.type)} but the handler is registered for "${event}". 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 "${hyphenate(event)}" instead of "${event}".`); - } - } - let handlerName; - let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize(event))]; - if (!handler && isModelListener2) { - handler = props[handlerName = toHandlerKey(hyphenate(event))]; - } - if (handler) { - callWithAsyncErrorHandling(handler, instance2, 6, args); - } - const onceHandler = props[handlerName + `Once`]; - if (onceHandler) { - if (!instance2.emitted) { - instance2.emitted = {}; - } else if (instance2.emitted[handlerName]) { + const { emitsOptions: E, propsOptions: [T] } = t; + if (E) + if (!(e in E)) + (!T || !(Bc(e) in T)) && st(`Component emitted event "${e}" but it is neither declared in the emits option nor as an "${Bc(e)}" prop.`); + else { + const S = E[e]; + ar(S) && (S(...r) || st(`Invalid event arguments: event validation failed for event "${e}".`)); + } + } + let i = r; + const l = e.startsWith("update:"), h = l && e.slice(7); + if (h && h in n) { + const E = `${h === "modelValue" ? "model" : h}Modifiers`, { number: T, trim: S } = n[E] || dn; + S && (i = r.map((A) => Nn(A) ? A.trim() : A)), T && (i = r.map(qP)); + } + if (process.env.NODE_ENV !== "production" && HA(t, e, i), process.env.NODE_ENV !== "production") { + const E = e.toLowerCase(); + E !== e && n[Bc(E)] && st(`Event "${E}" is emitted in component ${Iy(t, t.type)} but the handler is registered for "${e}". 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 "${Mo(e)}" instead of "${e}".`); + } + let s, m = n[s = Bc(e)] || n[s = Bc(Go(e))]; + !m && l && (m = n[s = Bc(Mo(e))]), m && na(m, t, 6, i); + const v = n[s + "Once"]; + if (v) { + if (!t.emitted) + t.emitted = {}; + else if (t.emitted[s]) return; - } - instance2.emitted[handlerName] = true; - callWithAsyncErrorHandling(onceHandler, instance2, 6, args); - } -} -function normalizeEmitsOptions(comp, appContext, asMixin = false) { - const cache2 = appContext.emitsCache; - const cached = cache2.get(comp); - if (cached !== void 0) { - return cached; - } - const raw = comp.emits; - let normalized = {}; - let hasExtends = false; - if (!isFunction(comp)) { - const extendEmits = (raw2) => { - const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true); - if (normalizedFromExtend) { - hasExtends = true; - extend$4(normalized, normalizedFromExtend); - } + t.emitted[s] = !0, na(v, t, 6, i); + } +} +function nS(t, e, r = !1) { + const n = e.emitsCache, i = n.get(t); + if (i !== void 0) + return i; + const l = t.emits; + let h = {}, s = !1; + if (!ar(t)) { + const m = (v) => { + const E = nS(v, e, !0); + E && (s = !0, kn(h, E)); }; - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendEmits); - } - if (comp.extends) { - extendEmits(comp.extends); - } - if (comp.mixins) { - comp.mixins.forEach(extendEmits); - } - } - if (!raw && !hasExtends) { - if (isObject(comp)) { - cache2.set(comp, null); - } - return null; + !r && e.mixins.length && e.mixins.forEach(m), t.extends && m(t.extends), t.mixins && t.mixins.forEach(m); } - if (isArray(raw)) { - raw.forEach((key) => normalized[key] = null); - } else { - extend$4(normalized, raw); - } - if (isObject(comp)) { - cache2.set(comp, normalized); - } - return normalized; + return !l && !s ? (rn(t) && n.set(t, null), null) : (Zt(l) ? l.forEach((m) => h[m] = null) : kn(h, l), rn(t) && n.set(t, h), h); } -function isEmitListener(options, key) { - if (!options || !isOn(key)) { - return false; - } - key = key.slice(2).replace(/Once$/, ""); - return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key); +function Ey(t, e) { + return !t || !$d(e) ? !1 : (e = e.slice(2).replace(/Once$/, ""), Ar(t, e[0].toLowerCase() + e.slice(1)) || Ar(t, Mo(e)) || Ar(t, e)); } -let currentRenderingInstance = null; -let currentScopeId = null; -function setCurrentRenderingInstance(instance2) { - const prev = currentRenderingInstance; - currentRenderingInstance = instance2; - currentScopeId = instance2 && instance2.type.__scopeId || null; - return prev; +let _i = null, iS = null; +function Mg(t) { + const e = _i; + return _i = t, iS = t && t.type.__scopeId || null, e; } -function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) { - if (!ctx) - return fn; - if (fn._n) { - return fn; - } - const renderFnWithContext = (...args) => { - if (renderFnWithContext._d) { - setBlockTracking(-1); - } - const prevInstance = setCurrentRenderingInstance(ctx); - let res; +function jd(t, e = _i, r) { + if (!e || t._n) + return t; + const n = (...i) => { + n._d && Xb(-1); + const l = Mg(e); + let h; try { - res = fn(...args); + h = t(...i); } finally { - setCurrentRenderingInstance(prevInstance); - if (renderFnWithContext._d) { - setBlockTracking(1); - } - } - if (process.env.NODE_ENV !== "production" || false) { - devtoolsComponentUpdated(ctx); + Mg(l), n._d && Xb(1); } - return res; + return process.env.NODE_ENV !== "production" && tS(e), h; }; - renderFnWithContext._n = true; - renderFnWithContext._c = true; - renderFnWithContext._d = true; - return renderFnWithContext; -} -let accessedAttrs = false; -function markAttrsAccessed() { - accessedAttrs = true; -} -function renderComponentRoot(instance2) { - const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit: emit2, render: render2, renderCache, data, setupState, ctx, inheritAttrs } = instance2; - let result; - let fallthroughAttrs; - const prev = setCurrentRenderingInstance(instance2); - if (process.env.NODE_ENV !== "production") { - accessedAttrs = false; - } + return n._n = !0, n._c = !0, n._d = !0, n; +} +let Jv = !1; +function Cg() { + Jv = !0; +} +function Q_(t) { + const { type: e, vnode: r, proxy: n, withProxy: i, props: l, propsOptions: [h], slots: s, attrs: m, emit: v, render: E, renderCache: T, data: S, setupState: A, ctx: L, inheritAttrs: B } = t; + let j, q; + const H = Mg(t); + process.env.NODE_ENV !== "production" && (Jv = !1); try { - if (vnode.shapeFlag & 4) { - const proxyToUse = withProxy || proxy; - result = normalizeVNode(render2.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); - fallthroughAttrs = attrs; + if (r.shapeFlag & 4) { + const he = i || n; + j = Sa(E.call(he, he, T, l, A, S, L)), q = m; } else { - const render3 = Component; - if (process.env.NODE_ENV !== "production" && attrs === props) { - markAttrsAccessed(); - } - result = normalizeVNode(render3.length > 1 ? render3(props, process.env.NODE_ENV !== "production" ? { + const he = e; + process.env.NODE_ENV !== "production" && m === l && Cg(), j = Sa(he.length > 1 ? he(l, process.env.NODE_ENV !== "production" ? { get attrs() { - markAttrsAccessed(); - return attrs; + return Cg(), m; }, - slots, - emit: emit2 - } : { attrs, slots, emit: emit2 }) : render3(props, null)); - fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs); - } - } catch (err) { - blockStack.length = 0; - handleError(err, instance2, 1); - result = createVNode(Comment); - } - let root = result; - let setRoot = void 0; - if (process.env.NODE_ENV !== "production" && result.patchFlag > 0 && result.patchFlag & 2048) { - [root, setRoot] = getChildRoot(result); - } - if (fallthroughAttrs && inheritAttrs !== false) { - const keys = Object.keys(fallthroughAttrs); - const { shapeFlag } = root; - if (keys.length) { - if (shapeFlag & (1 | 6)) { - if (propsOptions && keys.some(isModelListener)) { - fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); - } - root = cloneVNode(root, fallthroughAttrs); - } else if (process.env.NODE_ENV !== "production" && !accessedAttrs && root.type !== Comment) { - const allAttrs = Object.keys(attrs); - const eventAttrs = []; - const extraAttrs = []; - for (let i = 0, l = allAttrs.length; i < l; i++) { - const key = allAttrs[i]; - if (isOn(key)) { - if (!isModelListener(key)) { - eventAttrs.push(key[2].toLowerCase() + key.slice(3)); + slots: s, + emit: v + } : { attrs: m, slots: s, emit: v }) : he(l, null)), q = e.props ? m : JA(m); + } + } catch (he) { + dd.length = 0, by(he, t, 1), j = $t(Ii); + } + let ne = j, ee; + if (process.env.NODE_ENV !== "production" && j.patchFlag > 0 && j.patchFlag & 2048 && ([ne, ee] = YA(j)), q && B !== !1) { + const he = Object.keys(q), { shapeFlag: Te } = ne; + if (he.length) { + if (Te & 7) + h && he.some(vg) && (q = QA(q, h)), ne = as(ne, q); + else if (process.env.NODE_ENV !== "production" && !Jv && ne.type !== Ii) { + const ve = Object.keys(m), Oe = [], Me = []; + for (let Re = 0, He = ve.length; Re < He; Re++) { + const Ve = ve[Re]; + $d(Ve) ? vg(Ve) || Oe.push(Ve[2].toLowerCase() + Ve.slice(3)) : Me.push(Ve); + } + Me.length && st(`Extraneous non-props attributes (${Me.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`), Oe.length && st(`Extraneous non-emits event listeners (${Oe.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 r.dirs && (process.env.NODE_ENV !== "production" && !Db(ne) && st("Runtime directive used on component with non-element root node. The directives will not function as intended."), ne = as(ne), ne.dirs = ne.dirs ? ne.dirs.concat(r.dirs) : r.dirs), r.transition && (process.env.NODE_ENV !== "production" && !Db(ne) && st("Component inside renders non-element root node that cannot be animated."), ne.transition = r.transition), process.env.NODE_ENV !== "production" && ee ? ee(ne) : j = ne, Mg(H), j; +} +const YA = (t) => { + const e = t.children, r = t.dynamicChildren, n = oS(e); + if (!n) + return [t, void 0]; + const i = e.indexOf(n), l = r ? r.indexOf(n) : -1, h = (s) => { + e[i] = s, r && (l > -1 ? r[l] = s : s.patchFlag > 0 && (t.dynamicChildren = [...r, s])); + }; + return [Sa(n), h]; +}; +function oS(t) { + let e; + for (let r = 0; r < t.length; r++) { + const n = t[r]; + if (Rh(n)) { + if (n.type !== Ii || n.children === "v-if") { + if (e) + return; + e = n; + } + } else + return; + } + return e; +} +const JA = (t) => { + let e; + for (const r in t) + (r === "class" || r === "style" || $d(r)) && ((e || (e = {}))[r] = t[r]); + return e; +}, QA = (t, e) => { + const r = {}; + for (const n in t) + (!vg(n) || !(n.slice(9) in e)) && (r[n] = t[n]); + return r; +}, Db = (t) => t.shapeFlag & 7 || t.type === Ii; +function eO(t, e, r) { + const { props: n, children: i, component: l } = t, { props: h, children: s, patchFlag: m } = e, v = l.emitsOptions; + if (process.env.NODE_ENV !== "production" && (i || s) && Fl || e.dirs || e.transition) + return !0; + if (r && m >= 0) { + if (m & 1024) + return !0; + if (m & 16) + return n ? kb(n, h, v) : !!h; + if (m & 8) { + const E = e.dynamicProps; + for (let T = 0; T < E.length; T++) { + const S = E[T]; + if (h[S] !== n[S] && !Ey(v, S)) + return !0; + } + } + } else + return (i || s) && (!s || !s.$stable) ? !0 : n === h ? !1 : n ? h ? kb(n, h, v) : !0 : !!h; + return !1; +} +function kb(t, e, r) { + const n = Object.keys(e); + if (n.length !== Object.keys(t).length) + return !0; + for (let i = 0; i < n.length; i++) { + const l = n[i]; + if (e[l] !== t[l] && !Ey(r, l)) + return !0; + } + return !1; +} +function tO({ vnode: t, parent: e }, r) { + for (; e && e.subTree === t; ) + (t = e.vnode).el = r, e = e.parent; +} +const rO = (t) => t.__isSuspense; +function nO(t, e) { + e && e.pendingBranch ? Zt(t) ? e.effects.push(...t) : e.effects.push(t) : KT(t); +} +function aS(t, e) { + if (!Zn) + process.env.NODE_ENV !== "production" && st("provide() can only be used inside setup()."); + else { + let r = Zn.provides; + const n = Zn.parent && Zn.parent.provides; + n === r && (r = Zn.provides = Object.create(n)), r[t] = e; + } +} +function bh(t, e, r = !1) { + const n = Zn || _i; + if (n) { + const i = n.parent == null ? n.vnode.appContext && n.vnode.appContext.provides : n.parent.provides; + if (i && t in i) + return i[t]; + if (arguments.length > 1) + return r && ar(e) ? e.call(n.proxy) : e; + process.env.NODE_ENV !== "production" && st(`injection "${String(t)}" not found.`); + } else + process.env.NODE_ENV !== "production" && st("inject() can only be used inside setup() or functional components."); +} +function Da(t, e) { + return sx(t, null, e); +} +const Tm = {}; +function An(t, e, r) { + return process.env.NODE_ENV !== "production" && !ar(e) && st("`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."), sx(t, e, r); +} +function sx(t, e, { immediate: r, deep: n, flush: i, onTrack: l, onTrigger: h } = dn) { + process.env.NODE_ENV !== "production" && !e && (r !== void 0 && st('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'), n !== void 0 && st('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.')); + const s = (ee) => { + st("Invalid watch source: ", ee, "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types."); + }, m = IT() === (Zn == null ? void 0 : Zn.scope) ? Zn : null; + let v, E = !1, T = !1; + if (tn(t) ? (v = () => t.value, E = Eg(t)) : Aa(t) ? (v = () => t, n = !0) : Zt(t) ? (T = !0, E = t.some((ee) => Aa(ee) || Eg(ee)), v = () => t.map((ee) => { + if (tn(ee)) + return ee.value; + if (Aa(ee)) + return Wc(ee); + if (ar(ee)) + return Ns(ee, m, 2); + process.env.NODE_ENV !== "production" && s(ee); + })) : ar(t) ? e ? v = () => Ns(t, m, 2) : v = () => { + if (!(m && m.isUnmounted)) + return S && S(), na(t, m, 3, [A]); + } : (v = Ui, process.env.NODE_ENV !== "production" && s(t)), e && n) { + const ee = v; + v = () => Wc(ee()); + } + let S, A = (ee) => { + S = H.onStop = () => { + Ns(ee, m, 4); + }; + }, L; + if (Ad) + if (A = Ui, e ? r && na(e, m, 3, [ + v(), + T ? [] : void 0, + A + ]) : v(), i === "sync") { + const ee = fR(); + L = ee.__watcherHandles || (ee.__watcherHandles = []); + } else + return Ui; + let B = T ? new Array(t.length).fill(Tm) : Tm; + const j = () => { + if (!!H.active) + if (e) { + const ee = H.run(); + (n || E || (T ? ee.some((he, Te) => Td(he, B[Te])) : Td(ee, B))) && (S && S(), na(e, m, 3, [ + ee, + B === Tm ? void 0 : T && B[0] === Tm ? [] : B, + A + ]), B = ee); + } else + H.run(); + }; + j.allowRecurse = !!e; + let q; + i === "sync" ? q = j : i === "post" ? q = () => Eo(j, m && m.suspense) : (j.pre = !0, m && (j.id = m.uid), q = () => wy(j)); + const H = new ex(v, q); + process.env.NODE_ENV !== "production" && (H.onTrack = l, H.onTrigger = h), e ? r ? j() : B = H.run() : i === "post" ? Eo(H.run.bind(H), m && m.suspense) : H.run(); + const ne = () => { + H.stop(), m && m.scope && H0(m.scope.effects, H); + }; + return L && L.push(ne), ne; +} +function iO(t, e, r) { + const n = this.proxy, i = Nn(t) ? t.includes(".") ? sS(n, t) : () => n[t] : t.bind(n, n); + let l; + ar(e) ? l = e : (l = e.handler, r = e); + const h = Zn; + Lh(this); + const s = sx(i, l.bind(n), r); + return h ? Lh(h) : Jc(), s; +} +function sS(t, e) { + const r = e.split("."); + return () => { + let n = t; + for (let i = 0; i < r.length && n; i++) + n = n[r[i]]; + return n; + }; +} +function Wc(t, e) { + if (!rn(t) || t.__v_skip || (e = e || /* @__PURE__ */ new Set(), e.has(t))) + return t; + if (e.add(t), tn(t)) + Wc(t.value, e); + else if (Zt(t)) + for (let r = 0; r < t.length; r++) + Wc(t[r], e); + else if (wT(t) || Zc(t)) + t.forEach((r) => { + Wc(r, e); + }); + else if (TT(t)) + for (const r in t) + Wc(t[r], e); + return t; +} +function oO() { + const t = { + isMounted: !1, + isLeaving: !1, + isUnmounting: !1, + leavingVNodes: /* @__PURE__ */ new Map() + }; + return aa(() => { + t.isMounted = !0; + }), fS(() => { + t.isUnmounting = !0; + }), t; +} +const Jo = [Function, Array], aO = { + name: "BaseTransition", + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + onBeforeEnter: Jo, + onEnter: Jo, + onAfterEnter: Jo, + onEnterCancelled: Jo, + onBeforeLeave: Jo, + onLeave: Jo, + onAfterLeave: Jo, + onLeaveCancelled: Jo, + onBeforeAppear: Jo, + onAppear: Jo, + onAfterAppear: Jo, + onAppearCancelled: Jo + }, + setup(t, { slots: e }) { + const r = My(), n = oO(); + let i; + return () => { + const l = e.default && uS(e.default(), !0); + if (!l || !l.length) + return; + let h = l[0]; + if (l.length > 1) { + let B = !1; + for (const j of l) + if (j.type !== Ii) { + if (process.env.NODE_ENV !== "production" && B) { + st(" can only be used on a single element or component. Use for lists."); + break; } - } else { - extraAttrs.push(key); + if (h = j, B = !0, process.env.NODE_ENV === "production") + break; } - } - if (extraAttrs.length) { - warn(`Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`); - } - if (eventAttrs.length) { - warn(`Extraneous non-emits event listeners (${eventAttrs.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.`); - } } - } + const s = ir(t), { mode: m } = s; + if (process.env.NODE_ENV !== "production" && m && m !== "in-out" && m !== "out-in" && m !== "default" && st(`invalid mode: ${m}`), n.isLeaving) + return ev(h); + const v = Nb(h); + if (!v) + return ev(h); + const E = Qv(v, s, n, r); + e0(v, E); + const T = r.subTree, S = T && Nb(T); + let A = !1; + const { getTransitionKey: L } = v.type; + if (L) { + const B = L(); + i === void 0 ? i = B : B !== i && (i = B, A = !0); + } + if (S && S.type !== Ii && (!jc(v, S) || A)) { + const B = Qv(S, s, n, r); + if (e0(S, B), m === "out-in") + return n.isLeaving = !0, B.afterLeave = () => { + n.isLeaving = !1, r.update.active !== !1 && r.update(); + }, ev(h); + m === "in-out" && v.type !== Ii && (B.delayLeave = (j, q, H) => { + const ne = cS(n, S); + ne[String(S.key)] = S, j._leaveCb = () => { + q(), j._leaveCb = void 0, delete E.delayedLeave; + }, E.delayedLeave = H; + }); + } + return h; + }; } - if (vnode.dirs) { - if (process.env.NODE_ENV !== "production" && !isElementRoot(root)) { - warn(`Runtime directive used on component with non-element root node. The directives will not function as intended.`); +}, lS = aO; +function cS(t, e) { + const { leavingVNodes: r } = t; + let n = r.get(e.type); + return n || (n = /* @__PURE__ */ Object.create(null), r.set(e.type, n)), n; +} +function Qv(t, e, r, n) { + const { appear: i, mode: l, persisted: h = !1, onBeforeEnter: s, onEnter: m, onAfterEnter: v, onEnterCancelled: E, onBeforeLeave: T, onLeave: S, onAfterLeave: A, onLeaveCancelled: L, onBeforeAppear: B, onAppear: j, onAfterAppear: q, onAppearCancelled: H } = e, ne = String(t.key), ee = cS(r, t), he = (Oe, Me) => { + Oe && na(Oe, n, 9, Me); + }, Te = (Oe, Me) => { + const Re = Me[1]; + he(Oe, Me), Zt(Oe) ? Oe.every((He) => He.length <= 1) && Re() : Oe.length <= 1 && Re(); + }, ve = { + mode: l, + persisted: h, + beforeEnter(Oe) { + let Me = s; + if (!r.isMounted) + if (i) + Me = B || s; + else + return; + Oe._leaveCb && Oe._leaveCb(!0); + const Re = ee[ne]; + Re && jc(t, Re) && Re.el._leaveCb && Re.el._leaveCb(), he(Me, [Oe]); + }, + enter(Oe) { + let Me = m, Re = v, He = E; + if (!r.isMounted) + if (i) + Me = j || m, Re = q || v, He = H || E; + else + return; + let Ve = !1; + const dt = Oe._enterCb = (xe) => { + Ve || (Ve = !0, xe ? he(He, [Oe]) : he(Re, [Oe]), ve.delayedLeave && ve.delayedLeave(), Oe._enterCb = void 0); + }; + Me ? Te(Me, [Oe, dt]) : dt(); + }, + leave(Oe, Me) { + const Re = String(t.key); + if (Oe._enterCb && Oe._enterCb(!0), r.isUnmounting) + return Me(); + he(T, [Oe]); + let He = !1; + const Ve = Oe._leaveCb = (dt) => { + He || (He = !0, Me(), dt ? he(L, [Oe]) : he(A, [Oe]), Oe._leaveCb = void 0, ee[Re] === t && delete ee[Re]); + }; + ee[Re] = t, S ? Te(S, [Oe, Ve]) : Ve(); + }, + clone(Oe) { + return Qv(Oe, e, r, n); } - root = cloneVNode(root); - root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + }; + return ve; +} +function ev(t) { + if (Gd(t)) + return t = as(t), t.children = null, t; +} +function Nb(t) { + return Gd(t) ? t.children ? t.children[0] : void 0 : t; +} +function e0(t, e) { + t.shapeFlag & 6 && t.component ? e0(t.component.subTree, e) : t.shapeFlag & 128 ? (t.ssContent.transition = e.clone(t.ssContent), t.ssFallback.transition = e.clone(t.ssFallback)) : t.transition = e; +} +function uS(t, e = !1, r) { + let n = [], i = 0; + for (let l = 0; l < t.length; l++) { + let h = t[l]; + const s = r == null ? h.key : String(r) + String(h.key != null ? h.key : l); + h.type === pn ? (h.patchFlag & 128 && i++, n = n.concat(uS(h.children, e, s))) : (e || h.type !== Ii) && n.push(s != null ? as(h, { key: s }) : h); } - if (vnode.transition) { - if (process.env.NODE_ENV !== "production" && !isElementRoot(root)) { - warn(`Component inside renders non-element root node that cannot be animated.`); + if (i > 1) + for (let l = 0; l < n.length; l++) + n[l].patchFlag = -2; + return n; +} +function vr(t) { + return ar(t) ? { setup: t, name: t.name } : t; +} +const hd = (t) => !!t.type.__asyncLoader, Gd = (t) => t.type.__isKeepAlive; +function sO(t, e) { + hS(t, "a", e); +} +function lO(t, e) { + hS(t, "da", e); +} +function hS(t, e, r = Zn) { + const n = t.__wdc || (t.__wdc = () => { + let i = r; + for (; i; ) { + if (i.isDeactivated) + return; + i = i.parent; } - root.transition = vnode.transition; - } - if (process.env.NODE_ENV !== "production" && setRoot) { - setRoot(root); - } else { - result = root; + return t(); + }); + if (Ty(e, n, r), r) { + let i = r.parent; + for (; i && i.parent; ) + Gd(i.parent.vnode) && cO(n, e, r, i), i = i.parent; + } +} +function cO(t, e, r, n) { + const i = Ty(e, t, n, !0); + fu(() => { + H0(n[e], i); + }, r); +} +function Ty(t, e, r = Zn, n = !1) { + if (r) { + const i = r[t] || (r[t] = []), l = e.__weh || (e.__weh = (...h) => { + if (r.isUnmounted) + return; + uu(), Lh(r); + const s = na(e, r, t, h); + return Jc(), hu(), s; + }); + return n ? i.unshift(l) : i.push(l), l; + } else if (process.env.NODE_ENV !== "production") { + const i = Bc(nx[t].replace(/ hook$/, "")); + st(`${i} 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 qs = (t) => (e, r = Zn) => (!Ad || t === "sp") && Ty(t, (...n) => e(...n), r), uO = qs("bm"), aa = qs("m"), hO = qs("bu"), fO = qs("u"), fS = qs("bum"), fu = qs("um"), dO = qs("sp"), pO = qs("rtg"), mO = qs("rtc"); +function gO(t, e = Zn) { + Ty("ec", t, e); +} +function dS(t) { + VP(t) && st("Do not use built-in directive ids as custom directive id: " + t); +} +function Fb(t, e) { + const r = _i; + if (r === null) + return process.env.NODE_ENV !== "production" && st("withDirectives can only be used inside render functions."), t; + const n = Cy(r) || r.proxy, i = t.dirs || (t.dirs = []); + for (let l = 0; l < e.length; l++) { + let [h, s, m, v = dn] = e[l]; + h && (ar(h) && (h = { + mounted: h, + updated: h + }), h.deep && Wc(s), i.push({ + dir: h, + instance: n, + value: s, + oldValue: void 0, + arg: m, + modifiers: v + })); } - setCurrentRenderingInstance(prev); - return result; + return t; } -const getChildRoot = (vnode) => { - const rawChildren = vnode.children; - const dynamicChildren = vnode.dynamicChildren; - const childRoot = filterSingleRoot(rawChildren); - if (!childRoot) { - return [vnode, void 0]; - } - const index2 = rawChildren.indexOf(childRoot); - const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; - const setRoot = (updatedRoot) => { - rawChildren[index2] = updatedRoot; - if (dynamicChildren) { - if (dynamicIndex > -1) { - dynamicChildren[dynamicIndex] = updatedRoot; - } else if (updatedRoot.patchFlag > 0) { - vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; - } - } - }; - return [normalizeVNode(childRoot), setRoot]; -}; -function filterSingleRoot(children) { - let singleRoot; - for (let i = 0; i < children.length; i++) { - const child = children[i]; - if (isVNode(child)) { - if (child.type !== Comment || child.children === "v-if") { - if (singleRoot) { - return; - } else { - singleRoot = child; +function Pc(t, e, r, n) { + const i = t.dirs, l = e && e.dirs; + for (let h = 0; h < i.length; h++) { + const s = i[h]; + l && (s.oldValue = l[h].value); + let m = s.dir[n]; + m && (uu(), na(m, r, 8, [ + t.el, + s, + t, + e + ]), hu()); + } +} +const t0 = "components", yO = "directives"; +function _O(t, e) { + return pS(t0, t, !0, e) || t; +} +const vO = Symbol(); +function xO(t) { + return pS(yO, t); +} +function pS(t, e, r = !0, n = !1) { + const i = _i || Zn; + if (i) { + const l = i.type; + if (t === t0) { + const s = fx(l, !1); + if (s && (s === e || s === Go(e) || s === ru(Go(e)))) + return l; + } + const h = zb(i[t] || l[t], e) || zb(i.appContext[t], e); + if (!h && n) + return l; + if (process.env.NODE_ENV !== "production" && r && !h) { + const s = t === t0 ? ` +If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ""; + st(`Failed to resolve ${t.slice(0, -1)}: ${e}${s}`); + } + return h; + } else + process.env.NODE_ENV !== "production" && st(`resolve${ru(t.slice(0, -1))} can only be used in render() or setup().`); +} +function zb(t, e) { + return t && (t[e] || t[Go(e)] || t[ru(Go(e))]); +} +function ka(t, e, r, n) { + let i; + const l = r && r[n]; + if (Zt(t) || Nn(t)) { + i = new Array(t.length); + for (let h = 0, s = t.length; h < s; h++) + i[h] = e(t[h], h, void 0, l && l[h]); + } else if (typeof t == "number") { + process.env.NODE_ENV !== "production" && !Number.isInteger(t) && st(`The v-for range expect an integer value but got ${t}.`), i = new Array(t); + for (let h = 0; h < t; h++) + i[h] = e(h + 1, h, void 0, l && l[h]); + } else if (rn(t)) + if (t[Symbol.iterator]) + i = Array.from(t, (h, s) => e(h, s, void 0, l && l[s])); + else { + const h = Object.keys(t); + i = new Array(h.length); + for (let s = 0, m = h.length; s < m; s++) { + const v = h[s]; + i[s] = e(t[v], v, s, l && l[s]); + } + } + else + i = []; + return r && (r[n] = i), i; +} +function bO(t, e, r = {}, n, i) { + if (_i.isCE || _i.parent && hd(_i.parent) && _i.parent.isCE) + return e !== "default" && (r.name = e), $t("slot", r, n && n()); + let l = t[e]; + process.env.NODE_ENV !== "production" && l && l.length > 1 && (st("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."), l = () => []), l && l._c && (l._d = !1), tt(); + const h = l && mS(l(r)), s = Un(pn, { + key: r.key || h && h.key || `_${e}` + }, h || (n ? n() : []), h && t._ === 1 ? 64 : -2); + return !i && s.scopeId && (s.slotScopeIds = [s.scopeId + "-s"]), l && l._c && (l._d = !0), s; +} +function mS(t) { + return t.some((e) => Rh(e) ? !(e.type === Ii || e.type === pn && !mS(e.children)) : !0) ? t : null; +} +const r0 = (t) => t ? OS(t) ? Cy(t) || t.proxy : r0(t.parent) : null, Yc = /* @__PURE__ */ kn(/* @__PURE__ */ Object.create(null), { + $: (t) => t, + $el: (t) => t.vnode.el, + $data: (t) => t.data, + $props: (t) => process.env.NODE_ENV !== "production" ? uh(t.props) : t.props, + $attrs: (t) => process.env.NODE_ENV !== "production" ? uh(t.attrs) : t.attrs, + $slots: (t) => process.env.NODE_ENV !== "production" ? uh(t.slots) : t.slots, + $refs: (t) => process.env.NODE_ENV !== "production" ? uh(t.refs) : t.refs, + $parent: (t) => r0(t.parent), + $root: (t) => r0(t.root), + $emit: (t) => t.emit, + $options: (t) => cx(t), + $forceUpdate: (t) => t.f || (t.f = () => wy(t.update)), + $nextTick: (t) => t.n || (t.n = Sg.bind(t.proxy)), + $watch: (t) => iO.bind(t) +}), lx = (t) => t === "_" || t === "$", tv = (t, e) => t !== dn && !t.__isScriptSetup && Ar(t, e), gS = { + get({ _: t }, e) { + const { ctx: r, setupState: n, data: i, props: l, accessCache: h, type: s, appContext: m } = t; + if (process.env.NODE_ENV !== "production" && e === "__isVue") + return !0; + let v; + if (e[0] !== "$") { + const A = h[e]; + if (A !== void 0) + switch (A) { + case 1: + return n[e]; + case 2: + return i[e]; + case 4: + return r[e]; + case 3: + return l[e]; } + else { + if (tv(n, e)) + return h[e] = 1, n[e]; + if (i !== dn && Ar(i, e)) + return h[e] = 2, i[e]; + if ((v = t.propsOptions[0]) && Ar(v, e)) + return h[e] = 3, l[e]; + if (r !== dn && Ar(r, e)) + return h[e] = 4, r[e]; + n0 && (h[e] = 0); + } + } + const E = Yc[e]; + let T, S; + if (E) + return e === "$attrs" && (mo(t, "get", e), process.env.NODE_ENV !== "production" && Cg()), E(t); + if ((T = s.__cssModules) && (T = T[e])) + return T; + if (r !== dn && Ar(r, e)) + return h[e] = 4, r[e]; + if (S = m.config.globalProperties, Ar(S, e)) + return S[e]; + process.env.NODE_ENV !== "production" && _i && (!Nn(e) || e.indexOf("__v") !== 0) && (i !== dn && lx(e[0]) && Ar(i, e) ? st(`Property ${JSON.stringify(e)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`) : t === _i && st(`Property ${JSON.stringify(e)} was accessed during render but is not defined on instance.`)); + }, + set({ _: t }, e, r) { + const { data: n, setupState: i, ctx: l } = t; + return tv(i, e) ? (i[e] = r, !0) : process.env.NODE_ENV !== "production" && i.__isScriptSetup && Ar(i, e) ? (st(`Cannot mutate + + diff --git a/src/components/alert-notifications/notification-item.vue b/src/components/alert-notifications/notification-item.vue new file mode 100644 index 00000000..381fe1a4 --- /dev/null +++ b/src/components/alert-notifications/notification-item.vue @@ -0,0 +1,42 @@ + + + diff --git a/src/components/background-selector/background-selector.vue b/src/components/background-selector/background-selector.vue index f20dc04b..0d477b46 100644 --- a/src/components/background-selector/background-selector.vue +++ b/src/components/background-selector/background-selector.vue @@ -5,9 +5,11 @@ import { storeToRefs } from 'pinia' import { IBackgroundLayer } from '@/composables/background-layer/background-layer.model' import useBackgroundLayer from '@/composables/background-layer/background-layer.composable' + +import { useAlertNotificationsStore } from '@/stores/alert-notifications.store' import { useThemeStore } from '@/stores/config.store' import { useMapStore } from '@/stores/map.store' -import { statePersistorBgLayerService } from '@/services/state-persistor/state-persistor-layer-background.service' + import BackgroundSelectorItem from './background-selector-item.vue' import { bgConfigFixture } from '@/__fixtures__/background.config.fixture' import { ThemeNodeModel } from '@/composables/themes/themes.model' @@ -18,8 +20,6 @@ const mapStore = useMapStore() const themeStore = useThemeStore() const { bgLayer: bgLayerContext } = storeToRefs(mapStore) -statePersistorBgLayerService.bootstrap() - const props = defineProps({ isOpen: { type: Boolean, @@ -43,7 +43,7 @@ watch( { id: bgl.id, }, - bgLayersContext.find((l: ThemeNodeModel) => bgl.id == l.id), + bgLayersContext.find((l: ThemeNodeModel) => bgl.id === l.id), { name: bgl.icon_id, } @@ -66,8 +66,7 @@ watch( backgroundLayer.setBgLayer(backgroundLayer.defaultSelectedBgId.value) if (bgLayerContext === null) { - // TODO: implement alert message - console.log( + useAlertNotificationsStore().addNotification( t( "Aucune couche n'étant définie pour cette carte, une couche de fond a automatiquement été ajoutée.", { ns: 'client' } diff --git a/src/composables/background-layer/background-layer.composable.ts b/src/composables/background-layer/background-layer.composable.ts index 455fd690..cf6b2b39 100644 --- a/src/composables/background-layer/background-layer.composable.ts +++ b/src/composables/background-layer/background-layer.composable.ts @@ -1,7 +1,10 @@ import { computed } from 'vue' +import { storeToRefs } from 'pinia' + import { bgConfigFixture } from '@/__fixtures__/background.config.fixture' import useLayers from '@/composables/layers/layers.composable' +import { useAppStore } from '@/stores/app.store' import type { Layer } from '@/stores/map.store.model' import { useMapStore } from '@/stores/map.store' import { useThemeStore } from '@/stores/config.store' @@ -12,16 +15,23 @@ import { import useThemes from '@/composables/themes/themes.composable' export default function useBackgroundLayer() { + const appStore = useAppStore() + const { mapId } = storeToRefs(appStore) const theme = useThemes() const mapStore = useMapStore() const layers = useLayers() const defaultSelectedBgId = computed(() => { - const theme_name = useThemeStore().theme?.name - if (theme_name) { - const defaultBgLayers = bgConfigFixture() - .bg_layer_theme_defaults as BgLayerDefaultsType - return defaultBgLayers[theme_name] || getDefaultSelectedId() + if (!mapId.value) { + const themeName = useThemeStore().theme?.name + + if (themeName) { + const defaultBgLayers = bgConfigFixture() + .bg_layer_theme_defaults as BgLayerDefaultsType + + return defaultBgLayers[themeName] || getDefaultSelectedId() + } } + return getDefaultSelectedId() }) diff --git a/src/composables/map/ol.composable.ts b/src/composables/map/ol.composable.ts index 063df703..17b98a06 100644 --- a/src/composables/map/ol.composable.ts +++ b/src/composables/map/ol.composable.ts @@ -23,6 +23,7 @@ import { } from '@/__fixtures__/wmts.fixture' import { useStyleStore } from '@/stores/style.store' +const DEFAULT_BGZINDEX = -200 // Value comming from legacy const proxyWmsUrl = 'https://map.geoportail.lu/ogcproxywms' export const remoteProxyWms = 'https://map.geoportail.lu/httpsproxy' @@ -245,7 +246,9 @@ export default function useOpenLayers() { callbackFunction: (bgLayer: BaseLayer) => void ) { const mapLayers = olMap.getLayers() - const bgLayer = mapLayers.getArray().find(layer => layer.getZIndex() === -1) + const bgLayer = mapLayers + .getArray() + .find(layer => layer.getZIndex() === DEFAULT_BGZINDEX) if (bgLayer) callbackFunction(bgLayer) } @@ -257,7 +260,7 @@ export default function useOpenLayers() { const mapLayers = olMap.getLayers() const currentBgLayerPos = mapLayers .getArray() - .findIndex(layer => layer.getZIndex() === -1) + .findIndex(layer => layer.getZIndex() === DEFAULT_BGZINDEX) let bgBaseLayer: BaseLayer | undefined = undefined if (bgLayer) { @@ -279,14 +282,14 @@ export default function useOpenLayers() { if (currentBgLayerPos >= 0) { if (bgBaseLayer) { - bgBaseLayer.setZIndex(-1) + bgBaseLayer.setZIndex(DEFAULT_BGZINDEX) mapLayers.setAt(currentBgLayerPos, bgBaseLayer) } else { mapLayers.removeAt(currentBgLayerPos) } } else { if (bgBaseLayer) { - bgBaseLayer.setZIndex(-1) + bgBaseLayer.setZIndex(DEFAULT_BGZINDEX) olMap.addLayer(bgBaseLayer) } } diff --git a/src/services/state-persistor/state-persistor-bgstyle.service.ts b/src/services/state-persistor/state-persistor-bgstyle.service.ts index 20d828b6..ab9b15fe 100644 --- a/src/services/state-persistor/state-persistor-bgstyle.service.ts +++ b/src/services/state-persistor/state-persistor-bgstyle.service.ts @@ -7,7 +7,6 @@ import { useStyleStore } from '@/stores/style.store' import { useMapStore } from '@/stores/map.store' import { SP_KEY_SERIAL } from './state-persistor.model' import { StyleItem } from '@/composables/mvt-styles/mvt-styles.model' -// import { bgConfigFixture } from '@/__fixtures__/background.config.fixture' class StatePersistorStyleService { styleWatcher: WatchStopHandle diff --git a/src/services/state-persistor/state-persistor-mymap.service.ts b/src/services/state-persistor/state-persistor-mymap.service.ts new file mode 100644 index 00000000..267306fa --- /dev/null +++ b/src/services/state-persistor/state-persistor-mymap.service.ts @@ -0,0 +1,44 @@ +import { watchEffect, WatchStopHandle } from 'vue' + +import { useAppStore } from '@/stores/app.store' +import { SP_KEY_MAPID } from './state-persistor.model' +import { storageHelper } from './storage/storage.helper' + +// TODO: handle "My Map" functionality in v4 +// for now, only mapId x Permalink is implemented (for bg selection, use case when there is a mapId in the permalink) +// see legacy LayerPermalinkManager l. 609 + +class StatePersistorMyMapService { + bootstrap() { + this.restore() + + let stop: WatchStopHandle + // eslint-disable-next-line prefer-const + stop = watchEffect(() => { + this.persist() + stop && stop() // test if exists, for HMR support + }) + } + + persist() { + // TODO: activate persist if needed when implementing "My Map" + // const appStore = useAppStore() + // const { mapId } = storeToRefs(appStore) + // watch( + // mapId, + // (value, oldValue) => { + // if (oldValue !== value) { + // storageHelper.setValue(SP_KEY_MAPID, value) + // } + // }, + // { immediate: true } + // ) + } + + restore() { + const mapId = storageHelper.getValue(SP_KEY_MAPID) + useAppStore().setMapId(mapId) + } +} + +export const statePersistorMyMapService = new StatePersistorMyMapService() diff --git a/src/stores/alert-notifications.store.model.ts b/src/stores/alert-notifications.store.model.ts new file mode 100644 index 00000000..21c95649 --- /dev/null +++ b/src/stores/alert-notifications.store.model.ts @@ -0,0 +1,11 @@ +export enum AlertNotificationType { + INFO = 'alert-info', + WARNING = 'alert-warning', + ERROR = 'alert-danger', +} + +export interface AlertNotificationModel { + message: string + type?: AlertNotificationType + duration?: number +} diff --git a/src/stores/alert-notifications.store.spec.ts b/src/stores/alert-notifications.store.spec.ts new file mode 100644 index 00000000..5a54fd75 --- /dev/null +++ b/src/stores/alert-notifications.store.spec.ts @@ -0,0 +1,38 @@ +import { setActivePinia, createPinia } from 'pinia' + +import { useAlertNotificationsStore } from './alert-notifications.store' + +describe('AlertNotifications Store', () => { + beforeEach(() => { + setActivePinia(createPinia()) + }) + + describe('#addNotification', () => { + it('adds the notification to the store', () => { + const alertNotifications = useAlertNotificationsStore() + expect(alertNotifications.notifications.length).toBe(0) + alertNotifications.addNotification('Adding test message') + expect(alertNotifications.notifications.length).toBe(1) + alertNotifications.addNotification('Adding test message 2') + expect(alertNotifications.notifications.length).toBe(2) + }) + }) + + describe('#removeNotification', () => { + it('removes the notification at given index', () => { + const alertNotifications = useAlertNotificationsStore() + alertNotifications.addNotification('Adding test message 1') + alertNotifications.addNotification('Adding test message 2') + alertNotifications.addNotification('Adding test message 3') + expect(alertNotifications.notifications.length).toBe(3) + expect(alertNotifications.notifications[1].message).toBe( + 'Adding test message 2' + ) + alertNotifications.removeNotification(1) + expect(alertNotifications.notifications.length).toBe(2) + expect(alertNotifications.notifications[1].message).toBe( + 'Adding test message 3' + ) + }) + }) +}) diff --git a/src/stores/alert-notifications.store.ts b/src/stores/alert-notifications.store.ts new file mode 100644 index 00000000..342b71ba --- /dev/null +++ b/src/stores/alert-notifications.store.ts @@ -0,0 +1,51 @@ +import { Ref, ref } from 'vue' +import { acceptHMRUpdate, defineStore } from 'pinia' +import { + AlertNotificationModel, + AlertNotificationType, +} from './alert-notifications.store.model' + +const DEFAULT_NOTIFICATION_TYPE = AlertNotificationType.INFO +const DEFAULT_NOTIFICATION_DURATION = 7000 +const DEFAULT_NOTIFICATION_DURATION_WARNING = 4000 + +export const useAlertNotificationsStore = defineStore( + 'alert-notifications', + () => { + const notifications: Ref = ref([]) + + function addNotification( + message: string, + type = DEFAULT_NOTIFICATION_TYPE, + duration?: number + ) { + const notification = { + message, + type, + duration: + duration ?? + (type === AlertNotificationType.WARNING + ? DEFAULT_NOTIFICATION_DURATION_WARNING + : DEFAULT_NOTIFICATION_DURATION), + } + notifications.value.push(notification) + } + + function removeNotification(index: number) { + notifications.value.splice(index, 1) + } + + return { + notifications, + addNotification, + removeNotification, + } + }, + {} +) + +if (import.meta.hot) { + import.meta.hot.accept( + acceptHMRUpdate(useAlertNotificationsStore, import.meta.hot) + ) +} diff --git a/src/stores/app.store.ts b/src/stores/app.store.ts index ca426b99..09db5a0e 100644 --- a/src/stores/app.store.ts +++ b/src/stores/app.store.ts @@ -1,4 +1,4 @@ -import { ref } from 'vue' +import { Ref, ref } from 'vue' import { acceptHMRUpdate, defineStore } from 'pinia' export const DEFAULT_LANG = 'fr' @@ -13,6 +13,7 @@ export const useAppStore = defineStore( const layersOpen = ref(DEFAULT_LAYER_PANEL_OPENED) const myLayersTabOpen = ref(DEFAULT_MY_LAYERS_TAB_OPENED) const themeGridOpen = ref(DEFAULT_THEME_GRID_OPENED) + const mapId: Ref = ref() const remoteLayersOpen = ref() const styleEditorOpen = ref(false) @@ -45,6 +46,10 @@ export const useAppStore = defineStore( remoteLayersOpen.value = open } + function setMapId(id: string | undefined) { + mapId.value = id + } + function openStyleEditorPanel() { styleEditorOpen.value = true } @@ -58,6 +63,7 @@ export const useAppStore = defineStore( layersOpen, myLayersTabOpen, themeGridOpen, + mapId, styleEditorOpen, remoteLayersOpen, setLang, @@ -65,6 +71,7 @@ export const useAppStore = defineStore( setMyLayersTabOpen, setThemeGridOpen, setRemoteLayersOpen, + setMapId, openStyleEditorPanel, closeStyleEditorPanel, } diff --git a/tailwind.config.cjs b/tailwind.config.cjs index a5a33d56..64b39cfd 100644 --- a/tailwind.config.cjs +++ b/tailwind.config.cjs @@ -160,6 +160,9 @@ module.exports = { }, }, safelist: [ + 'lux-alert-info', + 'lux-alert-danger', + 'lux-alert-warning', 'md:bg-route', 'md:bg-topo_bw', 'md:bg-topo', diff --git a/vite-dist.config.ts b/vite-dist.config.ts index a890cf63..e5fe19da 100644 --- a/vite-dist.config.ts +++ b/vite-dist.config.ts @@ -36,7 +36,6 @@ export default defineConfig((/*{ command, mode }*/) => { } base.build = { - minify: false, lib: { entry: resolve(__dirname, 'src/bundle/lib.ts'), name: 'luxembourg-geoportail',